extend chat completion request body

Author: michal.zyga

core/src/main/scala/sttp/openai/requests/completions/chat/ChatRequestBody.scala

@@ -191,6 +191,46 @@ object ChatRequestBody {
     *   Controls which (if any) function is called by the model.
     * @param user
     *   A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
+    * @param store
+    *   Whether or not to store the output of this chat completion request for use in our model distillation or evals products.
+    * @param reasoningEffort
+    *   Constrains effort on reasoning for reasoning models. Currently supported values are low, medium, and high. Reducing reasoning effort
+    *   can result in faster responses and fewer tokens used on reasoning in a response.
+    * @param metadata
+    *   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.
+    * @param logprobs
+    *   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.
+    * @param topLogprobs
+    *   An integer between 0 and 20 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.
+    * @param maxCompletionTokens
+    *   An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning
+    *   tokens.
+    * @param modalities
+    *   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. To request that this model generate both text
+    *   and audio responses, you can use: ["text", "audio"].
+    * @param serviceTier
+    *   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', and the Project is Scale tier enabled, the system will utilize scale tier credits until they are exhausted.
+    *   - If set to 'auto', and the Project is not Scale tier enabled, the request will be processed using the default service tier with a
+    *     lower uptime SLA and no latency guarantee.
+    *   - If set to 'default', the request will be processed using the default service tier with a lower uptime SLA and no latency
+    *     guarantee.
+    *   - When not set, the default behavior is 'auto'.
+    * @param parallelToolCalls
+    *   Whether to enable parallel function calling during tool use.
+    * @param streamOptions
+    *   Options for streaming response. Only set this when you set stream: true.
+    * @param prediction
+    *   Configuration for a Predicted Output, which can greatly improve response times when large parts of the model response are known
+    *   ahead of time. This is most common when you are regenerating a file with only minor changes to most of the content.
+    * @param audio
+    *   Parameters for audio output. Required when audio output is requested with modalities: ["audio"].
     */
   case class ChatBody(
       messages: Seq[Message],
@@ -207,7 +247,19 @@ object ChatRequestBody {
       topP: Option[Double] = None,
       tools: Option[Seq[Tool]] = None,
       toolChoice: Option[ToolChoice] = None,
-      user: Option[String] = None
+      user: Option[String] = None,
+      store: Option[Boolean] = None,
+      reasoningEffort: Option[ReasoningEffort] = None,
+      metadata: Option[Map[String, String]] = None,
+      logprobs: Option[Boolean] = None,
+      topLogprobs: Option[Int] = None,
+      maxCompletionTokens: Option[Int] = None,
+      modalities: Option[Seq[String]] = None,
+      serviceTier: Option[String] = None,
+      parallelToolCalls: Option[Boolean] = None,
+      streamOptions: Option[StreamOptions] = None,
+      prediction: Option[Prediction] = None,
+      audio: Option[Audio] = None
   )
 
   object ChatBody {
@@ -220,6 +272,128 @@ object ChatRequestBody {
     implicit val chatRequestW: SnakePickle.Writer[ChatBody] = SnakePickle.macroW[ChatBody]
   }
 
+  /** @param voice
+    *   The voice the model uses to respond. Supported voices are ash, ballad, coral, sage, and verse (also supported but not recommended
+    *   are alloy, echo, and shimmer; these voices are less expressive).
+    * @param format
+    *   Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16.
+    */
+  case class Audio(
+      voice: Voice,
+      format: Format
+  )
+
+  object Audio {
+    implicit val audioW: SnakePickle.Writer[Audio] = SnakePickle.macroW[Audio]
+  }
+
+  sealed abstract class Voice(val value: String)
+
+  object Voice {
+    case object Ash extends Voice("ash")
+    case object Ballad extends Voice("ballad")
+    case object Coral extends Voice("coral")
+    case object Sage extends Voice("sage")
+    case object Verse extends Voice("verse")
+    case object Alloy extends Voice("alloy")
+    case object Echo extends Voice("echo")
+    case object Shimmer extends Voice("shimmer")
+    case class CustomVoice(customVoice: String) extends Voice(customVoice)
+
+    implicit val voiceW: SnakePickle.Writer[Voice] = SnakePickle
+      .writer[ujson.Value]
+      .comap[Voice](voice => SnakePickle.writeJs(voice.value))
+  }
+
+  sealed abstract class Format(val value: String)
+
+  object Format {
+    case object Wav extends Format("wav")
+    case object Mp3 extends Format("mp3")
+    case object Flac extends Format("flac")
+    case object Opus extends Format("opus")
+    case object Pcm16 extends Format("pcm16")
+    case class CustomFormat(customFormat: String) extends Format(customFormat)
+
+    implicit val formatW: SnakePickle.Writer[Format] = SnakePickle
+      .writer[ujson.Value]
+      .comap[Format](format => SnakePickle.writeJs(format.value))
+  }
+
+  /** @param `type`
+    *   The type of the predicted content you want to provide. This type is currently always content.
+    * @param content
+    *   The content that should be matched when generating a model response. If generated tokens would match this content, the entire model
+    *   response can be returned much more quickly.
+    */
+  case class Prediction(
+      `type`: String,
+      content: Content
+  )
+
+  object Prediction {
+    implicit val predictionW: SnakePickle.Writer[Prediction] = SnakePickle.macroW[Prediction]
+  }
+
+  sealed trait Content
+  case class SingleContent(value: String) extends Content
+  case class MultipartContent(value: Seq[ContentPart]) extends Content
+
+  object Content {
+    implicit val contentW: SnakePickle.Writer[Content] = SnakePickle
+      .writer[ujson.Value]
+      .comap[Content] {
+        case SingleContent(value)    => SnakePickle.writeJs(value)
+        case MultipartContent(value) => SnakePickle.writeJs(value)
+      }
+  }
+
+  /** An array of content parts with a defined type. Supported options differ based on the model being used to generate the response. Can
+    * contain text inputs.
+    *
+    * @param `type`
+    *   The type of the content part.
+    * @param text
+    *   The text content.
+    */
+  case class ContentPart(
+      `type`: String,
+      text: String
+  )
+
+  object ContentPart {
+    implicit val contentPartW: SnakePickle.Writer[ContentPart] = SnakePickle.macroW[ContentPart]
+  }
+
+  /** @param includeUsage
+    *   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.
+    */
+  case class StreamOptions(includeUsage: Option[Boolean] = None)
+
+  object StreamOptions {
+    implicit val streamOptionsW: SnakePickle.Writer[StreamOptions] = SnakePickle.macroW[StreamOptions]
+  }
+
+  sealed abstract class ReasoningEffort(val value: String)
+
+  object ReasoningEffort {
+
+    implicit val reasoningEffortW: SnakePickle.Writer[ReasoningEffort] = SnakePickle
+      .writer[ujson.Value]
+      .comap[ReasoningEffort](reasoningEffort => SnakePickle.writeJs(reasoningEffort.value))
+
+    case object Low extends ReasoningEffort("low")
+
+    case object Medium extends ReasoningEffort("medium")
+
+    case object High extends ReasoningEffort("high")
+
+    case class CustomReasoningEffort(customReasoningEffort: String) extends ReasoningEffort(customReasoningEffort)
+
+  }
+
   sealed abstract class ChatCompletionModel(val value: String)
 
   object ChatCompletionModel {

core/src/test/scala/sttp/openai/fixtures/ChatFixture.scala

@@ -111,7 +111,34 @@ object ChatFixture {
       |      "name": "function"
       |    }
       |  },
-      |  "user": "testUser"
+      |  "user": "testUser",
+      |  "store": true,
+      |  "reasoning_effort": "low",
+      |  "metadata": {
+      |    "key": "value"
+      |  },
+      |  "logprobs": true,
+      |  "top_logprobs": 1,
+      |  "max_completion_tokens": 10,
+      |  "modalities": ["text", "audio"],
+      |  "service_tier": "advanced",
+      |  "parallel_tool_calls": true,
+      |  "stream_options": {
+      |    "include_usage": true
+      |  },
+      |  "prediction": {
+      |    "type": "content",
+      |    "content": [
+      |      {
+      |        "type": "code",
+      |        "text": "simple text"
+      |      }
+      |    ]
+      |  },
+      |  "audio": {
+      |    "voice": "ash",
+      |    "format": "mp3"
+      |  }
       |}""".stripMargin
 
   val jsonResponse: String =

core/src/test/scala/sttp/openai/requests/completions/chat/ChatDataSpec.scala

@@ -4,17 +4,18 @@ import org.scalatest.EitherValues
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import sttp.openai.fixtures
-import sttp.openai.json.SnakePickle
-import sttp.openai.json.SttpUpickleApiExtension
+import sttp.openai.json.{SnakePickle, SttpUpickleApiExtension}
 import sttp.openai.requests.completions.Stop.SingleStop
 import sttp.openai.requests.completions.Usage
+import sttp.openai.requests.completions.chat.ChatRequestBody.Format.Mp3
+import sttp.openai.requests.completions.chat.ChatRequestBody.Voice.Ash
 import sttp.openai.utils.ChatCompletionFixtures._
 
 class ChatDataSpec extends AnyFlatSpec with Matchers with EitherValues {
 
   "Given chat completions response as Json" should "be properly deserialized to case class" in {
-    import ChatRequestResponseData._
     import ChatRequestResponseData.ChatResponse._
+    import ChatRequestResponseData._
 
     // given
     val jsonResponse = fixtures.ChatFixture.jsonResponse
@@ -72,7 +73,20 @@ class ChatDataSpec extends AnyFlatSpec with Matchers with EitherValues {
       responseFormat = Some(ResponseFormat.JsonObject),
       toolChoice = Some(ToolChoice.ToolFunction("function")),
       stop = Some(SingleStop("\n")),
-      user = Some("testUser")
+      user = Some("testUser"),
+      store = Some(true),
+      reasoningEffort = Some(ReasoningEffort.Low),
+      metadata = Some(Map("key" -> "value")),
+      logprobs = Some(true),
+      topLogprobs = Some(1),
+      maxCompletionTokens = Some(10),
+      modalities = Some(Seq("text", "audio")),
+      serviceTier = Some("advanced"),
+      parallelToolCalls = Some(true),
+      streamOptions = Some(StreamOptions(includeUsage = Some(true))),
+      prediction =
+        Some(Prediction(`type` = "content", content = MultipartContent(value = Seq(ContentPart(`type` = "code", text = "simple text"))))),
+      audio = Some(Audio(voice = Ash, format = Mp3))
     )
 
     val jsonRequest: ujson.Value = ujson.read(fixtures.ChatFixture.jsonRequest)