@ai-sdk/open-responses 2.0.51 → 2.0.54

package/src/responses/open-responses-language-model.ts

@@ -48,12 +48,18 @@ import {
   type OpenResponsesResponseBody,
   type OpenResponsesChunk,
   type ReasoningBody,
+  type ResponseError,
   type ToolChoiceParam,
 } from './open-responses-api';
 import { mapOpenResponsesFinishReason } from './map-open-responses-finish-reason';
 import type { OpenResponsesConfig } from './open-responses-config';
 import { openResponsesLanguageModelOptions } from './open-responses-language-model-options';
 
+const defaultFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: openResponsesErrorSchema,
+  errorToMessage: error => error.error.message,
+});
+
 export class OpenResponsesLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
 
@@ -147,6 +153,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       extensionRegistry: this.extensionRegistry,
       providerToolsByName,
       strictResponseInput: this.config.strictResponseInput,
+      customToolId: this.config.customToolId,
     });
 
     warnings.push(...inputWarnings);
@@ -166,6 +173,43 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
 
     for (const tool of tools ?? []) {
       if (tool.type === 'provider') {
+        if (
+          this.config.customToolId != null &&
+          tool.id === this.config.customToolId
+        ) {
+          const format =
+            tool.args.format != null &&
+            typeof tool.args.format === 'object' &&
+            !Array.isArray(tool.args.format)
+              ? tool.args.format
+              : undefined;
+
+          convertedTools.push({
+            type: 'custom',
+            name: tool.name,
+            description:
+              typeof tool.args.description === 'string'
+                ? tool.args.description
+                : undefined,
+            format:
+              format != null &&
+              'type' in format &&
+              format.type === 'grammar' &&
+              'syntax' in format &&
+              (format.syntax === 'regex' || format.syntax === 'lark') &&
+              'definition' in format &&
+              typeof format.definition === 'string'
+                ? {
+                    type: 'grammar',
+                    syntax: format.syntax,
+                    definition: format.definition,
+                  }
+                : format != null && 'type' in format && format.type === 'text'
+                  ? { type: 'text' }
+                  : undefined,
+          });
+          continue;
+        }
         const extension = this.extensionRegistry.byProviderToolId.get(tool.id);
         let encoded: OpenResponsesExtensionRecord | undefined;
 
@@ -219,7 +263,16 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       );
 
       if (registeredTool == null) {
-        if (!providerToolsByName.has(toolChoice.toolName)) {
+        if (
+          this.config.customToolId != null &&
+          providerToolsByName.get(toolChoice.toolName)?.id ===
+            this.config.customToolId
+        ) {
+          convertedToolChoice = {
+            type: 'custom',
+            name: toolChoice.toolName,
+          };
+        } else if (!providerToolsByName.has(toolChoice.toolName)) {
           convertedToolChoice = {
             type: 'function',
             name: toolChoice.toolName,
@@ -255,7 +308,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
     }
 
     const textFormat =
-      responseFormat?.type === 'json'
+      responseFormat?.type === 'json' && this.config.structuredOutputs !== false
         ? responseFormat.schema != null
           ? {
               type: 'json_schema' as const,
@@ -267,6 +320,13 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
           : { type: 'json_object' as const }
         : undefined;
 
+    if (
+      responseFormat?.type === 'json' &&
+      this.config.structuredOutputs === false
+    ) {
+      warnings.push({ type: 'unsupported', feature: 'responseFormat' });
+    }
+
     const openResponsesOptions = await parseProviderOptions({
       provider: this.config.providerOptionsName,
       providerOptions,
@@ -334,10 +394,8 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       url: this.config.url,
       headers: combineHeaders(this.config.headers?.(), options.headers),
       body,
-      failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: openResponsesErrorSchema,
-        errorToMessage: error => error.error.message,
-      }),
+      failedResponseHandler:
+        this.config.failedResponseHandler ?? defaultFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         // do not validate the response body, only apply types to the response body
         jsonSchema<OpenResponsesResponseBody>(() => {
@@ -349,14 +407,18 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
     });
 
     if (response.error) {
+      const errorMetadata = this.config.getResponseErrorMetadata?.(
+        response.error,
+      );
       throw new APICallError({
         message: response.error.message,
         url: this.config.url,
         requestBodyValues: body,
-        statusCode: 400,
+        statusCode: errorMetadata?.statusCode ?? 400,
+        isRetryable: errorMetadata?.isRetryable,
         responseHeaders,
         responseBody: rawResponse as string,
-        isRetryable: false,
+        data: response.error,
       });
     }
 
@@ -440,6 +502,20 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
           break;
         }
 
+        case 'custom_tool_call': {
+          hasToolCalls = true;
+          content.push({
+            type: 'tool-call',
+            toolCallId: part.call_id,
+            toolName: part.name,
+            input: JSON.stringify(part.input),
+            providerMetadata: {
+              [this.config.providerOptionsName]: { itemId: part.id },
+            },
+          });
+          break;
+        }
+
         default: {
           if (!isOpenResponsesExtensionItem(part)) {
             break;
@@ -464,6 +540,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
     const usage = response.usage;
     const inputTokens = usage?.input_tokens;
     const cachedInputTokens = usage?.input_tokens_details?.cached_tokens;
+    const cacheWriteTokens = usage?.input_tokens_details?.cache_write_tokens;
     const outputTokens = usage?.output_tokens;
     const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
 
@@ -479,9 +556,12 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       usage: {
         inputTokens: {
           total: inputTokens,
-          noCache: (inputTokens ?? 0) - (cachedInputTokens ?? 0),
+          noCache:
+            (inputTokens ?? 0) -
+            (cachedInputTokens ?? 0) -
+            (cacheWriteTokens ?? 0),
           cacheRead: cachedInputTokens,
-          cacheWrite: undefined,
+          cacheWrite: cacheWriteTokens,
         },
         outputTokens: {
           total: outputTokens,
@@ -515,10 +595,8 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
         ...body,
         stream: true,
       } satisfies OpenResponsesRequestBody,
-      failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: openResponsesErrorSchema,
-        errorToMessage: error => error.error.message,
-      }),
+      failedResponseHandler:
+        this.config.failedResponseHandler ?? defaultFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(z.any()),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
@@ -548,15 +626,20 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       const inputTokens = responseUsage.input_tokens;
       const cachedInputTokens =
         responseUsage.input_tokens_details?.cached_tokens;
+      const cacheWriteTokens =
+        responseUsage.input_tokens_details?.cache_write_tokens;
       const outputTokens = responseUsage.output_tokens;
       const reasoningTokens =
         responseUsage.output_tokens_details?.reasoning_tokens;
 
       usage.inputTokens = {
         total: inputTokens,
-        noCache: (inputTokens ?? 0) - (cachedInputTokens ?? 0),
+        noCache:
+          (inputTokens ?? 0) -
+          (cachedInputTokens ?? 0) -
+          (cacheWriteTokens ?? 0),
         cacheRead: cachedInputTokens,
-        cacheWrite: undefined,
+        cacheWrite: cacheWriteTokens,
       };
       usage.outputTokens = {
         total: outputTokens,
@@ -576,9 +659,14 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
       string,
       { toolName?: string; toolCallId?: string; arguments?: string }
     >();
+    const customToolCallsByItemId = new Map<
+      string,
+      { toolName?: string; toolCallId?: string; input?: string }
+    >();
     const providerOptionsName = this.config.providerOptionsName;
     const extensionRegistry = this.extensionRegistry;
     const extensionStreamState = new Map<string, unknown>();
+    const getResponseErrorMetadata = this.config.getResponseErrorMetadata;
 
     return {
       stream: response.pipeThrough(
@@ -670,7 +758,10 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
               const toolCall = toolCallsByItemId.get(chunk.item.id);
               const toolName = toolCall?.toolName ?? chunk.item.name;
               const toolCallId = toolCall?.toolCallId ?? chunk.item.call_id;
-              const input = toolCall?.arguments ?? chunk.item.arguments ?? '';
+              const input =
+                chunk.item.arguments !== ''
+                  ? chunk.item.arguments
+                  : (toolCall?.arguments ?? '');
 
               controller.enqueue({
                 type: 'tool-call',
@@ -686,6 +777,67 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
               hasToolCalls = true;
 
               toolCallsByItemId.delete(chunk.item.id);
+            } else if (
+              chunk.type === 'response.output_item.added' &&
+              chunk.item.type === 'custom_tool_call'
+            ) {
+              customToolCallsByItemId.set(chunk.item.id, {
+                toolName: chunk.item.name,
+                toolCallId: chunk.item.call_id,
+                input: chunk.item.input,
+              });
+              controller.enqueue({
+                type: 'tool-input-start',
+                id: chunk.item.call_id,
+                toolName: chunk.item.name,
+              });
+            } else if (chunk.type === 'response.custom_tool_call_input.delta') {
+              const toolCall = customToolCallsByItemId.get(chunk.item_id);
+              if (toolCall == null) {
+                customToolCallsByItemId.set(chunk.item_id, {
+                  input: chunk.delta,
+                });
+              } else {
+                toolCall.input = (toolCall.input ?? '') + chunk.delta;
+              }
+              controller.enqueue({
+                type: 'tool-input-delta',
+                id:
+                  customToolCallsByItemId.get(chunk.item_id)?.toolCallId ??
+                  chunk.item_id,
+                delta: chunk.delta,
+              });
+            } else if (chunk.type === 'response.custom_tool_call_input.done') {
+              const toolCall = customToolCallsByItemId.get(chunk.item_id);
+              if (toolCall == null) {
+                customToolCallsByItemId.set(chunk.item_id, {
+                  input: chunk.input,
+                });
+              } else {
+                toolCall.input = chunk.input;
+              }
+            } else if (
+              chunk.type === 'response.output_item.done' &&
+              chunk.item.type === 'custom_tool_call'
+            ) {
+              const toolCall = customToolCallsByItemId.get(chunk.item.id);
+              const toolCallId = toolCall?.toolCallId ?? chunk.item.call_id;
+              const input =
+                chunk.item.input !== ''
+                  ? chunk.item.input
+                  : (toolCall?.input ?? '');
+              controller.enqueue({ type: 'tool-input-end', id: toolCallId });
+              controller.enqueue({
+                type: 'tool-call',
+                toolCallId,
+                toolName: toolCall?.toolName ?? chunk.item.name,
+                input: JSON.stringify(input),
+                providerMetadata: {
+                  [providerOptionsName]: { itemId: chunk.item.id },
+                },
+              });
+              hasToolCalls = true;
+              customToolCallsByItemId.delete(chunk.item.id);
             } else if (
               chunk.type === 'response.output_item.done' &&
               isOpenResponsesExtensionItem(chunk.item)
@@ -804,6 +956,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
                     type: chunk.type,
                     error: chunk.response.error,
                     data: chunk,
+                    getResponseErrorMetadata,
                   }),
                 });
               }
@@ -818,6 +971,7 @@ export class OpenResponsesLanguageModel implements LanguageModelV4 {
                   type: chunk.type,
                   error: chunk.error,
                   data: chunk,
+                  getResponseErrorMetadata,
                 }),
               });
             }
@@ -850,15 +1004,18 @@ function createOpenResponsesStreamError({
   type,
   error,
   data,
+  getResponseErrorMetadata,
 }: {
   type: 'error' | 'response.failed';
-  error: { message: string; code: string };
+  error: ResponseError;
   data: unknown;
+  getResponseErrorMetadata: OpenResponsesConfig['getResponseErrorMetadata'];
 }) {
   return createProviderStreamError({
     message: error.message,
     type,
     code: error.code,
+    ...getResponseErrorMetadata?.(error),
     data,
   });
 }