@core-ai/anthropic 0.12.0 → 0.13.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { ChatModel } from '@core-ai/core-ai';
+import { ChatModel, ModelCapabilities } from '@core-ai/core-ai';
 import { z } from 'zod';
 
 type AnthropicProviderOptions$1 = {
@@ -18,6 +18,9 @@ type AnthropicReasoningMetadata = {
     redactedData?: string;
 };
 
+type AnthropicModelCapabilities = ModelCapabilities;
+declare function getAnthropicModelCapabilities(modelId: string): AnthropicModelCapabilities;
+
 declare const anthropicCacheControlSchema: z.ZodObject<{
     type: z.ZodLiteral<"ephemeral">;
     ttl: z.ZodOptional<z.ZodEnum<{
@@ -60,4 +63,4 @@ declare const anthropicProviderOptionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 type AnthropicProviderOptions = AnthropicGenerateProviderOptions;
 
-export { type AnthropicCacheControl, type AnthropicGenerateProviderOptions, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicCacheControlSchema, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic };
+export { type AnthropicCacheControl, type AnthropicGenerateProviderOptions, type AnthropicModelCapabilities, type AnthropicProviderOptions as AnthropicModelProviderOptions, type AnthropicProvider, type AnthropicProviderOptions$1 as AnthropicProviderOptions, type AnthropicReasoningMetadata, anthropicCacheControlSchema, anthropicGenerateProviderOptionsSchema, anthropicProviderOptionsSchema, createAnthropic, getAnthropicModelCapabilities };

package/dist/index.js

@@ -15,6 +15,7 @@ import { APIError, APIUserAbortError } from "@anthropic-ai/sdk";
 import {
   AbortedError,
   asObject,
+  clampReasoningEffort,
   getProviderMetadata,
   ProviderError,
   ValidationError,
@@ -23,70 +24,67 @@ import {
 } from "@core-ai/core-ai";
 
 // src/model-capabilities.ts
-import { stripModelDateSuffix } from "@core-ai/core-ai";
-var DEFAULT_CAPABILITIES = {
-  reasoning: {
-    thinkingMode: "adaptive",
-    supportsMaxEffort: false
-  }
-};
-var ADAPTIVE_MAX_EFFORT_CAPABILITIES = {
-  reasoning: {
-    thinkingMode: "adaptive",
-    supportsMaxEffort: true
-  }
-};
-var MODEL_CAPABILITIES = {
-  "claude-fable-5": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-mythos-5": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-mythos-preview": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-opus-4-8": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-opus-4-7": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-opus-4-6": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-sonnet-4-6": ADAPTIVE_MAX_EFFORT_CAPABILITIES,
-  "claude-opus-4-5": {
-    reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
-    }
-  },
-  "claude-sonnet-4-5": {
-    reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
-    }
-  },
-  "claude-opus-4-1": {
-    reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
-    }
-  },
-  "claude-opus-4": {
-    reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
-    }
-  },
-  "claude-sonnet-4": {
-    reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
-    }
-  },
-  "claude-haiku-4-5": {
-    reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
-    }
-  },
-  "claude-sonnet-3-7": {
+import {
+  stripModelDateSuffix
+} from "@core-ai/core-ai";
+var STANDARD_EFFORTS = [
+  "minimal",
+  "low",
+  "medium",
+  "high"
+];
+var MAX_EFFORTS = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "max"
+];
+function createCapabilities(supportedEfforts) {
+  return {
     reasoning: {
-      thinkingMode: "manual",
-      supportsMaxEffort: false
+      supported: true,
+      supportedEfforts,
+      restrictsSamplingParams: true
     }
-  }
-};
+  };
+}
+var STANDARD_CAPABILITIES = createCapabilities(STANDARD_EFFORTS);
+var MAX_EFFORT_CAPABILITIES = createCapabilities(MAX_EFFORTS);
+var ADAPTIVE_MAX_EFFORT_MODELS = /* @__PURE__ */ new Set([
+  "claude-fable-5",
+  "claude-mythos-5",
+  "claude-mythos-preview",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-5",
+  "claude-sonnet-4-6"
+]);
+var MANUAL_THINKING_MODELS = /* @__PURE__ */ new Set([
+  "claude-opus-4-5",
+  "claude-sonnet-4-5",
+  "claude-opus-4-1",
+  "claude-opus-4",
+  "claude-sonnet-4",
+  "claude-haiku-4-5",
+  "claude-sonnet-3-7"
+]);
+var MANUAL_INTERLEAVED_THINKING_MODELS = /* @__PURE__ */ new Set([
+  "claude-opus-4-5",
+  "claude-sonnet-4-5",
+  "claude-opus-4-1",
+  "claude-opus-4",
+  "claude-sonnet-4"
+]);
+var ALWAYS_RESTRICTED_SAMPLING_MODELS = /* @__PURE__ */ new Set([
+  "claude-fable-5",
+  "claude-mythos-5",
+  "claude-mythos-preview",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-sonnet-5"
+]);
 var ANTHROPIC_ADAPTIVE_EFFORT_MAP = {
   minimal: "low",
   low: "low",
@@ -101,20 +99,35 @@ var ANTHROPIC_MANUAL_BUDGET_MAP = {
   max: 65536
 };
 function getAnthropicModelCapabilities(modelId) {
-  const normalizedModelId = normalizeModelId(modelId);
-  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
+  if (supportsAnthropicMaxEffort(modelId) || getAnthropicThinkingMode(modelId) === "manual") {
+    return MAX_EFFORT_CAPABILITIES;
+  }
+  return STANDARD_CAPABILITIES;
 }
 function normalizeModelId(modelId) {
   return stripModelDateSuffix(modelId);
 }
+function getAnthropicThinkingMode(modelId) {
+  return MANUAL_THINKING_MODELS.has(normalizeModelId(modelId)) ? "manual" : "adaptive";
+}
+function supportsAnthropicMaxEffort(modelId) {
+  return ADAPTIVE_MAX_EFFORT_MODELS.has(normalizeModelId(modelId));
+}
+function requiresAnthropicInterleavedThinkingBeta(modelId) {
+  return MANUAL_INTERLEAVED_THINKING_MODELS.has(normalizeModelId(modelId));
+}
+function restrictsAnthropicSamplingParamsAlways(modelId) {
+  return ALWAYS_RESTRICTED_SAMPLING_MODELS.has(normalizeModelId(modelId));
+}
 function toAnthropicAdaptiveEffort(effort, supportsMaxEffort) {
   if (effort === "max") {
     return supportsMaxEffort ? "max" : "high";
   }
   return ANTHROPIC_ADAPTIVE_EFFORT_MAP[effort];
 }
-function toAnthropicManualBudget(effort) {
-  return ANTHROPIC_MANUAL_BUDGET_MAP[effort];
+function toAnthropicManualBudget(effort, maxTokens) {
+  const targetBudget = ANTHROPIC_MANUAL_BUDGET_MAP[effort];
+  return maxTokens === void 0 ? targetBudget : Math.min(targetBudget, maxTokens - 1);
 }
 
 // src/provider-options.ts
@@ -208,18 +221,17 @@ function convertMessages(messages) {
           });
           continue;
         }
-        if (part.text.length === 0) {
+        if (typeof signature === "string") {
+          contentBlocks.push({
+            type: "thinking",
+            thinking: part.text,
+            signature
+          });
           continue;
         }
-        if (typeof signature !== "string") {
+        if (part.text.length > 0) {
           contentBlocks.push({ type: "text", text: part.text });
-          continue;
         }
-        contentBlocks.push({
-          type: "thinking",
-          thinking: part.text,
-          signature
-        });
       }
       convertedMessages.push({
         role: "assistant",
@@ -405,13 +417,23 @@ function createStreamRequest(modelId, defaultMaxTokens, options) {
   return mapAnthropicProviderOptionsToRequest(baseRequest, anthropicOptions);
 }
 function createRequestBase(modelId, defaultMaxTokens, options, anthropicOptions) {
-  validateAnthropicReasoningConfig(modelId, options, anthropicOptions);
+  const maxTokens = options.maxTokens ?? defaultMaxTokens;
+  validateAnthropicReasoningConfig(
+    modelId,
+    maxTokens,
+    options,
+    anthropicOptions
+  );
   const converted = convertMessages(options.messages);
-  const reasoningFields = mapReasoningToRequestFields(modelId, options);
+  const reasoningFields = mapReasoningToRequestFields(
+    modelId,
+    maxTokens,
+    options
+  );
   return {
     model: modelId,
     messages: converted.messages,
-    max_tokens: options.maxTokens ?? defaultMaxTokens,
+    max_tokens: maxTokens,
     ...converted.system ? { system: converted.system } : {},
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
@@ -425,11 +447,40 @@ function mapSamplingToRequestFields(options) {
     ...options.topP !== void 0 ? { top_p: options.topP } : {}
   };
 }
-function validateAnthropicReasoningConfig(modelId, options, anthropicOptions) {
+function validateAnthropicReasoningConfig(modelId, maxTokens, options, anthropicOptions) {
+  const alwaysRestrictsSampling = restrictsAnthropicSamplingParamsAlways(modelId);
+  if (alwaysRestrictsSampling && options.temperature !== void 0 && options.temperature !== 1) {
+    throw new ValidationError(
+      `Anthropic model "${modelId}" only supports the default temperature of 1`,
+      void 0,
+      "anthropic"
+    );
+  }
+  if (alwaysRestrictsSampling && options.topP !== void 0 && options.topP !== 1) {
+    throw new ValidationError(
+      `Anthropic model "${modelId}" only supports the default topP of 1`,
+      void 0,
+      "anthropic"
+    );
+  }
+  if (alwaysRestrictsSampling && anthropicOptions?.topK !== void 0) {
+    throw new ValidationError(
+      `Anthropic model "${modelId}" does not support top_k`,
+      void 0,
+      "anthropic"
+    );
+  }
   if (!options.reasoning) {
     return;
   }
-  if (options.temperature !== void 0) {
+  if (getAnthropicThinkingMode(modelId) === "manual" && maxTokens <= 1024) {
+    throw new ValidationError(
+      `Anthropic model "${modelId}" requires maxTokens greater than 1024 when reasoning is enabled`,
+      void 0,
+      "anthropic"
+    );
+  }
+  if (options.temperature !== void 0 && (!alwaysRestrictsSampling || options.temperature !== 1)) {
     throw new ValidationError(
       `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
       void 0,
@@ -458,31 +509,48 @@ function validateAnthropicReasoningConfig(modelId, options, anthropicOptions) {
     );
   }
 }
-function mapReasoningToRequestFields(modelId, options) {
+function mapReasoningToRequestFields(modelId, maxTokens, options) {
   if (!options.reasoning) {
     return {};
   }
+  const thinkingMode = getAnthropicThinkingMode(modelId);
   const capabilities = getAnthropicModelCapabilities(modelId);
+  const effort = clampReasoningEffort(
+    options.reasoning.effort,
+    capabilities.reasoning.supportedEfforts
+  );
   const baseFields = {};
-  if (options.tools && Object.keys(options.tools).length > 0) {
-    baseFields["betas"] = ["interleaved-thinking-2025-05-14"];
-  }
-  if (capabilities.reasoning.thinkingMode === "adaptive") {
-    baseFields["thinking"] = { type: "adaptive" };
+  if (thinkingMode === "adaptive") {
+    baseFields["thinking"] = {
+      type: "adaptive",
+      display: "summarized"
+    };
     baseFields["output_config"] = {
       effort: toAnthropicAdaptiveEffort(
-        options.reasoning.effort,
-        capabilities.reasoning.supportsMaxEffort
+        effort,
+        supportsAnthropicMaxEffort(modelId)
       )
     };
     return baseFields;
   }
   baseFields["thinking"] = {
     type: "enabled",
-    budget_tokens: toAnthropicManualBudget(options.reasoning.effort)
+    budget_tokens: toAnthropicManualBudget(effort, maxTokens),
+    display: "summarized"
   };
   return baseFields;
 }
+function getAnthropicRequestBetas(modelId, options) {
+  const providerOptions = parseAnthropicGenerateProviderOptions(
+    options.providerOptions
+  );
+  const configuredBetas = providerOptions?.betas ?? [];
+  const shouldEnableInterleavedThinking = options.reasoning !== void 0 && options.tools !== void 0 && Object.keys(options.tools).length > 0 && requiresAnthropicInterleavedThinkingBeta(modelId);
+  return uniqueStrings([
+    ...configuredBetas,
+    ...shouldEnableInterleavedThinking ? ["interleaved-thinking-2025-05-14"] : []
+  ]);
+}
 function mapAnthropicProviderOptionsToRequest(baseRequest, providerOptions) {
   if (!providerOptions) {
     return baseRequest;
@@ -494,17 +562,12 @@ function mapAnthropicProviderOptionsToRequest(baseRequest, providerOptions) {
     ...baseOutputConfig,
     ...providerOptions.outputConfig ?? {}
   };
-  const mergedBetas = [
-    ...asStringArray(baseRequest.betas),
-    ...providerOptions.betas ?? []
-  ];
   const mergedRequest = {
     ...baseRequest,
     ...providerOptions.cacheControl ? { cache_control: providerOptions.cacheControl } : {},
     ...providerOptions.topK !== void 0 ? { top_k: providerOptions.topK } : {},
     ...providerOptions.stopSequences ? { stop_sequences: providerOptions.stopSequences } : {},
-    ...Object.keys(mergedOutputConfig).length > 0 ? { output_config: mergedOutputConfig } : {},
-    ...mergedBetas.length > 0 ? { betas: uniqueStrings(mergedBetas) } : {}
+    ...Object.keys(mergedOutputConfig).length > 0 ? { output_config: mergedOutputConfig } : {}
   };
   return mergedRequest;
 }
@@ -573,7 +636,7 @@ function mapGenerateResponse(response) {
         cacheReadTokens,
         cacheWriteTokens
       },
-      outputTokenDetails: {}
+      outputTokenDetails: mapAnthropicOutputTokenDetails(response.usage)
     }
   };
 }
@@ -604,7 +667,9 @@ async function* transformStream(stream) {
           cacheReadTokens,
           cacheWriteTokens
         },
-        outputTokenDetails: {}
+        outputTokenDetails: mapAnthropicOutputTokenDetails(
+          event.message.usage
+        )
       };
       continue;
     }
@@ -713,7 +778,10 @@ async function* transformStream(stream) {
           cacheReadTokens,
           cacheWriteTokens
         },
-        outputTokenDetails: {}
+        outputTokenDetails: {
+          ...usage.outputTokenDetails,
+          ...mapAnthropicOutputTokenDetails(event.usage)
+        }
       };
       continue;
     }
@@ -739,11 +807,10 @@ function mapStopReason(reason) {
   }
   return "unknown";
 }
-function asStringArray(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.filter((item) => typeof item === "string");
+function mapAnthropicOutputTokenDetails(usage) {
+  const outputTokenDetails = asObject(asObject(usage).output_tokens_details);
+  const reasoningTokens = outputTokenDetails.thinking_tokens;
+  return typeof reasoningTokens === "number" ? { reasoningTokens } : {};
 }
 function uniqueStrings(values) {
   return [...new Set(values)];
@@ -786,9 +853,14 @@ function wrapError(error) {
 // src/chat-model.ts
 function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
   const provider = "anthropic";
-  async function callAnthropicMessagesApi(request, signal) {
+  async function callAnthropicMessagesApi(request, betas, signal) {
     try {
       return await client.messages.create(request, {
+        ...betas.length > 0 ? {
+          headers: {
+            "anthropic-beta": betas.join(",")
+          }
+        } : {},
         signal
       });
     } catch (error) {
@@ -801,14 +873,18 @@ function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
       defaultMaxTokens,
       options
     );
-    const response = await callAnthropicMessagesApi(request, options.signal);
+    const response = await callAnthropicMessagesApi(request, getAnthropicRequestBetas(modelId, options), options.signal);
     return mapGenerateResponse(response);
   }
   async function streamChat(options) {
     const request = createStreamRequest(modelId, defaultMaxTokens, options);
     return createChatStream(
       async () => transformStream(
-        await callAnthropicMessagesApi(request, options.signal)
+        await callAnthropicMessagesApi(
+          request,
+          getAnthropicRequestBetas(modelId, options),
+          options.signal
+        )
       ),
       { signal: options.signal }
     );
@@ -816,6 +892,7 @@ function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
   return {
     provider,
     modelId,
+    capabilities: getAnthropicModelCapabilities(modelId),
     generate: generateChat,
     stream: streamChat,
     async generateObject(options) {
@@ -981,5 +1058,6 @@ export {
   anthropicCacheControlSchema,
   anthropicGenerateProviderOptionsSchema,
   anthropicProviderOptionsSchema,
-  createAnthropic
+  createAnthropic,
+  getAnthropicModelCapabilities
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.12.0",
+    "version": "0.13.1",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -44,8 +44,8 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.12.0",
-        "@anthropic-ai/sdk": "^0.78.0"
+        "@anthropic-ai/sdk": "^0.110.0",
+        "@core-ai/core-ai": "^0.13.1"
     },
     "peerDependencies": {
         "zod": "^4.0.0"