@ai-sdk/openai 4.0.24 → 4.0.25

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @ai-sdk/openai
 
+## 4.0.25
+
+### Patch Changes
+
+- beaecb3: fix(provider/openai): resolve responses doStream at response.in_progress instead of first output token
+
+  The early-stream-error peek treated `response.in_progress` as an unknown chunk, so `doStream` did not resolve until the first output item arrived — delaying stream availability (and downstream TTFB for proxies/gateways) by the model's full time-to-first-token. `response.in_progress` is now modeled in the chunk schema and marks the request as accepted: the peek keeps watching for error frames for a short grace window (50ms) so quota/rate-limit errors flushed alongside `response.in_progress` still throw as retryable `APICallError`s, while healthy streams become available right after upstream acknowledges the request.
+
+- b192878: feat: add experimental_toolCaller routing to generateText for code mode
+- Updated dependencies [d8210b6]
+- Updated dependencies [b192878]
+  - @ai-sdk/provider-utils@5.0.16
+
 ## 4.0.24
 
 ### Patch Changes

package/dist/index.d.ts

@@ -311,6 +311,14 @@ declare const openaiResponsesChunkSchema: _ai_sdk_provider_utils.LazySchema<{
         model: string;
         service_tier?: string | null | undefined;
     };
+} | {
+    type: "response.in_progress";
+    response: {
+        id: string;
+        created_at: number;
+        model: string;
+        service_tier?: string | null | undefined;
+    };
 } | {
     type: "response.output_item.added";
     output_index: number;
@@ -1300,13 +1308,13 @@ declare const openaiTools: {
      * Programmatic Tool Calling lets OpenAI Responses models write and execute
      * JavaScript that orchestrates eligible tools.
      */
-    programmaticToolCalling: () => _ai_sdk_provider_utils.ProviderExecutedTool<{
+    programmaticToolCalling: () => _ai_sdk_provider_utils.Experimental_ToolCallerTool<_ai_sdk_provider_utils.ProviderExecutedTool<{
         code: string;
         fingerprint: string;
     }, {
         result: string;
         status: "completed" | "incomplete";
-    }, {}>;
+    }, {}>>;
     /**
      * Tool search allows the model to dynamically search for and load deferred
      * tools into the model's context as needed. This helps reduce overall token

package/dist/index.js

@@ -83,15 +83,28 @@ async function throwIfOpenAIStreamErrorBeforeOutput({
   stream,
   getError,
   isOutputChunk,
+  isAcceptedChunk,
+  acceptedGraceMs = 50,
   url,
   requestBodyValues,
   responseHeaders
 }) {
   const [streamForEarlyError, streamForConsumer] = stream.tee();
   const reader = streamForEarlyError.getReader();
+  let drainAfterError = false;
   try {
+    let accepted = false;
     while (true) {
-      const result = await reader.read();
+      let result;
+      if (accepted) {
+        const raced = await raceWithTimeout(reader.read(), acceptedGraceMs);
+        if (raced.timedOut) {
+          return streamForConsumer;
+        }
+        result = raced.value;
+      } else {
+        result = await reader.read();
+      }
       if (result.done) {
         return streamForConsumer;
       }
@@ -101,7 +114,10 @@ async function throwIfOpenAIStreamErrorBeforeOutput({
       }
       const errorFrame = getError(chunk.value);
       if (errorFrame != null) {
-        streamForConsumer.cancel().catch(() => {
+        drainAfterError = true;
+        drainReader(reader).catch(() => {
+        });
+        drainReader(streamForConsumer.getReader()).catch(() => {
         });
         throw createOpenAIStreamError({
           frame: errorFrame,
@@ -113,13 +129,46 @@ async function throwIfOpenAIStreamErrorBeforeOutput({
       if (isOutputChunk(chunk.value)) {
         return streamForConsumer;
       }
+      if (!accepted && (isAcceptedChunk == null ? void 0 : isAcceptedChunk(chunk.value)) === true) {
+        accepted = true;
+      }
     }
   } finally {
-    reader.cancel().catch(() => {
-    });
+    if (!drainAfterError) {
+      reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+}
+async function drainReader(reader) {
+  try {
+    while (!(await reader.read()).done) {
+    }
+  } catch (e) {
+  } finally {
     reader.releaseLock();
   }
 }
+async function raceWithTimeout(promise, timeoutMs) {
+  let timer;
+  const wrapped = promise.then((value) => ({ timedOut: false, value }));
+  try {
+    const raced = await Promise.race([
+      wrapped,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ timedOut: true }), timeoutMs);
+      })
+    ]);
+    if (raced.timedOut) {
+      wrapped.catch(() => {
+      });
+    }
+    return raced;
+  } finally {
+    clearTimeout(timer);
+  }
+}
 function createOpenAIStreamError({
   frame,
   url,
@@ -3114,6 +3163,7 @@ var mcp = (args) => mcpToolFactory(args);
 // src/tool/programmatic-tool-calling.ts
 import {
   createProviderExecutedToolFactory as createProviderExecutedToolFactory7,
+  experimental_toolCaller,
   lazySchema as lazySchema23,
   zodSchema as zodSchema23
 } from "@ai-sdk/provider-utils";
@@ -3140,7 +3190,25 @@ var programmaticToolCallingFactory = createProviderExecutedToolFactory7({
   outputSchema: programmaticToolCallingOutputSchema,
   supportsDeferredResults: true
 });
-var programmaticToolCalling = () => programmaticToolCallingFactory({});
+var programmaticToolCalling = () => experimental_toolCaller(programmaticToolCallingFactory({}), {
+  type: "provider",
+  prepareProviderOptions: (providerOptions) => {
+    var _a;
+    const openaiOptions = providerOptions == null ? void 0 : providerOptions.openai;
+    return {
+      ...providerOptions,
+      openai: {
+        ...openaiOptions,
+        allowedCallers: [
+          .../* @__PURE__ */ new Set([
+            ...(_a = openaiOptions == null ? void 0 : openaiOptions.allowedCallers) != null ? _a : [],
+            "programmatic"
+          ])
+        ]
+      }
+    };
+  }
+});
 
 // src/openai-tools.ts
 var openaiTools = {
@@ -4870,6 +4938,15 @@ var openaiResponsesChunkSchema = lazySchema24(
           service_tier: z26.string().nullish()
         })
       }),
+      z26.object({
+        type: z26.literal("response.in_progress"),
+        response: z26.object({
+          id: z26.string(),
+          created_at: z26.number(),
+          model: z26.string(),
+          service_tier: z26.string().nullish()
+        })
+      }),
       z26.object({
         type: z26.literal("response.output_item.added"),
         output_index: z26.number(),
@@ -7275,6 +7352,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       stream: response,
       getError: (chunk) => isErrorChunk(chunk) || isResponseFailedChunk(chunk) && chunk.response.error != null ? chunk : void 0,
       isOutputChunk: isResponseOutputChunk,
+      isAcceptedChunk: isResponseInProgressChunk,
       url,
       requestBodyValues: body,
       responseHeaders
@@ -8316,8 +8394,11 @@ function isResponseAnnotationAddedChunk(chunk) {
 function isErrorChunk(chunk) {
   return chunk.type === "error";
 }
+function isResponseInProgressChunk(chunk) {
+  return chunk.type === "response.in_progress";
+}
 function isResponseOutputChunk(chunk) {
-  return !(chunk.type === "response.created" || chunk.type === "response.failed" || chunk.type === "error" || chunk.type === "unknown_chunk");
+  return !(chunk.type === "response.created" || chunk.type === "response.in_progress" || chunk.type === "response.failed" || chunk.type === "error" || chunk.type === "unknown_chunk");
 }
 function mapWebSearchOutput(action) {
   var _a;
@@ -9422,7 +9503,7 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.24" : "0.0.0-test";
+var VERSION = true ? "4.0.25" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {