Table of Contents

Description

OpenAI ENDPOINTS

BETA

Getting an API Key

Installation

Swift Package Manager

Compatibility

Platform Support

OpenAI-Compatible Providers

Usage

import SwiftOpenAI

letapiKey="your_openai_api_key_here"letservice=OpenAIServiceFactory.service(apiKey: apiKey)

letapiKey="your_openai_api_key_here"letoganizationID="your_organixation_id"letservice=OpenAIServiceFactory.service(apiKey: apiKey, organizationID: oganizationID)

letapiKey="your_openai_api_key_here"letorganizationID="your_organization_id"letsession=URLSession.sharedsession.configuration.timeoutIntervalForRequest=360 // e.g., 360 seconds or more.lethttpClient=URLSessionHTTPClientAdapter(urlSession: session)letservice=OpenAIServiceFactory.service(apiKey: apiKey, organizationID: organizationID, httpClient: httpClient)

How to get the status code of network errors

letservice=OpenAIServiceFactory.service(apiKey: apiKey)letparameters=ChatCompletionParameters(messages:[.init(role:.user, content:.text("hello world"))],                                          model:.gpt4o)do{letchoices=tryawait service.startChat(parameters: parameters).choices   // Work with choices}catchAPIError.responseUnsuccessful(let description,let statusCode){print("Network error with status code:\(statusCode) and description:\(description)")}catch{print(error.localizedDescription)}

Audio

Audio Transcriptions

publicstructAudioTranscriptionParameters:Encodable{      /// The name of the file asset is not documented in OpenAI's official documentation; however, it is essential for constructing the multipart request.letfileName:String   /// The audio file object (not file name) translate, in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.letfile:Data   /// ID of the model to use. Only whisper-1 is currently available.letmodel:String   /// The language of the input audio. Supplying the input language in [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) format will improve accuracy and latency.letlanguage:String?   /// An optional text to guide the model's style or continue a previous audio segment. The [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting) should match the audio language.letprompt:String?   /// The format of the transcript output, in one of these options: json, text, srt, verbose_json, or vtt. Defaults to jsonletresponseFormat:String?   /// The sampling temperature, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. If set to 0, the model will use [log probability](https://en.wikipedia.org/wiki/Log_probability) to automatically increase the temperature until certain thresholds are hit. Defaults to 0lettemperature:Double?publicenumModel{case whisperOnecase custom(model:String)}publicinit(      fileName:String,      file:Data,      model:Model=.whisperOne,      prompt:String?=nil,      responseFormat:String?=nil,      temperature:Double?=nil,      language:String?=nil){self.fileName= fileNameself.file= fileself.model= model.rawValueself.prompt= promptself.responseFormat= responseFormatself.temperature= temperatureself.language= language}}

publicstructAudioObject:Decodable{      /// The transcribed text if the request uses the `transcriptions` API, or the translated text if the request uses the `translations` endpoint.publiclettext:String}

letfileName="narcos.m4a"letdata=Data(contentsOfURL:_) // Data retrieved from the file named "narcos.m4a".letparameters=AudioTranscriptionParameters(fileName: fileName, file: data) // **Important**: in the file name always provide the file extension.letaudioObject=tryawait service.createTranscription(parameters: parameters)

Audio Translations

publicstructAudioTranslationParameters:Encodable{      /// The name of the file asset is not documented in OpenAI's official documentation; however, it is essential for constructing the multipart request.letfileName:String   /// The audio file object (not file name) translate, in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.letfile:Data   /// ID of the model to use. Only whisper-1 is currently available.letmodel:String   /// An optional text to guide the model's style or continue a previous audio segment. The [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting) should match the audio language.letprompt:String?   /// The format of the transcript output, in one of these options: json, text, srt, verbose_json, or vtt. Defaults to jsonletresponseFormat:String?   /// The sampling temperature, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. If set to 0, the model will use [log probability](https://en.wikipedia.org/wiki/Log_probability) to automatically increase the temperature until certain thresholds are hit. Defaults to 0lettemperature:Double?publicenumModel{case whisperOnecase custom(model:String)}publicinit(      fileName:String,      file:Data,      model:Model=.whisperOne,      prompt:String?=nil,      responseFormat:String?=nil,      temperature:Double?=nil){self.fileName= fileNameself.file= fileself.model= model.rawValueself.prompt= promptself.responseFormat= responseFormatself.temperature= temperature}}

publicstructAudioObject:Decodable{      /// The transcribed text if the request uses the `transcriptions` API, or the translated text if the request uses the `translations` endpoint.publiclettext:String}

letfileName="german.m4a"letdata=Data(contentsOfURL:_) // Data retrieved from the file named "german.m4a".letparameters=AudioTranslationParameters(fileName: fileName, file: data) // **Important**: in the file name always provide the file extension.letaudioObject=tryawait service.createTranslation(parameters: parameters)

Audio Speech

/// [Generates audio from the input text.](https://platform.openai.com/docs/api-reference/audio/createSpeech)publicstructAudioSpeechParameters:Encodable{   /// One of the available [TTS models](https://platform.openai.com/docs/models/tts): tts-1 or tts-1-hdletmodel:String   /// The text to generate audio for. The maximum length is 4096 characters.letinput:String   /// The voice to use when generating the audio. Supported voices are alloy, echo, fable, onyx, nova, and shimmer. Previews of the voices are available in the [Text to speech guide.](https://platform.openai.com/docs/guides/text-to-speech/voice-options)letvoice:String   /// Defaults to mp3, The format to audio in. Supported formats are mp3, opus, aac, and flac.letresponseFormat:String?   /// Defaults to 1,  The speed of the generated audio. Select a value from 0.25 to 4.0. 1.0 is the default.letspeed:Double?publicenumTTSModel:String{case tts1="tts-1"case tts1HD="tts-1-hd"}publicenumVoice:String{case alloycase echocase fablecase onyxcase novacase shimmer}publicenumResponseFormat:String{case mp3case opuscase aaccase flac}publicinit(      model:TTSModel,      input:String,      voice:Voice,      responseFormat:ResponseFormat?=nil,      speed:Double?=nil){self.model= model.rawValueself.input= inputself.voice= voice.rawValueself.responseFormat= responseFormat?.rawValueself.speed= speed}}

/// The [audio speech](https://platform.openai.com/docs/api-reference/audio/createSpeech) response.publicstructAudioSpeechObject:Decodable{   /// The audio file content data.publicletoutput:Data}

letprompt="Hello, how are you today?"letparameters=AudioSpeechParameters(model:.tts1, input: prompt, voice:.shimmer)letaudioObjectData=tryawait service.createSpeech(parameters: parameters).outputplayAudio(from: audioObjectData)// Play dataprivatefunc playAudio(from data:Data){do{           // Initialize the audio player with the data           audioPlayer=tryAVAudioPlayer(data: data)           audioPlayer?.prepareToPlay()           audioPlayer?.play()}catch{           // Handle errorsprint("Error playing audio:\(error.localizedDescription)")}}

Audio Realtime

/// Configuration for creating a realtime sessionpublicstructOpenAIRealtimeSessionConfiguration:Encodable,Sendable{   /// The input audio format. Options: .pcm16, .g711_ulaw, .g711_alaw. Default is .pcm16letinputAudioFormat:AudioFormat?   /// Configuration for input audio transcription using WhisperletinputAudioTranscription:InputAudioTranscription?   /// System instructions for the model. Recommended default providedletinstructions:String?   /// Maximum tokens for response output. Can be .value(Int) or .infiniteletmaxResponseOutputTokens:MaxResponseOutputTokens?   /// Output modalities: [.audio, .text] or [.text] only. Default is [.audio, .text]letmodalities:[Modality]?   /// The output audio format. Options: .pcm16, .g711_ulaw, .g711_alaw. Default is .pcm16letoutputAudioFormat:AudioFormat?   /// Audio playback speed. Range: 0.25 to 4.0. Default is 1.0letspeed:Double?   /// Sampling temperature for model responses. Range: 0.6 to 1.2. Default is 0.8lettemperature:Double?   /// Array of tools/functions available for the model to calllettools:[Tool]?   /// Tool selection mode: .none, .auto, .required, or .specific(functionName: String)lettoolChoice:ToolChoice?   /// Voice activity detection configuration. Options: .serverVAD or .semanticVADletturnDetection:TurnDetection?   /// The voice to use. Options: "alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"letvoice:String?   /// Available audio formatspublicenumAudioFormat:String,Encodable,Sendable{case pcm16case g711_ulaw="g711-ulaw"case g711_alaw="g711-alaw"}   /// Output modalitiespublicenumModality:String,Encodable,Sendable{case audiocase text}   /// Turn detection configurationpublicstructTurnDetection:Encodable,Sendable{      /// Server-based VAD with customizable timingpublicstaticfunc serverVAD(         prefixPaddingMs:Int=300,         silenceDurationMs:Int=500,         threshold:Double=0.5)-> TurnDetection      /// Semantic VAD with eagerness level      public staticfunc semanticVAD(eagerness:Eagerness=.medium)->TurnDetection      publicenum Eagerness: String, Encodable, Sendable{         case low, medium, high}}}

/// Messages received from the realtime APIpublicenumOpenAIRealtimeMessage:Sendable{case error(String?)                    // Error occurredcase sessionCreated                    // Session successfully createdcase sessionUpdated                    // Configuration updatedcase responseCreated                   // Model started generating responsecase responseAudioDelta(String)        // Audio chunk (base64 PCM16)case inputAudioBufferSpeechStarted     // User started speaking (VAD detected)case responseFunctionCallArgumentsDone(name:String, arguments:String, callId:String)case responseTranscriptDelta(String)   // Partial AI transcriptcase responseTranscriptDone(String)    // Complete AI transcriptcase inputAudioBufferTranscript(String)           // User audio transcriptcase inputAudioTranscriptionDelta(String)         // Partial user transcriptioncase inputAudioTranscriptionCompleted(String)     // Complete user transcription}

/// Manages microphone input and audio playback for realtime conversations./// Audio played through AudioController does not interfere with mic input (the model won't hear itself).@RealtimeActorpublicfinalclassAudioController{   /// Initialize with specified modes   /// - Parameter modes: Array of .record (for microphone) and/or .playback (for audio output)publicinit(modes:[Mode])asyncthrowspublicenumMode{case record   // Enable microphone streamingcase playback // Enable audio playback}   /// Returns an AsyncStream of microphone audio buffers   /// - Throws: OpenAIError if .record mode wasn't enabled during initializationpublicfunc micStream()throws->AsyncStream<AVAudioPCMBuffer>   /// Plays base64-encoded PCM16 audio from the model   /// - Parameter base64String: Base64-encoded PCM16 audio datapublicfunc playPCM16Audio(base64String:String)   /// Interrupts current audio playback (useful when user starts speaking)   publicfunc interruptPlayback()   /// Stops all audio operations   publicfunc stop()}/// Utility for encoding audio buffers to base64publicenum AudioUtils{   /// Converts AVAudioPCMBuffer to base64 string for transmission   public staticfunc base64EncodeAudioPCMBuffer(from buffer:AVAudioPCMBuffer)->String?   /// Checks if headphones are connected   public staticvarheadphonesConnected:Bool}

// 1. Create session configurationletconfiguration=OpenAIRealtimeSessionConfiguration(   voice:"alloy",   instructions:"You are a helpful AI assistant. Be concise and friendly.",   turnDetection:.serverVAD(      prefixPaddingMs:300,      silenceDurationMs:500,      threshold:0.5),   inputAudioTranscription:.init(model:"whisper-1"))// 2. Create realtime sessionletsession=tryawait service.realtimeSession(   model:"gpt-4o-mini-realtime-preview-2024-12-17",   configuration: configuration)// 3. Initialize audio controller for recording and playbackletaudioController=tryawaitAudioController(modes:[.record,.playback])// 4. Handle incoming messages from OpenAITask{forawaitmessagein session.receiver{switch message{case.responseAudioDelta(let audio):         // Play audio from the model         audioController.playPCM16Audio(base64String: audio)case.inputAudioBufferSpeechStarted:         // User started speaking - interrupt model's audio         audioController.interruptPlayback()case.responseTranscriptDelta(let text):         // Display partial model transcriptprint("Model (partial):\(text)")case.responseTranscriptDone(let text):         // Display complete model transcriptprint("Model:\(text)")case.inputAudioTranscriptionCompleted(let text):         // Display user's transcribed speechprint("User:\(text)")case.responseFunctionCallArgumentsDone(let name,let args,let callId):         // Handle function call from modelprint("Function call:\(name) with args:\(args)")         // Execute function and send result backcase.error(let error):print("Error:\(error??"Unknown error")")default:break}}}// 5. Stream microphone audio to OpenAITask{do{fortryawaitbufferin audioController.micStream(){         // Encode audio buffer to base64guardlet base64Audio=AudioUtils.base64EncodeAudioPCMBuffer(from: buffer)else{continue}         // Send audio to OpenAItryawait session.sendMessage(OpenAIRealtimeInputAudioBufferAppend(audio: base64Audio))}}catch{print("Microphone error:\(error)")}}// 6. Manually trigger a response (optional - usually VAD handles this)tryawait session.sendMessage(OpenAIRealtimeResponseCreate())// 7. Update session configuration mid-conversation (optional)letnewConfig=OpenAIRealtimeSessionConfiguration(   voice:"shimmer",   temperature:0.9)tryawait session.sendMessage(OpenAIRealtimeSessionUpdate(sessionConfig: newConfig))// 8. Cleanup when doneaudioController.stop()session.disconnect()

// Define tools in configurationlettools:[OpenAIRealtimeSessionConfiguration.Tool]=[.init(      name:"get_weather",      description:"Get the current weather in a location",      parameters:["type":"object","properties":["location":["type":"string","description":"City name, e.g. San Francisco"]],"required":["location"]])]letconfig=OpenAIRealtimeSessionConfiguration(   voice:"alloy",   tools: tools,   toolChoice:.auto)// Handle function calls in message receivercase.responseFunctionCallArgumentsDone(let name, let args, let callId):if name=="get_weather"{      // Parse arguments and execute functionletresult=getWeather(arguments: args)      // Send result back to modeltryawait session.sendMessage(OpenAIRealtimeConversationItemCreate(            item:.functionCallOutput(               callId: callId,               output: result)))}

Chat

publicstructChatCompletionParameters:Encodable{      /// A list of messages comprising the conversation so far. [Example Python code](https://cookbook.openai.com/examples/how_to_format_inputs_to_chatgpt_models)publicvarmessages:[Message]   /// ID of the model to use. See the [model endpoint compatibility](https://platform.openai.com/docs/models/how-we-use-your-data) table for details on which models work with the Chat API.   /// Supports GPT-4, GPT-4o, GPT-5, and other models. For GPT-5 family: .gpt5, .gpt5Mini, .gpt5Nanopublicvarmodel:String   /// Whether or not to store the output of this chat completion request for use in our [model distillation](https://platform.openai.com/docs/guides/distillation) or [evals](https://platform.openai.com/docs/guides/evals) products.   /// Defaults to falsepublicvarstore:Bool?   /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim. Defaults to 0   /// [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/gpt/parameter-details)publicvarfrequencyPenalty:Double?   /// Controls how the model responds to function calls. none means the model does not call a function, and responds to the end-user. auto means the model can pick between an end-user or calling a function. Specifying a particular function via {"name": "my_function"} forces the model to call that function. none is the default when no functions are present. auto is the default if functions are present.@available(*, deprecated, message:"Deprecated in favor of tool_choice.")publicvarfunctionCall:FunctionCall?   /// Controls which (if any) function is called by the model. none means the model will not call a function and instead generates a message.    /// auto means the model can pick between generating a message or calling a function. Specifying a particular function via `{"type: "function", "function": {"name": "my_function"}}` forces the model to call that function.   /// `none` is the default when no functions are present. auto is the default if functions are present.publicvartoolChoice:ToolChoice?   /// A list of functions the model may generate JSON inputs for.@available(*, deprecated, message:"Deprecated in favor of tools.")publicvarfunctions:[ChatFunction]?   /// A list of tools the model may call. Currently, only functions are supported as a tool. Use this to provide a list of functions the model may generate JSON inputs for.publicvartools:[Tool]?   /// Whether to enable parallel function calling during tool use. Defaults to true.publicvarparallelToolCalls:Bool?   /// Modify the likelihood of specified tokens appearing in the completion.   /// Accepts a json object that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100. Mathematically, the bias is added to the logits generated by the model prior to sampling. The exact effect will vary per model, but values between -1 and 1 should decrease or increase likelihood of selection; values like -100 or 100 should result in a ban or exclusive selection of the relevant token. Defaults to null.publicvarlogitBias:[Int:Double]?   /// Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message. This option is currently not available on the gpt-4-vision-preview model. Defaults to false.publicvarlogprobs:Bool?   /// An integer between 0 and 5 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.publicvartopLogprobs:Int?   /// The maximum number of [tokens](https://platform.openai.com/tokenizer) that can be generated in the chat completion. This value can be used to control [costs](https://openai.com/api/pricing/) for text generated via API.   /// This value is now deprecated in favor of max_completion_tokens, and is not compatible with [o1 series models](https://platform.openai.com/docs/guides/reasoning)publicvarmaxTokens:Int?   /// An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and [reasoning tokens](https://platform.openai.com/docs/guides/reasoning)publicvarmaCompletionTokens:Int?   /// How many chat completion choices to generate for each input message. Defaults to 1.publicvarn:Int?   /// Output types that you would like the model to generate for this request. Most models are capable of generating text, which is the default:   /// ["text"]   ///The gpt-4o-audio-preview model can also be used to [generate audio](https://platform.openai.com/docs/guides/audio). To request that this model generate both text and audio responses, you can use:   /// ["text", "audio"]publicvarmodalities:[String]?   /// Parameters for audio output. Required when audio output is requested with modalities: ["audio"]. [Learn more.](https://platform.openai.com/docs/guides/audio)publicvaraudio:Audio?   /// Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics. Defaults to 0   /// [See more information about frequency and presence penalties.](https://platform.openai.com/docs/guides/gpt/parameter-details)publicvarpresencePenalty:Double?   /// An object specifying the format that the model must output. Used to enable JSON mode.   /// Setting to `{ type: "json_object" }` enables `JSON` mode, which guarantees the message the model generates is valid JSON.   ///Important: when using `JSON` mode you must still instruct the model to produce `JSON` yourself via some conversation message, for example via your system message. If you don't do this, the model may generate an unending stream of whitespace until the generation reaches the token limit, which may take a lot of time and give the appearance of a "stuck" request. Also note that the message content may be partial (i.e. cut off) if `finish_reason="length"`, which indicates the generation exceeded `max_tokens` or the conversation exceeded the max context length.publicvarresponseFormat:ResponseFormat?   /// Specifies the latency tier to use for processing the request. This parameter is relevant for customers subscribed to the scale tier service:   /// If set to 'auto', the system will utilize scale tier credits until they are exhausted.   /// If set to 'default', the request will be processed in the shared cluster.   /// When this parameter is set, the response body will include the service_tier utilized.publicvarserviceTier:String?   /// This feature is in `Beta`. If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same `seed` and parameters should return the same result.   /// Determinism is not guaranteed, and you should refer to the `system_fingerprint` response parameter to monitor changes in the backend.publicvarseed:Int?   /// Up to 4 sequences where the API will stop generating further tokens. Defaults to null.publicvarstop:[String]?   /// If set, partial message deltas will be sent, like in ChatGPT. Tokens will be sent as data-only [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#event_stream_format) as they become available, with the stream terminated by a data: [DONE] message. [Example Python code](https://cookbook.openai.com/examples/how_to_stream_completions ).   /// Defaults to false.varstream:Bool?=nil   /// Options for streaming response. Only set this when you set stream: truevarstreamOptions:StreamOptions?   /// What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.   /// We generally recommend altering this or `top_p` but not both. Defaults to 1.publicvartemperature:Double?   /// An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered.   /// We generally recommend altering this or `temperature` but not both. Defaults to 1publicvartopP:Double?   /// A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.   /// [Learn more](https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids).publicvaruser:String?publicstructMessage:Encodable{            /// The role of the messages author. One of system, user, assistant, or tool message.letrole:String      /// The contents of the message. content is required for all messages, and may be null for assistant messages with function calls.letcontent:ContentType      /// The name of the author of this message. name is required if role is function, and it should be the name of the function whose response is in the content. May contain a-z, A-Z, 0-9, and underscores, with a maximum length of 64 characters.letname:String?      /// The name and arguments of a function that should be called, as generated by the model.@available(*, deprecated, message:"Deprecated and replaced by `tool_calls`")letfunctionCall:FunctionCall?      /// The tool calls generated by the model, such as function calls.lettoolCalls:[ToolCall]?      /// Tool call that this message is responding to.lettoolCallID:String?publicenumContentType:Encodable{case text(String)case contentArray([MessageContent])publicfunc encode(to encoder:Encoder)throws{varcontainer= encoder.singleValueContainer()switchself{case.text(let text):try container.encode(text)case.contentArray(let contentArray):try container.encode(contentArray)}}publicenumMessageContent:Encodable,Equatable,Hashable{case text(String)case imageUrl(ImageDetail)publicstructImageDetail:Encodable,Equatable,Hashable{publicleturl:URLpublicletdetail:String?enumCodingKeys:String,CodingKey{case urlcase detail}publicfunc encode(to encoder:Encoder)throws{varcontainer= encoder.container(keyedBy:CodingKeys.self)try container.encode(url, forKey:.url)try container.encode(detail, forKey:.detail)}publicinit(url:URL, detail:String?=nil){self.url= urlself.detail= detail}}enumCodingKeys:String,CodingKey{case typecase textcase imageUrl="image_url"}publicfunc encode(to encoder:Encoder)throws{varcontainer= encoder.container(keyedBy:CodingKeys.self)switchself{case.text(let text):try container.encode("text", forKey:.type)try container.encode(text, forKey:.text)case.imageUrl(let imageDetail):try container.encode("image_url", forKey:.type)try container.encode(imageDetail, forKey:.imageUrl)}}publicfunc hash(into hasher:inoutHasher){switchself{case.text(let string):                  hasher.combine(string)case.imageUrl(let imageDetail):                  hasher.combine(imageDetail)}}publicstaticfunc==(lhs:MessageContent, rhs:MessageContent)->Bool{switch(lhs, rhs){caselet(.text(a),.text(b)):return a== bcaselet(.imageUrl(a),.imageUrl(b)):return a== bdefault:returnfalse}}}}publicenumRole:String{case system // content, rolecase user // content, rolecase assistant // content, role, tool_callscase tool // content, role, tool_call_id}enumCodingKeys:String,CodingKey{case rolecase contentcase namecase functionCall="function_call"case toolCalls="tool_calls"case toolCallID="tool_call_id"}publicinit(         role:Role,         content:ContentType,         name:String?=nil,         functionCall:FunctionCall?=nil,         toolCalls:[ToolCall]?=nil,         toolCallID:String?=nil){self.role= role.rawValueself.content= contentself.name= nameself.functionCall= functionCallself.toolCalls= toolCallsself.toolCallID= toolCallID}}@available(*, deprecated, message:"Deprecated in favor of ToolChoice.")publicenumFunctionCall:Encodable,Equatable{case nonecase autocase function(String)enumCodingKeys:String,CodingKey{case none="none"case auto="auto"case function="name"}publicfunc encode(to encoder:Encoder)throws{switchself{case.none:varcontainer= encoder.singleValueContainer()try container.encode(CodingKeys.none.rawValue)case.auto:varcontainer= encoder.singleValueContainer()try container.encode(CodingKeys.auto.rawValue)case.function(let name):varcontainer= encoder.container(keyedBy:CodingKeys.self)try container.encode(name, forKey:.function)}}}      /// [Documentation](https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools)publicstructTool:Encodable{            /// The type of the tool. Currently, only `function` is supported.lettype:String      /// objectletfunction:ChatFunctionpublicinit(         type:String="function",         function:ChatFunction){self.type= typeself.function= function}}publicstructChatFunction:Codable,Equatable{            /// The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.letname:String      /// A description of what the function does, used by the model to choose when and how to call the function.letdescription:String?      /// The parameters the functions accepts, described as a JSON Schema object. See the [guide](https://platform.openai.com/docs/guides/gpt/function-calling) for examples, and the [JSON Schema reference](https://json-schema.org/understanding-json-schema) for documentation about the format.      /// Omitting parameters defines a function with an empty parameter list.letparameters:JSONSchema?      /// Defaults to false, Whether to enable strict schema adherence when generating the function call. If set to true, the model will follow the exact schema defined in the parameters field. Only a subset of JSON Schema is supported when strict is true. Learn more about Structured Outputs in the [function calling guide].(https://platform.openai.com/docs/api-reference/chat/docs/guides/function-calling)letstrict:Bool?publicinit(         name:String,         strict:Bool?,         description:String?,         parameters:JSONSchema?){self.name= nameself.strict= strictself.description= descriptionself.parameters= parameters}}publicenumServiceTier:String,Encodable{      /// Specifies the latency tier to use for processing the request. This parameter is relevant for customers subscribed to the scale tier service:      /// If set to 'auto', the system will utilize scale tier credits until they are exhausted.      /// If set to 'default', the request will be processed in the shared cluster.      /// When this parameter is set, the response body will include the service_tier utilized.case autocase `default`}publicstructStreamOptions:Encodable{      /// If set, an additional chunk will be streamed before the data: [DONE] message.      /// The usage field on this chunk shows the token usage statistics for the entire request,      /// and the choices field will always be an empty array. All other chunks will also include      /// a usage field, but with a null value.letincludeUsage:BoolenumCodingKeys:String,CodingKey{case includeUsage="include_usage"}}      /// Parameters for audio output. Required when audio output is requested with modalities: ["audio"]   /// [Learn more.](https://platform.openai.com/docs/guides/audio)publicstructAudio:Encodable{      /// Specifies the voice type. Supported voices are alloy, echo, fable, onyx, nova, and shimmer.publicletvoice:String      /// Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.publicletformat:Stringpublicinit(         voice:String,         format:String){self.voice= voiceself.format= format}}enumCodingKeys:String,CodingKey{case messagescase modelcase storecase frequencyPenalty="frequency_penalty"case toolChoice="tool_choice"case functionCall="function_call"case toolscase parallelToolCalls="parallel_tool_calls"case functionscase logitBias="logit_bias"case logprobscase topLogprobs="top_logprobs"case maxTokens="max_tokens"case maCompletionTokens="max_completion_tokens"case ncase modalitiescase audiocase responseFormat="response_format"case presencePenalty="presence_penalty"case seedcase serviceTier="service_tier"case stopcase streamcase streamOptions="stream_options"case temperaturecase topP="top_p"case user}publicinit(      messages:[Message],      model:Model,      store:Bool?=nil,      frequencyPenalty:Double?=nil,      functionCall:FunctionCall?=nil,      toolChoice:ToolChoice?=nil,      functions:[ChatFunction]?=nil,      tools:[Tool]?=nil,      parallelToolCalls:Bool?=nil,      logitBias:[Int:Double]?=nil,      logProbs:Bool?=nil,      topLogprobs:Int?=nil,      maxTokens:Int?=nil,      n:Int?=nil,      modalities:[String]?=nil,      audio:Audio?=nil,      responseFormat:ResponseFormat?=nil,      presencePenalty:Double?=nil,      serviceTier:ServiceTier?=nil,      seed:Int?=nil,      stop:[String]?=nil,      temperature:Double?=nil,      topProbability:Double?=nil,      user:String?=nil){self.messages= messagesself.model= model.valueself.store= storeself.frequencyPenalty= frequencyPenaltyself.functionCall= functionCallself.toolChoice= toolChoiceself.functions= functionsself.tools= toolsself.parallelToolCalls= parallelToolCallsself.logitBias= logitBiasself.logprobs= logProbsself.topLogprobs= topLogprobsself.maxTokens= maxTokensself.n= nself.modalities= modalitiesself.audio= audioself.responseFormat= responseFormatself.presencePenalty= presencePenaltyself.serviceTier= serviceTier?.rawValueself.seed= seedself.stop= stopself.temperature= temperatureself.topP= topProbabilityself.user= user}}

Chat completion object

/// Represents a chat [completion](https://platform.openai.com/docs/api-reference/chat/object) response returned by model, based on the provided input.publicstructChatCompletionObject:Decodable{      /// A unique identifier for the chat completion.publicletid:String   /// A list of chat completion choices. Can be more than one if n is greater than 1.publicletchoices:[ChatChoice]   /// The Unix timestamp (in seconds) of when the chat completion was created.publicletcreated:Int   /// The model used for the chat completion.publicletmodel:String   /// The service tier used for processing the request. This field is only included if the service_tier parameter is specified in the request.publicletserviceTier:String?   /// This fingerprint represents the backend configuration that the model runs with.   /// Can be used in conjunction with the seed request parameter to understand when backend changes have been made that might impact determinism.publicletsystemFingerprint:String?   /// The object type, which is always chat.completion.publicletobject:String   /// Usage statistics for the completion request.publicletusage:ChatUsagepublicstructChatChoice:Decodable{            /// The reason the model stopped generating tokens. This will be stop if the model hit a natural stop point or a provided stop sequence, length if the maximum number of tokens specified in the request was reached, content_filter if content was omitted due to a flag from our content filters, tool_calls if the model called a tool, or function_call (deprecated) if the model called a function.publicletfinishReason:IntOrStringValue?      /// The index of the choice in the list of choices.publicletindex:Int      /// A chat completion message generated by the model.publicletmessage:ChatMessage         /// Log probability information for the choice.publicletlogprobs:LogProb?publicstructChatMessage:Decodable{                  /// The contents of the message.publicletcontent:String?         /// The tool calls generated by the model, such as function calls.publiclettoolCalls:[ToolCall]?         /// The name and arguments of a function that should be called, as generated by the model.@available(*, deprecated, message:"Deprecated and replaced by `tool_calls`")publicletfunctionCall:FunctionCall?         /// The role of the author of this message.publicletrole:String         /// Provided by the Vision API.publicletfinishDetails:FinishDetails?         /// The refusal message generated by the model.publicletrefusal:String?         /// If the audio output modality is requested, this object contains data about the audio response from the model. [Learn more](https://platform.openai.com/docs/guides/audio).publicletaudio:Audio?                  /// Provided by the Vision API.publicstructFinishDetails:Decodable{lettype:String}publicstructAudio:Decodable{            /// Unique identifier for this audio response.publicletid:String            /// The Unix timestamp (in seconds) for when this audio response will no longer be accessible on the server for use in multi-turn conversations.publicletexpiresAt:Int            /// Base64 encoded audio bytes generated by the model, in the format specified in the request.publicletdata:String            /// Transcript of the audio generated by the model.publiclettranscript:StringenumCodingKeys:String,CodingKey{case idcase expiresAt="expires_at"case datacase transcript}}}publicstructLogProb:Decodable{         /// A list of message content tokens with log probability information.letcontent:[TokenDetail]}publicstructTokenDetail:Decodable{         /// The token.lettoken:String         /// The log probability of this token.letlogprob:Double         /// A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be null if there is no bytes representation for the token.letbytes:[Int]?         /// List of the most likely tokens and their log probability, at this token position. In rare cases, there may be fewer than the number of requested top_logprobs returned.lettopLogprobs:[TopLogProb]enumCodingKeys:String,CodingKey{case token, logprob, bytescase topLogprobs="top_logprobs"}structTopLogProb:Decodable{            /// The token.lettoken:String            /// The log probability of this token.letlogprob:Double            /// A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be null if there is no bytes representation for the token.letbytes:[Int]?}}}publicstructChatUsage:Decodable{            /// Number of tokens in the generated completion.publicletcompletionTokens:Int      /// Number of tokens in the prompt.publicletpromptTokens:Int      /// Total number of tokens used in the request (prompt + completion).publiclettotalTokens:Int}}

letprompt="Tell me a joke"letparameters=ChatCompletionParameters(messages:[.init(role:.user, content:.text(prompt))], model:.gpt4o)letchatCompletionObject= service.startChat(parameters: parameters)

Chat completion chunk object

/// Represents a [streamed](https://platform.openai.com/docs/api-reference/chat/streaming) chunk of a chat completion response returned by model, based on the provided input.publicstructChatCompletionChunkObject:Decodable{      /// A unique identifier for the chat completion chunk.publicletid:String   /// A list of chat completion choices. Can be more than one if n is greater than 1.publicletchoices:[ChatChoice]   /// The Unix timestamp (in seconds) of when the chat completion chunk was created.publicletcreated:Int   /// The model to generate the completion.publicletmodel:String   /// The service tier used for processing the request. This field is only included if the service_tier parameter is specified in the request.publicletserviceTier:String?   /// This fingerprint represents the backend configuration that the model runs with.   /// Can be used in conjunction with the seed request parameter to understand when backend changes have been made that might impact determinism.publicletsystemFingerprint:String?   /// The object type, which is always chat.completion.chunk.publicletobject:StringpublicstructChatChoice:Decodable{            /// A chat completion delta generated by streamed model responses.publicletdelta:Delta      /// The reason the model stopped generating tokens. This will be stop if the model hit a natural stop point or a provided stop sequence, length if the maximum number of tokens specified in the request was reached, content_filter if content was omitted due to a flag from our content filters, tool_calls if the model called a tool, or function_call (deprecated) if the model called a function.publicletfinishReason:IntOrStringValue?      /// The index of the choice in the list of choices.publicletindex:Int      /// Provided by the Vision API.publicletfinishDetails:FinishDetails?publicstructDelta:Decodable{                  /// The contents of the chunk message.publicletcontent:String?         /// The tool calls generated by the model, such as function calls.publiclettoolCalls:[ToolCall]?         /// The name and arguments of a function that should be called, as generated by the model.@available(*, deprecated, message:"Deprecated and replaced by `tool_calls`")publicletfunctionCall:FunctionCall?         /// The role of the author of this message.publicletrole:String?}publicstructLogProb:Decodable{         /// A list of message content tokens with log probability information.letcontent:[TokenDetail]}publicstructTokenDetail:Decodable{         /// The token.lettoken:String         /// The log probability of this token.letlogprob:Double         /// A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be null if there is no bytes representation for the token.letbytes:[Int]?         /// List of the most likely tokens and their log probability, at this token position. In rare cases, there may be fewer than the number of requested top_logprobs returned.lettopLogprobs:[TopLogProb]enumCodingKeys:String,CodingKey{case token, logprob, bytescase topLogprobs="top_logprobs"}structTopLogProb:Decodable{            /// The token.lettoken:String            /// The log probability of this token.letlogprob:Double            /// A list of integers representing the UTF-8 bytes representation of the token. Useful in instances where characters are represented by multiple tokens and their byte representations must be combined to generate the correct text representation. Can be null if there is no bytes representation for the token.letbytes:[Int]?}}            /// Provided by the Vision API.publicstructFinishDetails:Decodable{lettype:String}}}

letprompt="Tell me a joke"letparameters=ChatCompletionParameters(messages:[.init(role:.user, content:.text(prompt))], model:.gpt4o)letchatCompletionObject=tryawait service.startStreamedChat(parameters: parameters)

Function Calling

publicstructToolCall:Codable{publicletindex:Int   /// The ID of the tool call.publicletid:String?   /// The type of the tool. Currently, only `function` is supported.publiclettype:String?   /// The function that the model called.publicletfunction:FunctionCallpublicinit(      index:Int,      id:String,      type:String="function",      function:FunctionCall){self.index= indexself.id= idself.type= typeself.function= function}}publicstructFunctionCall:Codable{   /// The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function.letarguments:String   /// The name of the function to call.letname:Stringpublicinit(      arguments:String,      name:String){self.arguments= argumentsself.name= name}}

/// Define a `ToolCall`vartool:ToolCall{.init(      type:"function", // The type of the tool. Currently, only "function" is supported.      function:.init(         name:"create_image",         description:"Call this function if the request asks to generate an image",         parameters:.init(            type:.object,            properties:["prompt":.init(type:.string, description:"The exact prompt passed in."),"count":.init(type:.integer, description:"The number of images requested")],            required:["prompt","count"])))}letprompt="Show me an image of an unicorn eating ice cream"letcontent:ChatCompletionParameters.Message.ContentType=.text(prompt)letparameters=ChatCompletionParameters(messages:[.init(role:.user, content: content)], model:.gpt41106Preview, tools:[tool])letchatCompletionObject=tryawait service.startStreamedChat(parameters: parameters)

Structured Outputs

Documentation:

How to use Structured Outputs in SwiftOpenAI

{"schema": {"type":"object","properties": {"steps": {"type":"array","items": {"type":"object","properties": {"explanation": {"type":"string"            },"output": {"type":"string"            }          },"required": ["explanation","output"],"additionalProperties":false        }      },"final_answer": {"type":"string"      }    },"required": ["steps","final_answer"],"additionalProperties":false  }}

// 1: Define the Step schema objectletstepSchema=JSONSchema(   type:.object,   properties:["explanation":JSONSchema(type:.string),"output":JSONSchema(         type:.string)],   required:["explanation","output"],   additionalProperties:false)// 2. Define the steps Array schema.letstepsArraySchema=JSONSchema(type:.array, items: stepSchema)// 3. Define the final Answer schema.letfinalAnswerSchema=JSONSchema(type:.string)// 4. Define math reponse JSON schema.letmathResponseSchema=JSONSchema(      type:.object,      properties:["steps": stepsArraySchema,"final_answer": finalAnswerSchema],      required:["steps","final_answer"],      additionalProperties:false)lettool=ChatCompletionParameters.Tool(            function:.init(               name:"math_response",               strict:true,               parameters: mathResponseSchema)))letprompt="solve 8x + 31 = 2"letsystemMessage=ChatCompletionParameters.Message(role:.system, content:.text("You are a math tutor"))letuserMessage=ChatCompletionParameters.Message(role:.user, content:.text(prompt))letparameters=ChatCompletionParameters(   messages:[systemMessage, userMessage],   model:.gpt4o20240806,   tools:[tool])letchat=tryawait service.startChat(parameters: parameters)

// 1: Define the Step schema objectletstepSchema=JSONSchema(   type:.object,   properties:["explanation":JSONSchema(type:.string),"output":JSONSchema(         type:.string)],   required:["explanation","output"],   additionalProperties:false)// 2. Define the steps Array schema.letstepsArraySchema=JSONSchema(type:.array, items: stepSchema)// 3. Define the final Answer schema.letfinalAnswerSchema=JSONSchema(type:.string)// 4. Define the response format JSON schema.letresponseFormatSchema=JSONSchemaResponseFormat(   name:"math_response",   strict:true,   schema:JSONSchema(      type:.object,      properties:["steps": stepsArraySchema,"final_answer": finalAnswerSchema],      required:["steps","final_answer"],      additionalProperties:false))letprompt="solve 8x + 31 = 2"letsystemMessage=ChatCompletionParameters.Message(role:.system, content:.text("You are a math tutor"))letuserMessage=ChatCompletionParameters.Message(role:.user, content:.text(prompt))letparameters=ChatCompletionParameters(   messages:[systemMessage, userMessage],   model:.gpt4o20240806,   responseFormat:.jsonSchema(responseFormatSchema))

Vision

letimageURL="https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"letprompt="What is this?"letmessageContent:[ChatCompletionParameters.Message.ContentType.MessageContent]=[.text(prompt),.imageUrl(.init(url: imageURL)] // Users can add as many `.imageUrl` instances to the service.letparameters=ChatCompletionParameters(messages:[.init(role:.user, content:.contentArray(messageContent))], model:.gpt4o)letchatCompletionObject=tryawait service.startStreamedChat(parameters: parameters)

Response

ModelResponseParameter

letparameters=ModelResponseParameter(    input:.text("What is the answer to life, the universe, and everything?"),    model:.gpt5,  // Support for GPT-5, GPT-5-mini, GPT-5-nano    text:TextConfiguration(        format:.text,        verbosity:"low"  // NEW: Control response verbosity ("low", "medium", "high")),    temperature:0.7)letresponse=tryawait service.responseCreate(parameters)

Available GPT-5 Models

publicenumModel{case gpt5        // Complex reasoning, broad world knowledge, and code-heavy or multi-step agentic taskscase gpt5Mini    // Cost-optimized reasoning and chat; balances speed, cost, and capabilitycase gpt5Nano    // High-throughput tasks, especially simple instruction-following or classification    // ... other models}

TextConfiguration with Verbosity

// Create a text configuration with verbosity controllettextConfig=TextConfiguration(    format:.text,       // Can be .text, .jsonObject, or .jsonSchema    verbosity:"medium"  // Controls response detail level)

/// [Creates a model response.](https://platform.openai.com/docs/api-reference/responses/create)publicstructModelResponseParameter:Codable{   /// Text, image, or file inputs to the model, used to generate a response.   /// A text input to the model, equivalent to a text input with the user role.   /// A list of one or many input items to the model, containing different content types.publicvarinput:InputType   /// Model ID used to generate the response, like gpt-4o or o1. OpenAI offers a wide range of models with   /// different capabilities, performance characteristics, and price points.   /// Refer to the model guide to browse and compare available models.publicvarmodel:String   /// Specify additional output data to include in the model response. Currently supported values are:   /// file_search_call.results : Include the search results of the file search tool call.   /// message.input_image.image_url : Include image urls from the input message.   /// computer_call_output.output.image_url : Include image urls from the computer call output.publicvarinclude:[String]?   /// Inserts a system (or developer) message as the first item in the model's context.   /// When using along with previous_response_id, the instructions from a previous response will be not be   /// carried over to the next response. This makes it simple to swap out system (or developer) messages in new responses.publicvarinstructions:String?   /// An upper bound for the number of tokens that can be generated for a response, including visible output tokens   /// and reasoning tokens.publicvarmaxOutputTokens:Int?   /// Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information   /// about the object in a structured format, and querying for objects via API or the dashboard.   /// Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.publicvarmetadata:[String:String]?   /// Whether to allow the model to run tool calls in parallel.   /// Defaults to truepublicvarparallelToolCalls:Bool?   /// The unique ID of the previous response to the model. Use this to create multi-turn conversations.   /// Learn more about conversation state.publicvarpreviousResponseId:String?   /// o-series models only   /// Configuration options for reasoning models.publicvarreasoning:Reasoning?   /// Whether to store the generated model response for later retrieval via API.   /// Defaults to truepublicvarstore:Bool?   /// If set to true, the model response data will be streamed to the client as it is generated using server-sent events.publicvarstream:Bool?   /// What sampling temperature to use, between 0 and 2.   /// Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.   /// We generally recommend altering this or top_p but not both.   /// Defaults to 1publicvartemperature:Double?   /// Configuration options for a text response from the model. Can be plain text or structured JSON data.publicvartext:TextConfiguration?   /// How the model should select which tool (or tools) to use when generating a response.   /// See the tools parameter to see how to specify which tools the model can call.publicvartoolChoice:ToolChoiceMode?   /// An array of tools the model may call while generating a response. You can specify which tool to use by setting the tool_choice parameter.publicvartools:[Tool]?   /// An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.   /// So 0.1 means only the tokens comprising the top 10% probability mass are considered.   /// We generally recommend altering this or temperature but not both.   /// Defaults to 1publicvartopP:Double?   /// The truncation strategy to use for the model response.   /// Defaults to disabledpublicvartruncation:String?   /// A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.publicvaruser:String?}

/// The Response object returned when retrieving a model responsepublicstructResponseModel:Decodable{   /// Unix timestamp (in seconds) of when this Response was created.publicletcreatedAt:Int   /// An error object returned when the model fails to generate a Response.publicleterror:ErrorObject?   /// Unique identifier for this Response.publicletid:String   /// Details about why the response is incomplete.publicletincompleteDetails:IncompleteDetails?   /// Inserts a system (or developer) message as the first item in the model's context.publicletinstructions:String?   /// An upper bound for the number of tokens that can be generated for a response, including visible output tokens   /// and reasoning tokens.publicletmaxOutputTokens:Int?   /// Set of 16 key-value pairs that can be attached to an object.publicletmetadata:[String:String]   /// Model ID used to generate the response, like gpt-4o or o1.publicletmodel:String   /// The object type of this resource - always set to response.publicletobject:String   /// An array of content items generated by the model.publicletoutput:[OutputItem]   /// Whether to allow the model to run tool calls in parallel.publicletparallelToolCalls:Bool   /// The unique ID of the previous response to the model. Use this to create multi-turn conversations.publicletpreviousResponseId:String?   /// Configuration options for reasoning models.publicletreasoning:Reasoning?   /// The status of the response generation. One of completed, failed, in_progress, or incomplete.publicletstatus:String   /// What sampling temperature to use, between 0 and 2.publiclettemperature:Double?   /// Configuration options for a text response from the model.publiclettext:TextConfiguration   /// How the model should select which tool (or tools) to use when generating a response.publiclettoolChoice:ToolChoiceMode   /// An array of tools the model may call while generating a response.publiclettools:[Tool]   /// An alternative to sampling with temperature, called nucleus sampling.publiclettopP:Double?   /// The truncation strategy to use for the model response.publiclettruncation:String?   /// Represents token usage details.publicletusage:Usage?   /// A unique identifier representing your end-user.publicletuser:String?      /// Convenience property that aggregates all text output from output_text items in the output array.   /// Similar to the outputText property in Python and JavaScript SDKs.publicvaroutputText:String?}

// InputType represents the input to the Response APIpublicenumInputType:Codable{case string(String)  // Simple text inputcase array([InputItem])  // Array of input items for complex conversations}// InputItem represents different types of inputpublicenumInputItem:Codable{case message(InputMessage)  // User, assistant, system messagescase functionToolCall(FunctionToolCall)  // Function callscase functionToolCallOutput(FunctionToolCallOutput)  // Function outputs    // ... other input types}// InputMessage structure with support for response IDspublicstructInputMessage:Codable{publicletrole:String  // "user", "assistant", "system"publicletcontent:MessageContentpubliclettype:String?  // Always "message"publicletstatus:String?  // "completed" for assistant messagespublicletid:String?  // Response ID for assistant messages}// MessageContent can be text or array of content itemspublicenumMessageContent:Codable{case text(String)case array([ContentItem])  // For multimodal content}

letprompt="What is the capital of France?"letparameters=ModelResponseParameter(input:.string(prompt), model:.gpt4o)letresponse=tryawait service.responseCreate(parameters)

letprompt="How much wood would a woodchuck chuck?"letparameters=ModelResponseParameter(    input:.string(prompt),    model:.o3Mini,    reasoning:Reasoning(effort:"high"))letresponse=tryawait service.responseCreate(parameters)

lettextPrompt="What is in this image?"letimageUrl="https://example.com/path/to/image.jpg"letimageContent=ContentItem.imageUrl(ImageUrlContent(imageUrl: imageUrl))lettextContent=ContentItem.text(TextContent(text: textPrompt))letmessage=InputItem(role:"user", content:[textContent, imageContent])letparameters=ModelResponseParameter(input:.array([message]), model:.gpt4o)letresponse=tryawait service.responseCreate(parameters)

letprompt="What was a positive news story from today?"letparameters=ModelResponseParameter(    input:.string(prompt),    model:.gpt4o,    tools:[Tool(type:"web_search_preview", function:nil)])letresponse=tryawait service.responseCreate(parameters)

letprompt="What are the key points in the document?"letparameters=ModelResponseParameter(    input:.string(prompt),    model:.gpt4o,    tools:[Tool(            type:"file_search",            function:ChatCompletionParameters.ChatFunction(                name:"file_search",                strict:false,                description:"Search through files",                parameters:JSONSchema(                    type:.object,                    properties:["vector_store_ids":JSONSchema(                            type:.array,                            items:JSONSchema(type:.string)),"max_num_results":JSONSchema(type:.integer)],                    required:["vector_store_ids"],                    additionalProperties:false)))])letresponse=tryawait service.responseCreate(parameters)

letprompt="What is the weather like in Boston today?"letparameters=ModelResponseParameter(    input:.string(prompt),    model:.gpt4o,    tools:[Tool(            type:"function",            function:ChatCompletionParameters.ChatFunction(                name:"get_current_weather",                strict:false,                description:"Get the current weather in a given location",                parameters:JSONSchema(                    type:.object,                    properties:["location":JSONSchema(                            type:.string,                            description:"The city and state, e.g. San Francisco, CA"),"unit":JSONSchema(                            type:.string,                            enum:["celsius","fahrenheit"])],                    required:["location","unit"],                    additionalProperties:false)))],    toolChoice:.auto)letresponse=tryawait service.responseCreate(parameters)

letresponseId="resp_abc123"letresponse=tryawait service.responseModel(id: responseId)

Streaming Responses

// The ResponseStreamEvent enum represents all possible streaming eventspublicenumResponseStreamEvent:Decodable{case responseCreated(ResponseCreatedEvent)case responseInProgress(ResponseInProgressEvent)case responseCompleted(ResponseCompletedEvent)case responseFailed(ResponseFailedEvent)case outputItemAdded(OutputItemAddedEvent)case outputTextDelta(OutputTextDeltaEvent)case outputTextDone(OutputTextDoneEvent)case functionCallArgumentsDelta(FunctionCallArgumentsDeltaEvent)case reasoningSummaryTextDelta(ReasoningSummaryTextDeltaEvent)case error(ErrorEvent)  // ... and many more event types}

// Enable streaming by setting stream: trueletparameters=ModelResponseParameter(    input:.string("Tell me a story"),    model:.gpt4o,    stream:true)// Create a streamletstream=tryawait service.responseCreateStream(parameters)// Process events as they arrivefortryawaiteventin stream{switch event{case.outputTextDelta(let delta):        // Append text chunk to your UIprint(delta.delta, terminator:"")case.responseCompleted(let completed):        // Response is completeprint("\nResponse ID:\(completed.response.id)")case.error(let error):        // Handle errorsprint("Error:\(error.message)")default:        // Handle other events as neededbreak}}

// Maintain conversation continuity with previousResponseIdvarpreviousResponseId:String?=nilvarmessages:[(role:String, content:String)]=[]// First messageletfirstParams=ModelResponseParameter(    input:.string("Hello!"),    model:.gpt4o,    stream:true)letfirstStream=tryawait service.responseCreateStream(firstParams)varfirstResponse=""fortryawaiteventin firstStream{switch event{case.outputTextDelta(let delta):        firstResponse+= delta.deltacase.responseCompleted(let completed):        previousResponseId= completed.response.id        messages.append((role:"user", content:"Hello!"))        messages.append((role:"assistant", content: firstResponse))default:break}}// Follow-up message with conversation contextvarinputArray:[InputItem]=[]// Add conversation historyformessagein messages{    inputArray.append(.message(InputMessage(        role: message.role,        content:.text(message.content))))}// Add new user messageinputArray.append(.message(InputMessage(    role:"user",    content:.text("How are you?"))))letfollowUpParams=ModelResponseParameter(    input:.array(inputArray),    model:.gpt4o,    previousResponseId: previousResponseId,    stream:true)letfollowUpStream=tryawait service.responseCreateStream(followUpParams)// Process the follow-up stream...

letparameters=ModelResponseParameter(    input:.string("What's the weather in San Francisco?"),    model:.gpt4o,    tools:[Tool(            type:"function",            function:ChatCompletionParameters.ChatFunction(                name:"get_weather",                description:"Get current weather",                parameters:JSONSchema(                    type:.object,                    properties:["location":JSONSchema(type:.string)],                    required:["location"])))],    stream:true)letstream=tryawait service.responseCreateStream(parameters)varfunctionCallArguments=""fortryawaiteventin stream{switch event{case.functionCallArgumentsDelta(let delta):        // Accumulate function call arguments        functionCallArguments+= delta.deltacase.functionCallArgumentsDone(let done):        // Function call is completeprint("Function:\(done.name)")print("Arguments:\(functionCallArguments)")case.outputTextDelta(let delta):        // Regular text outputprint(delta.delta, terminator:"")default:break}}

// Streams can be canceled using Swift's task cancellationletstreamTask=Task{letstream=tryawait service.responseCreateStream(parameters)fortryawaiteventin stream{        // Check if task is cancelledifTask.isCancelled{break}                // Process events...}}// Cancel the stream when neededstreamTask.cancel()

@MainActor@ObservableclassResponseStreamProvider{varmessages:[Message]=[]varisStreaming=falsevarerror:String?privateletservice:OpenAIServiceprivatevarpreviousResponseId:String?privatevarstreamTask:Task<Void,Never>?init(service:OpenAIService){self.service= service}func sendMessage(_ text:String){        streamTask?.cancel()                // Add user message        messages.append(Message(role:.user, content: text))                // Start streaming        streamTask=Task{awaitstreamResponse(for: text)}}privatefunc streamResponse(for userInput:String)async{        isStreaming=true        error=nil                // Create streaming message placeholderletstreamingMessage=Message(role:.assistant, content:"", isStreaming:true)        messages.append(streamingMessage)do{            // Build conversation historyvarinputArray:[InputItem]=[]formessagein messages.dropLast(2){                inputArray.append(.message(InputMessage(                    role: message.role.rawValue,                    content:.text(message.content))))}            inputArray.append(.message(InputMessage(                role:"user",                content:.text(userInput))))letparameters=ModelResponseParameter(                input:.array(inputArray),                model:.gpt4o,                previousResponseId: previousResponseId,                stream:true)letstream=tryawait service.responseCreateStream(parameters)varaccumulatedText=""fortryawaiteventin stream{guard !Task.isCancelledelse{break}switch event{case.outputTextDelta(let delta):                    accumulatedText+= delta.deltaupdateStreamingMessage(with: accumulatedText)case.responseCompleted(let completed):                    previousResponseId= completed.response.idfinalizeStreamingMessage(with: accumulatedText, responseId: completed.response.id)case.error(let errorEvent):throwAPIError.requestFailed(description: errorEvent.message)default:break}}}catch{self.error= error.localizedDescription            messages.removeLast() // Remove streaming message on error}                isStreaming=false}privatefunc updateStreamingMessage(with content:String){iflet index= messages.lastIndex(where:{ $0.isStreaming}){messages[index].content= content}}privatefunc finalizeStreamingMessage(with content:String, responseId:String){iflet index= messages.lastIndex(where:{ $0.isStreaming}){messages[index].content= contentmessages[index].isStreaming=falsemessages[index].responseId= responseId}}}

Embeddings

/// [Creates](https://platform.openai.com/docs/api-reference/embeddings/create) an embedding vector representing the input text.publicstructEmbeddingParameter:Encodable{      /// ID of the model to use. You can use the List models API to see all of your available models, or see our [Model overview ](https://platform.openai.com/docs/models/overview) for descriptions of them.letmodel:String   /// Input text to embed, encoded as a string or array of tokens. To embed multiple inputs in a single request, pass an array of strings or an array of token arrays. Each input must not exceed the max input tokens for the model (8191 tokens for text-embedding-ada-002) and cannot be an empty string. [How to Count Tokens with `tiktoken`](https://cookbook.openai.com/examples/how_to_count_tokens_with_tiktoken)letinput:String      /// A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse. [Learn more.](https://platform.openai.com/docs/guides/safety-best-practices/end-user-ids)letuser:String?publicenumModel:String{case textEmbeddingAda002="text-embedding-ada-002"}publicinit(      model:Model=.textEmbeddingAda002,      input:String,      user:String?=nil){self.model= model.valueself.input= inputself.user= user}}

/// [Represents an embedding vector returned by embedding endpoint.](https://platform.openai.com/docs/api-reference/embeddings/object)publicstructEmbeddingObject:Decodable{      /// The object type, which is always "embedding".publicletobject:String   /// The embedding vector, which is a list of floats. The length of vector depends on the model as listed in the embedding guide.[https://platform.openai.com/docs/guides/embeddings]publicletembedding:[Float]   /// The index of the embedding in the list of embeddings.publicletindex:Int}

letprompt="Hello world."letembeddingObjects=tryawait service.createEmbeddings(parameters: parameters).data

Fine-tuning

/// [Creates a job](https://platform.openai.com/docs/api-reference/fine-tuning/create) that fine-tunes a specified model from a given dataset.///Response includes details of the enqueued job including job status and the name of the fine-tuned models once complete.publicstructFineTuningJobParameters:Encodable{      /// The name of the model to fine-tune. You can select one of the [supported models](https://platform.openai.com/docs/models/overview).letmodel:String   /// The ID of an uploaded file that contains training data.   /// See [upload file](https://platform.openai.com/docs/api-reference/files/upload) for how to upload a file.   /// Your dataset must be formatted as a JSONL file. Additionally, you must upload your file with the purpose fine-tune.   /// See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning) for more details.lettrainingFile:String   /// The hyperparameters used for the fine-tuning job.lethyperparameters:HyperParameters?   /// A string of up to 18 characters that will be added to your fine-tuned model name.   /// For example, a suffix of "custom-model-name" would produce a model name like ft:gpt-3.5-turbo:openai:custom-model-name:7p4lURel.   /// Defaults to null.letsuffix:String?   /// The ID of an uploaded file that contains validation data.   /// If you provide this file, the data is used to generate validation metrics periodically during fine-tuning. These metrics can be viewed in the fine-tuning results file. The same data should not be present in both train and validation files.   /// Your dataset must be formatted as a JSONL file. You must upload your file with the purpose fine-tune.   /// See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning) for more details.letvalidationFile:String?   /// A list of integrations to enable for your fine-tuning job.letintegrations:[Integration]?   /// The seed controls the reproducibility of the job. Passing in the same seed and job parameters should produce the same results, but may differ in rare cases. If a seed is not specified, one will be generated for you.letseed:Int?      /// Fine-tuning is [currently available](https://platform.openai.com/docs/guides/fine-tuning/what-models-can-be-fine-tuned) for the following models:   /// gpt-3.5-turbo-0613 (recommended)   /// babbage-002   /// davinci-002   /// OpenAI expects gpt-3.5-turbo to be the right model for most users in terms of results and ease of use, unless you are migrating a legacy fine-tuned model.publicenumModel:String{case gpt35="gpt-3.5-turbo-0613" /// recommendedcase babbage002="babbage-002"case davinci002="davinci-002"}publicstructHyperParameters:Encodable{      /// The number of epochs to train the model for. An epoch refers to one full cycle through the training dataset.      /// Defaults to auto.letnEpochs:Int?publicinit(         nEpochs:Int?){self.nEpochs= nEpochs}}publicinit(      model:Model,      trainingFile:String,      hyperparameters:HyperParameters?=nil,      suffix:String?=nil,      validationFile:String?=nil){self.model= model.rawValueself.trainingFile= trainingFileself.hyperparameters= hyperparametersself.suffix= suffixself.validationFile= validationFile}}

/// The fine_tuning.job object represents a [fine-tuning job](https://platform.openai.com/docs/api-reference/fine-tuning/object) that has been created through the API.publicstructFineTuningJobObject:Decodable{      /// The object identifier, which can be referenced in the API endpoints.publicletid:String   /// The Unix timestamp (in seconds) for when the fine-tuning job was created.publicletcreatedAt:Int  /// For fine-tuning jobs that have failed, this will contain more information on the cause of the failure.publicleterror:OpenAIErrorResponse.Error?   /// The name of the fine-tuned model that is being created. The value will be null if the fine-tuning job is still running.publicletfineTunedModel:String?   /// The Unix timestamp (in seconds) for when the fine-tuning job was finished. The value will be null if the fine-tuning job is still running.publicletfinishedAt:Int?   /// The hyperparameters used for the fine-tuning job. See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)  for more details.publiclethyperparameters:HyperParameters   /// The base model that is being fine-tuned.publicletmodel:String   /// The object type, which is always "fine_tuning.job".publicletobject:String   /// The organization that owns the fine-tuning job.publicletorganizationId:String   /// The compiled results file ID(s) for the fine-tuning job. You can retrieve the results with the [Files API](https://platform.openai.com/docs/api-reference/files/retrieve-contents).publicletresultFiles:[String]   /// The current status of the fine-tuning job, which can be either `validating_files`, `queued`, `running`, `succeeded`, `failed`, or `cancelled`.publicletstatus:String   /// The total number of billable tokens processed by this fine-tuning job. The value will be null if the fine-tuning job is still running.publiclettrainedTokens:Int?      /// The file ID used for training. You can retrieve the training data with the [Files API](https://platform.openai.com/docs/api-reference/files/retrieve-contents).publiclettrainingFile:String   /// The file ID used for validation. You can retrieve the validation results with the [Files API](https://platform.openai.com/docs/api-reference/files/retrieve-contents).publicletvalidationFile:String?publicenumStatus:String{case validatingFiles="validating_files"case queuedcase runningcase succeededcase failedcase cancelled}publicstructHyperParameters:Decodable{      /// The number of epochs to train the model for. An epoch refers to one full cycle through the training dataset. "auto" decides the optimal number of epochs based on the size of the dataset. If setting the number manually, we support any number between 1 and 50 epochs.publicletnEpochs:IntOrStringValue}}

letfineTuningJobs=tryawait service.istFineTuningJobs()

lettrainingFileID="file-Atc9okK0MOuQwQzDJCZXnrh6" // The id of the file that has been uploaded using the `Files` API. https://platform.openai.com/docs/api-reference/fine-tuning/create#fine-tuning/create-training_fileletparameters=FineTuningJobParameters(model:.gpt35, trainingFile: trainingFileID)letfineTuningJob=tryawait service.createFineTuningJob(parameters: parameters)

letfineTuningJobID="ftjob-abc123"letfineTuningJob=tryawait service.retrieveFineTuningJob(id: fineTuningJobID)

letfineTuningJobID="ftjob-abc123"letcanceledFineTuningJob=tryawait service.cancelFineTuningJobWith(id: fineTuningJobID)

Fine-tuning job event object

/// [Fine-tuning job event object](https://platform.openai.com/docs/api-reference/fine-tuning/event-object)publicstructFineTuningJobEventObject:Decodable{publicletid:StringpublicletcreatedAt:Intpublicletlevel:Stringpublicletmessage:Stringpublicletobject:Stringpubliclettype:String?publicletdata:Data?publicstructData:Decodable{publicletstep:IntpubliclettrainLoss:DoublepubliclettrainMeanTokenAccuracy:Double}}

letfineTuningJobID="ftjob-abc123"letjobEvents=tryawait service.listFineTuningEventsForJobWith(id: id, after:nil, limit:nil).data

Batch

publicstructBatchParameter:Encodable{      /// The ID of an uploaded file that contains requests for the new batch.   /// See [upload file](https://platform.openai.com/docs/api-reference/files/create) for how to upload a file.   /// Your input file must be formatted as a [JSONL file](https://platform.openai.com/docs/api-reference/batch/requestInput), and must be uploaded with the purpose batch.letinputFileID:String   /// The endpoint to be used for all requests in the batch. Currently only /v1/chat/completions is supported.letendpoint:String   /// The time frame within which the batch should be processed. Currently only 24h is supported.letcompletionWindow:String   /// Optional custom metadata for the batch.letmetadata:[String:String]?enumCodingKeys:String,CodingKey{case inputFileID="input_file_id"case endpointcase completionWindow="completion_window"case metadata}}

publicstructBatchObject:Decodable{letid:String   /// The object type, which is always batch.letobject:String   /// The OpenAI API endpoint used by the batch.letendpoint:Stringleterrors:Error   /// The ID of the input file for the batch.letinputFileID:String   /// The time frame within which the batch should be processed.letcompletionWindow:String   /// The current status of the batch.letstatus:String   /// The ID of the file containing the outputs of successfully executed requests.letoutputFileID:String   /// The ID of the file containing the outputs of requests with errors.leterrorFileID:String   /// The Unix timestamp (in seconds) for when the batch was created.letcreatedAt:Int   /// The Unix timestamp (in seconds) for when the batch started processing.letinProgressAt:Int   /// The Unix timestamp (in seconds) for when the batch will expire.letexpiresAt:Int   /// The Unix timestamp (in seconds) for when the batch started finalizing.letfinalizingAt:Int   /// The Unix timestamp (in seconds) for when the batch was completed.letcompletedAt:Int   /// The Unix timestamp (in seconds) for when the batch failed.letfailedAt:Int   /// The Unix timestamp (in seconds) for when the batch expired.letexpiredAt:Int   /// The Unix timestamp (in seconds) for when the batch started cancelling.letcancellingAt:Int   /// The Unix timestamp (in seconds) for when the batch was cancelled.letcancelledAt:Int   /// The request counts for different statuses within the batch.letrequestCounts:RequestCount   /// Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format. Keys can be a maximum of 64 characters long and values can be a maxium of 512 characters long.letmetadata:[String:String]publicstructError:Decodable{letobject:Stringletdata:[Data]publicstructData:Decodable{                  /// An error code identifying the error type.letcode:String         /// A human-readable message providing more details about the error.letmessage:String         /// The name of the parameter that caused the error, if applicable.letparam:String?         /// The line number of the input file where the error occurred, if applicable.letline:Int?}}publicstructRequestCount:Decodable{            /// Total number of requests in the batch.lettotal:Int      /// Number of requests that have been completed successfully.letcompleted:Int      /// Number of requests that have failed.letfailed:Int}}

letinputFileID="file-abc123"letendpoint="/v1/chat/completions"letcompletionWindow="24h"letparameter=BatchParameter(inputFileID: inputFileID, endpoint: endpoint, completionWindow: completionWindow, metadata:nil)letbatch=tryawait service.createBatch(parameters: parameters)

letbatchID="batch_abc123"letbatch=tryawait service.retrieveBatch(id: batchID)