Installation 🚀

"io.cequence" %% "openai-scala-client" % "1.3.0.RC.1"

<dependency>    <groupId>io.cequence</groupId>    <artifactId>openai-scala-client_2.12</artifactId>    <version>1.3.0.RC.1</version></dependency>

Config ⚙️

Usage 👨‍🎓

implicitvalec=ExecutionContext.globalimplicitvalmaterializer=Materializer(ActorSystem())

valservice=OpenAIServiceFactory()

valconfig=ConfigFactory.load("path_to_my_custom_config")valservice=OpenAIServiceFactory(config)

valservice=OpenAIServiceFactory(     apiKey="your_api_key",     orgId=Some("your_org_id")// if you have one  )

valservice=OpenAIServiceFactory.forAzureWithApiKey(    resourceName="your-resource-name",    deploymentId="your-deployment-id",// usually model name such as "gpt-35-turbo"    apiVersion="2023-05-15",// newest version    apiKey="your_api_key"  )

valservice=OpenAICoreServiceFactory("http://localhost:8000/v1/")

valservice=OpenAIChatCompletionServiceFactory.forAzureAI(    endpoint= sys.env("AZURE_AI_COHERE_R_PLUS_ENDPOINT"),    region= sys.env("AZURE_AI_COHERE_R_PLUS_REGION"),    accessToken= sys.env("AZURE_AI_COHERE_R_PLUS_ACCESS_KEY")  )

valservice=AnthropicServiceFactory.asOpenAI()// or AnthropicServiceFactory.bedrockAsOpenAI

valservice=VertexAIServiceFactory.asOpenAI()

valservice=GeminiServiceFactory.asOpenAI()

valservice=SonarServiceFactory.asOpenAI()

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.novita)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.novita)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.groq)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.groq)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.grok)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.grok)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.fireworks)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.fireworks)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.octoML)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.octoML)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.togetherAI)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.togetherAI)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.cerebras)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.cerebras)

valservice=OpenAIChatCompletionServiceFactory(ChatProviderSettings.mistral)// or with streamingvalservice=OpenAIChatCompletionServiceFactory.withStreaming(ChatProviderSettings.mistral)

valservice=OpenAIChatCompletionServiceFactory(    coreUrl="http://localhost:11434/v1/"  )

valservice=OpenAIChatCompletionServiceFactory.withStreaming(    coreUrl="http://localhost:11434/v1/"  )

importio.cequence.openaiscala.service.StreamedServiceTypes.OpenAIStreamedServiceimportio.cequence.openaiscala.service.OpenAIStreamedServiceImplicits._valservice:OpenAIStreamedService=OpenAIServiceFactory.withStreaming()

importio.cequence.openaiscala.service.OpenAIStreamedServiceImplicits._valservice=OpenAIChatCompletionServiceFactory.withStreaming(    coreUrl="https://api.fireworks.ai/inference/v1/",    authHeaders=Seq(("Authorization",s"Bearer${sys.env("FIREWORKS_API_KEY")}"))  )

valservice:OpenAIChatCompletionStreamedServiceExtra=OpenAIChatCompletionStreamedServiceFactory(      coreUrl="https://api.fireworks.ai/inference/v1/",      authHeaders=Seq(("Authorization",s"Bearer${sys.env("FIREWORKS_API_KEY")}"))   )

classMyClass@Inject() (openAIService:OpenAIService) {...}

  service.listModels.map(models=>    models.foreach(println)  )

  service.retrieveModel(ModelId.text_davinci_003).map(model=>    println(model.getOrElse("N/A"))  )

valcreateChatCompletionSettings=CreateChatCompletionSettings(    model=ModelId.gpt_4o  )valmessages=Seq(SystemMessage("You are a helpful assistant."),UserMessage("Who won the world series in 2020?"),AssistantMessage("The Los Angeles Dodgers won the World Series in 2020."),UserMessage("Where was it played?"),  )  service.createChatCompletion(    messages= messages,    settings= createChatCompletionSettings  ).map { chatCompletion=>    println(chatCompletion.contentHead)  }

valmessages=Seq(SystemMessage("You are a helpful assistant."),UserMessage("What's the weather like in San Francisco, Tokyo, and Paris?")  )// as a param type we can use "number", "string", "boolean", "object", "array", and "null"valtools=Seq(FunctionSpec(      name="get_current_weather",      description=Some("Get the current weather in a given location"),      parameters=Map("type"->"object","properties"->Map("location"->Map("type"->"string","description"->"The city and state, e.g. San Francisco, CA"          ),"unit"->Map("type"->"string","enum"->Seq("celsius","fahrenheit")          )        ),"required"->Seq("location")      )    )  )// if we want to force the model to use the above function as a response// we can do so by passing: responseToolChoice = Some("get_current_weather")`  service.createChatToolCompletion(    messages= messages,    tools= tools,    responseToolChoice=None,// means "auto"    settings=CreateChatCompletionSettings(ModelId.gpt_4o)  ).map { response=>valchatFunCompletionMessage= response.choices.head.messagevaltoolCalls= chatFunCompletionMessage.tool_calls.collect {case (id,x:FunctionCallSpec)=> (id, x)    }    println("tool call ids                :"+ toolCalls.map(_._1).mkString(",")    )    println("function/tool call names     :"+ toolCalls.map(_._2.name).mkString(",")    )    println("function/tool call arguments :"+ toolCalls.map(_._2.arguments).mkString(",")    )  }

valmessages=Seq(SystemMessage("Give me the most populous capital cities in JSON format."),UserMessage("List only african countries")  )valcapitalsSchema=JsonSchema.Object(    properties=Map("countries"->JsonSchema.Array(        items=JsonSchema.Object(          properties=Map("country"->JsonSchema.String(              description=Some("The name of the country")            ),"capital"->JsonSchema.String(              description=Some("The capital city of the country")            )          ),          required=Seq("country","capital")        )      )    ),    required=Seq("countries")  )valjsonSchemaDef=JsonSchemaDef(    name="capitals_response",    strict=true,    structure= capitalsSchema  )  service    .createChatCompletion(      messages= messages,      settings=CreateChatCompletionSettings(        model=ModelId.o3_mini,        max_tokens=Some(1000),        response_format_type=Some(ChatCompletionResponseFormatType.json_schema),        jsonSchema=Some(jsonSchemaDef)      )    )    .map { response=>valjson=Json.parse(response.contentHead)      println(Json.prettyPrint(json))    }

importio.cequence.openaiscala.service.OpenAIChatCompletionExtra._  ...  service    .createChatCompletionWithJSON[JsObject](      messages= messages,      settings=CreateChatCompletionSettings(        model=ModelId.o3_mini,        max_tokens=Some(1000),        response_format_type=Some(ChatCompletionResponseFormatType.json_schema),        jsonSchema=Some(jsonSchemaDef)      )    )    .map { json=>      println(Json.prettyPrint(json))    }

importio.cequence.openaiscala.service.OpenAIChatCompletionExtra._valmessages=Seq(SystemMessage("You are a helpful weather assistant."),UserMessage("What is the weather like in Norway?")  )  service    .createChatCompletionWithFailover(      messages= messages,      settings=CreateChatCompletionSettings(        model=ModelId.o3_mini      ),      failoverModels=Seq(ModelId.gpt_4_5_preview,ModelId.gpt_4o),      retryOnAnyError=true,      failureMessage="Weather assistant failed to provide a response."    )    .map { response=>      print(response.contentHead)    }

importio.cequence.openaiscala.service.OpenAIChatCompletionExtra._valcapitalsSchema=JsonSchema.Object(    properties=Map("countries"->JsonSchema.Array(        items=JsonSchema.Object(          properties=Map("country"->JsonSchema.String(              description=Some("The name of the country")            ),"capital"->JsonSchema.String(              description=Some("The capital city of the country")            )          ),          required=Seq("country","capital")        )      )    ),    required=Seq("countries")  )valjsonSchemaDef=JsonSchemaDef(    name="capitals_response",    strict=true,    structure= capitalsSchema  )// Define the chat messagesvalmessages=Seq(SystemMessage("Give me the most populous capital cities in JSON format."),UserMessage("List only african countries")  )// Call the service with failover support  service    .createChatCompletionWithJSON[JsObject](      messages= messages,      settings=CreateChatCompletionSettings(        model=ModelId.o3_mini,// Primary model        max_tokens=Some(1000),        response_format_type=Some(ChatCompletionResponseFormatType.json_schema),        jsonSchema=Some(jsonSchemaDef)      ),      failoverModels=Seq(ModelId.gpt_4_5_preview,// First fallback modelModelId.gpt_4o// Second fallback model      ),      maxRetries=Some(3),// Maximum number of retries per model      retryOnAnyError=true,// Retry on any error, not just retryable ones      taskNameForLogging=Some("capitals-query")// For better logging    )    .map { json=>      println(Json.prettyPrint(json))    }

importio.cequence.openaiscala.domain.responsesapi.Inputs  service    .createModelResponse(Inputs.Text("What is the capital of France?")    )    .map { response=>      println(response.outputText.getOrElse("N/A"))    }

importio.cequence.openaiscala.domain.responsesapi.Input  service    .createModelResponse(Inputs.Items(Input.ofInputSystemTextMessage("You are a helpful assistant. Be verbose and detailed and don't be afraid to use emojis."        ),Input.ofInputUserTextMessage("What is the capital of France?")      )    )    .map { response=>      println(response.outputText.getOrElse("N/A"))    }

importio.cequence.openaiscala.domain.responsesapi.{Inputs,Input}importio.cequence.openaiscala.domain.responsesapi.InputMessageContentimportio.cequence.openaiscala.domain.ChatRole  service    .createModelResponse(Inputs.Items(Input.ofInputMessage(Seq(InputMessageContent.Text("what is in this image?"),InputMessageContent.Image(              imageUrl=Some("https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"              )            )          ),          role=ChatRole.User        )      )    )    .map { response=>      println(response.outputText.getOrElse("N/A"))    }

  service    .createModelResponse(Inputs.Text("What are the attributes of an ancient brown dragon?"),      settings=CreateModelResponseSettings(        model=ModelId.gpt_4o_2024_08_06,        tools=Seq(FileSearchTool(            vectorStoreIds=Seq("vs_1234567890"),            maxNumResults=Some(20),            filters=None,            rankingOptions=None          )        )      )    )    .map { response=>      println(response.outputText.getOrElse("N/A"))// citationsvalcitations:Seq[Annotation.FileCitation]= response.outputMessageContents.collect {casee:OutputText=>          e.annotations.collect {casecitation:Annotation.FileCitation=> citation }      }.flatten      println("Citations:")      citations.foreach { citation=>        println(s"${citation.fileId} -${citation.filename}")      }    }

  service    .createModelResponse(Inputs.Text("What was a positive news story from today?"),      settings=CreateModelResponseSettings(        model=ModelId.gpt_4o_2024_08_06,        tools=Seq(WebSearchTool())      )    )    .map { response=>      println(response.outputText.getOrElse("N/A"))// citationsvalcitations:Seq[Annotation.UrlCitation]= response.outputMessageContents.collect {casee:OutputText=>          e.annotations.collect {casecitation:Annotation.UrlCitation=> citation }      }.flatten      println("Citations:")      citations.foreach { citation=>        println(s"${citation.title} -${citation.url}")      }    }

  service    .createModelResponse(Inputs.Text("What is the weather like in Boston today?"),      settings=CreateModelResponseSettings(        model=ModelId.gpt_4o_2024_08_06,        tools=Seq(FunctionTool(            name="get_current_weather",            parameters=JsonSchema.Object(              properties=Map("location"->JsonSchema.String(                  description=Some("The city and state, e.g. San Francisco, CA")                ),"unit"->JsonSchema.String(                  `enum`=Seq("celsius","fahrenheit")                )              ),              required=Seq("location","unit")            ),            description=Some("Get the current weather in a given location"),            strict=true          )        ),        toolChoice=Some(ToolChoice.Mode.Auto)      )    )    .map { response=>valfunctionCall= response.outputFunctionCalls.headOption        .getOrElse(thrownewRuntimeException("No function call output found"))      println(s"""Function Call Details:           |Name:${functionCall.name}           |Arguments:${functionCall.arguments}           |Call ID:${functionCall.callId}           |ID:${functionCall.id}           |Status:${functionCall.status}""".stripMargin      )valtoolsUsed= response.tools.map(_.typeString)      println(s"${toolsUsed.size} tools used:${toolsUsed.mkString(",")}")    }

importio.cequence.openaiscala.service.OpenAICountTokensHelperimportio.cequence.openaiscala.domain.{AssistantMessage,BaseMessage,FunctionSpec,ModelId,SystemMessage,UserMessage}classMyCompletionServiceextendsOpenAICountTokensHelper {defexec= {valmodel=ModelId.gpt_4_turbo_2024_04_09// messages to be sent to OpenAIvalmessages:Seq[BaseMessage]=Seq(SystemMessage("You are a helpful assistant."),UserMessage("Who won the world series in 2020?"),AssistantMessage("The Los Angeles Dodgers won the World Series in 2020."),UserMessage("Where was it played?"),    )valtokenCount= countMessageTokens(model, messages)  }}

importio.cequence.openaiscala.service.OpenAICountTokensHelperimportio.cequence.openaiscala.domain.{BaseMessage,FunctionSpec,ModelId,SystemMessage,UserMessage}classMyCompletionServiceextendsOpenAICountTokensHelper {defexec= {valmodel=ModelId.gpt_4_turbo_2024_04_09// messages to be sent to OpenAIvalmessages:Seq[BaseMessage]=Seq(SystemMessage("You are a helpful assistant."),UserMessage("What's the weather like in San Francisco, Tokyo, and Paris?")     )// function to be calledvalfunction:FunctionSpec=FunctionSpec(      name="getWeather",      parameters=Map("type"->"object","properties"->Map("location"->Map("type"->"string","description"->"The city to get the weather for"          ),"unit"->Map("type"->"string","enum"->List("celsius","fahrenheit"))        )      )    )valtokenCount= countFunMessageTokens(model, messages,Seq(function),Some(function.name))  }}

valadapters=OpenAIServiceAdapters.forFullServicevalservice1=OpenAIServiceFactory("your-api-key1")valservice2=OpenAIServiceFactory("your-api-key2")valservice= adapters.roundRobin(service1, service2)

valadapters=OpenAIServiceAdapters.forFullServicevalservice1=OpenAIServiceFactory("your-api-key1")valservice2=OpenAIServiceFactory("your-api-key2")valservice= adapters.randomOrder(service1, service2)

valadapters=OpenAIServiceAdapters.forFullServicevalrawService=OpenAIServiceFactory()valservice= adapters.log(    rawService,"openAIService",    logger.log  )

valadapters=OpenAIServiceAdapters.forFullServiceimplicitvalretrySettings:RetrySettings=RetrySettings(maxRetries=10).constantInterval(10.seconds)valservice= adapters.retry(OpenAIServiceFactory(),Some(println(_))// simple logging  )

classMyCompletionService@Inject() (valactorSystem:ActorSystem,implicitvalec:ExecutionContext,implicitvalscheduler:Scheduler)(valapiKey:String)extendsRetryHelpers {valservice:OpenAIService=OpenAIServiceFactory(apiKey)implicitvalretrySettings:RetrySettings=RetrySettings(interval=10.seconds)defask(prompt:String):Future[String]=for {      completion<- service        .createChatCompletion(List(MessageSpec(ChatRole.User, prompt))        )        .retryOnFailure    }yield completion.choices.head.message.content}

valadapters=OpenAIServiceAdapters.forFullService// OctoAIvaloctoMLService=OpenAIChatCompletionServiceFactory(    coreUrl="https://text.octoai.run/v1/",    authHeaders=Seq(("Authorization",s"Bearer${sys.env("OCTOAI_TOKEN")}"))  )// AnthropicvalanthropicService=AnthropicServiceFactory.asOpenAI()// OpenAIvalopenAIService=OpenAIServiceFactory()valservice:OpenAIService=    adapters.chatCompletionRouter(// OpenAI service is default so no need to specify its models here      serviceModels=Map(        octoMLService->Seq(NonOpenAIModelId.mixtral_8x22b_instruct),        anthropicService->Seq(NonOpenAIModelId.claude_2_1,NonOpenAIModelId.claude_3_opus_20240229,NonOpenAIModelId.claude_3_haiku_20240307        )      ),      openAIService    )

valadapters=OpenAIServiceAdapters.forCoreServicevalservice= adapters.chatToCompletion(OpenAICoreServiceFactory(        coreUrl="https://api.fireworks.ai/inference/v1/",        authHeaders=Seq(("Authorization",s"Bearer${sys.env("FIREWORKS_API_KEY")}"))      )    )

FAQ 🤔

openai-scala-client {    timeouts {        requestTimeoutSec = 200        readTimeoutSec = 200        connectTimeoutSec = 5        pooledConnectionIdleTimeoutSec = 60    }}

License ⚖️

Contributors 🙏