@core-ai/anthropic 0.16.0 → 0.18.0

package/dist/index.js

@@ -2,18 +2,181 @@
 import Anthropic from "@anthropic-ai/sdk";
 
 // src/chat-adapter.ts
-import { APIError, APIUserAbortError } from "@anthropic-ai/sdk";
 import {
-  AbortedError,
   asObject,
   clampReasoningEffort,
   getProviderMetadata,
-  ProviderError,
   ValidationError,
   safeParseJsonObject,
   zodSchemaToJsonSchema
 } from "@core-ai/core-ai";
 
+// src/anthropic-error.ts
+import { APIError, APIUserAbortError } from "@anthropic-ai/sdk";
+import {
+  AbortedError,
+  ContextLengthExceededError,
+  ModelOverloadedError,
+  ProviderError,
+  RateLimitError,
+  ServiceUnavailableError,
+  asRecord,
+  getErrorMessage,
+  getHttpStatusCode,
+  getRetryAfterSecondsFromError,
+  getString,
+  isAbortErrorByName,
+  isRateLimitStatus,
+  isTransientUnavailableStatus
+} from "@core-ai/core-ai";
+var OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES = /* @__PURE__ */ new Set([
+  500,
+  502,
+  503,
+  504,
+  529
+]);
+function wrapAnthropicError(error, provider = "anthropic") {
+  if (isAnthropicAbortError(error)) {
+    return new AbortedError(error, provider);
+  }
+  const message = getErrorMessage(error);
+  const statusCode = error instanceof APIError ? error.status : getHttpStatusCode(error, ["status"]);
+  const providerMessage = getAnthropicErrorMessage(error);
+  const errorType = getAnthropicErrorType(error);
+  const options = { statusCode, cause: error };
+  const contextLength = getContextLengthDetails(providerMessage, errorType);
+  if (contextLength) {
+    return new ContextLengthExceededError(message, provider, {
+      ...options,
+      ...contextLength
+    });
+  }
+  if (isAnthropicOverloaded(errorType, providerMessage, message, statusCode)) {
+    return new ModelOverloadedError(message, provider, options);
+  }
+  if (isAnthropicRateLimit(error, statusCode, errorType)) {
+    return new RateLimitError(message, provider, {
+      ...options,
+      retryAfterSeconds: getRetryAfterSecondsFromError(error)
+    });
+  }
+  if (isUnavailableStatus(error) || isTransientUnavailableStatus(statusCode)) {
+    return new ServiceUnavailableError(message, provider, options);
+  }
+  return new ProviderError(message, provider, options);
+}
+function isAnthropicAbortError(error) {
+  return error instanceof APIUserAbortError || isAbortErrorByName(error);
+}
+function isAnthropicOverloaded(errorType, providerMessage, message, statusCode) {
+  return statusCode === 529 || errorType === "overloaded_error" || indicatesAnthropicOverload(
+    `${providerMessage ?? ""} ${message}`,
+    statusCode
+  );
+}
+function indicatesAnthropicOverload(text, statusCode) {
+  if (statusCode !== void 0 && !OVERLOAD_MESSAGE_ELIGIBLE_STATUS_CODES.has(statusCode)) {
+    return false;
+  }
+  return /\boverloaded\b/i.test(text);
+}
+function isAnthropicRateLimit(error, statusCode, errorType) {
+  return isRateLimitStatus(statusCode) || errorType === "rate_limit_error" || isResourceExhaustedError(error);
+}
+function getContextLengthDetails(providerMessage, errorType) {
+  if (errorType === "rate_limit_error" || !providerMessage) {
+    return void 0;
+  }
+  if (!/prompt is too long/i.test(providerMessage)) {
+    const inputTokensMatch = providerMessage.match(
+      /Input tokens exceed the context limit of (\d+)/i
+    );
+    if (inputTokensMatch?.[1]) {
+      return { maxTokens: parseInt(inputTokensMatch[1], 10) };
+    }
+    return void 0;
+  }
+  const withMaximum = providerMessage.match(
+    /prompt is too long: (\d+) tokens > (\d+) maximum/i
+  );
+  if (withMaximum) {
+    const actualTokens = withMaximum[1];
+    const maxTokens = withMaximum[2];
+    if (actualTokens !== void 0 && maxTokens !== void 0) {
+      return {
+        maxTokens: parseInt(maxTokens, 10),
+        actualTokens: parseInt(actualTokens, 10)
+      };
+    }
+  }
+  const withoutMaximum = providerMessage.match(
+    /prompt is too long: (\d+) tokens > (\d+)/i
+  );
+  if (withoutMaximum) {
+    const actualTokens = withoutMaximum[1];
+    const maxTokens = withoutMaximum[2];
+    if (actualTokens !== void 0 && maxTokens !== void 0) {
+      return {
+        maxTokens: parseInt(maxTokens, 10),
+        actualTokens: parseInt(actualTokens, 10)
+      };
+    }
+  }
+  return {};
+}
+function isResourceExhaustedError(error) {
+  const body = getNestedGoogleApiErrorBody(error);
+  if (!body) {
+    return false;
+  }
+  const code = typeof body.code === "number" ? body.code : Number(body.code);
+  return code === 429 || body.status?.toUpperCase() === "RESOURCE_EXHAUSTED";
+}
+function isUnavailableStatus(error) {
+  const body = getNestedGoogleApiErrorBody(error);
+  return body?.status?.toUpperCase() === "UNAVAILABLE";
+}
+function getNestedGoogleApiErrorBody(error) {
+  const record = asRecord(error);
+  const outer = asRecord(record?.error);
+  if (!outer) {
+    return void 0;
+  }
+  const inner = asRecord(outer.error);
+  if (inner && ("code" in inner || "status" in inner)) {
+    return inner;
+  }
+  if ("code" in outer || "status" in outer) {
+    return outer;
+  }
+  return void 0;
+}
+function getAnthropicErrorMessage(error) {
+  if (error instanceof APIError) {
+    const nested = asRecord(error.error);
+    return getString(nested, "message") ?? error.message;
+  }
+  const record = asRecord(error);
+  const outer = asRecord(record?.error);
+  const inner = asRecord(outer?.error);
+  return getString(inner, "message") ?? getString(outer, "message") ?? getString(record, "message");
+}
+function getAnthropicErrorType(error) {
+  if (error instanceof APIError) {
+    if (typeof error.type === "string") {
+      return error.type;
+    }
+    if (typeof error.error === "object" && error.error) {
+      return getString(asRecord(error.error), "type");
+    }
+  }
+  const record = asRecord(error);
+  const outer = asRecord(record?.error);
+  const inner = asRecord(outer?.error);
+  return getString(inner, "type") ?? getString(outer, "type");
+}
+
 // src/model-capabilities.ts
 import {
   stripModelDateSuffix
@@ -34,9 +197,10 @@ var MAX_EFFORTS = [
 function createCapabilities(supportedEfforts) {
   return {
     reasoning: {
-      supported: true,
+      mode: "optional",
       supportedEfforts,
-      restrictsSamplingParams: true
+      restrictsSamplingParams: true,
+      supportedToolChoices: ["auto", "none"]
     }
   };
 }
@@ -46,6 +210,7 @@ var ADAPTIVE_MAX_EFFORT_MODELS = /* @__PURE__ */ new Set([
   "claude-fable-5",
   "claude-mythos-5",
   "claude-mythos-preview",
+  "claude-opus-5",
   "claude-opus-4-8",
   "claude-opus-4-7",
   "claude-opus-4-6",
@@ -72,6 +237,7 @@ var ALWAYS_RESTRICTED_SAMPLING_MODELS = /* @__PURE__ */ new Set([
   "claude-fable-5",
   "claude-mythos-5",
   "claude-mythos-preview",
+  "claude-opus-5",
   "claude-opus-4-8",
   "claude-opus-4-7",
   "claude-sonnet-5"
@@ -477,6 +643,7 @@ function validateAnthropicReasoningConfig(modelId, maxTokens, options, anthropic
       provider
     );
   }
+  const capabilities = getAnthropicModelCapabilities(modelId);
   if (options.temperature !== void 0 && (!alwaysRestrictsSampling || options.temperature !== 1)) {
     throw new ValidationError(
       `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
@@ -491,9 +658,10 @@ function validateAnthropicReasoningConfig(modelId, maxTokens, options, anthropic
       provider
     );
   }
-  if (options.toolChoice && options.toolChoice !== "auto" && options.toolChoice !== "none") {
+  const toolChoiceMode = typeof options.toolChoice === "object" ? options.toolChoice.type : options.toolChoice;
+  if (toolChoiceMode !== void 0 && !capabilities.reasoning.supportedToolChoices.includes(toolChoiceMode)) {
     throw new ValidationError(
-      `Anthropic model "${modelId}" only supports toolChoice "auto" or "none" when reasoning is enabled`,
+      `Anthropic model "${modelId}" does not support toolChoice "${toolChoiceMode}" when reasoning is enabled`,
       void 0,
       provider
     );
@@ -840,20 +1008,6 @@ function extractThinkingText(value) {
     return typeof text === "string" ? [text] : [];
   }).join("");
 }
-function wrapError(error, provider = DEFAULT_PROVIDER_ID) {
-  if (error instanceof APIUserAbortError || error instanceof Error && error.name === "AbortError") {
-    return new AbortedError(error, provider);
-  }
-  if (error instanceof APIError) {
-    return new ProviderError(error.message, provider, error.status, error);
-  }
-  return new ProviderError(
-    error instanceof Error ? error.message : String(error),
-    provider,
-    void 0,
-    error
-  );
-}
 
 // src/chat-model.ts
 import {
@@ -878,7 +1032,7 @@ function createAnthropicChatModel(client, modelId, modelOptions = {}) {
         signal
       });
     } catch (error) {
-      throw wrapError(error, provider);
+      throw wrapAnthropicError(error, provider);
     }
   }
   async function generateChat(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.16.0",
+    "version": "0.18.0",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -45,7 +45,7 @@
     },
     "dependencies": {
         "@anthropic-ai/sdk": "^0.110.0",
-        "@core-ai/core-ai": "^0.16.0"
+        "@core-ai/core-ai": "^0.18.0"
     },
     "peerDependencies": {
         "zod": "^4.0.0"