@ai-sdk/openai 4.0.43 → 4.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.43",
+  "version": "4.0.45",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.7",
-    "@ai-sdk/provider-utils": "5.0.27"
+    "@ai-sdk/provider-utils": "5.0.28"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/chat/openai-chat-language-model.ts

@@ -377,7 +377,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
     for (const toolCall of choice.message.tool_calls ?? []) {
       content.push({
         type: 'tool-call' as const,
-        toolCallId: toolCall.id ?? generateId(),
+        toolCallId: toolCall.id || generateId(),
         toolName: toolCall.function.name,
         input: toolCall.function.arguments!,
       });

package/src/responses/convert-to-openai-responses-input.ts

@@ -1,6 +1,8 @@
 import {
   UnsupportedFunctionalityError,
   type LanguageModelV4Prompt,
+  type LanguageModelV4ToolResultOutput,
+  type LanguageModelV4ToolResultPart,
   type SharedV4ProviderOptions,
   type LanguageModelV4ToolApprovalResponsePart,
   type SharedV4Warning,
@@ -43,6 +45,10 @@ import {
   programmaticToolCallingInputSchema,
   programmaticToolCallingOutputSchema,
 } from '../tool/programmatic-tool-calling';
+import {
+  getParallelToolCallMetadata,
+  type ParallelToolCallMetadata,
+} from './expand-parallel-tool-call';
 
 function serializeToolCallArguments(input: unknown): string {
   return JSON.stringify(input === undefined ? {} : input);
@@ -61,6 +67,217 @@ function mapToolCaller(
       : caller;
 }
 
+async function convertFunctionToolResultOutput({
+  output,
+  toolName,
+  outputSchemaToolNames,
+  providerOptionsName,
+  warnings,
+}: {
+  output: LanguageModelV4ToolResultOutput;
+  toolName: string;
+  outputSchemaToolNames: Set<string> | undefined;
+  providerOptionsName: string;
+  warnings: Array<SharedV4Warning>;
+}): Promise<OpenAIResponsesFunctionCallOutput['output']> {
+  // `output` is always a string, but for functions with output_schema OpenAI
+  // parses the contents of that string as JSON. Text-like results therefore
+  // need JSON.stringify to become valid JSON string literals.
+  const hasOutputSchema = outputSchemaToolNames?.has(toolName);
+
+  switch (output.type) {
+    case 'text':
+    case 'error-text':
+      return hasOutputSchema ? JSON.stringify(output.value) : output.value;
+    case 'execution-denied': {
+      const reason = output.reason ?? 'Tool call execution denied.';
+      return hasOutputSchema ? JSON.stringify(reason) : reason;
+    }
+    case 'json':
+    case 'error-json':
+      return JSON.stringify(output.value);
+    case 'content':
+      return output.value
+        .map(item => {
+          const promptCacheBreakpoint = getPromptCacheBreakpoint(
+            item.providerOptions,
+            providerOptionsName,
+          );
+          switch (item.type) {
+            case 'text': {
+              return {
+                type: 'input_text' as const,
+                text: item.text,
+                ...(promptCacheBreakpoint != null && {
+                  prompt_cache_breakpoint: promptCacheBreakpoint,
+                }),
+              };
+            }
+
+            case 'file': {
+              const topLevel = getTopLevelMediaType(item.mediaType);
+              const imageDetail =
+                item.providerOptions?.[providerOptionsName]?.imageDetail;
+
+              if (item.data.type === 'data') {
+                const fullMediaType = resolveFullMediaType({ part: item });
+                if (topLevel === 'image') {
+                  return {
+                    type: 'input_image' as const,
+                    image_url: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`,
+                    detail: imageDetail,
+                    ...(promptCacheBreakpoint != null && {
+                      prompt_cache_breakpoint: promptCacheBreakpoint,
+                    }),
+                  };
+                }
+                return {
+                  type: 'input_file' as const,
+                  filename: item.filename ?? 'data',
+                  file_data: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`,
+                  ...(promptCacheBreakpoint != null && {
+                    prompt_cache_breakpoint: promptCacheBreakpoint,
+                  }),
+                };
+              }
+
+              if (item.data.type === 'url') {
+                if (topLevel === 'image') {
+                  return {
+                    type: 'input_image' as const,
+                    image_url: item.data.url.toString(),
+                    detail: imageDetail,
+                    ...(promptCacheBreakpoint != null && {
+                      prompt_cache_breakpoint: promptCacheBreakpoint,
+                    }),
+                  };
+                }
+                return {
+                  type: 'input_file' as const,
+                  file_url: item.data.url.toString(),
+                  ...(promptCacheBreakpoint != null && {
+                    prompt_cache_breakpoint: promptCacheBreakpoint,
+                  }),
+                };
+              }
+
+              warnings.push({
+                type: 'other',
+                message: `unsupported tool content part type: ${item.type} with data type: ${item.data.type}`,
+              });
+              return undefined;
+            }
+
+            default: {
+              warnings.push({
+                type: 'other',
+                message: `unsupported tool content part type: ${item.type}`,
+              });
+              return undefined;
+            }
+          }
+        })
+        .filter(isNonNullable);
+  }
+}
+
+type ParallelToolResultGroup = {
+  metadata: ParallelToolCallMetadata;
+  results: Array<LanguageModelV4ToolResultPart>;
+};
+
+function hasSameParallelToolCall(
+  first: ParallelToolCallMetadata,
+  second: ParallelToolCallMetadata,
+): boolean {
+  return (
+    first.itemId === second.itemId &&
+    first.toolCallId === second.toolCallId &&
+    first.toolName === second.toolName &&
+    first.input === second.input &&
+    first.count === second.count
+  );
+}
+
+function collectCompleteParallelToolResultGroups({
+  prompt,
+  providerOptionsName,
+}: {
+  prompt: LanguageModelV4Prompt;
+  providerOptionsName: string;
+}): Map<string, ParallelToolResultGroup> {
+  const pendingGroups = new Map<
+    string,
+    {
+      metadata: ParallelToolCallMetadata;
+      results: Map<number, LanguageModelV4ToolResultPart>;
+      invalid: boolean;
+    }
+  >();
+
+  for (const message of prompt) {
+    if (message.role !== 'tool') {
+      continue;
+    }
+
+    for (const part of message.content) {
+      if (part.type !== 'tool-result') {
+        continue;
+      }
+
+      const metadata = getParallelToolCallMetadata({
+        providerOptions: part.providerOptions,
+        providerOptionsName,
+      });
+
+      if (metadata == null) {
+        continue;
+      }
+
+      const existing = pendingGroups.get(metadata.toolCallId);
+      if (existing == null) {
+        pendingGroups.set(metadata.toolCallId, {
+          metadata,
+          results: new Map([[metadata.index, part]]),
+          invalid: false,
+        });
+        continue;
+      }
+
+      if (
+        !hasSameParallelToolCall(existing.metadata, metadata) ||
+        existing.results.has(metadata.index)
+      ) {
+        existing.invalid = true;
+        continue;
+      }
+
+      existing.results.set(metadata.index, part);
+    }
+  }
+
+  const completeGroups = new Map<string, ParallelToolResultGroup>();
+
+  for (const [toolCallId, group] of pendingGroups) {
+    if (group.invalid || group.results.size !== group.metadata.count) {
+      continue;
+    }
+
+    const results = Array.from({ length: group.metadata.count }, (_, index) =>
+      group.results.get(index),
+    );
+
+    if (results.every(isNonNullable)) {
+      completeGroups.set(toolCallId, {
+        metadata: group.metadata,
+        results,
+      });
+    }
+  }
+
+  return completeGroups;
+}
+
 type OpenAIPromptCacheBreakpoint = { mode: 'explicit' };
 
 function getPromptCacheBreakpoint(
@@ -123,6 +340,15 @@ export async function convertToOpenAIResponsesInput({
   let input: OpenAIResponsesInput = [];
   const warnings: Array<SharedV4Warning> = [];
   const processedApprovalIds = new Set<string>();
+  const parallelToolResultGroups =
+    hasConversation || hasPreviousResponseId
+      ? collectCompleteParallelToolResultGroups({
+          prompt,
+          providerOptionsName,
+        })
+      : new Map<string, ParallelToolResultGroup>();
+  const emittedParallelToolCalls = new Set<string>();
+  const emittedParallelToolResults = new Set<string>();
 
   for (const { role, content, providerOptions } of prompt) {
     switch (role) {
@@ -348,6 +574,49 @@ export async function convertToOpenAIResponsesInput({
               break;
             }
             case 'tool-call': {
+              const parallelToolCallMetadata = getParallelToolCallMetadata({
+                providerOptions: part.providerOptions,
+                providerOptionsName,
+              });
+              const parallelToolResultGroup =
+                parallelToolCallMetadata == null
+                  ? undefined
+                  : parallelToolResultGroups.get(
+                      parallelToolCallMetadata.toolCallId,
+                    );
+
+              if (
+                parallelToolCallMetadata != null &&
+                parallelToolResultGroup != null &&
+                hasSameParallelToolCall(
+                  parallelToolResultGroup.metadata,
+                  parallelToolCallMetadata,
+                )
+              ) {
+                if (
+                  !emittedParallelToolCalls.has(
+                    parallelToolResultGroup.metadata.toolCallId,
+                  )
+                ) {
+                  emittedParallelToolCalls.add(
+                    parallelToolResultGroup.metadata.toolCallId,
+                  );
+
+                  // Conversations already contain the original wrapper item.
+                  // previousResponseId chains require plain client function
+                  // calls to be reconstructed in full.
+                  if (!hasConversation) {
+                    input.push({
+                      type: 'function_call',
+                      call_id: parallelToolResultGroup.metadata.toolCallId,
+                      name: parallelToolResultGroup.metadata.toolName,
+                      arguments: parallelToolResultGroup.metadata.input,
+                    });
+                  }
+                }
+                break;
+              }
+
               const id = (part.providerOptions?.[providerOptionsName]?.itemId ??
                 (
                   part as {
@@ -918,6 +1187,63 @@ export async function convertToOpenAIResponsesInput({
             continue;
           }
 
+          const parallelToolCallMetadata = getParallelToolCallMetadata({
+            providerOptions: part.providerOptions,
+            providerOptionsName,
+          });
+          const parallelToolResultGroup =
+            parallelToolCallMetadata == null
+              ? undefined
+              : parallelToolResultGroups.get(
+                  parallelToolCallMetadata.toolCallId,
+                );
+
+          if (
+            parallelToolCallMetadata != null &&
+            parallelToolResultGroup != null &&
+            hasSameParallelToolCall(
+              parallelToolResultGroup.metadata,
+              parallelToolCallMetadata,
+            )
+          ) {
+            if (
+              !emittedParallelToolResults.has(
+                parallelToolResultGroup.metadata.toolCallId,
+              )
+            ) {
+              emittedParallelToolResults.add(
+                parallelToolResultGroup.metadata.toolCallId,
+              );
+
+              const toolOutputs = await Promise.all(
+                parallelToolResultGroup.results.map(async result =>
+                  convertFunctionToolResultOutput({
+                    output: result.output,
+                    toolName: result.toolName,
+                    outputSchemaToolNames,
+                    providerOptionsName,
+                    warnings,
+                  }),
+                ),
+              );
+
+              input.push({
+                type: 'function_call_output',
+                call_id: parallelToolResultGroup.metadata.toolCallId,
+                // The internal wrapper returns one output containing the child
+                // results in the same order as the original tool_uses array.
+                output: toolOutputs
+                  .map(output =>
+                    typeof output === 'string'
+                      ? output
+                      : JSON.stringify(output),
+                  )
+                  .join('\n'),
+              });
+            }
+            continue;
+          }
+
           const output = part.output;
 
           // Skip execution-denied with approvalId - already handled via tool-approval-response
@@ -1152,114 +1478,13 @@ export async function convertToOpenAIResponsesInput({
             continue;
           }
 
-          let contentValue: OpenAIResponsesFunctionCallOutput['output'];
-          // `output` is always a string, but for functions with output_schema
-          // OpenAI parses the contents of that string as JSON. Text-like results
-          // therefore need JSON.stringify to become valid JSON string literals.
-          const hasOutputSchema = outputSchemaToolNames?.has(part.toolName);
-          switch (output.type) {
-            case 'text':
-            case 'error-text':
-              contentValue = hasOutputSchema
-                ? JSON.stringify(output.value)
-                : output.value;
-              break;
-            case 'execution-denied': {
-              const reason = output.reason ?? 'Tool call execution denied.';
-              contentValue = hasOutputSchema ? JSON.stringify(reason) : reason;
-              break;
-            }
-            case 'json':
-            case 'error-json':
-              contentValue = JSON.stringify(output.value);
-              break;
-            case 'content':
-              contentValue = output.value
-                .map(item => {
-                  const promptCacheBreakpoint = getPromptCacheBreakpoint(
-                    item.providerOptions,
-                    providerOptionsName,
-                  );
-                  switch (item.type) {
-                    case 'text': {
-                      return {
-                        type: 'input_text' as const,
-                        text: item.text,
-                        ...(promptCacheBreakpoint != null && {
-                          prompt_cache_breakpoint: promptCacheBreakpoint,
-                        }),
-                      };
-                    }
-
-                    case 'file': {
-                      const topLevel = getTopLevelMediaType(item.mediaType);
-                      const imageDetail =
-                        item.providerOptions?.[providerOptionsName]
-                          ?.imageDetail;
-
-                      if (item.data.type === 'data') {
-                        const fullMediaType = resolveFullMediaType({
-                          part: item,
-                        });
-                        if (topLevel === 'image') {
-                          return {
-                            type: 'input_image' as const,
-                            image_url: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`,
-                            detail: imageDetail,
-                            ...(promptCacheBreakpoint != null && {
-                              prompt_cache_breakpoint: promptCacheBreakpoint,
-                            }),
-                          };
-                        }
-                        return {
-                          type: 'input_file' as const,
-                          filename: item.filename ?? 'data',
-                          file_data: `data:${fullMediaType};base64,${convertToBase64(item.data.data)}`,
-                          ...(promptCacheBreakpoint != null && {
-                            prompt_cache_breakpoint: promptCacheBreakpoint,
-                          }),
-                        };
-                      }
-
-                      if (item.data.type === 'url') {
-                        if (topLevel === 'image') {
-                          return {
-                            type: 'input_image' as const,
-                            image_url: item.data.url.toString(),
-                            detail: imageDetail,
-                            ...(promptCacheBreakpoint != null && {
-                              prompt_cache_breakpoint: promptCacheBreakpoint,
-                            }),
-                          };
-                        }
-                        return {
-                          type: 'input_file' as const,
-                          file_url: item.data.url.toString(),
-                          ...(promptCacheBreakpoint != null && {
-                            prompt_cache_breakpoint: promptCacheBreakpoint,
-                          }),
-                        };
-                      }
-
-                      warnings.push({
-                        type: 'other',
-                        message: `unsupported tool content part type: ${item.type} with data type: ${item.data.type}`,
-                      });
-                      return undefined;
-                    }
-
-                    default: {
-                      warnings.push({
-                        type: 'other',
-                        message: `unsupported tool content part type: ${item.type}`,
-                      });
-                      return undefined;
-                    }
-                  }
-                })
-                .filter(isNonNullable);
-              break;
-          }
+          const contentValue = await convertFunctionToolResultOutput({
+            output,
+            toolName: part.toolName,
+            outputSchemaToolNames,
+            providerOptionsName,
+            warnings,
+          });
 
           const caller = mapToolCaller(
             part.providerOptions?.[providerOptionsName]?.caller as

package/src/responses/expand-parallel-tool-call.ts

@@ -0,0 +1,142 @@
+import {
+  isJSONObject,
+  type LanguageModelV4FunctionTool,
+  type LanguageModelV4ToolCall,
+  type SharedV4ProviderOptions,
+} from '@ai-sdk/provider';
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+
+const parallelToolName = 'parallel';
+const recipientNamePrefix = 'functions.';
+
+/**
+ * Preserves the original wrapper identity so child results can be sent back as
+ * one function output when Responses API server-side state is used.
+ */
+export type ParallelToolCallMetadata = {
+  itemId: string;
+  toolCallId: string;
+  toolName: string;
+  input: string;
+  index: number;
+  count: number;
+};
+
+export function getParallelToolCallMetadata({
+  providerOptions,
+  providerOptionsName,
+}: {
+  providerOptions: SharedV4ProviderOptions | undefined;
+  providerOptionsName: string;
+}): ParallelToolCallMetadata | undefined {
+  const metadata = providerOptions?.[providerOptionsName]?.parallelToolCall;
+
+  if (
+    !isJSONObject(metadata) ||
+    typeof metadata.itemId !== 'string' ||
+    typeof metadata.toolCallId !== 'string' ||
+    typeof metadata.toolName !== 'string' ||
+    typeof metadata.input !== 'string' ||
+    typeof metadata.index !== 'number' ||
+    !Number.isInteger(metadata.index) ||
+    typeof metadata.count !== 'number' ||
+    !Number.isInteger(metadata.count) ||
+    metadata.index < 0 ||
+    metadata.count <= metadata.index
+  ) {
+    return undefined;
+  }
+
+  return metadata as ParallelToolCallMetadata;
+}
+
+export function isUndeclaredParallelToolCall({
+  toolName,
+  tools,
+}: {
+  toolName: string;
+  tools: Array<LanguageModelV4FunctionTool>;
+}): boolean {
+  return (
+    toolName === parallelToolName &&
+    !tools.some(tool => tool.name === parallelToolName)
+  );
+}
+
+/**
+ * Expands the internal parallel tool wrapper that OpenAI models can emit as a
+ * regular function call. The wrapper is only recognized when every nested
+ * recipient is a declared client-side function tool.
+ */
+export async function expandParallelToolCall({
+  toolCall,
+  tools,
+  providerOptionsName,
+  itemId,
+}: {
+  toolCall: Pick<LanguageModelV4ToolCall, 'toolCallId' | 'toolName' | 'input'>;
+  tools: Array<LanguageModelV4FunctionTool>;
+  providerOptionsName: string;
+  itemId: string;
+}): Promise<Array<LanguageModelV4ToolCall> | undefined> {
+  if (!isUndeclaredParallelToolCall({ toolName: toolCall.toolName, tools })) {
+    return undefined;
+  }
+
+  const parsedInput = await safeParseJSON({ text: toolCall.input });
+
+  if (!parsedInput.success || !isJSONObject(parsedInput.value)) {
+    return undefined;
+  }
+
+  const toolUses = parsedInput.value.tool_uses;
+  if (!Array.isArray(toolUses) || toolUses.length === 0) {
+    return undefined;
+  }
+
+  const availableToolNames = new Set(tools.map(tool => tool.name));
+  const expandedToolCalls: Array<LanguageModelV4ToolCall> = [];
+
+  for (const [index, toolUse] of toolUses.entries()) {
+    if (!isJSONObject(toolUse)) {
+      return undefined;
+    }
+
+    const recipientName = toolUse.recipient_name;
+    const parameters = toolUse.parameters;
+
+    if (
+      typeof recipientName !== 'string' ||
+      !recipientName.startsWith(recipientNamePrefix) ||
+      !isJSONObject(parameters)
+    ) {
+      return undefined;
+    }
+
+    const toolName = recipientName.slice(recipientNamePrefix.length);
+    if (toolName.length === 0 || !availableToolNames.has(toolName)) {
+      return undefined;
+    }
+
+    expandedToolCalls.push({
+      type: 'tool-call',
+      toolCallId: `${toolCall.toolCallId}_${index}`,
+      toolName,
+      input: JSON.stringify(parameters),
+      providerMetadata: {
+        [providerOptionsName]: {
+          parallelToolCall: {
+            itemId,
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input,
+            index,
+            count: toolUses.length,
+          } satisfies ParallelToolCallMetadata,
+        },
+      },
+    });
+  }
+
+  return expandedToolCalls;
+}