@ai-sdk/openai 3.0.72 → 3.0.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "3.0.72",
+  "version": "3.0.74",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider-utils": "4.0.30",
-    "@ai-sdk/provider": "3.0.10"
+    "@ai-sdk/provider": "3.0.10",
+    "@ai-sdk/provider-utils": "4.0.30"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/responses/convert-openai-responses-usage.ts

@@ -5,9 +5,12 @@ export type OpenAIResponsesUsage = {
   output_tokens: number;
   input_tokens_details?: {
     cached_tokens?: number | null;
+    orchestration_input_tokens?: number | null;
+    orchestration_input_cached_tokens?: number | null;
   } | null;
   output_tokens_details?: {
     reasoning_tokens?: number | null;
+    orchestration_output_tokens?: number | null;
   } | null;
 };
 

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

@@ -281,10 +281,29 @@ export async function convertToOpenAIResponsesInput({
                 break;
               }
 
-              if (store && id != null) {
-                if (hasPreviousResponseId) {
-                  break;
-                }
+              // When chaining with a previous response id, items already part
+              // of that response chain must not be resent.
+              if (hasPreviousResponseId && store && id != null) {
+                break;
+              }
+
+              // Provider-defined tool calls (local_shell, shell, apply_patch,
+              // and custom tools) are stored by the API and can be sent as an
+              // `item_reference` to reduce payload size. Plain client-executed
+              // function calls must NOT be: the matching `function_call_output`
+              // can only reference the call by `call_id` (`call_...`), which
+              // the API cannot reconcile with an item id (`fc_...`) or an
+              // `item_reference`. Sending either breaks call/output pairing and
+              // makes follow-up requests fail with "No tool call found for
+              // function call output with call_id", most visibly with parallel
+              // tool calls across multiple steps.
+              const isProviderDefinedToolCall =
+                (hasLocalShellTool && resolvedToolName === 'local_shell') ||
+                (hasShellTool && resolvedToolName === 'shell') ||
+                (hasApplyPatchTool && resolvedToolName === 'apply_patch') ||
+                (customProviderToolNames?.has(resolvedToolName) ?? false);
+
+              if (store && id != null && isProviderDefinedToolCall) {
                 input.push({ type: 'item_reference', id });
                 break;
               }
@@ -366,7 +385,6 @@ export async function convertToOpenAIResponsesInput({
                 call_id: part.toolCallId,
                 name: resolvedToolName,
                 arguments: serializeToolCallArguments(part.input),
-                id,
                 ...(namespace != null && { namespace }),
               });
               break;

package/src/responses/openai-responses-api.ts

@@ -500,11 +500,18 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
           usage: z.object({
             input_tokens: z.number(),
             input_tokens_details: z
-              .object({ cached_tokens: z.number().nullish() })
+              .object({
+                cached_tokens: z.number().nullish(),
+                orchestration_input_tokens: z.number().nullish(),
+                orchestration_input_cached_tokens: z.number().nullish(),
+              })
               .nullish(),
             output_tokens: z.number(),
             output_tokens_details: z
-              .object({ reasoning_tokens: z.number().nullish() })
+              .object({
+                reasoning_tokens: z.number().nullish(),
+                orchestration_output_tokens: z.number().nullish(),
+              })
               .nullish(),
           }),
           service_tier: z.string().nullish(),
@@ -524,11 +531,18 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
             .object({
               input_tokens: z.number(),
               input_tokens_details: z
-                .object({ cached_tokens: z.number().nullish() })
+                .object({
+                  cached_tokens: z.number().nullish(),
+                  orchestration_input_tokens: z.number().nullish(),
+                  orchestration_input_cached_tokens: z.number().nullish(),
+                })
                 .nullish(),
               output_tokens: z.number(),
               output_tokens_details: z
-                .object({ reasoning_tokens: z.number().nullish() })
+                .object({
+                  reasoning_tokens: z.number().nullish(),
+                  orchestration_output_tokens: z.number().nullish(),
+                })
                 .nullish(),
             })
             .nullish(),
@@ -1377,11 +1391,18 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
         .object({
           input_tokens: z.number(),
           input_tokens_details: z
-            .object({ cached_tokens: z.number().nullish() })
+            .object({
+              cached_tokens: z.number().nullish(),
+              orchestration_input_tokens: z.number().nullish(),
+              orchestration_input_cached_tokens: z.number().nullish(),
+            })
             .nullish(),
           output_tokens: z.number(),
           output_tokens_details: z
-            .object({ reasoning_tokens: z.number().nullish() })
+            .object({
+              reasoning_tokens: z.number().nullish(),
+              orchestration_output_tokens: z.number().nullish(),
+            })
             .nullish(),
         })
         .optional(),