in anthropic-java-core/src/main/kotlin/com/anthropic/services/blocking/beta/messages/BatchServiceImpl.kt [67:276]
override fun delete(
params: BatchDeleteParams,
requestOptions: RequestOptions,
): BetaDeletedMessageBatch =
// delete /v1/messages/batches/{message_batch_id}?beta=true
withRawResponse().delete(params, requestOptions).parse()
override fun cancel(
params: BatchCancelParams,
requestOptions: RequestOptions,
): BetaMessageBatch =
// post /v1/messages/batches/{message_batch_id}/cancel?beta=true
withRawResponse().cancel(params, requestOptions).parse()
override fun resultsStreaming(
params: BatchResultsParams,
requestOptions: RequestOptions,
): StreamResponse<BetaMessageBatchIndividualResponse> =
// get /v1/messages/batches/{message_batch_id}/results?beta=true
withRawResponse().resultsStreaming(params, requestOptions).parse()
class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
BatchService.WithRawResponse {
private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
private val createHandler: Handler<BetaMessageBatch> =
jsonHandler<BetaMessageBatch>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
override fun create(
params: BatchCreateParams,
requestOptions: RequestOptions,
): HttpResponseFor<BetaMessageBatch> {
val request =
HttpRequest.builder()
.method(HttpMethod.POST)
.addPathSegments("v1", "messages", "batches")
.putQueryParam("beta", "true")
.putAllHeaders(DEFAULT_HEADERS)
.body(json(clientOptions.jsonMapper, params._body()))
.build()
.prepare(clientOptions, params)
val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
val response = clientOptions.httpClient.execute(request, requestOptions)
return response.parseable {
response
.use { createHandler.handle(it) }
.also {
if (requestOptions.responseValidation!!) {
it.validate()
}
}
}
}
private val retrieveHandler: Handler<BetaMessageBatch> =
jsonHandler<BetaMessageBatch>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
override fun retrieve(
params: BatchRetrieveParams,
requestOptions: RequestOptions,
): HttpResponseFor<BetaMessageBatch> {
val request =
HttpRequest.builder()
.method(HttpMethod.GET)
.addPathSegments("v1", "messages", "batches", params._pathParam(0))
.putQueryParam("beta", "true")
.putAllHeaders(DEFAULT_HEADERS)
.build()
.prepare(clientOptions, params)
val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
val response = clientOptions.httpClient.execute(request, requestOptions)
return response.parseable {
response
.use { retrieveHandler.handle(it) }
.also {
if (requestOptions.responseValidation!!) {
it.validate()
}
}
}
}
private val listHandler: Handler<BatchListPageResponse> =
jsonHandler<BatchListPageResponse>(clientOptions.jsonMapper)
.withErrorHandler(errorHandler)
override fun list(
params: BatchListParams,
requestOptions: RequestOptions,
): HttpResponseFor<BatchListPage> {
val request =
HttpRequest.builder()
.method(HttpMethod.GET)
.addPathSegments("v1", "messages", "batches")
.putQueryParam("beta", "true")
.putAllHeaders(DEFAULT_HEADERS)
.build()
.prepare(clientOptions, params)
val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
val response = clientOptions.httpClient.execute(request, requestOptions)
return response.parseable {
response
.use { listHandler.handle(it) }
.also {
if (requestOptions.responseValidation!!) {
it.validate()
}
}
.let {
BatchListPage.builder()
.service(BatchServiceImpl(clientOptions))
.params(params)
.response(it)
.build()
}
}
}
private val deleteHandler: Handler<BetaDeletedMessageBatch> =
jsonHandler<BetaDeletedMessageBatch>(clientOptions.jsonMapper)
.withErrorHandler(errorHandler)
override fun delete(
params: BatchDeleteParams,
requestOptions: RequestOptions,
): HttpResponseFor<BetaDeletedMessageBatch> {
val request =
HttpRequest.builder()
.method(HttpMethod.DELETE)
.addPathSegments("v1", "messages", "batches", params._pathParam(0))
.putQueryParam("beta", "true")
.putAllHeaders(DEFAULT_HEADERS)
.apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } }
.build()
.prepare(clientOptions, params)
val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
val response = clientOptions.httpClient.execute(request, requestOptions)
return response.parseable {
response
.use { deleteHandler.handle(it) }
.also {
if (requestOptions.responseValidation!!) {
it.validate()
}
}
}
}
private val cancelHandler: Handler<BetaMessageBatch> =
jsonHandler<BetaMessageBatch>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
override fun cancel(
params: BatchCancelParams,
requestOptions: RequestOptions,
): HttpResponseFor<BetaMessageBatch> {
val request =
HttpRequest.builder()
.method(HttpMethod.POST)
.addPathSegments("v1", "messages", "batches", params._pathParam(0), "cancel")
.putQueryParam("beta", "true")
.putAllHeaders(DEFAULT_HEADERS)
.apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } }
.build()
.prepare(clientOptions, params)
val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
val response = clientOptions.httpClient.execute(request, requestOptions)
return response.parseable {
response
.use { cancelHandler.handle(it) }
.also {
if (requestOptions.responseValidation!!) {
it.validate()
}
}
}
}
private val resultsStreamingHandler:
Handler<StreamResponse<BetaMessageBatchIndividualResponse>> =
jsonlHandler<BetaMessageBatchIndividualResponse>(clientOptions.jsonMapper)
.withErrorHandler(errorHandler)
override fun resultsStreaming(
params: BatchResultsParams,
requestOptions: RequestOptions,
): HttpResponseFor<StreamResponse<BetaMessageBatchIndividualResponse>> {
val request =
HttpRequest.builder()
.method(HttpMethod.GET)
.addPathSegments("v1", "messages", "batches", params._pathParam(0), "results")
.putQueryParam("beta", "true")
.putAllHeaders(DEFAULT_HEADERS)
.build()
.prepare(clientOptions, params)
val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
val response = clientOptions.httpClient.execute(request, requestOptions)
return response.parseable {
response
.let { resultsStreamingHandler.handle(it) }
.let { streamResponse ->
if (requestOptions.responseValidation!!) {
streamResponse.map { it.validate() }
} else {
streamResponse
}
}
}
}
}