feat(api): new o1 and GPT-4o models + preference fine-tuning (#46)

learn more here: https://platform.openai.com/docs/changelog

Author: stainless-app[bot]

.stats.yml

@@ -1,2 +1,2 @@
 configured_endpoints: 24
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-2e0e0678be19d1118fd796af291822075e40538dba326611e177e9f3dc245a53.yml
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-779ea2754025daf5e18eb8ceb203ec321692636bc3a999338556a479178efa6c.yml

README.md

@@ -95,7 +95,7 @@ ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
         .role(ChatCompletionUserMessageParam.Role.USER)
         .content(ChatCompletionUserMessageParam.Content.ofTextContent("Say this is a test"))
         .build())))
-    .model(ChatModel.O1_PREVIEW)
+    .model(ChatModel.O1)
     .build();
 ChatCompletion chatCompletion = client.chat().completions().create(params);
 ```

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

@@ -28,6 +28,7 @@ import java.util.Objects
 import java.util.Optional
 import kotlin.jvm.optionals.getOrNull
 
+/** Messages sent by the model in response to user messages. */
 @JsonDeserialize(builder = ChatCompletionAssistantMessageParam.Builder::class)
 @NoAutoDetect
 class ChatCompletionAssistantMessageParam

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

@@ -0,0 +1,353 @@
+// 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
+
+/**
+ * Developer-provided instructions that the model should follow, regardless of messages sent by the
+ * user. With o1 models and newer, `developer` messages replace the previous `system` messages.
+ */
+@JsonDeserialize(builder = ChatCompletionDeveloperMessageParam.Builder::class)
+@NoAutoDetect
+class ChatCompletionDeveloperMessageParam
+private constructor(
+    private val content: JsonField<Content>,
+    private val role: JsonField<Role>,
+    private val name: JsonField<String>,
+    private val additionalProperties: Map<String, JsonValue>,
+) {
+
+    private var validated: Boolean = false
+
+    /** The contents of the developer message. */
+    fun content(): Content = content.getRequired("content")
+
+    /** The role of the messages author, in this case `developer`. */
+    fun role(): Role = role.getRequired("role")
+
+    /**
+     * An optional name for the participant. Provides the model information to differentiate between
+     * participants of the same role.
+     */
+    fun name(): Optional<String> = Optional.ofNullable(name.getNullable("name"))
+
+    /** The contents of the developer message. */
+    @JsonProperty("content") @ExcludeMissing fun _content() = content
+
+    /** The role of the messages author, in this case `developer`. */
+    @JsonProperty("role") @ExcludeMissing fun _role() = role
+
+    /**
+     * An optional name for the participant. Provides the model information to differentiate between
+     * participants of the same role.
+     */
+    @JsonProperty("name") @ExcludeMissing fun _name() = name
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> = additionalProperties
+
+    fun validate(): ChatCompletionDeveloperMessageParam = apply {
+        if (!validated) {
+            content()
+            role()
+            name()
+            validated = true
+        }
+    }
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder {
+
+        private var content: JsonField<Content> = JsonMissing.of()
+        private var role: JsonField<Role> = JsonMissing.of()
+        private var name: JsonField<String> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(
+            chatCompletionDeveloperMessageParam: ChatCompletionDeveloperMessageParam
+        ) = apply {
+            this.content = chatCompletionDeveloperMessageParam.content
+            this.role = chatCompletionDeveloperMessageParam.role
+            this.name = chatCompletionDeveloperMessageParam.name
+            additionalProperties(chatCompletionDeveloperMessageParam.additionalProperties)
+        }
+
+        /** The contents of the developer message. */
+        fun content(content: Content) = content(JsonField.of(content))
+
+        /** The contents of the developer message. */
+        @JsonProperty("content")
+        @ExcludeMissing
+        fun content(content: JsonField<Content>) = apply { this.content = content }
+
+        /** The role of the messages author, in this case `developer`. */
+        fun role(role: Role) = role(JsonField.of(role))
+
+        /** The role of the messages author, in this case `developer`. */
+        @JsonProperty("role")
+        @ExcludeMissing
+        fun role(role: JsonField<Role>) = apply { this.role = role }
+
+        /**
+         * An optional name for the participant. Provides the model information to differentiate
+         * between participants of the same role.
+         */
+        fun name(name: String) = name(JsonField.of(name))
+
+        /**
+         * An optional name for the participant. Provides the model information to differentiate
+         * between participants of the same role.
+         */
+        @JsonProperty("name")
+        @ExcludeMissing
+        fun name(name: JsonField<String>) = apply { this.name = name }
+
+        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(): ChatCompletionDeveloperMessageParam =
+            ChatCompletionDeveloperMessageParam(
+                content,
+                role,
+                name,
+                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 contents of the developer message. */
+        fun textContent(): Optional<String> = Optional.ofNullable(textContent)
+        /**
+         * An array of content parts with a defined type. For developer messages, only type `text`
+         * is supported.
+         */
+        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 && textContent == other.textContent && arrayOfContentParts == other.arrayOfContentParts /* spotless:on */
+        }
+
+        override fun hashCode(): Int = /* spotless:off */ Objects.hash(textContent, arrayOfContentParts) /* spotless:on */
+
+        override fun toString(): String =
+            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 Role
+    @JsonCreator
+    private constructor(
+        private val value: JsonField<String>,
+    ) : Enum {
+
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val DEVELOPER = of("developer")
+
+            @JvmStatic fun of(value: String) = Role(JsonField.of(value))
+        }
+
+        enum class Known {
+            DEVELOPER,
+        }
+
+        enum class Value {
+            DEVELOPER,
+            _UNKNOWN,
+        }
+
+        fun value(): Value =
+            when (this) {
+                DEVELOPER -> Value.DEVELOPER
+                else -> Value._UNKNOWN
+            }
+
+        fun known(): Known =
+            when (this) {
+                DEVELOPER -> Known.DEVELOPER
+                else -> throw OpenAIInvalidDataException("Unknown Role: $value")
+            }
+
+        fun asString(): String = _value().asStringOrThrow()
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Role && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is ChatCompletionDeveloperMessageParam && content == other.content && role == other.role && name == other.name && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(content, role, name, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "ChatCompletionDeveloperMessageParam{content=$content, role=$role, name=$name, additionalProperties=$additionalProperties}"
+}