@ai-sdk/openai 4.0.0-canary.69 → 4.0.0-canary.71

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @ai-sdk/openai
 
+## 4.0.0-canary.71
+
+### Patch Changes
+
+- ae7f932: fix(openai): throw retryable errors for OpenAI stream failures before output starts
+
+## 4.0.0-canary.70
+
+### Patch Changes
+
+- 6a5800e: feat(openai): add namespaces for tool definitions
+
 ## 4.0.0-canary.69
 
 ### Patch Changes

package/dist/index.d.ts

@@ -209,6 +209,21 @@ type OpenAIResponsesFileSearchToolCompoundFilter = {
 declare const openaiResponsesChunkSchema: _ai_sdk_provider_utils.LazySchema<{
     type: "unknown_chunk";
     message: string;
+} | {
+    type: "error";
+    sequence_number: number;
+    error: {
+        type: string;
+        code: string;
+        message: string;
+        param?: string | null | undefined;
+    };
+} | {
+    type: "error";
+    sequence_number: number;
+    message: string;
+    code?: string | null | undefined;
+    param?: string | null | undefined;
 } | {
     type: "response.output_text.delta";
     item_id: string;
@@ -241,6 +256,7 @@ declare const openaiResponsesChunkSchema: _ai_sdk_provider_utils.LazySchema<{
     };
 } | {
     type: "response.failed";
+    sequence_number: number;
     response: {
         error?: {
             message: string;
@@ -653,15 +669,6 @@ declare const openaiResponsesChunkSchema: _ai_sdk_provider_utils.LazySchema<{
     item_id: string;
     output_index: number;
     diff: string;
-} | {
-    type: "error";
-    sequence_number: number;
-    error: {
-        type: string;
-        code: string;
-        message: string;
-        param?: string | null | undefined;
-    };
 }>;
 type OpenAIResponsesChunk = InferSchema<typeof openaiResponsesChunkSchema>;
 type OpenAIResponsesLogprobs = NonNullable<(OpenAIResponsesChunk & {

package/dist/index.js

@@ -56,6 +56,129 @@ function getOpenAILanguageModelCapabilities(modelId) {
   };
 }
 
+// src/openai-stream-error.ts
+import { APICallError } from "@ai-sdk/provider";
+async function throwIfOpenAIStreamErrorBeforeOutput({
+  stream,
+  getError,
+  isOutputChunk,
+  url,
+  requestBodyValues,
+  responseHeaders
+}) {
+  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
+}) {
+  var _a;
+  const streamError = parseStreamError(frame);
+  return new APICallError({
+    message: (_a = streamError == null ? void 0 : streamError.message) != null ? _a : "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) {
+  var _a;
+  const value = asRecord(frame);
+  if (value == null) {
+    return void 0;
+  }
+  if (value.type === "response.failed") {
+    const response = asRecord(value.response);
+    const responseError = asRecord(response == null ? void 0 : response.error);
+    return typeof (responseError == null ? void 0 : responseError.message) === "string" ? {
+      message: responseError.message,
+      code: getStringOrNumber(responseError.code),
+      type: "response.failed",
+      frame
+    } : void 0;
+  }
+  const error = (_a = asRecord(value.error)) != null ? _a : 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 : void 0,
+    frame
+  } : void 0;
+}
+function getStatusCode(error) {
+  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) {
+  return typeof value === "object" && value != null ? value : void 0;
+}
+function getStringOrNumber(value) {
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function isHttpErrorStatusCode(value) {
+  return Number.isInteger(value) && value >= 400 && value <= 599;
+}
+
 // src/chat/convert-openai-chat-usage.ts
 function convertOpenAIChatUsage(usage) {
   var _a, _b, _c, _d, _e, _f;
@@ -962,11 +1085,12 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
         include_usage: true
       }
     };
+    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((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
@@ -976,6 +1100,14 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
+    const checkedResponse = await throwIfOpenAIStreamErrorBeforeOutput({
+      stream: response,
+      getError: (chunk) => "error" in chunk ? chunk.error : void 0,
+      isOutputChunk: isOpenAIChatOutputChunk,
+      url,
+      requestBodyValues: body,
+      responseHeaders
+    });
     let toolCallTracker;
     let finishReason = {
       unified: "other",
@@ -985,8 +1117,8 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
     let metadataExtracted = false;
     let isActiveText = false;
     const providerMetadata = { openai: {} };
-    return {
-      stream: response.pipeThrough(
+    const result = {
+      stream: checkedResponse.pipeThrough(
         new TransformStream({
           start(controller) {
             toolCallTracker = new StreamingToolCallTracker(controller, {
@@ -1089,8 +1221,18 @@ var OpenAIChatLanguageModel = class _OpenAIChatLanguageModel {
       request: { body },
       response: { headers: responseHeaders }
     };
+    return result;
   }
 };
+function isOpenAIChatOutputChunk(chunk) {
+  if ("error" in chunk) {
+    return false;
+  }
+  return chunk.choices.some((choice) => {
+    const delta = choice.delta;
+    return (delta == null ? void 0 : delta.content) != null && delta.content.length > 0 || (delta == null ? void 0 : delta.tool_calls) != null && delta.tool_calls.length > 0 || (delta == null ? void 0 : delta.annotations) != null && delta.annotations.length > 0;
+  });
+}
 
 // src/completion/openai-completion-language-model.ts
 import {
@@ -1510,11 +1652,12 @@ var OpenAICompletionLanguageModel = class _OpenAICompletionLanguageModel {
         include_usage: true
       }
     };
+    const url = this.config.url({
+      path: "/completions",
+      modelId: this.modelId
+    });
     const { responseHeaders, value: response } = await postJsonToApi2({
-      url: this.config.url({
-        path: "/completions",
-        modelId: this.modelId
-      }),
+      url,
       headers: combineHeaders2((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
@@ -1524,6 +1667,14 @@ var OpenAICompletionLanguageModel = class _OpenAICompletionLanguageModel {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
+    const checkedResponse = await throwIfOpenAIStreamErrorBeforeOutput({
+      stream: response,
+      getError: (chunk) => "error" in chunk ? chunk.error : void 0,
+      isOutputChunk: isOpenAICompletionOutputChunk,
+      url,
+      requestBodyValues: body,
+      responseHeaders
+    });
     let finishReason = {
       unified: "other",
       raw: void 0
@@ -1531,8 +1682,8 @@ var OpenAICompletionLanguageModel = class _OpenAICompletionLanguageModel {
     const providerMetadata = { openai: {} };
     let usage = void 0;
     let isFirstChunk = true;
-    return {
-      stream: response.pipeThrough(
+    const result = {
+      stream: checkedResponse.pipeThrough(
         new TransformStream({
           start(controller) {
             controller.enqueue({ type: "stream-start", warnings });
@@ -1597,8 +1748,12 @@ var OpenAICompletionLanguageModel = class _OpenAICompletionLanguageModel {
       request: { body },
       response: { headers: responseHeaders }
     };
+    return result;
   }
 };
+function isOpenAICompletionOutputChunk(chunk) {
+  return !("error" in chunk) && chunk.choices.some((choice) => choice.text.length > 0);
+}
 
 // src/embedding/openai-embedding-model.ts
 import {
@@ -3260,7 +3415,7 @@ var OpenAIRealtimeModel = class {
 
 // src/responses/openai-responses-language-model.ts
 import {
-  APICallError
+  APICallError as APICallError2
 } from "@ai-sdk/provider";
 import {
   combineHeaders as combineHeaders6,
@@ -4062,6 +4217,23 @@ var jsonValueSchema2 = z24.lazy(
     z24.record(z24.string(), jsonValueSchema2.optional())
   ])
 );
+var openaiResponsesNestedErrorChunkSchema = z24.object({
+  type: z24.literal("error"),
+  sequence_number: z24.number(),
+  error: z24.object({
+    type: z24.string(),
+    code: z24.string(),
+    message: z24.string(),
+    param: z24.string().nullish()
+  })
+});
+var openaiResponsesErrorChunkSchema = z24.object({
+  type: z24.literal("error"),
+  sequence_number: z24.number(),
+  code: z24.string().nullish(),
+  message: z24.string(),
+  param: z24.string().nullish()
+});
 var openaiResponsesChunkSchema = lazySchema22(
   () => zodSchema22(
     z24.union([
@@ -4097,6 +4269,7 @@ var openaiResponsesChunkSchema = lazySchema22(
       }),
       z24.object({
         type: z24.literal("response.failed"),
+        sequence_number: z24.number(),
         response: z24.object({
           error: z24.object({
             code: z24.string().nullish(),
@@ -4588,16 +4761,8 @@ var openaiResponsesChunkSchema = lazySchema22(
         output_index: z24.number(),
         diff: z24.string()
       }),
-      z24.object({
-        type: z24.literal("error"),
-        sequence_number: z24.number(),
-        error: z24.object({
-          type: z24.string(),
-          code: z24.string(),
-          message: z24.string(),
-          param: z24.string().nullish()
-        })
-      }),
+      openaiResponsesNestedErrorChunkSchema,
+      openaiResponsesErrorChunkSchema,
       z24.object({ type: z24.string() }).loose().transform((value) => ({
         type: "unknown_chunk",
         message: value.type
@@ -5194,20 +5359,37 @@ async function prepareResponsesTools({
     return { tools: void 0, toolChoice: void 0, toolWarnings };
   }
   const openaiTools2 = [];
+  const namespaceTools = /* @__PURE__ */ new Map();
   const resolvedCustomProviderToolNames = customProviderToolNames != null ? customProviderToolNames : /* @__PURE__ */ new Set();
   for (const tool of tools) {
     switch (tool.type) {
       case "function": {
         const openaiOptions = (_a = tool.providerOptions) == null ? void 0 : _a.openai;
-        const deferLoading = openaiOptions == null ? void 0 : openaiOptions.deferLoading;
-        openaiTools2.push({
-          type: "function",
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema,
-          ...tool.strict != null ? { strict: tool.strict } : {},
-          ...deferLoading != null ? { defer_loading: deferLoading } : {}
+        const openaiFunctionTool = prepareFunctionTool({
+          tool,
+          options: openaiOptions
         });
+        const namespace = openaiOptions == null ? void 0 : openaiOptions.namespace;
+        if (namespace == null) {
+          openaiTools2.push(openaiFunctionTool);
+        } else {
+          let namespaceTool = namespaceTools.get(namespace.name);
+          if (namespaceTool == null) {
+            namespaceTool = {
+              type: "namespace",
+              name: namespace.name,
+              description: namespace.description,
+              tools: []
+            };
+            namespaceTools.set(namespace.name, namespaceTool);
+            openaiTools2.push(namespaceTool);
+          } else if (namespaceTool.description !== namespace.description) {
+            throw new UnsupportedFunctionalityError5({
+              functionality: `conflicting descriptions for OpenAI tool namespace "${namespace.name}"`
+            });
+          }
+          namespaceTool.tools.push(openaiFunctionTool);
+        }
         break;
       }
       case "provider": {
@@ -5420,6 +5602,20 @@ async function prepareResponsesTools({
     }
   }
 }
+function prepareFunctionTool({
+  tool,
+  options
+}) {
+  const deferLoading = options == null ? void 0 : options.deferLoading;
+  return {
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema,
+    ...tool.strict != null ? { strict: tool.strict } : {},
+    ...deferLoading != null ? { defer_loading: deferLoading } : {}
+  };
+}
 function mapShellEnvironment(environment) {
   if (environment.type === "containerReference") {
     const env2 = environment;
@@ -5796,7 +5992,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       fetch: this.config.fetch
     });
     if (response.error) {
-      throw new APICallError({
+      throw new APICallError2({
         message: response.error.message,
         url,
         requestBodyValues: body,
@@ -6266,11 +6462,12 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       providerOptionsName,
       isShellProviderExecuted
     } = await this.getArgs(options);
+    const url = this.config.url({
+      path: "/responses",
+      modelId: this.modelId
+    });
     const { responseHeaders, value: response } = await postJsonToApi5({
-      url: this.config.url({
-        path: "/responses",
-        modelId: this.modelId
-      }),
+      url,
       headers: combineHeaders6((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: {
         ...body,
@@ -6283,6 +6480,14 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
+    const checkedResponse = await throwIfOpenAIStreamErrorBeforeOutput({
+      stream: response,
+      getError: (chunk) => isErrorChunk(chunk) || isResponseFailedChunk(chunk) && chunk.response.error != null ? chunk : void 0,
+      isOutputChunk: isResponseOutputChunk,
+      url,
+      requestBodyValues: body,
+      responseHeaders
+    });
     const self = this;
     const approvalRequestIdToDummyToolCallIdFromPrompt = extractApprovalRequestIdToToolCallIdMapping(options.prompt);
     const approvalRequestIdToDummyToolCallIdFromStream = /* @__PURE__ */ new Map();
@@ -6300,8 +6505,9 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
     const activeReasoning = {};
     let serviceTier;
     const hostedToolSearchCallIds = [];
-    return {
-      stream: response.pipeThrough(
+    let encounteredStreamError = false;
+    const result = {
+      stream: checkedResponse.pipeThrough(
         new TransformStream({
           start(controller) {
             controller.enqueue({ type: "stream-start", warnings });
@@ -6614,12 +6820,12 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                   toolName: toolNameMapping.toCustomToolName("file_search"),
                   result: {
                     queries: value.item.queries,
-                    results: (_f = (_e = value.item.results) == null ? void 0 : _e.map((result) => ({
-                      attributes: result.attributes,
-                      fileId: result.file_id,
-                      filename: result.filename,
-                      score: result.score,
-                      text: result.text
+                    results: (_f = (_e = value.item.results) == null ? void 0 : _e.map((result2) => ({
+                      attributes: result2.attributes,
+                      fileId: result2.file_id,
+                      filename: result2.filename,
+                      score: result2.score,
+                      text: result2.text
                     }))) != null ? _f : null
                   }
                 });
@@ -7064,6 +7270,21 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 raw: incompleteReason != null ? incompleteReason : "error"
               };
               usage = (_z = value.response.usage) != null ? _z : void 0;
+              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") {
@@ -7124,6 +7345,8 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
                 });
               }
             } else if (isErrorChunk(value)) {
+              encounteredStreamError = true;
+              finishReason = { unified: "error", raw: "error" };
               controller.enqueue({ type: "error", error: value });
             }
           },
@@ -7147,6 +7370,7 @@ var OpenAIResponsesLanguageModel = class _OpenAIResponsesLanguageModel {
       request: { body },
       response: { headers: responseHeaders }
     };
+    return result;
   }
 };
 function isTextDeltaChunk(chunk) {
@@ -7194,6 +7418,9 @@ function isResponseAnnotationAddedChunk(chunk) {
 function isErrorChunk(chunk) {
   return chunk.type === "error";
 }
+function isResponseOutputChunk(chunk) {
+  return !(chunk.type === "response.created" || chunk.type === "response.failed" || chunk.type === "error" || chunk.type === "unknown_chunk");
+}
 function mapWebSearchOutput(action) {
   var _a;
   if (action == null) {
@@ -7711,7 +7938,7 @@ var OpenAISkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.0-canary.69" : "0.0.0-test";
+var VERSION = true ? "4.0.0-canary.71" : "0.0.0-test";
 
 // src/openai-provider.ts
 function createOpenAI(options = {}) {