diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 3f63a6728..7f3f5c846 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.22.1" + ".": "0.23.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 920dcbc36..2e67f53d3 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 61 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-dfb00c627f58e5180af7a9b29ed2f2aa0764a3b9daa6a32a1cc45bc8e48dfe15.yml +configured_endpoints: 65 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-4aa6ee65ba9efc789e05e6a5ef0883b2cadf06def8efd863dbf75e9e233067e1.yml diff --git a/CHANGELOG.md b/CHANGELOG.md index 6bf8b93cb..69f6c5e95 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.23.0 (2025-02-14) + +Full Changelog: [v0.22.1...v0.23.0](https://github.com/openai/openai-java/compare/v0.22.1...v0.23.0) + +### Features + +* **api:** add support for storing chat completions ([#216](https://github.com/openai/openai-java/issues/216)) ([68a7883](https://github.com/openai/openai-java/commit/68a7883782574f1af0d724c1d838fd70a99f2958)) + ## 0.22.1 (2025-02-12) Full Changelog: [v0.22.0...v0.22.1](https://github.com/openai/openai-java/compare/v0.22.0...v0.22.1) diff --git a/README.md b/README.md index 2043b6219..bc612a5c0 100644 --- a/README.md +++ b/README.md @@ -9,8 +9,8 @@ -[![Maven Central](https://img.shields.io/maven-central/v/com.openai/openai-java)](https://central.sonatype.com/artifact/com.openai/openai-java/0.22.1) -[![javadoc](https://javadoc.io/badge2/com.openai/openai-java/0.22.1/javadoc.svg)](https://javadoc.io/doc/com.openai/openai-java/0.22.1) +[![Maven Central](https://img.shields.io/maven-central/v/com.openai/openai-java)](https://central.sonatype.com/artifact/com.openai/openai-java/0.23.0) +[![javadoc](https://javadoc.io/badge2/com.openai/openai-java/0.23.0/javadoc.svg)](https://javadoc.io/doc/com.openai/openai-java/0.23.0) @@ -25,7 +25,7 @@ The REST API documentation can be found on [platform.openai.com](https://platfor ### Gradle ```kotlin -implementation("com.openai:openai-java:0.22.1") +implementation("com.openai:openai-java:0.23.0") ``` ### Maven @@ -34,7 +34,7 @@ implementation("com.openai:openai-java:0.22.1") com.openai openai-java - 0.22.1 + 0.23.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index 9eddb3cc9..25c92f6cd 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.openai" - version = "0.22.1" // x-release-please-version + version = "0.23.0" // x-release-please-version } subprojects { diff --git a/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingAsyncStreamResponse.kt b/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingAsyncStreamResponse.kt index 12817e89b..389f062a0 100644 --- a/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingAsyncStreamResponse.kt +++ b/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingAsyncStreamResponse.kt @@ -5,36 +5,46 @@ import com.openai.core.http.AsyncStreamResponse.Handler import java.util.Optional import java.util.concurrent.Executor +/** + * A delegating wrapper around an `AsyncStreamResponse` that closes it once it's only phantom + * reachable. + * + * This class ensures the `AsyncStreamResponse` is closed even if the user forgets to close it. + */ internal class PhantomReachableClosingAsyncStreamResponse( private val asyncStreamResponse: AsyncStreamResponse ) : AsyncStreamResponse { + + /** + * An object used for keeping `asyncStreamResponse` open while the object is still reachable. + */ + private val reachabilityTracker = Object() + init { - closeWhenPhantomReachable(this, asyncStreamResponse::close) + closeWhenPhantomReachable(reachabilityTracker, asyncStreamResponse::close) } override fun subscribe(handler: Handler): AsyncStreamResponse = apply { - asyncStreamResponse.subscribe(HandlerReferencingAsyncStreamResponse(handler, this)) + asyncStreamResponse.subscribe(TrackedHandler(handler, reachabilityTracker)) } override fun subscribe(handler: Handler, executor: Executor): AsyncStreamResponse = apply { - asyncStreamResponse.subscribe( - HandlerReferencingAsyncStreamResponse(handler, this), - executor - ) + asyncStreamResponse.subscribe(TrackedHandler(handler, reachabilityTracker), executor) } override fun close() = asyncStreamResponse.close() } /** - * A wrapper around a `Handler` that also references an `AsyncStreamResponse` so that the latter - * will not only be phantom reachable and get reclaimed early while the handler itself is reachable - * and subscribed to the response. + * A wrapper around a `Handler` that also references a `reachabilityTracker` object. + * + * Referencing the `reachabilityTracker` object prevents it from getting reclaimed while the handler + * is still reachable. */ -private class HandlerReferencingAsyncStreamResponse( +private class TrackedHandler( private val handler: Handler, - private val asyncStreamResponse: AsyncStreamResponse + private val reachabilityTracker: Any, ) : Handler { override fun onNext(value: T) = handler.onNext(value) diff --git a/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingHttpClient.kt b/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingHttpClient.kt index 19b0d18b9..43c0f4c09 100644 --- a/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingHttpClient.kt +++ b/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingHttpClient.kt @@ -4,6 +4,11 @@ import com.openai.core.RequestOptions import com.openai.core.closeWhenPhantomReachable import java.util.concurrent.CompletableFuture +/** + * A delegating wrapper around an `HttpClient` that closes it once it's only phantom reachable. + * + * This class ensures the `HttpClient` is closed even if the user forgets to close it. + */ internal class PhantomReachableClosingHttpClient(private val httpClient: HttpClient) : HttpClient { init { closeWhenPhantomReachable(this, httpClient) diff --git a/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingStreamResponse.kt b/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingStreamResponse.kt index 1cb2e2953..4321edb49 100644 --- a/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingStreamResponse.kt +++ b/openai-java-core/src/main/kotlin/com/openai/core/http/PhantomReachableClosingStreamResponse.kt @@ -3,6 +3,11 @@ package com.openai.core.http import com.openai.core.closeWhenPhantomReachable import java.util.stream.Stream +/** + * A delegating wrapper around a `StreamResponse` that closes it once it's only phantom reachable. + * + * This class ensures the `StreamResponse` is closed even if the user forgets to close it. + */ internal class PhantomReachableClosingStreamResponse( private val streamResponse: StreamResponse ) : StreamResponse { diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionDeleteParams.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionDeleteParams.kt new file mode 100644 index 000000000..edde0e348 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionDeleteParams.kt @@ -0,0 +1,218 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import com.openai.core.JsonValue +import com.openai.core.NoAutoDetect +import com.openai.core.Params +import com.openai.core.checkRequired +import com.openai.core.http.Headers +import com.openai.core.http.QueryParams +import com.openai.core.toImmutable +import java.util.Objects +import java.util.Optional + +/** + * Delete a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` can be deleted. + */ +class ChatCompletionDeleteParams +private constructor( + private val completionId: String, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, + private val additionalBodyProperties: Map, +) : Params { + + fun completionId(): String = completionId + + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + fun _additionalBodyProperties(): Map = additionalBodyProperties + + @JvmSynthetic + internal fun _body(): Optional> = + Optional.ofNullable(additionalBodyProperties.ifEmpty { null }) + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + fun getPathParam(index: Int): String { + return when (index) { + 0 -> completionId + else -> "" + } + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionDeleteParams]. */ + @NoAutoDetect + class Builder internal constructor() { + + private var completionId: String? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + private var additionalBodyProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(chatCompletionDeleteParams: ChatCompletionDeleteParams) = apply { + completionId = chatCompletionDeleteParams.completionId + additionalHeaders = chatCompletionDeleteParams.additionalHeaders.toBuilder() + additionalQueryParams = chatCompletionDeleteParams.additionalQueryParams.toBuilder() + additionalBodyProperties = + chatCompletionDeleteParams.additionalBodyProperties.toMutableMap() + } + + fun completionId(completionId: String) = apply { this.completionId = completionId } + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + this.additionalBodyProperties.clear() + putAllAdditionalBodyProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + additionalBodyProperties.put(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + this.additionalBodyProperties.putAll(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { + additionalBodyProperties.remove(key) + } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalBodyProperty) + } + + fun build(): ChatCompletionDeleteParams = + ChatCompletionDeleteParams( + checkRequired("completionId", completionId), + additionalHeaders.build(), + additionalQueryParams.build(), + additionalBodyProperties.toImmutable(), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionDeleteParams && completionId == other.completionId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(completionId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */ + + override fun toString() = + "ChatCompletionDeleteParams{completionId=$completionId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}" +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionDeleted.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionDeleted.kt new file mode 100644 index 000000000..74b5e3a38 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionDeleted.kt @@ -0,0 +1,150 @@ +// 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.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.checkRequired +import com.openai.core.immutableEmptyMap +import com.openai.core.toImmutable +import com.openai.errors.OpenAIInvalidDataException +import java.util.Objects + +@NoAutoDetect +class ChatCompletionDeleted +@JsonCreator +private constructor( + @JsonProperty("id") @ExcludeMissing private val id: JsonField = JsonMissing.of(), + @JsonProperty("deleted") + @ExcludeMissing + private val deleted: JsonField = JsonMissing.of(), + @JsonProperty("object") @ExcludeMissing private val object_: JsonValue = JsonMissing.of(), + @JsonAnySetter private val additionalProperties: Map = immutableEmptyMap(), +) { + + /** The ID of the chat completion that was deleted. */ + fun id(): String = id.getRequired("id") + + /** Whether the chat completion was deleted. */ + fun deleted(): Boolean = deleted.getRequired("deleted") + + /** The type of object being deleted. */ + @JsonProperty("object") @ExcludeMissing fun _object_(): JsonValue = object_ + + /** The ID of the chat completion that was deleted. */ + @JsonProperty("id") @ExcludeMissing fun _id(): JsonField = id + + /** Whether the chat completion was deleted. */ + @JsonProperty("deleted") @ExcludeMissing fun _deleted(): JsonField = deleted + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + private var validated: Boolean = false + + fun validate(): ChatCompletionDeleted = apply { + if (validated) { + return@apply + } + + id() + deleted() + _object_().let { + if (it != JsonValue.from("chat.completion.deleted")) { + throw OpenAIInvalidDataException("'object_' is invalid, received $it") + } + } + validated = true + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionDeleted]. */ + class Builder internal constructor() { + + private var id: JsonField? = null + private var deleted: JsonField? = null + private var object_: JsonValue = JsonValue.from("chat.completion.deleted") + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(chatCompletionDeleted: ChatCompletionDeleted) = apply { + id = chatCompletionDeleted.id + deleted = chatCompletionDeleted.deleted + object_ = chatCompletionDeleted.object_ + additionalProperties = chatCompletionDeleted.additionalProperties.toMutableMap() + } + + /** The ID of the chat completion that was deleted. */ + fun id(id: String) = id(JsonField.of(id)) + + /** The ID of the chat completion that was deleted. */ + fun id(id: JsonField) = apply { this.id = id } + + /** Whether the chat completion was deleted. */ + fun deleted(deleted: Boolean) = deleted(JsonField.of(deleted)) + + /** Whether the chat completion was deleted. */ + fun deleted(deleted: JsonField) = apply { this.deleted = deleted } + + /** The type of object being deleted. */ + fun object_(object_: JsonValue) = apply { this.object_ = object_ } + + fun additionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + additionalProperties.put(key, value) + } + + fun putAllAdditionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) } + + fun removeAllAdditionalProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalProperty) + } + + fun build(): ChatCompletionDeleted = + ChatCompletionDeleted( + checkRequired("id", id), + checkRequired("deleted", deleted), + object_, + additionalProperties.toImmutable(), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionDeleted && id == other.id && deleted == other.deleted && object_ == other.object_ && additionalProperties == other.additionalProperties /* spotless:on */ + } + + /* spotless:off */ + private val hashCode: Int by lazy { Objects.hash(id, deleted, object_, additionalProperties) } + /* spotless:on */ + + override fun hashCode(): Int = hashCode + + override fun toString() = + "ChatCompletionDeleted{id=$id, deleted=$deleted, object_=$object_, additionalProperties=$additionalProperties}" +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListPage.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListPage.kt new file mode 100644 index 000000000..6a0c3a0e6 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListPage.kt @@ -0,0 +1,199 @@ +// 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.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.immutableEmptyMap +import com.openai.core.toImmutable +import com.openai.services.blocking.chat.completions.MessageService +import java.util.Objects +import java.util.Optional +import java.util.stream.Stream +import java.util.stream.StreamSupport + +/** + * Get the messages in a stored chat completion. Only chat completions that have been created with + * the `store` parameter set to `true` will be returned. + */ +class ChatCompletionMessageListPage +private constructor( + private val messagesService: MessageService, + private val params: ChatCompletionMessageListParams, + private val response: Response, +) { + + fun response(): Response = response + + fun data(): List = response().data() + + fun hasMore(): Optional = response().hasMore() + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionMessageListPage && messagesService == other.messagesService && params == other.params && response == other.response /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(messagesService, params, response) /* spotless:on */ + + override fun toString() = + "ChatCompletionMessageListPage{messagesService=$messagesService, params=$params, response=$response}" + + fun hasNextPage(): Boolean { + return !data().isEmpty() + } + + fun getNextPageParams(): Optional { + if (!hasNextPage()) { + return Optional.empty() + } + + return Optional.of( + ChatCompletionMessageListParams.builder().from(params).after(data().last().id()).build() + ) + } + + fun getNextPage(): Optional { + return getNextPageParams().map { messagesService.list(it) } + } + + fun autoPager(): AutoPager = AutoPager(this) + + companion object { + + @JvmStatic + fun of( + messagesService: MessageService, + params: ChatCompletionMessageListParams, + response: Response + ) = + ChatCompletionMessageListPage( + messagesService, + params, + response, + ) + } + + @NoAutoDetect + class Response + @JsonCreator + constructor( + @JsonProperty("data") + private val data: JsonField> = JsonMissing.of(), + @JsonProperty("has_more") private val hasMore: JsonField = JsonMissing.of(), + @JsonAnySetter + private val additionalProperties: Map = immutableEmptyMap(), + ) { + + fun data(): List = data.getNullable("data") ?: listOf() + + fun hasMore(): Optional = Optional.ofNullable(hasMore.getNullable("has_more")) + + @JsonProperty("data") + fun _data(): Optional>> = + Optional.ofNullable(data) + + @JsonProperty("has_more") + fun _hasMore(): Optional> = Optional.ofNullable(hasMore) + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + private var validated: Boolean = false + + fun validate(): Response = apply { + if (validated) { + return@apply + } + + data().map { it.validate() } + hasMore() + validated = true + } + + fun toBuilder() = Builder().from(this) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is Response && data == other.data && hasMore == other.hasMore && additionalProperties == other.additionalProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(data, hasMore, additionalProperties) /* spotless:on */ + + override fun toString() = + "Response{data=$data, hasMore=$hasMore, additionalProperties=$additionalProperties}" + + companion object { + + @JvmStatic fun builder() = Builder() + } + + class Builder { + + private var data: JsonField> = JsonMissing.of() + private var hasMore: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(page: Response) = apply { + this.data = page.data + this.hasMore = page.hasMore + this.additionalProperties.putAll(page.additionalProperties) + } + + fun data(data: List) = data(JsonField.of(data)) + + fun data(data: JsonField>) = apply { this.data = data } + + fun hasMore(hasMore: Boolean) = hasMore(JsonField.of(hasMore)) + + fun hasMore(hasMore: JsonField) = apply { this.hasMore = hasMore } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + this.additionalProperties.put(key, value) + } + + fun build() = + Response( + data, + hasMore, + additionalProperties.toImmutable(), + ) + } + } + + class AutoPager( + private val firstPage: ChatCompletionMessageListPage, + ) : Iterable { + + override fun iterator(): Iterator = iterator { + var page = firstPage + var index = 0 + while (true) { + while (index < page.data().size) { + yield(page.data()[index++]) + } + page = page.getNextPage().orElse(null) ?: break + index = 0 + } + } + + fun stream(): Stream { + return StreamSupport.stream(spliterator(), false) + } + } +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListPageAsync.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListPageAsync.kt new file mode 100644 index 000000000..772f759ea --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListPageAsync.kt @@ -0,0 +1,212 @@ +// 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.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.immutableEmptyMap +import com.openai.core.toImmutable +import com.openai.services.async.chat.completions.MessageServiceAsync +import java.util.Objects +import java.util.Optional +import java.util.concurrent.CompletableFuture +import java.util.concurrent.Executor +import java.util.function.Predicate + +/** + * Get the messages in a stored chat completion. Only chat completions that have been created with + * the `store` parameter set to `true` will be returned. + */ +class ChatCompletionMessageListPageAsync +private constructor( + private val messagesService: MessageServiceAsync, + private val params: ChatCompletionMessageListParams, + private val response: Response, +) { + + fun response(): Response = response + + fun data(): List = response().data() + + fun hasMore(): Optional = response().hasMore() + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionMessageListPageAsync && messagesService == other.messagesService && params == other.params && response == other.response /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(messagesService, params, response) /* spotless:on */ + + override fun toString() = + "ChatCompletionMessageListPageAsync{messagesService=$messagesService, params=$params, response=$response}" + + fun hasNextPage(): Boolean { + return !data().isEmpty() + } + + fun getNextPageParams(): Optional { + if (!hasNextPage()) { + return Optional.empty() + } + + return Optional.of( + ChatCompletionMessageListParams.builder().from(params).after(data().last().id()).build() + ) + } + + fun getNextPage(): CompletableFuture> { + return getNextPageParams() + .map { messagesService.list(it).thenApply { Optional.of(it) } } + .orElseGet { CompletableFuture.completedFuture(Optional.empty()) } + } + + fun autoPager(): AutoPager = AutoPager(this) + + companion object { + + @JvmStatic + fun of( + messagesService: MessageServiceAsync, + params: ChatCompletionMessageListParams, + response: Response + ) = + ChatCompletionMessageListPageAsync( + messagesService, + params, + response, + ) + } + + @NoAutoDetect + class Response + @JsonCreator + constructor( + @JsonProperty("data") + private val data: JsonField> = JsonMissing.of(), + @JsonProperty("has_more") private val hasMore: JsonField = JsonMissing.of(), + @JsonAnySetter + private val additionalProperties: Map = immutableEmptyMap(), + ) { + + fun data(): List = data.getNullable("data") ?: listOf() + + fun hasMore(): Optional = Optional.ofNullable(hasMore.getNullable("has_more")) + + @JsonProperty("data") + fun _data(): Optional>> = + Optional.ofNullable(data) + + @JsonProperty("has_more") + fun _hasMore(): Optional> = Optional.ofNullable(hasMore) + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + private var validated: Boolean = false + + fun validate(): Response = apply { + if (validated) { + return@apply + } + + data().map { it.validate() } + hasMore() + validated = true + } + + fun toBuilder() = Builder().from(this) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is Response && data == other.data && hasMore == other.hasMore && additionalProperties == other.additionalProperties /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(data, hasMore, additionalProperties) /* spotless:on */ + + override fun toString() = + "Response{data=$data, hasMore=$hasMore, additionalProperties=$additionalProperties}" + + companion object { + + @JvmStatic fun builder() = Builder() + } + + class Builder { + + private var data: JsonField> = JsonMissing.of() + private var hasMore: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(page: Response) = apply { + this.data = page.data + this.hasMore = page.hasMore + this.additionalProperties.putAll(page.additionalProperties) + } + + fun data(data: List) = data(JsonField.of(data)) + + fun data(data: JsonField>) = apply { this.data = data } + + fun hasMore(hasMore: Boolean) = hasMore(JsonField.of(hasMore)) + + fun hasMore(hasMore: JsonField) = apply { this.hasMore = hasMore } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + this.additionalProperties.put(key, value) + } + + fun build() = + Response( + data, + hasMore, + additionalProperties.toImmutable(), + ) + } + } + + class AutoPager( + private val firstPage: ChatCompletionMessageListPageAsync, + ) { + + fun forEach( + action: Predicate, + executor: Executor + ): CompletableFuture { + fun CompletableFuture>.forEach( + action: (ChatCompletionStoreMessage) -> Boolean, + executor: Executor + ): CompletableFuture = + thenComposeAsync( + { page -> + page + .filter { it.data().all(action) } + .map { it.getNextPage().forEach(action, executor) } + .orElseGet { CompletableFuture.completedFuture(null) } + }, + executor + ) + return CompletableFuture.completedFuture(Optional.of(firstPage)) + .forEach(action::test, executor) + } + + fun toList(executor: Executor): CompletableFuture> { + val values = mutableListOf() + return forEach(values::add, executor).thenApply { values } + } + } +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListParams.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListParams.kt new file mode 100644 index 000000000..64313bba6 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionMessageListParams.kt @@ -0,0 +1,344 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import com.fasterxml.jackson.annotation.JsonCreator +import com.openai.core.Enum +import com.openai.core.JsonField +import com.openai.core.NoAutoDetect +import com.openai.core.Params +import com.openai.core.checkRequired +import com.openai.core.http.Headers +import com.openai.core.http.QueryParams +import com.openai.errors.OpenAIInvalidDataException +import java.util.Objects +import java.util.Optional + +/** + * Get the messages in a stored chat completion. Only chat completions that have been created with + * the `store` parameter set to `true` will be returned. + */ +class ChatCompletionMessageListParams +private constructor( + private val completionId: String, + private val after: String?, + private val limit: Long?, + private val order: Order?, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + fun completionId(): String = completionId + + /** Identifier for the last message from the previous pagination request. */ + fun after(): Optional = Optional.ofNullable(after) + + /** Number of messages to retrieve. */ + fun limit(): Optional = Optional.ofNullable(limit) + + /** + * Sort order for messages by timestamp. Use `asc` for ascending order or `desc` for descending + * order. Defaults to `asc`. + */ + fun order(): Optional = Optional.ofNullable(order) + + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams { + val queryParams = QueryParams.builder() + this.after?.let { queryParams.put("after", listOf(it.toString())) } + this.limit?.let { queryParams.put("limit", listOf(it.toString())) } + this.order?.let { queryParams.put("order", listOf(it.toString())) } + queryParams.putAll(additionalQueryParams) + return queryParams.build() + } + + fun getPathParam(index: Int): String { + return when (index) { + 0 -> completionId + else -> "" + } + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionMessageListParams]. */ + @NoAutoDetect + class Builder internal constructor() { + + private var completionId: String? = null + private var after: String? = null + private var limit: Long? = null + private var order: Order? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from(chatCompletionMessageListParams: ChatCompletionMessageListParams) = + apply { + completionId = chatCompletionMessageListParams.completionId + after = chatCompletionMessageListParams.after + limit = chatCompletionMessageListParams.limit + order = chatCompletionMessageListParams.order + additionalHeaders = chatCompletionMessageListParams.additionalHeaders.toBuilder() + additionalQueryParams = + chatCompletionMessageListParams.additionalQueryParams.toBuilder() + } + + fun completionId(completionId: String) = apply { this.completionId = completionId } + + /** Identifier for the last message from the previous pagination request. */ + fun after(after: String?) = apply { this.after = after } + + /** Identifier for the last message from the previous pagination request. */ + fun after(after: Optional) = after(after.orElse(null)) + + /** Number of messages to retrieve. */ + fun limit(limit: Long?) = apply { this.limit = limit } + + /** Number of messages to retrieve. */ + fun limit(limit: Long) = limit(limit as Long?) + + /** Number of messages to retrieve. */ + @Suppress("USELESS_CAST") // See https://youtrack.jetbrains.com/issue/KT-74228 + fun limit(limit: Optional) = limit(limit.orElse(null) as Long?) + + /** + * Sort order for messages by timestamp. Use `asc` for ascending order or `desc` for + * descending order. Defaults to `asc`. + */ + fun order(order: Order?) = apply { this.order = order } + + /** + * Sort order for messages by timestamp. Use `asc` for ascending order or `desc` for + * descending order. Defaults to `asc`. + */ + fun order(order: Optional) = order(order.orElse(null)) + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun build(): ChatCompletionMessageListParams = + ChatCompletionMessageListParams( + checkRequired("completionId", completionId), + after, + limit, + order, + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + /** + * Sort order for messages by timestamp. Use `asc` for ascending order or `desc` for descending + * order. Defaults to `asc`. + */ + class Order + @JsonCreator + private constructor( + private val value: JsonField, + ) : Enum { + + /** + * Returns this class instance's raw value. + * + * This is usually only useful if this instance was deserialized from data that doesn't + * match any known member, and you want to know that value. For example, if the SDK is on an + * older version than the API, then the API may respond with new members that the SDK is + * unaware of. + */ + @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField = value + + companion object { + + @JvmField val ASC = of("asc") + + @JvmField val DESC = of("desc") + + @JvmStatic fun of(value: String) = Order(JsonField.of(value)) + } + + /** An enum containing [Order]'s known values. */ + enum class Known { + ASC, + DESC, + } + + /** + * An enum containing [Order]'s known values, as well as an [_UNKNOWN] member. + * + * An instance of [Order] can contain an unknown value in a couple of cases: + * - It was deserialized from data that doesn't match any known member. For example, if the + * SDK is on an older version than the API, then the API may respond with new members that + * the SDK is unaware of. + * - It was constructed with an arbitrary value using the [of] method. + */ + enum class Value { + ASC, + DESC, + /** An enum member indicating that [Order] was instantiated with an unknown value. */ + _UNKNOWN, + } + + /** + * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN] + * if the class was instantiated with an unknown value. + * + * Use the [known] method instead if you're certain the value is always known or if you want + * to throw for the unknown case. + */ + fun value(): Value = + when (this) { + ASC -> Value.ASC + DESC -> Value.DESC + else -> Value._UNKNOWN + } + + /** + * Returns an enum member corresponding to this class instance's value. + * + * Use the [value] method instead if you're uncertain the value is always known and don't + * want to throw for the unknown case. + * + * @throws OpenAIInvalidDataException if this class instance's value is a not a known + * member. + */ + fun known(): Known = + when (this) { + ASC -> Known.ASC + DESC -> Known.DESC + else -> throw OpenAIInvalidDataException("Unknown Order: $value") + } + + fun asString(): String = _value().asStringOrThrow() + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is Order && 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 ChatCompletionMessageListParams && completionId == other.completionId && after == other.after && limit == other.limit && order == other.order && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(completionId, after, limit, order, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ChatCompletionMessageListParams{completionId=$completionId, after=$after, limit=$limit, order=$order, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionRetrieveParams.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionRetrieveParams.kt new file mode 100644 index 000000000..02d291ba6 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionRetrieveParams.kt @@ -0,0 +1,182 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import com.openai.core.NoAutoDetect +import com.openai.core.Params +import com.openai.core.checkRequired +import com.openai.core.http.Headers +import com.openai.core.http.QueryParams +import java.util.Objects + +/** + * Get a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` will be returned. + */ +class ChatCompletionRetrieveParams +private constructor( + private val completionId: String, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + fun completionId(): String = completionId + + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + fun getPathParam(index: Int): String { + return when (index) { + 0 -> completionId + else -> "" + } + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionRetrieveParams]. */ + @NoAutoDetect + class Builder internal constructor() { + + private var completionId: String? = null + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from(chatCompletionRetrieveParams: ChatCompletionRetrieveParams) = apply { + completionId = chatCompletionRetrieveParams.completionId + additionalHeaders = chatCompletionRetrieveParams.additionalHeaders.toBuilder() + additionalQueryParams = chatCompletionRetrieveParams.additionalQueryParams.toBuilder() + } + + fun completionId(completionId: String) = apply { this.completionId = completionId } + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun build(): ChatCompletionRetrieveParams = + ChatCompletionRetrieveParams( + checkRequired("completionId", completionId), + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionRetrieveParams && completionId == other.completionId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(completionId, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ChatCompletionRetrieveParams{completionId=$completionId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionStoreMessage.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionStoreMessage.kt new file mode 100644 index 000000000..d3615cfba --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionStoreMessage.kt @@ -0,0 +1,304 @@ +// 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.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.checkRequired +import com.openai.core.immutableEmptyMap +import com.openai.core.toImmutable +import com.openai.errors.OpenAIInvalidDataException +import java.util.Objects +import java.util.Optional + +/** A chat completion message generated by the model. */ +@NoAutoDetect +class ChatCompletionStoreMessage +@JsonCreator +private constructor( + @JsonProperty("content") + @ExcludeMissing + private val content: JsonField = JsonMissing.of(), + @JsonProperty("refusal") + @ExcludeMissing + private val refusal: JsonField = JsonMissing.of(), + @JsonProperty("role") @ExcludeMissing private val role: JsonValue = JsonMissing.of(), + @JsonProperty("audio") + @ExcludeMissing + private val audio: JsonField = JsonMissing.of(), + @JsonProperty("function_call") + @ExcludeMissing + private val functionCall: JsonField = JsonMissing.of(), + @JsonProperty("tool_calls") + @ExcludeMissing + private val toolCalls: JsonField> = JsonMissing.of(), + @JsonProperty("id") @ExcludeMissing private val id: JsonField = JsonMissing.of(), + @JsonAnySetter private val additionalProperties: Map = immutableEmptyMap(), +) { + + /** The contents of the message. */ + fun content(): Optional = Optional.ofNullable(content.getNullable("content")) + + /** The refusal message generated by the model. */ + fun refusal(): Optional = Optional.ofNullable(refusal.getNullable("refusal")) + + /** The role of the author of this message. */ + @JsonProperty("role") @ExcludeMissing fun _role(): JsonValue = role + + /** + * 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). + */ + fun audio(): Optional = Optional.ofNullable(audio.getNullable("audio")) + + /** + * Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be + * called, as generated by the model. + */ + @Deprecated("deprecated") + fun functionCall(): Optional = + Optional.ofNullable(functionCall.getNullable("function_call")) + + /** The tool calls generated by the model, such as function calls. */ + fun toolCalls(): Optional> = + Optional.ofNullable(toolCalls.getNullable("tool_calls")) + + /** The identifier of the chat message. */ + fun id(): String = id.getRequired("id") + + /** The contents of the message. */ + @JsonProperty("content") @ExcludeMissing fun _content(): JsonField = content + + /** The refusal message generated by the model. */ + @JsonProperty("refusal") @ExcludeMissing fun _refusal(): JsonField = refusal + + /** + * 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). + */ + @JsonProperty("audio") @ExcludeMissing fun _audio(): JsonField = audio + + /** + * Deprecated and replaced by `tool_calls`. The name and arguments of a function that should be + * called, as generated by the model. + */ + @Deprecated("deprecated") + @JsonProperty("function_call") + @ExcludeMissing + fun _functionCall(): JsonField = functionCall + + /** The tool calls generated by the model, such as function calls. */ + @JsonProperty("tool_calls") + @ExcludeMissing + fun _toolCalls(): JsonField> = toolCalls + + /** The identifier of the chat message. */ + @JsonProperty("id") @ExcludeMissing fun _id(): JsonField = id + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + fun toChatCompletionMessage(): ChatCompletionMessage = + ChatCompletionMessage.builder() + .content(content) + .refusal(refusal) + .role(role) + .audio(audio) + .functionCall(functionCall) + .toolCalls(toolCalls) + .build() + + private var validated: Boolean = false + + fun validate(): ChatCompletionStoreMessage = apply { + if (validated) { + return@apply + } + + content() + refusal() + _role().let { + if (it != JsonValue.from("assistant")) { + throw OpenAIInvalidDataException("'role' is invalid, received $it") + } + } + audio().ifPresent { it.validate() } + functionCall().ifPresent { it.validate() } + toolCalls().ifPresent { it.forEach { it.validate() } } + id() + validated = true + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionStoreMessage]. */ + class Builder internal constructor() { + + private var content: JsonField? = null + private var refusal: JsonField? = null + private var role: JsonValue = JsonValue.from("assistant") + private var audio: JsonField = JsonMissing.of() + private var functionCall: JsonField = JsonMissing.of() + private var toolCalls: JsonField>? = null + private var id: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(chatCompletionStoreMessage: ChatCompletionStoreMessage) = apply { + content = chatCompletionStoreMessage.content + refusal = chatCompletionStoreMessage.refusal + role = chatCompletionStoreMessage.role + audio = chatCompletionStoreMessage.audio + functionCall = chatCompletionStoreMessage.functionCall + toolCalls = chatCompletionStoreMessage.toolCalls.map { it.toMutableList() } + id = chatCompletionStoreMessage.id + additionalProperties = chatCompletionStoreMessage.additionalProperties.toMutableMap() + } + + /** The contents of the message. */ + fun content(content: String?) = content(JsonField.ofNullable(content)) + + /** The contents of the message. */ + fun content(content: Optional) = content(content.orElse(null)) + + /** The contents of the message. */ + fun content(content: JsonField) = apply { this.content = content } + + /** The refusal message generated by the model. */ + fun refusal(refusal: String?) = refusal(JsonField.ofNullable(refusal)) + + /** The refusal message generated by the model. */ + fun refusal(refusal: Optional) = refusal(refusal.orElse(null)) + + /** The refusal message generated by the model. */ + fun refusal(refusal: JsonField) = apply { this.refusal = refusal } + + /** The role of the author of this message. */ + fun role(role: JsonValue) = apply { this.role = role } + + /** + * 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). + */ + fun audio(audio: ChatCompletionAudio?) = audio(JsonField.ofNullable(audio)) + + /** + * 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). + */ + fun audio(audio: Optional) = audio(audio.orElse(null)) + + /** + * 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). + */ + fun audio(audio: JsonField) = apply { this.audio = audio } + + /** + * Deprecated and replaced by `tool_calls`. The name and arguments of a function that should + * be called, as generated by the model. + */ + @Deprecated("deprecated") + fun functionCall(functionCall: ChatCompletionMessage.FunctionCall) = + functionCall(JsonField.of(functionCall)) + + /** + * Deprecated and replaced by `tool_calls`. The name and arguments of a function that should + * be called, as generated by the model. + */ + @Deprecated("deprecated") + fun functionCall(functionCall: JsonField) = apply { + this.functionCall = functionCall + } + + /** The tool calls generated by the model, such as function calls. */ + fun toolCalls(toolCalls: List) = + toolCalls(JsonField.of(toolCalls)) + + /** The tool calls generated by the model, such as function calls. */ + fun toolCalls(toolCalls: JsonField>) = apply { + this.toolCalls = toolCalls.map { it.toMutableList() } + } + + /** The tool calls generated by the model, such as function calls. */ + fun addToolCall(toolCall: ChatCompletionMessageToolCall) = apply { + toolCalls = + (toolCalls ?: JsonField.of(mutableListOf())).apply { + asKnown() + .orElseThrow { + IllegalStateException( + "Field was set to non-list type: ${javaClass.simpleName}" + ) + } + .add(toolCall) + } + } + + /** The identifier of the chat message. */ + fun id(id: String) = id(JsonField.of(id)) + + /** The identifier of the chat message. */ + fun id(id: JsonField) = apply { this.id = id } + + fun additionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + additionalProperties.put(key, value) + } + + fun putAllAdditionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) } + + fun removeAllAdditionalProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalProperty) + } + + fun build(): ChatCompletionStoreMessage = + ChatCompletionStoreMessage( + checkRequired("content", content), + checkRequired("refusal", refusal), + role, + audio, + functionCall, + (toolCalls ?: JsonMissing.of()).map { it.toImmutable() }, + checkRequired("id", id), + additionalProperties.toImmutable(), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionStoreMessage && content == other.content && refusal == other.refusal && role == other.role && audio == other.audio && functionCall == other.functionCall && toolCalls == other.toolCalls && id == other.id && additionalProperties == other.additionalProperties /* spotless:on */ + } + + /* spotless:off */ + private val hashCode: Int by lazy { Objects.hash(content, refusal, role, audio, functionCall, toolCalls, id, additionalProperties) } + /* spotless:on */ + + override fun hashCode(): Int = hashCode + + override fun toString() = + "ChatCompletionStoreMessage{content=$content, refusal=$refusal, role=$role, audio=$audio, functionCall=$functionCall, toolCalls=$toolCalls, id=$id, additionalProperties=$additionalProperties}" +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionUpdateParams.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionUpdateParams.kt new file mode 100644 index 000000000..f1ac4545e --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatCompletionUpdateParams.kt @@ -0,0 +1,410 @@ +// 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.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.Params +import com.openai.core.checkRequired +import com.openai.core.http.Headers +import com.openai.core.http.QueryParams +import com.openai.core.immutableEmptyMap +import com.openai.core.toImmutable +import java.util.Objects +import java.util.Optional + +/** + * Modify a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` can be modified. Currently, the only supported modification is to update + * the `metadata` field. + */ +class ChatCompletionUpdateParams +private constructor( + private val completionId: String, + private val body: ChatCompletionUpdateBody, + private val additionalHeaders: Headers, + private val additionalQueryParams: QueryParams, +) : Params { + + fun completionId(): String = completionId + + /** + * 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. + */ + fun metadata(): Optional = body.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. + */ + fun _metadata(): JsonField = body._metadata() + + fun _additionalBodyProperties(): Map = body._additionalProperties() + + fun _additionalHeaders(): Headers = additionalHeaders + + fun _additionalQueryParams(): QueryParams = additionalQueryParams + + @JvmSynthetic internal fun _body(): ChatCompletionUpdateBody = body + + override fun _headers(): Headers = additionalHeaders + + override fun _queryParams(): QueryParams = additionalQueryParams + + fun getPathParam(index: Int): String { + return when (index) { + 0 -> completionId + else -> "" + } + } + + @NoAutoDetect + class ChatCompletionUpdateBody + @JsonCreator + internal constructor( + @JsonProperty("metadata") + @ExcludeMissing + private val metadata: JsonField = JsonMissing.of(), + @JsonAnySetter + private val additionalProperties: Map = immutableEmptyMap(), + ) { + + /** + * 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. + */ + fun metadata(): Optional = Optional.ofNullable(metadata.getNullable("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. + */ + @JsonProperty("metadata") @ExcludeMissing fun _metadata(): JsonField = metadata + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + private var validated: Boolean = false + + fun validate(): ChatCompletionUpdateBody = apply { + if (validated) { + return@apply + } + + metadata().ifPresent { it.validate() } + validated = true + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionUpdateBody]. */ + class Builder internal constructor() { + + private var metadata: JsonField? = null + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(chatCompletionUpdateBody: ChatCompletionUpdateBody) = apply { + metadata = chatCompletionUpdateBody.metadata + additionalProperties = chatCompletionUpdateBody.additionalProperties.toMutableMap() + } + + /** + * 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. + */ + fun metadata(metadata: Metadata?) = metadata(JsonField.ofNullable(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. + */ + fun metadata(metadata: Optional) = metadata(metadata.orElse(null)) + + /** + * 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. + */ + fun metadata(metadata: JsonField) = apply { this.metadata = metadata } + + fun additionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.clear() + putAllAdditionalProperties(additionalProperties) + } + + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + additionalProperties.put(key, value) + } + + fun putAllAdditionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) } + + fun removeAllAdditionalProperties(keys: Set) = apply { + keys.forEach(::removeAdditionalProperty) + } + + fun build(): ChatCompletionUpdateBody = + ChatCompletionUpdateBody( + checkRequired("metadata", metadata), + additionalProperties.toImmutable() + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionUpdateBody && metadata == other.metadata && additionalProperties == other.additionalProperties /* spotless:on */ + } + + /* spotless:off */ + private val hashCode: Int by lazy { Objects.hash(metadata, additionalProperties) } + /* spotless:on */ + + override fun hashCode(): Int = hashCode + + override fun toString() = + "ChatCompletionUpdateBody{metadata=$metadata, additionalProperties=$additionalProperties}" + } + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + /** A builder for [ChatCompletionUpdateParams]. */ + @NoAutoDetect + class Builder internal constructor() { + + private var completionId: String? = null + private var body: ChatCompletionUpdateBody.Builder = ChatCompletionUpdateBody.builder() + private var additionalHeaders: Headers.Builder = Headers.builder() + private var additionalQueryParams: QueryParams.Builder = QueryParams.builder() + + @JvmSynthetic + internal fun from(chatCompletionUpdateParams: ChatCompletionUpdateParams) = apply { + completionId = chatCompletionUpdateParams.completionId + body = chatCompletionUpdateParams.body.toBuilder() + additionalHeaders = chatCompletionUpdateParams.additionalHeaders.toBuilder() + additionalQueryParams = chatCompletionUpdateParams.additionalQueryParams.toBuilder() + } + + fun completionId(completionId: String) = apply { this.completionId = completionId } + + /** + * 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. + */ + fun metadata(metadata: Metadata?) = apply { body.metadata(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. + */ + fun metadata(metadata: Optional) = metadata(metadata.orElse(null)) + + /** + * 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. + */ + fun metadata(metadata: JsonField) = apply { body.metadata(metadata) } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + body.additionalProperties(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + body.putAdditionalProperty(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + body.putAllAdditionalProperties(additionalBodyProperties) + } + + fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) } + + fun removeAllAdditionalBodyProperties(keys: Set) = apply { + body.removeAllAdditionalProperties(keys) + } + + fun additionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) + } + + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) + } + + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.put(name, values) + } + + fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.putAll(additionalHeaders) + } + + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replace(name, value) + } + + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replace(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.replaceAll(additionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + additionalHeaders.removeAll(names) + } + + fun additionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.put(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.putAll(additionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replace(key, value) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replace(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + this.additionalQueryParams.replaceAll(additionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + additionalQueryParams.removeAll(keys) + } + + fun build(): ChatCompletionUpdateParams = + ChatCompletionUpdateParams( + checkRequired("completionId", completionId), + body.build(), + additionalHeaders.build(), + additionalQueryParams.build(), + ) + } + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return /* spotless:off */ other is ChatCompletionUpdateParams && completionId == other.completionId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */ + } + + override fun hashCode(): Int = /* spotless:off */ Objects.hash(completionId, body, additionalHeaders, additionalQueryParams) /* spotless:on */ + + override fun toString() = + "ChatCompletionUpdateParams{completionId=$completionId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" +} diff --git a/openai-java-core/src/main/kotlin/com/openai/models/Moderation.kt b/openai-java-core/src/main/kotlin/com/openai/models/Moderation.kt index c1646edb2..bbfc8d282 100644 --- a/openai-java-core/src/main/kotlin/com/openai/models/Moderation.kt +++ b/openai-java-core/src/main/kotlin/com/openai/models/Moderation.kt @@ -17,6 +17,7 @@ import com.openai.core.immutableEmptyMap import com.openai.core.toImmutable import com.openai.errors.OpenAIInvalidDataException import java.util.Objects +import java.util.Optional @NoAutoDetect class Moderation @@ -245,14 +246,15 @@ private constructor( * wrongdoing, or that gives advice or instruction on how to commit illicit acts. For * example, "how to shoplift" would fit this category. */ - fun illicit(): Boolean = illicit.getRequired("illicit") + fun illicit(): Optional = Optional.ofNullable(illicit.getNullable("illicit")) /** * Content that includes instructions or advice that facilitate the planning or execution of * wrongdoing that also includes violence, or that gives advice or instruction on the * procurement of any weapon. */ - fun illicitViolent(): Boolean = illicitViolent.getRequired("illicit/violent") + fun illicitViolent(): Optional = + Optional.ofNullable(illicitViolent.getNullable("illicit/violent")) /** * Content that promotes, encourages, or depicts acts of self-harm, such as suicide, @@ -500,7 +502,22 @@ private constructor( * execution of wrongdoing, or that gives advice or instruction on how to commit illicit * acts. For example, "how to shoplift" would fit this category. */ - fun illicit(illicit: Boolean) = illicit(JsonField.of(illicit)) + fun illicit(illicit: Boolean?) = illicit(JsonField.ofNullable(illicit)) + + /** + * Content that includes instructions or advice that facilitate the planning or + * execution of wrongdoing, or that gives advice or instruction on how to commit illicit + * acts. For example, "how to shoplift" would fit this category. + */ + fun illicit(illicit: Boolean) = illicit(illicit as Boolean?) + + /** + * Content that includes instructions or advice that facilitate the planning or + * execution of wrongdoing, or that gives advice or instruction on how to commit illicit + * acts. For example, "how to shoplift" would fit this category. + */ + @Suppress("USELESS_CAST") // See https://youtrack.jetbrains.com/issue/KT-74228 + fun illicit(illicit: Optional) = illicit(illicit.orElse(null) as Boolean?) /** * Content that includes instructions or advice that facilitate the planning or @@ -514,8 +531,24 @@ private constructor( * execution of wrongdoing that also includes violence, or that gives advice or * instruction on the procurement of any weapon. */ - fun illicitViolent(illicitViolent: Boolean) = - illicitViolent(JsonField.of(illicitViolent)) + fun illicitViolent(illicitViolent: Boolean?) = + illicitViolent(JsonField.ofNullable(illicitViolent)) + + /** + * Content that includes instructions or advice that facilitate the planning or + * execution of wrongdoing that also includes violence, or that gives advice or + * instruction on the procurement of any weapon. + */ + fun illicitViolent(illicitViolent: Boolean) = illicitViolent(illicitViolent as Boolean?) + + /** + * Content that includes instructions or advice that facilitate the planning or + * execution of wrongdoing that also includes violence, or that gives advice or + * instruction on the procurement of any weapon. + */ + @Suppress("USELESS_CAST") // See https://youtrack.jetbrains.com/issue/KT-74228 + fun illicitViolent(illicitViolent: Optional) = + illicitViolent(illicitViolent.orElse(null) as Boolean?) /** * Content that includes instructions or advice that facilitate the planning or diff --git a/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsync.kt b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsync.kt index 9f804b890..d8f6b0d94 100644 --- a/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsync.kt +++ b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsync.kt @@ -9,10 +9,17 @@ import com.openai.core.http.AsyncStreamResponse import com.openai.models.ChatCompletion import com.openai.models.ChatCompletionChunk import com.openai.models.ChatCompletionCreateParams +import com.openai.models.ChatCompletionDeleteParams +import com.openai.models.ChatCompletionDeleted +import com.openai.models.ChatCompletionRetrieveParams +import com.openai.models.ChatCompletionUpdateParams +import com.openai.services.async.chat.completions.MessageServiceAsync import java.util.concurrent.CompletableFuture interface CompletionServiceAsync { + fun messages(): MessageServiceAsync + /** * Creates a model response for the given chat conversation. Learn more in the * [text generation](https://platform.openai.com/docs/guides/text-generation), @@ -46,4 +53,35 @@ interface CompletionServiceAsync { params: ChatCompletionCreateParams, requestOptions: RequestOptions = RequestOptions.none() ): AsyncStreamResponse + + /** + * Get a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` will be returned. + */ + @JvmOverloads + fun retrieve( + params: ChatCompletionRetrieveParams, + requestOptions: RequestOptions = RequestOptions.none() + ): CompletableFuture + + /** + * Modify a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be modified. Currently, the only supported modification + * is to update the `metadata` field. + */ + @JvmOverloads + fun update( + params: ChatCompletionUpdateParams, + requestOptions: RequestOptions = RequestOptions.none() + ): CompletableFuture + + /** + * Delete a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be deleted. + */ + @JvmOverloads + fun delete( + params: ChatCompletionDeleteParams, + requestOptions: RequestOptions = RequestOptions.none() + ): CompletableFuture } diff --git a/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsyncImpl.kt b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsyncImpl.kt index 09bfb9020..e1be73e44 100644 --- a/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsyncImpl.kt +++ b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/CompletionServiceAsyncImpl.kt @@ -23,6 +23,12 @@ import com.openai.errors.OpenAIError import com.openai.models.ChatCompletion import com.openai.models.ChatCompletionChunk import com.openai.models.ChatCompletionCreateParams +import com.openai.models.ChatCompletionDeleteParams +import com.openai.models.ChatCompletionDeleted +import com.openai.models.ChatCompletionRetrieveParams +import com.openai.models.ChatCompletionUpdateParams +import com.openai.services.async.chat.completions.MessageServiceAsync +import com.openai.services.async.chat.completions.MessageServiceAsyncImpl import java.util.concurrent.CompletableFuture class CompletionServiceAsyncImpl @@ -32,6 +38,10 @@ internal constructor( private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + private val messages: MessageServiceAsync by lazy { MessageServiceAsyncImpl(clientOptions) } + + override fun messages(): MessageServiceAsync = messages + private val createHandler: Handler = jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) @@ -121,4 +131,97 @@ internal constructor( } .toAsync(clientOptions.streamHandlerExecutor) } + + private val retrieveHandler: Handler = + jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) + + /** + * Get a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` will be returned. + */ + override fun retrieve( + params: ChatCompletionRetrieveParams, + requestOptions: RequestOptions + ): CompletableFuture { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .addPathSegments("chat", "completions", params.getPathParam(0)) + .build() + .prepareAsync(clientOptions, params) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + response + .use { retrieveHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + } + } + + private val updateHandler: Handler = + jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) + + /** + * Modify a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be modified. Currently, the only supported modification + * is to update the `metadata` field. + */ + override fun update( + params: ChatCompletionUpdateParams, + requestOptions: RequestOptions + ): CompletableFuture { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .addPathSegments("chat", "completions", params.getPathParam(0)) + .body(json(clientOptions.jsonMapper, params._body())) + .build() + .prepareAsync(clientOptions, params) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + response + .use { updateHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + } + } + + private val deleteHandler: Handler = + jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) + + /** + * Delete a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be deleted. + */ + override fun delete( + params: ChatCompletionDeleteParams, + requestOptions: RequestOptions + ): CompletableFuture { + val request = + HttpRequest.builder() + .method(HttpMethod.DELETE) + .addPathSegments("chat", "completions", params.getPathParam(0)) + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepareAsync(clientOptions, params) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + response + .use { deleteHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + } + } } diff --git a/openai-java-core/src/main/kotlin/com/openai/services/async/chat/completions/MessageServiceAsync.kt b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/completions/MessageServiceAsync.kt new file mode 100644 index 000000000..be816fab1 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/completions/MessageServiceAsync.kt @@ -0,0 +1,23 @@ +// File generated from our OpenAPI spec by Stainless. + +@file:Suppress("OVERLOADS_INTERFACE") // See https://youtrack.jetbrains.com/issue/KT-36102 + +package com.openai.services.async.chat.completions + +import com.openai.core.RequestOptions +import com.openai.models.ChatCompletionMessageListPageAsync +import com.openai.models.ChatCompletionMessageListParams +import java.util.concurrent.CompletableFuture + +interface MessageServiceAsync { + + /** + * Get the messages in a stored chat completion. Only chat completions that have been created + * with the `store` parameter set to `true` will be returned. + */ + @JvmOverloads + fun list( + params: ChatCompletionMessageListParams, + requestOptions: RequestOptions = RequestOptions.none() + ): CompletableFuture +} diff --git a/openai-java-core/src/main/kotlin/com/openai/services/async/chat/completions/MessageServiceAsyncImpl.kt b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/completions/MessageServiceAsyncImpl.kt new file mode 100644 index 000000000..2beb84d80 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/services/async/chat/completions/MessageServiceAsyncImpl.kt @@ -0,0 +1,57 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.chat.completions + +import com.openai.core.ClientOptions +import com.openai.core.RequestOptions +import com.openai.core.handlers.errorHandler +import com.openai.core.handlers.jsonHandler +import com.openai.core.handlers.withErrorHandler +import com.openai.core.http.HttpMethod +import com.openai.core.http.HttpRequest +import com.openai.core.http.HttpResponse.Handler +import com.openai.core.prepareAsync +import com.openai.errors.OpenAIError +import com.openai.models.ChatCompletionMessageListPageAsync +import com.openai.models.ChatCompletionMessageListParams +import java.util.concurrent.CompletableFuture + +class MessageServiceAsyncImpl +internal constructor( + private val clientOptions: ClientOptions, +) : MessageServiceAsync { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + private val listHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + /** + * Get the messages in a stored chat completion. Only chat completions that have been created + * with the `store` parameter set to `true` will be returned. + */ + override fun list( + params: ChatCompletionMessageListParams, + requestOptions: RequestOptions + ): CompletableFuture { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .addPathSegments("chat", "completions", params.getPathParam(0), "messages") + .build() + .prepareAsync(clientOptions, params) + return request + .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) } + .thenApply { response -> + response + .use { listHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + .let { ChatCompletionMessageListPageAsync.of(this, params, it) } + } + } +} diff --git a/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionService.kt b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionService.kt index fd5b20898..96e11687d 100644 --- a/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionService.kt +++ b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionService.kt @@ -10,9 +10,16 @@ import com.openai.core.http.StreamResponse import com.openai.models.ChatCompletion import com.openai.models.ChatCompletionChunk import com.openai.models.ChatCompletionCreateParams +import com.openai.models.ChatCompletionDeleteParams +import com.openai.models.ChatCompletionDeleted +import com.openai.models.ChatCompletionRetrieveParams +import com.openai.models.ChatCompletionUpdateParams +import com.openai.services.blocking.chat.completions.MessageService interface CompletionService { + fun messages(): MessageService + /** * Creates a model response for the given chat conversation. Learn more in the * [text generation](https://platform.openai.com/docs/guides/text-generation), @@ -47,4 +54,35 @@ interface CompletionService { params: ChatCompletionCreateParams, requestOptions: RequestOptions = RequestOptions.none() ): StreamResponse + + /** + * Get a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` will be returned. + */ + @JvmOverloads + fun retrieve( + params: ChatCompletionRetrieveParams, + requestOptions: RequestOptions = RequestOptions.none() + ): ChatCompletion + + /** + * Modify a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be modified. Currently, the only supported modification + * is to update the `metadata` field. + */ + @JvmOverloads + fun update( + params: ChatCompletionUpdateParams, + requestOptions: RequestOptions = RequestOptions.none() + ): ChatCompletion + + /** + * Delete a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be deleted. + */ + @JvmOverloads + fun delete( + params: ChatCompletionDeleteParams, + requestOptions: RequestOptions = RequestOptions.none() + ): ChatCompletionDeleted } diff --git a/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionServiceImpl.kt b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionServiceImpl.kt index 6770ef2d5..d92578f1c 100644 --- a/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionServiceImpl.kt +++ b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/CompletionServiceImpl.kt @@ -21,6 +21,12 @@ import com.openai.errors.OpenAIError import com.openai.models.ChatCompletion import com.openai.models.ChatCompletionChunk import com.openai.models.ChatCompletionCreateParams +import com.openai.models.ChatCompletionDeleteParams +import com.openai.models.ChatCompletionDeleted +import com.openai.models.ChatCompletionRetrieveParams +import com.openai.models.ChatCompletionUpdateParams +import com.openai.services.blocking.chat.completions.MessageService +import com.openai.services.blocking.chat.completions.MessageServiceImpl class CompletionServiceImpl internal constructor( @@ -29,6 +35,10 @@ internal constructor( private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + private val messages: MessageService by lazy { MessageServiceImpl(clientOptions) } + + override fun messages(): MessageService = messages + private val createHandler: Handler = jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) @@ -111,4 +121,88 @@ internal constructor( } } } + + private val retrieveHandler: Handler = + jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) + + /** + * Get a stored chat completion. Only chat completions that have been created with the `store` + * parameter set to `true` will be returned. + */ + override fun retrieve( + params: ChatCompletionRetrieveParams, + requestOptions: RequestOptions + ): ChatCompletion { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .addPathSegments("chat", "completions", params.getPathParam(0)) + .build() + .prepare(clientOptions, params) + val response = clientOptions.httpClient.execute(request, requestOptions) + return response + .use { retrieveHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + } + + private val updateHandler: Handler = + jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) + + /** + * Modify a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be modified. Currently, the only supported modification + * is to update the `metadata` field. + */ + override fun update( + params: ChatCompletionUpdateParams, + requestOptions: RequestOptions + ): ChatCompletion { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .addPathSegments("chat", "completions", params.getPathParam(0)) + .body(json(clientOptions.jsonMapper, params._body())) + .build() + .prepare(clientOptions, params) + val response = clientOptions.httpClient.execute(request, requestOptions) + return response + .use { updateHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + } + + private val deleteHandler: Handler = + jsonHandler(clientOptions.jsonMapper).withErrorHandler(errorHandler) + + /** + * Delete a stored chat completion. Only chat completions that have been created with the + * `store` parameter set to `true` can be deleted. + */ + override fun delete( + params: ChatCompletionDeleteParams, + requestOptions: RequestOptions + ): ChatCompletionDeleted { + val request = + HttpRequest.builder() + .method(HttpMethod.DELETE) + .addPathSegments("chat", "completions", params.getPathParam(0)) + .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + .prepare(clientOptions, params) + val response = clientOptions.httpClient.execute(request, requestOptions) + return response + .use { deleteHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + } } diff --git a/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/completions/MessageService.kt b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/completions/MessageService.kt new file mode 100644 index 000000000..4a42b2984 --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/completions/MessageService.kt @@ -0,0 +1,22 @@ +// File generated from our OpenAPI spec by Stainless. + +@file:Suppress("OVERLOADS_INTERFACE") // See https://youtrack.jetbrains.com/issue/KT-36102 + +package com.openai.services.blocking.chat.completions + +import com.openai.core.RequestOptions +import com.openai.models.ChatCompletionMessageListPage +import com.openai.models.ChatCompletionMessageListParams + +interface MessageService { + + /** + * Get the messages in a stored chat completion. Only chat completions that have been created + * with the `store` parameter set to `true` will be returned. + */ + @JvmOverloads + fun list( + params: ChatCompletionMessageListParams, + requestOptions: RequestOptions = RequestOptions.none() + ): ChatCompletionMessageListPage +} diff --git a/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/completions/MessageServiceImpl.kt b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/completions/MessageServiceImpl.kt new file mode 100644 index 000000000..8177d3d4d --- /dev/null +++ b/openai-java-core/src/main/kotlin/com/openai/services/blocking/chat/completions/MessageServiceImpl.kt @@ -0,0 +1,53 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.blocking.chat.completions + +import com.openai.core.ClientOptions +import com.openai.core.RequestOptions +import com.openai.core.handlers.errorHandler +import com.openai.core.handlers.jsonHandler +import com.openai.core.handlers.withErrorHandler +import com.openai.core.http.HttpMethod +import com.openai.core.http.HttpRequest +import com.openai.core.http.HttpResponse.Handler +import com.openai.core.prepare +import com.openai.errors.OpenAIError +import com.openai.models.ChatCompletionMessageListPage +import com.openai.models.ChatCompletionMessageListParams + +class MessageServiceImpl +internal constructor( + private val clientOptions: ClientOptions, +) : MessageService { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + private val listHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + /** + * Get the messages in a stored chat completion. Only chat completions that have been created + * with the `store` parameter set to `true` will be returned. + */ + override fun list( + params: ChatCompletionMessageListParams, + requestOptions: RequestOptions + ): ChatCompletionMessageListPage { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .addPathSegments("chat", "completions", params.getPathParam(0), "messages") + .build() + .prepare(clientOptions, params) + val response = clientOptions.httpClient.execute(request, requestOptions) + return response + .use { listHandler.handle(it) } + .also { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + it.validate() + } + } + .let { ChatCompletionMessageListPage.of(this, params, it) } + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionDeleteParamsTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionDeleteParamsTest.kt new file mode 100644 index 000000000..d33b6ae57 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionDeleteParamsTest.kt @@ -0,0 +1,24 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class ChatCompletionDeleteParamsTest { + + @Test + fun create() { + ChatCompletionDeleteParams.builder().completionId("completion_id").build() + } + + @Test + fun getPathParam() { + val params = ChatCompletionDeleteParams.builder().completionId("completion_id").build() + assertThat(params).isNotNull + // path param "completionId" + assertThat(params.getPathParam(0)).isEqualTo("completion_id") + // out-of-bound path param + assertThat(params.getPathParam(1)).isEqualTo("") + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionDeletedTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionDeletedTest.kt new file mode 100644 index 000000000..7f81c3678 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionDeletedTest.kt @@ -0,0 +1,17 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class ChatCompletionDeletedTest { + + @Test + fun createChatCompletionDeleted() { + val chatCompletionDeleted = ChatCompletionDeleted.builder().id("id").deleted(true).build() + assertThat(chatCompletionDeleted).isNotNull + assertThat(chatCompletionDeleted.id()).isEqualTo("id") + assertThat(chatCompletionDeleted.deleted()).isEqualTo(true) + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionMessageListParamsTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionMessageListParamsTest.kt new file mode 100644 index 000000000..d86679fcb --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionMessageListParamsTest.kt @@ -0,0 +1,53 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import com.openai.core.http.QueryParams +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class ChatCompletionMessageListParamsTest { + + @Test + fun create() { + ChatCompletionMessageListParams.builder() + .completionId("completion_id") + .after("after") + .limit(0L) + .order(ChatCompletionMessageListParams.Order.ASC) + .build() + } + + @Test + fun queryParams() { + val params = + ChatCompletionMessageListParams.builder() + .completionId("completion_id") + .after("after") + .limit(0L) + .order(ChatCompletionMessageListParams.Order.ASC) + .build() + val expected = QueryParams.builder() + expected.put("after", "after") + expected.put("limit", "0") + expected.put("order", ChatCompletionMessageListParams.Order.ASC.toString()) + assertThat(params._queryParams()).isEqualTo(expected.build()) + } + + @Test + fun queryParamsWithoutOptionalFields() { + val params = ChatCompletionMessageListParams.builder().completionId("completion_id").build() + val expected = QueryParams.builder() + assertThat(params._queryParams()).isEqualTo(expected.build()) + } + + @Test + fun getPathParam() { + val params = ChatCompletionMessageListParams.builder().completionId("completion_id").build() + assertThat(params).isNotNull + // path param "completionId" + assertThat(params.getPathParam(0)).isEqualTo("completion_id") + // out-of-bound path param + assertThat(params.getPathParam(1)).isEqualTo("") + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionRetrieveParamsTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionRetrieveParamsTest.kt new file mode 100644 index 000000000..4a617d30d --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionRetrieveParamsTest.kt @@ -0,0 +1,24 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class ChatCompletionRetrieveParamsTest { + + @Test + fun create() { + ChatCompletionRetrieveParams.builder().completionId("completion_id").build() + } + + @Test + fun getPathParam() { + val params = ChatCompletionRetrieveParams.builder().completionId("completion_id").build() + assertThat(params).isNotNull + // path param "completionId" + assertThat(params.getPathParam(0)).isEqualTo("completion_id") + // out-of-bound path param + assertThat(params.getPathParam(1)).isEqualTo("") + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionUpdateParamsTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionUpdateParamsTest.kt new file mode 100644 index 000000000..b3ae945c4 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/models/ChatCompletionUpdateParamsTest.kt @@ -0,0 +1,76 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.models + +import com.openai.core.JsonValue +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class ChatCompletionUpdateParamsTest { + + @Test + fun create() { + ChatCompletionUpdateParams.builder() + .completionId("completion_id") + .metadata( + Metadata.builder().putAdditionalProperty("foo", JsonValue.from("string")).build() + ) + .build() + } + + @Test + fun body() { + val params = + ChatCompletionUpdateParams.builder() + .completionId("completion_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + val body = params._body() + assertThat(body).isNotNull + assertThat(body.metadata()) + .contains( + Metadata.builder().putAdditionalProperty("foo", JsonValue.from("string")).build() + ) + } + + @Test + fun bodyWithoutOptionalFields() { + val params = + ChatCompletionUpdateParams.builder() + .completionId("completion_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + val body = params._body() + assertThat(body).isNotNull + assertThat(body.metadata()) + .contains( + Metadata.builder().putAdditionalProperty("foo", JsonValue.from("string")).build() + ) + } + + @Test + fun getPathParam() { + val params = + ChatCompletionUpdateParams.builder() + .completionId("completion_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + assertThat(params).isNotNull + // path param "completionId" + assertThat(params.getPathParam(0)).isEqualTo("completion_id") + // out-of-bound path param + assertThat(params.getPathParam(1)).isEqualTo("") + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt index 7cca94726..857ffb750 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt @@ -7,13 +7,16 @@ import com.openai.client.okhttp.OpenAIOkHttpClient import com.openai.core.JsonValue import com.openai.models.ChatCompletionAudioParam import com.openai.models.ChatCompletionCreateParams +import com.openai.models.ChatCompletionDeleteParams import com.openai.models.ChatCompletionDeveloperMessageParam import com.openai.models.ChatCompletionModality import com.openai.models.ChatCompletionPredictionContent import com.openai.models.ChatCompletionReasoningEffort +import com.openai.models.ChatCompletionRetrieveParams import com.openai.models.ChatCompletionStreamOptions import com.openai.models.ChatCompletionTool import com.openai.models.ChatCompletionToolChoiceOption +import com.openai.models.ChatCompletionUpdateParams import com.openai.models.ChatModel import com.openai.models.FunctionDefinition import com.openai.models.FunctionParameters @@ -208,4 +211,59 @@ class CompletionServiceTest { } } } + + @Test + fun callRetrieve() { + val client = + OpenAIOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionService = client.chat().completions() + val chatCompletion = + completionService.retrieve( + ChatCompletionRetrieveParams.builder().completionId("completion_id").build() + ) + println(chatCompletion) + chatCompletion.validate() + } + + @Test + fun callUpdate() { + val client = + OpenAIOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionService = client.chat().completions() + val chatCompletion = + completionService.update( + ChatCompletionUpdateParams.builder() + .completionId("completion_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + println(chatCompletion) + chatCompletion.validate() + } + + @Test + fun callDelete() { + val client = + OpenAIOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionService = client.chat().completions() + val chatCompletionDeleted = + completionService.delete( + ChatCompletionDeleteParams.builder().completionId("completion_id").build() + ) + println(chatCompletionDeleted) + chatCompletionDeleted.validate() + } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt new file mode 100644 index 000000000..d03a2576e --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt @@ -0,0 +1,29 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.blocking.chat.completions + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClient +import com.openai.models.ChatCompletionMessageListParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class MessageServiceTest { + + @Test + fun callList() { + val client = + OpenAIOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageService = client.chat().completions().messages() + val chatCompletionMessageList = + messageService.list( + ChatCompletionMessageListParams.builder().completionId("completion_id").build() + ) + println(chatCompletionMessageList) + chatCompletionMessageList.data().forEach { it.validate() } + } +}