@ai-sdk/openai 4.0.24 → 4.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.24",
+  "version": "4.0.26",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,16 +35,16 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.4",
-    "@ai-sdk/provider-utils": "5.0.15"
+    "@ai-sdk/provider-utils": "5.0.17",
+    "@ai-sdk/provider": "4.0.4"
   },
   "devDependencies": {
     "@types/node": "22.19.19",
     "tsup": "^8.5.1",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "2.0.0",
-    "@vercel/ai-tsconfig": "0.0.0"
+    "@vercel/ai-tsconfig": "0.0.0",
+    "@ai-sdk/test-server": "2.0.1"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

package/src/files/openai-files.ts

@@ -60,7 +60,11 @@ export class OpenAIFiles implements FilesV4 {
     formData.append('purpose', openaiOptions?.purpose ?? 'assistants');
 
     if (openaiOptions?.expiresAfter != null) {
-      formData.append('expires_after', String(openaiOptions.expiresAfter));
+      formData.append('expires_after[anchor]', 'created_at');
+      formData.append(
+        'expires_after[seconds]',
+        String(openaiOptions.expiresAfter),
+      );
     }
 
     const { value: response } = await postFormDataToApi({

package/src/openai-stream-error.ts

@@ -12,6 +12,8 @@ export async function throwIfOpenAIStreamErrorBeforeOutput<T>({
   stream,
   getError,
   isOutputChunk,
+  isAcceptedChunk,
+  acceptedGraceMs = 50,
   url,
   requestBodyValues,
   responseHeaders,
@@ -19,16 +21,44 @@ export async function throwIfOpenAIStreamErrorBeforeOutput<T>({
   stream: ReadableStream<ParseResult<T>>;
   getError: (chunk: T) => unknown | undefined;
   isOutputChunk: (chunk: T) => boolean;
+  /**
+   * Marks a chunk that proves the request was accepted and generation has
+   * started (e.g. the Responses API `response.in_progress` event). Once seen,
+   * the early-error peek stops blocking indefinitely: each subsequent read is
+   * raced against `acceptedGraceMs` so error frames that are flushed together
+   * with the accepted chunk (e.g. `insufficient_quota`) still throw, while a
+   * healthy stream becomes available without waiting for the first output
+   * token.
+   */
+  isAcceptedChunk?: (chunk: T) => boolean;
+  /**
+   * How long to keep peeking for an error frame after an accepted chunk was
+   * seen. Only used when `isAcceptedChunk` is provided.
+   */
+  acceptedGraceMs?: number;
   url: string;
   requestBodyValues: unknown;
   responseHeaders?: Record<string, string>;
 }): Promise<ReadableStream<ParseResult<T>>> {
   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: ReadableStreamReadResult<ParseResult<T>>;
+
+      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;
@@ -43,7 +73,12 @@ export async function throwIfOpenAIStreamErrorBeforeOutput<T>({
       const errorFrame = getError(chunk.value);
 
       if (errorFrame != null) {
-        streamForConsumer.cancel().catch(() => {});
+        // Let the source finish instead of cancelling its transform pipeline.
+        // Node.js 26 can otherwise leave a queued pipe write rejected with
+        // the cancellation reason after the API error has already surfaced.
+        drainAfterError = true;
+        drainReader(reader).catch(() => {});
+        drainReader(streamForConsumer.getReader()).catch(() => {});
         throw createOpenAIStreamError({
           frame: errorFrame,
           url,
@@ -55,13 +90,59 @@ export async function throwIfOpenAIStreamErrorBeforeOutput<T>({
       if (isOutputChunk(chunk.value)) {
         return streamForConsumer;
       }
+
+      if (!accepted && isAcceptedChunk?.(chunk.value) === true) {
+        accepted = true;
+      }
     }
   } finally {
-    reader.cancel().catch(() => {});
+    if (!drainAfterError) {
+      reader.cancel().catch(() => {});
+      reader.releaseLock();
+    }
+  }
+}
+
+async function drainReader<T>(
+  reader: ReadableStreamDefaultReader<T>,
+): Promise<void> {
+  try {
+    while (!(await reader.read()).done) {
+      // Drain the source without retaining its remaining chunks.
+    }
+  } catch {
+    // The API error has already been reported to the caller.
+  } finally {
     reader.releaseLock();
   }
 }
 
+async function raceWithTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+): Promise<{ timedOut: false; value: T } | { timedOut: true }> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const wrapped = promise.then(value => ({ timedOut: false as const, value }));
+  try {
+    const raced = await Promise.race([
+      wrapped,
+      new Promise<{ timedOut: true }>(resolve => {
+        timer = setTimeout(() => resolve({ timedOut: true }), timeoutMs);
+      }),
+    ]);
+    if (raced.timedOut) {
+      // The losing read settles later (typically when the peek branch is
+      // cancelled after the stream is handed to the consumer, or rejects if
+      // the source errors). Adopt it so it can never surface as an
+      // unhandled rejection; the consumer branch sees the same outcome.
+      wrapped.catch(() => {});
+    }
+    return raced;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 function createOpenAIStreamError({
   frame,
   url,

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

@@ -798,6 +798,15 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
           service_tier: z.string().nullish(),
         }),
       }),
+      z.object({
+        type: z.literal('response.in_progress'),
+        response: z.object({
+          id: z.string(),
+          created_at: z.number(),
+          model: z.string(),
+          service_tier: z.string().nullish(),
+        }),
+      }),
       z.object({
         type: z.literal('response.output_item.added'),
         output_index: z.number(),

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

@@ -1316,6 +1316,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
           ? chunk
           : undefined,
       isOutputChunk: isResponseOutputChunk,
+      isAcceptedChunk: isResponseInProgressChunk,
       url,
       requestBodyValues: body,
       responseHeaders,
@@ -2674,9 +2675,16 @@ function isErrorChunk(
   return chunk.type === 'error';
 }
 
+function isResponseInProgressChunk(
+  chunk: OpenAIResponsesChunk,
+): chunk is OpenAIResponsesChunk & { type: 'response.in_progress' } {
+  return chunk.type === 'response.in_progress';
+}
+
 function isResponseOutputChunk(chunk: OpenAIResponsesChunk): boolean {
   return !(
     chunk.type === 'response.created' ||
+    chunk.type === 'response.in_progress' ||
     chunk.type === 'response.failed' ||
     chunk.type === 'error' ||
     chunk.type === 'unknown_chunk'

package/src/tool/programmatic-tool-calling.ts

@@ -1,5 +1,6 @@
 import {
   createProviderExecutedToolFactory,
+  experimental_toolCaller,
   lazySchema,
   zodSchema,
 } from '@ai-sdk/provider-utils';
@@ -54,4 +55,25 @@ const programmaticToolCallingFactory = createProviderExecutedToolFactory<
   supportsDeferredResults: true,
 });
 
-export const programmaticToolCalling = () => programmaticToolCallingFactory({});
+export const programmaticToolCalling = () =>
+  experimental_toolCaller(programmaticToolCallingFactory({}), {
+    type: 'provider',
+    prepareProviderOptions: providerOptions => {
+      const openaiOptions = providerOptions?.openai as
+        | { allowedCallers?: Array<'direct' | 'programmatic'> }
+        | undefined;
+
+      return {
+        ...providerOptions,
+        openai: {
+          ...openaiOptions,
+          allowedCallers: [
+            ...new Set([
+              ...(openaiOptions?.allowedCallers ?? []),
+              'programmatic' as const,
+            ]),
+          ],
+        },
+      };
+    },
+  });