@ai-sdk/openai 3.0.80 → 3.0.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "3.0.80",
+  "version": "3.0.82",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "3.0.13",
-    "@ai-sdk/provider-utils": "4.0.35"
+    "@ai-sdk/provider-utils": "4.0.37"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/chat/convert-to-openai-chat-messages.ts

@@ -200,7 +200,7 @@ export function convertToOpenAIChatMessages({
               contentValue = output.value;
               break;
             case 'execution-denied':
-              contentValue = output.reason ?? 'Tool execution denied.';
+              contentValue = output.reason ?? 'Tool call execution denied.';
               break;
             case 'content':
             case 'json':

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

@@ -15,7 +15,6 @@ import {
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   generateId,
-  isParsableJson,
   parseProviderOptions,
   postJsonToApi,
   type FetchFunction,
@@ -23,6 +22,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import { openaiFailedResponseHandler } from '../openai-error';
 import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
+import { throwIfOpenAIStreamErrorBeforeOutput } from '../openai-stream-error';
 import {
   convertOpenAIChatUsage,
   type OpenAIChatUsage,
@@ -414,11 +414,13 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
       },
     };
 
+    const url = this.config.url({
+      path: '/chat/completions',
+      modelId: this.modelId,
+    });
+
     const { responseHeaders, value: response } = await postJsonToApi({
-      url: this.config.url({
-        path: '/chat/completions',
-        modelId: this.modelId,
-      }),
+      url,
       headers: combineHeaders(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
@@ -429,6 +431,15 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
+    const checkedResponse = await throwIfOpenAIStreamErrorBeforeOutput({
+      stream: response,
+      getError: chunk => ('error' in chunk ? chunk.error : undefined),
+      isOutputChunk: isOpenAIChatOutputChunk,
+      url,
+      requestBodyValues: body,
+      responseHeaders,
+    });
+
     const toolCalls: Array<{
       id: string;
       type: 'function';
@@ -449,8 +460,8 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
 
     const providerMetadata: SharedV3ProviderMetadata = { openai: {} };
 
-    return {
-      stream: response.pipeThrough(
+    const result = {
+      stream: checkedResponse.pipeThrough(
         new TransformStream<
           ParseResult<OpenAIChatChunk>,
           LanguageModelV3StreamPart
@@ -605,23 +616,6 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
                         delta: toolCall.function.arguments,
                       });
                     }
-
-                    // check if tool call is complete
-                    // (some providers send the full tool call in one chunk):
-                    if (isParsableJson(toolCall.function.arguments)) {
-                      controller.enqueue({
-                        type: 'tool-input-end',
-                        id: toolCall.id,
-                      });
-
-                      controller.enqueue({
-                        type: 'tool-call',
-                        toolCallId: toolCall.id ?? generateId(),
-                        toolName: toolCall.function.name,
-                        input: toolCall.function.arguments,
-                      });
-                      toolCall.hasFinished = true;
-                    }
                   }
 
                   continue;
@@ -645,26 +639,6 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
                   id: toolCall.id,
                   delta: toolCallDelta.function.arguments ?? '',
                 });
-
-                // check if tool call is complete
-                if (
-                  toolCall.function?.name != null &&
-                  toolCall.function?.arguments != null &&
-                  isParsableJson(toolCall.function.arguments)
-                ) {
-                  controller.enqueue({
-                    type: 'tool-input-end',
-                    id: toolCall.id,
-                  });
-
-                  controller.enqueue({
-                    type: 'tool-call',
-                    toolCallId: toolCall.id ?? generateId(),
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
-                  });
-                  toolCall.hasFinished = true;
-                }
               }
             }
 
@@ -687,6 +661,26 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
               controller.enqueue({ type: 'text-end', id: '0' });
             }
 
+            // Finalize any unfinished tool calls. Tool calls are only
+            // finalized here (on stream end) to prevent premature
+            // execution when partial JSON is coincidentally parsable.
+            for (const toolCall of toolCalls) {
+              if (!toolCall.hasFinished) {
+                controller.enqueue({
+                  type: 'tool-input-end',
+                  id: toolCall.id,
+                });
+
+                controller.enqueue({
+                  type: 'tool-call',
+                  toolCallId: toolCall.id ?? generateId(),
+                  toolName: toolCall.function.name,
+                  input: toolCall.function.arguments,
+                });
+                toolCall.hasFinished = true;
+              }
+            }
+
             controller.enqueue({
               type: 'finish',
               finishReason,
@@ -699,5 +693,23 @@ export class OpenAIChatLanguageModel implements LanguageModelV3 {
       request: { body },
       response: { headers: responseHeaders },
     };
+
+    return result;
+  }
+}
+
+function isOpenAIChatOutputChunk(chunk: OpenAIChatChunk): boolean {
+  if ('error' in chunk) {
+    return false;
   }
+
+  return chunk.choices.some(choice => {
+    const delta = choice.delta;
+
+    return (
+      (delta?.content != null && delta.content.length > 0) ||
+      (delta?.tool_calls != null && delta.tool_calls.length > 0) ||
+      (delta?.annotations != null && delta.annotations.length > 0)
+    );
+  });
 }

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

@@ -18,6 +18,7 @@ import {
   type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { openaiFailedResponseHandler } from '../openai-error';
+import { throwIfOpenAIStreamErrorBeforeOutput } from '../openai-stream-error';
 import {
   convertOpenAICompletionUsage,
   type OpenAICompletionUsage,
@@ -224,11 +225,13 @@ export class OpenAICompletionLanguageModel implements LanguageModelV3 {
       },
     };
 
+    const url = this.config.url({
+      path: '/completions',
+      modelId: this.modelId,
+    });
+
     const { responseHeaders, value: response } = await postJsonToApi({
-      url: this.config.url({
-        path: '/completions',
-        modelId: this.modelId,
-      }),
+      url,
       headers: combineHeaders(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
@@ -239,6 +242,15 @@ export class OpenAICompletionLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
+    const checkedResponse = await throwIfOpenAIStreamErrorBeforeOutput({
+      stream: response,
+      getError: chunk => ('error' in chunk ? chunk.error : undefined),
+      isOutputChunk: isOpenAICompletionOutputChunk,
+      url,
+      requestBodyValues: body,
+      responseHeaders,
+    });
+
     let finishReason: LanguageModelV3FinishReason = {
       unified: 'other',
       raw: undefined,
@@ -247,8 +259,8 @@ export class OpenAICompletionLanguageModel implements LanguageModelV3 {
     let usage: OpenAICompletionUsage | undefined = undefined;
     let isFirstChunk = true;
 
-    return {
-      stream: response.pipeThrough(
+    const result = {
+      stream: checkedResponse.pipeThrough(
         new TransformStream<
           ParseResult<OpenAICompletionChunk>,
           LanguageModelV3StreamPart
@@ -332,5 +344,13 @@ export class OpenAICompletionLanguageModel implements LanguageModelV3 {
       request: { body },
       response: { headers: responseHeaders },
     };
+
+    return result;
   }
 }
+
+function isOpenAICompletionOutputChunk(chunk: OpenAICompletionChunk): boolean {
+  return (
+    !('error' in chunk) && chunk.choices.some(choice => choice.text.length > 0)
+  );
+}

package/src/openai-stream-error.ts

@@ -0,0 +1,181 @@
+import { APICallError } from '@ai-sdk/provider';
+import type { ParseResult } from '@ai-sdk/provider-utils';
+
+type StreamError = {
+  message: string;
+  code?: string | number | null;
+  type?: string | null;
+  frame: unknown;
+};
+
+export async function throwIfOpenAIStreamErrorBeforeOutput<T>({
+  stream,
+  getError,
+  isOutputChunk,
+  url,
+  requestBodyValues,
+  responseHeaders,
+}: {
+  stream: ReadableStream<ParseResult<T>>;
+  getError: (chunk: T) => unknown | undefined;
+  isOutputChunk: (chunk: T) => boolean;
+  url: string;
+  requestBodyValues: unknown;
+  responseHeaders?: Record<string, string>;
+}): Promise<ReadableStream<ParseResult<T>>> {
+  const [streamForEarlyError, streamForConsumer] = stream.tee();
+  const reader = streamForEarlyError.getReader();
+
+  try {
+    while (true) {
+      const result = await reader.read();
+
+      if (result.done) {
+        return streamForConsumer;
+      }
+
+      const chunk = result.value;
+
+      if (!chunk.success) {
+        return streamForConsumer;
+      }
+
+      const errorFrame = getError(chunk.value);
+
+      if (errorFrame != null) {
+        streamForConsumer.cancel().catch(() => {});
+        throw createOpenAIStreamError({
+          frame: errorFrame,
+          url,
+          requestBodyValues,
+          responseHeaders,
+        });
+      }
+
+      if (isOutputChunk(chunk.value)) {
+        return streamForConsumer;
+      }
+    }
+  } finally {
+    reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
+function createOpenAIStreamError({
+  frame,
+  url,
+  requestBodyValues,
+  responseHeaders,
+}: {
+  frame: unknown;
+  url: string;
+  requestBodyValues: unknown;
+  responseHeaders?: Record<string, string>;
+}): APICallError {
+  const streamError = parseStreamError(frame);
+  return new APICallError({
+    message:
+      streamError?.message ??
+      'OpenAI stream failed before any output was generated',
+    url,
+    requestBodyValues,
+    statusCode: streamError == null ? 500 : getStatusCode(streamError),
+    responseHeaders,
+    responseBody: JSON.stringify(frame),
+    data: frame,
+  });
+}
+
+function parseStreamError(frame: unknown): StreamError | undefined {
+  const value = asRecord(frame);
+
+  if (value == null) {
+    return undefined;
+  }
+
+  if (value.type === 'response.failed') {
+    const response = asRecord(value.response);
+    const responseError = asRecord(response?.error);
+
+    return typeof responseError?.message === 'string'
+      ? {
+          message: responseError.message,
+          code: getStringOrNumber(responseError.code),
+          type: 'response.failed',
+          frame,
+        }
+      : undefined;
+  }
+
+  const error = asRecord(value.error) ?? value;
+
+  return typeof error.message === 'string' &&
+    (asRecord(value.error) != null ||
+      typeof error.type === 'string' ||
+      'code' in error ||
+      'param' in error)
+    ? {
+        message: error.message,
+        code: getStringOrNumber(error.code),
+        type: typeof error.type === 'string' ? error.type : undefined,
+        frame,
+      }
+    : undefined;
+}
+
+function getStatusCode(error: StreamError): number {
+  if (typeof error.code === 'number' && isHttpErrorStatusCode(error.code)) {
+    return error.code;
+  }
+
+  if (typeof error.code === 'string' && /^\d{3}$/.test(error.code)) {
+    const numericCode = Number(error.code);
+    if (isHttpErrorStatusCode(numericCode)) {
+      return numericCode;
+    }
+  }
+
+  const discriminator = [error.code, error.type]
+    .filter(value => typeof value === 'string' || typeof value === 'number')
+    .join(' ')
+    .toLowerCase();
+
+  if (
+    ['insufficient_quota', 'rate_limit'].some(term =>
+      discriminator.includes(term),
+    )
+  ) {
+    return 429;
+  }
+  if (discriminator.includes('authentication')) return 401;
+  if (discriminator.includes('permission')) return 403;
+  if (discriminator.includes('not_found')) return 404;
+  if (
+    ['invalid', 'bad_request', 'context_length'].some(term =>
+      discriminator.includes(term),
+    )
+  ) {
+    return 400;
+  }
+  if (discriminator.includes('overload')) return 503;
+  if (discriminator.includes('timeout')) return 504;
+
+  return 500;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value != null
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function getStringOrNumber(value: unknown): string | number | undefined {
+  return typeof value === 'string' || typeof value === 'number'
+    ? value
+    : undefined;
+}
+
+function isHttpErrorStatusCode(value: number): boolean {
+  return Number.isInteger(value) && value >= 400 && value <= 599;
+}

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

@@ -734,7 +734,7 @@ export async function convertToOpenAIResponsesInput({
                 outputValue = output.value;
                 break;
               case 'execution-denied':
-                outputValue = output.reason ?? 'Tool execution denied.';
+                outputValue = output.reason ?? 'Tool call execution denied.';
                 break;
               case 'json':
               case 'error-json':
@@ -801,7 +801,7 @@ export async function convertToOpenAIResponsesInput({
               contentValue = output.value;
               break;
             case 'execution-denied':
-              contentValue = output.reason ?? 'Tool execution denied.';
+              contentValue = output.reason ?? 'Tool call execution denied.';
               break;
             case 'json':
             case 'error-json':

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

@@ -472,6 +472,30 @@ export type OpenAIResponsesReasoning = {
   }>;
 };
 
+// Captured from the Responses API when OpenAI returned an early
+// insufficient_quota stream error after HTTP 200. This shape differs from the
+// currently documented ResponseErrorEvent below.
+const openaiResponsesNestedErrorChunkSchema = z.object({
+  type: z.literal('error'),
+  sequence_number: z.number(),
+  error: z.object({
+    type: z.string(),
+    code: z.string(),
+    message: z.string(),
+    param: z.string().nullish(),
+  }),
+});
+
+// Current OpenAI OpenAPI docs define ResponseErrorEvent with top-level
+// code/message/param fields.
+const openaiResponsesErrorChunkSchema = z.object({
+  type: z.literal('error'),
+  sequence_number: z.number(),
+  code: z.string().nullish(),
+  message: z.string(),
+  param: z.string().nullish(),
+});
+
 export const openaiResponsesChunkSchema = lazySchema(() =>
   zodSchema(
     z.union([
@@ -520,6 +544,7 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
       }),
       z.object({
         type: z.literal('response.failed'),
+        sequence_number: z.number(),
         response: z.object({
           error: z
             .object({
@@ -1034,16 +1059,8 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
         output_index: z.number(),
         diff: z.string(),
       }),
-      z.object({
-        type: z.literal('error'),
-        sequence_number: z.number(),
-        error: z.object({
-          type: z.string(),
-          code: z.string(),
-          message: z.string(),
-          param: z.string().nullish(),
-        }),
-      }),
+      openaiResponsesNestedErrorChunkSchema,
+      openaiResponsesErrorChunkSchema,
       z
         .object({ type: z.string() })
         .loose()

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

@@ -28,6 +28,7 @@ import {
 import type { OpenAIConfig } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
 import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
+import { throwIfOpenAIStreamErrorBeforeOutput } from '../openai-stream-error';
 import type { applyPatchInputSchema } from '../tool/apply-patch';
 import type {
   codeInterpreterInputSchema,
@@ -1057,6 +1058,19 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       fetch: this.config.fetch,
     });
 
+    const checkedResponse = await throwIfOpenAIStreamErrorBeforeOutput({
+      stream: response,
+      getError: chunk =>
+        isErrorChunk(chunk) ||
+        (isResponseFailedChunk(chunk) && chunk.response.error != null)
+          ? chunk
+          : undefined,
+      isOutputChunk: isResponseOutputChunk,
+      url,
+      requestBodyValues: body,
+      responseHeaders,
+    });
+
     const self = this;
 
     const approvalRequestIdToDummyToolCallIdFromPrompt =
@@ -1117,9 +1131,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
 
     let serviceTier: string | undefined;
     const hostedToolSearchCallIds: string[] = [];
+    let encounteredStreamError = false;
 
-    return {
-      stream: response.pipeThrough(
+    const result = {
+      stream: checkedResponse.pipeThrough(
         new TransformStream<
           ParseResult<OpenAIResponsesChunk>,
           LanguageModelV3StreamPart
@@ -2046,6 +2061,22 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                 raw: incompleteReason ?? 'error',
               };
               usage = value.response.usage ?? undefined;
+
+              if (!encounteredStreamError && value.response.error != null) {
+                encounteredStreamError = true;
+                controller.enqueue({
+                  type: 'error',
+                  error: {
+                    type: 'response.failed',
+                    sequence_number: value.sequence_number,
+                    response: {
+                      error: value.response.error,
+                      incomplete_details: value.response.incomplete_details,
+                      service_tier: value.response.service_tier,
+                    },
+                  },
+                });
+              }
             } else if (isResponseAnnotationAddedChunk(value)) {
               ongoingAnnotations.push(value.annotation);
               if (value.annotation.type === 'url_citation') {
@@ -2115,6 +2146,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                 });
               }
             } else if (isErrorChunk(value)) {
+              encounteredStreamError = true;
+              finishReason = { unified: 'error', raw: 'error' };
               controller.enqueue({ type: 'error', error: value });
             }
           },
@@ -2140,6 +2173,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
       request: { body },
       response: { headers: responseHeaders },
     };
+
+    return result;
   }
 }
 
@@ -2293,6 +2328,15 @@ function isErrorChunk(
   return chunk.type === 'error';
 }
 
+function isResponseOutputChunk(chunk: OpenAIResponsesChunk): boolean {
+  return !(
+    chunk.type === 'response.created' ||
+    chunk.type === 'response.failed' ||
+    chunk.type === 'error' ||
+    chunk.type === 'unknown_chunk'
+  );
+}
+
 function mapWebSearchOutput(
   action: OpenAIResponsesWebSearchAction | null | undefined,
 ): InferSchema<typeof webSearchOutputSchema> {