@core-ai/anthropic 0.13.0 → 0.13.1

package/dist/index.js

@@ -15,6 +15,7 @@ import { APIError, APIUserAbortError } from "@anthropic-ai/sdk";
 import {
   AbortedError,
   asObject,
+  clampReasoningEffort,
   getProviderMetadata,
   ProviderError,
   ValidationError,
@@ -69,6 +70,21 @@ var MANUAL_THINKING_MODELS = /* @__PURE__ */ new Set([
   "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",
@@ -97,14 +113,21 @@ function getAnthropicThinkingMode(modelId) {
 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
@@ -198,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",
@@ -395,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) } : {},
@@ -415,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,
@@ -448,20 +509,25 @@ 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 (thinkingMode === "adaptive") {
-    baseFields["thinking"] = { type: "adaptive" };
+    baseFields["thinking"] = {
+      type: "adaptive",
+      display: "summarized"
+    };
     baseFields["output_config"] = {
       effort: toAnthropicAdaptiveEffort(
-        options.reasoning.effort,
+        effort,
         supportsAnthropicMaxEffort(modelId)
       )
     };
@@ -469,10 +535,22 @@ function mapReasoningToRequestFields(modelId, options) {
   }
   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;
@@ -484,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;
 }
@@ -563,7 +636,7 @@ function mapGenerateResponse(response) {
         cacheReadTokens,
         cacheWriteTokens
       },
-      outputTokenDetails: {}
+      outputTokenDetails: mapAnthropicOutputTokenDetails(response.usage)
     }
   };
 }
@@ -594,7 +667,9 @@ async function* transformStream(stream) {
           cacheReadTokens,
           cacheWriteTokens
         },
-        outputTokenDetails: {}
+        outputTokenDetails: mapAnthropicOutputTokenDetails(
+          event.message.usage
+        )
       };
       continue;
     }
@@ -703,7 +778,10 @@ async function* transformStream(stream) {
           cacheReadTokens,
           cacheWriteTokens
         },
-        outputTokenDetails: {}
+        outputTokenDetails: {
+          ...usage.outputTokenDetails,
+          ...mapAnthropicOutputTokenDetails(event.usage)
+        }
       };
       continue;
     }
@@ -729,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)];
@@ -776,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) {
@@ -791,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 }
     );

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.13.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.13.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"