feat(api): add support for predicted outputs

chore: unknown commit message

Author: stainless-bot

.stats.yml

@@ -1,2 +1,2 @@
 configured_endpoints: 24
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-7b0a5d715d94f75ac7795bd4d2175a0e3243af9b935a86c273f371e45583140f.yml
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-2f8ca92b9b1879fd535b685e4767338413fcd533d42f3baac13a9c41da3fce35.yml

openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionContentPartImage.kt

@@ -124,7 +124,7 @@ private constructor(
 
         /**
          * Specifies the detail level of the image. Learn more in the
-         * [Vision guide](https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding).
+         * [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
          */
         fun detail(): Optional<Detail> = Optional.ofNullable(detail.getNullable("detail"))
 
@@ -133,7 +133,7 @@ private constructor(
 
         /**
          * Specifies the detail level of the image. Learn more in the
-         * [Vision guide](https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding).
+         * [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
          */
         @JsonProperty("detail") @ExcludeMissing fun _detail() = detail
 
@@ -179,13 +179,13 @@ private constructor(
 
             /**
              * Specifies the detail level of the image. Learn more in the
-             * [Vision guide](https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding).
+             * [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
              */
             fun detail(detail: Detail) = detail(JsonField.of(detail))
 
             /**
              * Specifies the detail level of the image. Learn more in the
-             * [Vision guide](https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding).
+             * [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
              */
             @JsonProperty("detail")
             @ExcludeMissing

openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionCreateParams.kt

@@ -0,0 +1,354 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openai.models
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openai.core.BaseDeserializer
+import com.openai.core.BaseSerializer
+import com.openai.core.Enum
+import com.openai.core.ExcludeMissing
+import com.openai.core.JsonField
+import com.openai.core.JsonMissing
+import com.openai.core.JsonValue
+import com.openai.core.NoAutoDetect
+import com.openai.core.getOrThrow
+import com.openai.core.toImmutable
+import com.openai.errors.OpenAIInvalidDataException
+import java.util.Objects
+import java.util.Optional
+
+/**
+ * Static predicted output content, such as the content of a text file that is being regenerated.
+ */
+@JsonDeserialize(builder = ChatCompletionPredictionContent.Builder::class)
+@NoAutoDetect
+class ChatCompletionPredictionContent
+private constructor(
+    private val type: JsonField<Type>,
+    private val content: JsonField<Content>,
+    private val additionalProperties: Map<String, JsonValue>,
+) {
+
+    private var validated: Boolean = false
+
+    /**
+     * The type of the predicted content you want to provide. This type is currently always
+     * `content`.
+     */
+    fun type(): Type = type.getRequired("type")
+
+    /**
+     * 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.
+     */
+    fun content(): Content = content.getRequired("content")
+
+    /**
+     * The type of the predicted content you want to provide. This type is currently always
+     * `content`.
+     */
+    @JsonProperty("type") @ExcludeMissing fun _type() = type
+
+    /**
+     * 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.
+     */
+    @JsonProperty("content") @ExcludeMissing fun _content() = content
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> = additionalProperties
+
+    fun validate(): ChatCompletionPredictionContent = apply {
+        if (!validated) {
+            type()
+            content()
+            validated = true
+        }
+    }
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder {
+
+        private var type: JsonField<Type> = JsonMissing.of()
+        private var content: JsonField<Content> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(chatCompletionPredictionContent: ChatCompletionPredictionContent) =
+            apply {
+                this.type = chatCompletionPredictionContent.type
+                this.content = chatCompletionPredictionContent.content
+                additionalProperties(chatCompletionPredictionContent.additionalProperties)
+            }
+
+        /**
+         * The type of the predicted content you want to provide. This type is currently always
+         * `content`.
+         */
+        fun type(type: Type) = type(JsonField.of(type))
+
+        /**
+         * The type of the predicted content you want to provide. This type is currently always
+         * `content`.
+         */
+        @JsonProperty("type")
+        @ExcludeMissing
+        fun type(type: JsonField<Type>) = apply { this.type = type }
+
+        /**
+         * 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.
+         */
+        fun content(content: Content) = content(JsonField.of(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.
+         */
+        @JsonProperty("content")
+        @ExcludeMissing
+        fun content(content: JsonField<Content>) = apply { this.content = content }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        @JsonAnySetter
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            this.additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun build(): ChatCompletionPredictionContent =
+            ChatCompletionPredictionContent(
+                type,
+                content,
+                additionalProperties.toImmutable(),
+            )
+    }
+
+    @JsonDeserialize(using = Content.Deserializer::class)
+    @JsonSerialize(using = Content.Serializer::class)
+    class Content
+    private constructor(
+        private val textContent: String? = null,
+        private val arrayOfContentParts: List<ChatCompletionContentPartText>? = null,
+        private val _json: JsonValue? = null,
+    ) {
+
+        private var validated: Boolean = false
+
+        /**
+         * The content used for a Predicted Output. This is often the text of a file you are
+         * regenerating with minor changes.
+         */
+        fun textContent(): Optional<String> = Optional.ofNullable(textContent)
+        /**
+         * An array of content parts with a defined type. Supported options differ based on the
+         * [model](https://platform.openai.com/docs/models) being used to generate the response. Can
+         * contain text inputs.
+         */
+        fun arrayOfContentParts(): Optional<List<ChatCompletionContentPartText>> =
+            Optional.ofNullable(arrayOfContentParts)
+
+        fun isTextContent(): Boolean = textContent != null
+
+        fun isArrayOfContentParts(): Boolean = arrayOfContentParts != null
+
+        fun asTextContent(): String = textContent.getOrThrow("textContent")
+
+        fun asArrayOfContentParts(): List<ChatCompletionContentPartText> =
+            arrayOfContentParts.getOrThrow("arrayOfContentParts")
+
+        fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+        fun <T> accept(visitor: Visitor<T>): T {
+            return when {
+                textContent != null -> visitor.visitTextContent(textContent)
+                arrayOfContentParts != null -> visitor.visitArrayOfContentParts(arrayOfContentParts)
+                else -> visitor.unknown(_json)
+            }
+        }
+
+        fun validate(): Content = apply {
+            if (!validated) {
+                if (textContent == null && arrayOfContentParts == null) {
+                    throw OpenAIInvalidDataException("Unknown Content: $_json")
+                }
+                arrayOfContentParts?.forEach { it.validate() }
+                validated = true
+            }
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Content && this.textContent == other.textContent && this.arrayOfContentParts == other.arrayOfContentParts /* spotless:on */
+        }
+
+        override fun hashCode(): Int {
+            return /* spotless:off */ Objects.hash(textContent, arrayOfContentParts) /* spotless:on */
+        }
+
+        override fun toString(): String {
+            return when {
+                textContent != null -> "Content{textContent=$textContent}"
+                arrayOfContentParts != null -> "Content{arrayOfContentParts=$arrayOfContentParts}"
+                _json != null -> "Content{_unknown=$_json}"
+                else -> throw IllegalStateException("Invalid Content")
+            }
+        }
+
+        companion object {
+
+            @JvmStatic fun ofTextContent(textContent: String) = Content(textContent = textContent)
+
+            @JvmStatic
+            fun ofArrayOfContentParts(arrayOfContentParts: List<ChatCompletionContentPartText>) =
+                Content(arrayOfContentParts = arrayOfContentParts)
+        }
+
+        interface Visitor<out T> {
+
+            fun visitTextContent(textContent: String): T
+
+            fun visitArrayOfContentParts(
+                arrayOfContentParts: List<ChatCompletionContentPartText>
+            ): T
+
+            fun unknown(json: JsonValue?): T {
+                throw OpenAIInvalidDataException("Unknown Content: $json")
+            }
+        }
+
+        class Deserializer : BaseDeserializer<Content>(Content::class) {
+
+            override fun ObjectCodec.deserialize(node: JsonNode): Content {
+                val json = JsonValue.fromJsonNode(node)
+
+                tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                    return Content(textContent = it, _json = json)
+                }
+                tryDeserialize(node, jacksonTypeRef<List<ChatCompletionContentPartText>>()) {
+                        it.forEach { it.validate() }
+                    }
+                    ?.let {
+                        return Content(arrayOfContentParts = it, _json = json)
+                    }
+
+                return Content(_json = json)
+            }
+        }
+
+        class Serializer : BaseSerializer<Content>(Content::class) {
+
+            override fun serialize(
+                value: Content,
+                generator: JsonGenerator,
+                provider: SerializerProvider
+            ) {
+                when {
+                    value.textContent != null -> generator.writeObject(value.textContent)
+                    value.arrayOfContentParts != null ->
+                        generator.writeObject(value.arrayOfContentParts)
+                    value._json != null -> generator.writeObject(value._json)
+                    else -> throw IllegalStateException("Invalid Content")
+                }
+            }
+        }
+    }
+
+    class Type
+    @JsonCreator
+    private constructor(
+        private val value: JsonField<String>,
+    ) : Enum {
+
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Type && this.value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+
+        companion object {
+
+            @JvmField val CONTENT = Type(JsonField.of("content"))
+
+            @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+        }
+
+        enum class Known {
+            CONTENT,
+        }
+
+        enum class Value {
+            CONTENT,
+            _UNKNOWN,
+        }
+
+        fun value(): Value =
+            when (this) {
+                CONTENT -> Value.CONTENT
+                else -> Value._UNKNOWN
+            }
+
+        fun known(): Known =
+            when (this) {
+                CONTENT -> Known.CONTENT
+                else -> throw OpenAIInvalidDataException("Unknown Type: $value")
+            }
+
+        fun asString(): String = _value().asStringOrThrow()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is ChatCompletionPredictionContent && this.type == other.type && this.content == other.content && this.additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    private var hashCode: Int = 0
+
+    override fun hashCode(): Int {
+        if (hashCode == 0) {
+            hashCode = /* spotless:off */ Objects.hash(type, content, additionalProperties) /* spotless:on */
+        }
+        return hashCode
+    }
+
+    override fun toString() =
+        "ChatCompletionPredictionContent{type=$type, content=$content, additionalProperties=$additionalProperties}"
+}