@ai-sdk/openai 4.0.24 → 4.0.25

package/dist/internal/index.d.ts

@@ -425,6 +425,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;
@@ -1462,7 +1470,7 @@ declare const programmaticToolCallingOutputSchema: _ai_sdk_provider_utils.LazySc
     result: string;
     status: "completed" | "incomplete";
 }>;
-declare const programmaticToolCalling: () => _ai_sdk_provider_utils.ProviderExecutedTool<{
+declare const programmaticToolCalling: () => _ai_sdk_provider_utils.Experimental_ToolCallerTool<_ai_sdk_provider_utils.ProviderExecutedTool<{
     /**
      * JavaScript source generated and executed by OpenAI.
      */
@@ -1480,7 +1488,7 @@ declare const programmaticToolCalling: () => _ai_sdk_provider_utils.ProviderExec
      * Whether the program completed or stopped before producing a final result.
      */
     status: "completed" | "incomplete";
-}, {}>;
+}, {}>>;
 
 declare const webSearchArgsSchema: _ai_sdk_provider_utils.LazySchema<{
     externalWebAccess?: boolean | undefined;

package/dist/internal/index.js

@@ -74,15 +74,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;
       }
@@ -92,7 +105,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,
@@ -104,13 +120,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,
@@ -3384,6 +3433,7 @@ var toolSearchToolFactory = createProviderDefinedToolFactoryWithOutputSchema5({
 // src/tool/programmatic-tool-calling.ts
 import {
   createProviderExecutedToolFactory,
+  experimental_toolCaller,
   lazySchema as lazySchema17,
   zodSchema as zodSchema17
 } from "@ai-sdk/provider-utils";
@@ -3410,7 +3460,25 @@ var programmaticToolCallingFactory = createProviderExecutedToolFactory({
   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/responses/convert-to-openai-responses-input.ts
 function serializeToolCallArguments2(input) {
@@ -4548,6 +4616,15 @@ var openaiResponsesChunkSchema = lazySchema18(
           service_tier: z20.string().nullish()
         })
       }),
+      z20.object({
+        type: z20.literal("response.in_progress"),
+        response: z20.object({
+          id: z20.string(),
+          created_at: z20.number(),
+          model: z20.string(),
+          service_tier: z20.string().nullish()
+        })
+      }),
       z20.object({
         type: z20.literal("response.output_item.added"),
         output_index: z20.number(),
@@ -7304,6 +7381,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
@@ -8345,8 +8423,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;