@core-ai/openai 0.22.0 → 0.24.0

package/dist/{chunk-MKAXZHMO.js → chunk-SCXEGDFV.js}

@@ -271,7 +271,10 @@ var openaiCompatProviderOptionsSchema = openaiChatGenerateProviderOptionsSchema;
 var openaiCompatGenerateProviderOptionsSchema = openaiChatGenerateProviderOptionsSchema;
 
 // src/chat-completions/chat-model.ts
-import { createObjectStream, createChatStream } from "@core-ai/core-ai";
+import {
+  createObjectStream,
+  createChatStream
+} from "@core-ai/core-ai";
 
 // src/chat-completions/chat-adapter.ts
 import {
@@ -875,6 +878,7 @@ import {
   ContextLengthExceededError,
   ModelOverloadedError,
   ProviderError,
+  ProviderQuotaExceededError,
   RateLimitError,
   ServiceUnavailableError,
   asRecord,
@@ -895,6 +899,7 @@ var TOKEN_LIMIT_PATTERNS = [
   /maximum context length is (\d+) tokens.*you requested (\d+) tokens/i,
   /configured limit of (\d+) tokens.*resulted in (\d+) tokens/i
 ];
+var CONTEXT_LENGTH_MESSAGE_PATTERN = /\binput exceeds the context window\b/i;
 var OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
 function wrapOpenAIError(error, provider = "openai") {
   if (isOpenAIAbortError(error)) {
@@ -902,7 +907,11 @@ function wrapOpenAIError(error, provider = "openai") {
   }
   const message = getErrorMessage(error);
   const statusCode = error instanceof APIError ? error.status : getHttpStatusCode(error, ["status"]);
-  const options = { statusCode, cause: error };
+  const options = {
+    statusCode,
+    code: getProviderErrorCode(error) ?? getProviderErrorType(error),
+    cause: error
+  };
   const contextLength = getContextLengthDetails(error, message);
   if (contextLength) {
     return new ContextLengthExceededError(message, provider, {
@@ -913,8 +922,8 @@ function wrapOpenAIError(error, provider = "openai") {
   if (isAzureOpenAIBackendCapacityError(error)) {
     return new ServiceUnavailableError(message, provider, options);
   }
-  if (isOpenAIInsufficientQuota(error)) {
-    return new ProviderError(message, provider, options);
+  if (isOpenAIQuotaExceeded(error, statusCode)) {
+    return new ProviderQuotaExceededError(message, provider, options);
   }
   if (isAzureOpenAINoCapacity(error)) {
     return new ModelOverloadedError(message, provider, options);
@@ -928,11 +937,16 @@ function wrapOpenAIError(error, provider = "openai") {
       retryAfterSeconds: getRetryAfterSecondsFromError(error)
     });
   }
-  if (isTransientUnavailableStatus(statusCode)) {
+  if (isTransientUnavailableStatus(statusCode) || isOpenAIServerError(error)) {
     return new ServiceUnavailableError(message, provider, options);
   }
   return new ProviderError(message, provider, options);
 }
+function isOpenAIServerError(error) {
+  const code = getProviderErrorCode(error);
+  const type = getProviderErrorType(error);
+  return code === "server_error" || code === "service_unavailable" || type === "server_error";
+}
 function isOpenAIAbortError(error) {
   return error instanceof APIUserAbortError || isAbortErrorByName(error);
 }
@@ -963,7 +977,7 @@ function getContextLengthDetails(error, fallbackMessage) {
   if (tokenCounts) {
     return tokenCounts;
   }
-  if (!isKnownContextLengthCode) {
+  if (!isKnownContextLengthCode && !CONTEXT_LENGTH_MESSAGE_PATTERN.test(providerMessage)) {
     return void 0;
   }
   return {};
@@ -991,13 +1005,14 @@ function isAzureOpenAIBackendCapacityError(error) {
   const providerMessage = getProviderMessage(error);
   return type === "invalid_request_error" && providerMessage?.toLowerCase() === "backend error.";
 }
-function isOpenAIInsufficientQuota(error) {
+function isOpenAIQuotaExceeded(error, statusCode) {
   const code = getProviderErrorCode(error);
   const type = getProviderErrorType(error);
-  return code === "insufficient_quota" || type === "insufficient_quota";
+  return statusCode === 402 || code === "insufficient_quota" || type === "insufficient_quota" || code === "credit_balance_exhausted";
 }
 function isAzureOpenAINoCapacity(error) {
-  return getProviderErrorCode(error) === "NoCapacity";
+  const code = getProviderErrorCode(error);
+  return code === "NoCapacity" || code === "no_capacity";
 }
 function getProviderMessage(error) {
   if (error instanceof APIError) {
@@ -1323,7 +1338,10 @@ function createOpenAIChatCompletionsModel(client, modelId, modelOptions) {
         await callOpenAIChatCompletionsApi(request, options.signal),
         adapterOptions
       ),
-      { signal: options.signal }
+      {
+        signal: options.signal,
+        mapError: (error) => wrapOpenAIError(error, provider)
+      }
     );
   }
   return {
@@ -1383,6 +1401,7 @@ import {
 import { createObjectStream as createObjectStream2, createChatStream as createChatStream2 } from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
+import { APIError as APIError2 } from "openai";
 import {
   getProviderMetadata as getProviderMetadata2,
   clampReasoningEffort as clampReasoningEffort2,
@@ -1644,6 +1663,13 @@ function mapOpenAIProviderOptionsToRequestFields2(options) {
   };
 }
 function mapGenerateResponse2(response, adapterOptions = {}) {
+  if (response.status === "failed") {
+    throw createInBandStreamError(
+      response.error ?? {
+        message: "Response failed without error details"
+      }
+    );
+  }
   const providerId = adapterOptions.providerId ?? DEFAULT_PROVIDER_ID;
   const parts = [];
   for (const item of response.output) {
@@ -1845,6 +1871,16 @@ async function* transformStream2(stream, adapterOptions = {}) {
     };
   };
   for await (const event of stream) {
+    if (event.type === "error") {
+      throw createInBandStreamError(event);
+    }
+    if (event.type === "response.failed") {
+      throw createInBandStreamError(
+        event.response.error ?? {
+          message: "Response failed without error details"
+        }
+      );
+    }
     if (event.type === "response.reasoning_summary_text.delta") {
       const summaryPart = {
         itemId: event.item_id,
@@ -1984,7 +2020,10 @@ async function* transformStream2(stream, adapterOptions = {}) {
           }
         }
         const reasoningEndEvent2 = getNextReasoningEndEvent(
-          createReasoningProviderMetadata(providerId, encryptedContent)
+          createReasoningProviderMetadata(
+            providerId,
+            encryptedContent
+          )
         );
         if (reasoningEndEvent2) {
           yield reasoningEndEvent2;
@@ -2021,7 +2060,7 @@ async function* transformStream2(stream, adapterOptions = {}) {
       }
       continue;
     }
-    if (event.type === "response.completed") {
+    if (event.type === "response.completed" || event.type === "response.incomplete") {
       latestResponse = event.response;
       yield* closeText();
       const reasoningEndEvent2 = getNextReasoningEndEvent(
@@ -2069,6 +2108,9 @@ async function* transformStream2(stream, adapterOptions = {}) {
     usage
   };
 }
+function createInBandStreamError(body) {
+  return new APIError2(void 0, body, body.message, void 0);
+}
 function mapReasoningToRequestFields2(options, capabilities) {
   if (!options.reasoning) {
     return {};
@@ -2118,7 +2160,11 @@ function createOpenAIChatModel(client, modelId, capabilities, providerId = DEFAU
       request,
       options.signal
     );
-    return mapGenerateResponse2(response, { providerId: provider });
+    try {
+      return mapGenerateResponse2(response, { providerId: provider });
+    } catch (error) {
+      throw wrapOpenAIError(error, provider);
+    }
   }
   async function streamChat(options) {
     const request = createStreamRequest2(modelId, options, adapterOptions);
@@ -2127,7 +2173,10 @@ function createOpenAIChatModel(client, modelId, capabilities, providerId = DEFAU
         await callOpenAIResponsesApi(request, options.signal),
         { providerId: provider }
       ),
-      { signal: options.signal }
+      {
+        signal: options.signal,
+        mapError: (error) => wrapOpenAIError(error, provider)
+      }
     );
   }
   return {

package/dist/compat.js

@@ -4,7 +4,7 @@ import {
   getOpenAIModelCapabilities,
   openaiCompatGenerateProviderOptionsSchema,
   openaiCompatProviderOptionsSchema
-} from "./chunk-MKAXZHMO.js";
+} from "./chunk-SCXEGDFV.js";
 
 // src/compat/provider.ts
 import OpenAI from "openai";

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   openaiImageProviderOptionsSchema,
   openaiResponsesGenerateProviderOptionsSchema,
   openaiResponsesProviderOptionsSchema
-} from "./chunk-MKAXZHMO.js";
+} from "./chunk-SCXEGDFV.js";
 
 // src/provider.ts
 function createOpenAI(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/openai",
-    "version": "0.22.0",
+    "version": "0.24.0",
     "description": "OpenAI provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -50,7 +50,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.22.0",
+        "@core-ai/core-ai": "^0.24.0",
         "openai": "^6.46.0"
     },
     "peerDependencies": {