@ai-sdk/openai 3.0.97 → 3.0.99

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

@@ -6,6 +6,7 @@ import {
   type LanguageModelV3CallOptions,
   type LanguageModelV3Content,
   type LanguageModelV3FinishReason,
+  type LanguageModelV3FunctionTool,
   type LanguageModelV3GenerateResult,
   type LanguageModelV3ProviderTool,
   type LanguageModelV3StreamPart,
@@ -49,6 +50,10 @@ import {
   type OpenAIResponsesUsage,
 } from './convert-openai-responses-usage';
 import { convertToOpenAIResponsesInput } from './convert-to-openai-responses-input';
+import {
+  expandParallelToolCall,
+  isUndeclaredParallelToolCall,
+} from './expand-parallel-tool-call';
 import { mapOpenAIResponseFinishReason } from './map-openai-responses-finish-reason';
 import {
   openaiResponsesChunkSchema,
@@ -538,6 +543,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
 
     const content: Array<LanguageModelV3Content> = [];
     const logprobs: Array<OpenAIResponsesLogprobs> = [];
+    const functionTools =
+      options.tools?.filter(
+        (tool): tool is LanguageModelV3FunctionTool => tool.type === 'function',
+      ) ?? [];
 
     // flag that checks if there have been client-side tool calls (not executed by openai)
     let hasFunctionCall = false;
@@ -798,6 +807,22 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
         case 'function_call': {
           hasFunctionCall = true;
 
+          const expandedToolCalls = await expandParallelToolCall({
+            toolCall: {
+              toolCallId: part.call_id,
+              toolName: part.name,
+              input: part.arguments,
+            },
+            tools: functionTools,
+            providerOptionsName,
+            itemId: part.id,
+          });
+
+          if (expandedToolCalls != null) {
+            content.push(...expandedToolCalls);
+            break;
+          }
+
           content.push({
             type: 'tool-call',
             toolCallId: part.call_id,
@@ -1105,6 +1130,11 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
     const approvalRequestIdToDummyToolCallIdFromPrompt =
       extractApprovalRequestIdToToolCallIdMapping(options.prompt);
 
+    const functionTools =
+      options.tools?.filter(
+        (tool): tool is LanguageModelV3FunctionTool => tool.type === 'function',
+      ) ?? [];
+
     const approvalRequestIdToDummyToolCallIdFromStream = new Map<
       string,
       string
@@ -1131,6 +1161,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
             endEmitted: boolean;
           };
           toolSearchExecution?: 'server' | 'client';
+          suppressInputStreaming?: boolean;
+          bufferedInputDeltas?: string[];
         }
       | undefined
     > = {};
@@ -1199,16 +1231,25 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
 
             if (isResponseOutputItemAddedChunk(value)) {
               if (value.item.type === 'function_call') {
+                const suppressInputStreaming = isUndeclaredParallelToolCall({
+                  toolName: value.item.name,
+                  tools: functionTools,
+                });
+
                 ongoingToolCalls[value.output_index] = {
                   toolName: value.item.name,
                   toolCallId: value.item.call_id,
+                  suppressInputStreaming,
+                  bufferedInputDeltas: suppressInputStreaming ? [] : undefined,
                 };
 
-                controller.enqueue({
-                  type: 'tool-input-start',
-                  id: value.item.call_id,
-                  toolName: value.item.name,
-                });
+                if (!suppressInputStreaming) {
+                  controller.enqueue({
+                    type: 'tool-input-start',
+                    id: value.item.call_id,
+                    toolName: value.item.name,
+                  });
+                }
               } else if (value.item.type === 'custom_tool_call') {
                 const toolName = toolNameMapping.toCustomToolName(
                   value.item.name,
@@ -1439,34 +1480,111 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                   },
                 });
               } else if (value.item.type === 'function_call') {
+                const item = value.item;
+                const ongoingToolCall = ongoingToolCalls[value.output_index];
                 ongoingToolCalls[value.output_index] = undefined;
                 hasFunctionCall = true;
 
-                controller.enqueue({
-                  type: 'tool-input-end',
-                  id: value.item.call_id,
-                  ...(value.item.namespace != null && {
+                const suppressInputStreaming =
+                  ongoingToolCall?.suppressInputStreaming ??
+                  isUndeclaredParallelToolCall({
+                    toolName: item.name,
+                    tools: functionTools,
+                  });
+
+                const enqueueUnexpandedToolCall = () => {
+                  if (suppressInputStreaming) {
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: item.call_id,
+                      toolName: item.name,
+                    });
+
+                    const bufferedInputDeltas =
+                      ongoingToolCall?.bufferedInputDeltas ?? [];
+
+                    if (bufferedInputDeltas.length > 0) {
+                      for (const delta of bufferedInputDeltas) {
+                        controller.enqueue({
+                          type: 'tool-input-delta',
+                          id: item.call_id,
+                          delta,
+                        });
+                      }
+                    } else if (item.arguments.length > 0) {
+                      controller.enqueue({
+                        type: 'tool-input-delta',
+                        id: item.call_id,
+                        delta: item.arguments,
+                      });
+                    }
+                  }
+
+                  controller.enqueue({
+                    type: 'tool-input-end',
+                    id: item.call_id,
+                    ...(item.namespace != null && {
+                      providerMetadata: {
+                        [providerOptionsName]: {
+                          namespace: item.namespace,
+                        },
+                      },
+                    }),
+                  });
+
+                  controller.enqueue({
+                    type: 'tool-call',
+                    toolCallId: item.call_id,
+                    toolName: item.name,
+                    input: item.arguments,
                     providerMetadata: {
                       [providerOptionsName]: {
-                        namespace: value.item.namespace,
+                        itemId: item.id,
+                        ...(item.namespace != null && {
+                          namespace: item.namespace,
+                        }),
                       },
                     },
-                  }),
-                });
+                  });
+                };
 
-                controller.enqueue({
-                  type: 'tool-call',
-                  toolCallId: value.item.call_id,
-                  toolName: value.item.name,
-                  input: value.item.arguments,
-                  providerMetadata: {
-                    [providerOptionsName]: {
-                      itemId: value.item.id,
-                      ...(value.item.namespace != null && {
-                        namespace: value.item.namespace,
-                      }),
-                    },
+                if (!suppressInputStreaming) {
+                  enqueueUnexpandedToolCall();
+                  return;
+                }
+
+                return expandParallelToolCall({
+                  toolCall: {
+                    toolCallId: item.call_id,
+                    toolName: item.name,
+                    input: item.arguments,
                   },
+                  tools: functionTools,
+                  providerOptionsName,
+                  itemId: item.id,
+                }).then(expandedToolCalls => {
+                  if (expandedToolCalls == null) {
+                    enqueueUnexpandedToolCall();
+                    return;
+                  }
+
+                  for (const toolCall of expandedToolCalls) {
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: toolCall.toolCallId,
+                      toolName: toolCall.toolName,
+                    });
+                    controller.enqueue({
+                      type: 'tool-input-delta',
+                      id: toolCall.toolCallId,
+                      delta: toolCall.input,
+                    });
+                    controller.enqueue({
+                      type: 'tool-input-end',
+                      id: toolCall.toolCallId,
+                    });
+                    controller.enqueue(toolCall);
+                  }
                 });
               } else if (value.item.type === 'custom_tool_call') {
                 ongoingToolCalls[value.output_index] = undefined;
@@ -1863,11 +1981,15 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
               const toolCall = ongoingToolCalls[value.output_index];
 
               if (toolCall != null) {
-                controller.enqueue({
-                  type: 'tool-input-delta',
-                  id: toolCall.toolCallId,
-                  delta: value.delta,
-                });
+                if (toolCall.suppressInputStreaming) {
+                  toolCall.bufferedInputDeltas?.push(value.delta);
+                } else {
+                  controller.enqueue({
+                    type: 'tool-input-delta',
+                    id: toolCall.toolCallId,
+                    delta: value.delta,
+                  });
+                }
               }
             } else if (isResponseCustomToolCallInputDeltaChunk(value)) {
               const toolCall = ongoingToolCalls[value.output_index];
@@ -2189,6 +2311,26 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
           },
 
           flush(controller) {
+            for (const toolCall of Object.values(ongoingToolCalls)) {
+              if (!toolCall?.suppressInputStreaming) {
+                continue;
+              }
+
+              controller.enqueue({
+                type: 'tool-input-start',
+                id: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+              });
+
+              for (const delta of toolCall.bufferedInputDeltas ?? []) {
+                controller.enqueue({
+                  type: 'tool-input-delta',
+                  id: toolCall.toolCallId,
+                  delta,
+                });
+              }
+            }
+
             const providerMetadata: SharedV3ProviderMetadata = {
               [providerOptionsName]: {
                 responseId: responseId,

package/src/responses/openai-responses-prepare-tools.ts

@@ -15,10 +15,15 @@ import { toolSearchArgsSchema } from '../tool/tool-search';
 import { webSearchArgsSchema } from '../tool/web-search';
 import { webSearchPreviewArgsSchema } from '../tool/web-search-preview';
 import type {
+  OpenAIResponsesAllowedTool,
   OpenAIResponsesFunctionTool,
   OpenAIResponsesTool,
 } from './openai-responses-api';
 
+type AllowedToolResolution =
+  | { supported: true; entry: OpenAIResponsesAllowedTool }
+  | { supported: false; reason: string };
+
 type OpenAIToolOptions = {
   deferLoading?: boolean;
   namespace?: {
@@ -60,7 +65,7 @@ export async function prepareResponsesTools({
     | {
         type: 'allowed_tools';
         mode: 'auto' | 'required';
-        tools: Array<{ type: 'function'; name: string }>;
+        tools: Array<OpenAIResponsesAllowedTool>;
       };
   toolWarnings: SharedV3Warning[];
 }> {
@@ -81,6 +86,35 @@ export async function prepareResponsesTools({
   const resolvedCustomProviderToolNames =
     customProviderToolNames ?? new Set<string>();
 
+  const allowedToolResolutions = new Map<string, AllowedToolResolution>();
+  const allowedToolAliases = new Map<
+    string,
+    AllowedToolResolution | 'ambiguous'
+  >();
+
+  const recordAllowedTool = (
+    toolName: string,
+    resolution: AllowedToolResolution,
+    canonicalName: string | undefined,
+  ) => {
+    allowedToolResolutions.set(toolName, resolution);
+
+    if (canonicalName == null || canonicalName === toolName) {
+      return;
+    }
+
+    const existingAlias = allowedToolAliases.get(canonicalName);
+
+    if (existingAlias == null) {
+      allowedToolAliases.set(canonicalName, resolution);
+    } else if (
+      existingAlias !== 'ambiguous' &&
+      !isSameAllowedTool(existingAlias, resolution)
+    ) {
+      allowedToolAliases.set(canonicalName, 'ambiguous');
+    }
+  };
+
   for (const tool of tools) {
     switch (tool.type) {
       case 'function': {
@@ -115,9 +149,32 @@ export async function prepareResponsesTools({
 
           namespaceTool.tools.push(openaiFunctionTool);
         }
+
+        recordAllowedTool(
+          tool.name,
+          namespace != null
+            ? {
+                supported: false,
+                reason:
+                  'tools inside an OpenAI tool namespace are not visible to tool_choice.allowed_tools',
+              }
+            : openaiOptions?.deferLoading === true
+              ? {
+                  supported: false,
+                  reason:
+                    'deferred tools are not visible to tool_choice.allowed_tools',
+                }
+              : {
+                  supported: true,
+                  entry: { type: 'function', name: tool.name },
+                },
+          undefined,
+        );
         break;
       }
       case 'provider': {
+        const openaiToolCountBefore = openaiTools.length;
+
         switch (tool.id) {
           case 'openai.file_search': {
             const args = await validateTypes({
@@ -321,6 +378,16 @@ export async function prepareResponsesTools({
             break;
           }
         }
+
+        if (openaiTools.length > openaiToolCountBefore) {
+          const openaiTool = openaiTools[openaiToolCountBefore];
+
+          recordAllowedTool(
+            tool.name,
+            toAllowedToolResolution(openaiTool),
+            toolNameMapping?.toProviderToolName(tool.name),
+          );
+        }
         break;
       }
       default:
@@ -333,15 +400,74 @@ export async function prepareResponsesTools({
   }
 
   if (allowedTools != null) {
+    const allowedToolEntries: Array<OpenAIResponsesAllowedTool> = [];
+    const droppedToolNames: string[] = [];
+
+    for (const name of allowedTools.toolNames) {
+      const directResolution = allowedToolResolutions.get(name);
+      const resolution = directResolution ?? allowedToolAliases.get(name);
+
+      if (directResolution != null && allowedToolAliases.has(name)) {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `allowedTools entry "${name}"`,
+          details:
+            'this name is both a tool name and the provider tool name of another tool in this request; the tool with this name is allowed',
+        });
+      }
+
+      if (resolution === 'ambiguous') {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `allowedTools entry "${name}"`,
+          details:
+            'several tools in this request share this provider tool name; use the tool name from the tools for this request instead',
+        });
+        droppedToolNames.push(name);
+        continue;
+      }
+
+      if (resolution == null) {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `allowedTools entry "${name}"`,
+          details:
+            'the tool is not part of the tools for this request and is sent as a function tool',
+        });
+        allowedToolEntries.push({
+          type: 'function',
+          name: toolNameMapping?.toProviderToolName(name) ?? name,
+        });
+        continue;
+      }
+
+      if (!resolution.supported) {
+        toolWarnings.push({
+          type: 'unsupported',
+          feature: `allowedTools entry "${name}"`,
+          details: `${resolution.reason}; the tool is removed from the allowed tools`,
+        });
+        droppedToolNames.push(name);
+        continue;
+      }
+
+      allowedToolEntries.push(resolution.entry);
+    }
+
+    if (allowedToolEntries.length === 0) {
+      throw new UnsupportedFunctionalityError({
+        functionality: `allowedTools with only tools that cannot be allow-listed (${droppedToolNames.join(
+          ', ',
+        )})`,
+      });
+    }
+
     return {
       tools: openaiTools,
       toolChoice: {
         type: 'allowed_tools',
         mode: allowedTools.mode ?? 'auto',
-        tools: allowedTools.toolNames.map(name => ({
-          type: 'function',
-          name: toolNameMapping?.toProviderToolName(name) ?? name,
-        })),
+        tools: allowedToolEntries,
       },
       toolWarnings,
     };
@@ -389,6 +515,61 @@ export async function prepareResponsesTools({
   }
 }
 
+function allowedToolKey(entry: OpenAIResponsesAllowedTool): string {
+  switch (entry.type) {
+    case 'mcp':
+      return `mcp:${entry.server_label}`;
+    case 'function':
+    case 'custom':
+      return `${entry.type}:${entry.name}`;
+    default:
+      return entry.type;
+  }
+}
+
+function isSameAllowedTool(
+  a: AllowedToolResolution,
+  b: AllowedToolResolution,
+): boolean {
+  if (a.supported && b.supported) {
+    return allowedToolKey(a.entry) === allowedToolKey(b.entry);
+  }
+
+  if (!a.supported && !b.supported) {
+    return a.reason === b.reason;
+  }
+
+  return false;
+}
+
+function toAllowedToolResolution(
+  tool: OpenAIResponsesTool,
+): AllowedToolResolution {
+  switch (tool.type) {
+    case 'custom':
+      return { supported: true, entry: { type: 'custom', name: tool.name } };
+    case 'mcp':
+      return {
+        supported: true,
+        entry: { type: 'mcp', server_label: tool.server_label },
+      };
+    case 'file_search':
+    case 'web_search':
+    case 'web_search_preview':
+    case 'image_generation':
+    case 'code_interpreter':
+    case 'apply_patch':
+    case 'shell':
+    case 'local_shell':
+      return { supported: true, entry: { type: tool.type } };
+    default:
+      return {
+        supported: false,
+        reason: `OpenAI does not support ${tool.type} tools in tool_choice.allowed_tools`,
+      };
+  }
+}
+
 function prepareFunctionTool({
   tool,
   options,