@core-ai/anthropic 0.3.0 → 0.5.1

package/dist/index.js

@@ -14,6 +14,103 @@ import {
 import { APIError } from "@anthropic-ai/sdk";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { ProviderError } from "@core-ai/core-ai";
+
+// src/model-capabilities.ts
+var DEFAULT_CAPABILITIES = {
+  reasoning: {
+    thinkingMode: "adaptive",
+    supportsMaxEffort: false
+  }
+};
+var MODEL_CAPABILITIES = {
+  "claude-opus-4-6": {
+    reasoning: {
+      thinkingMode: "adaptive",
+      supportsMaxEffort: true
+    }
+  },
+  "claude-sonnet-4-6": {
+    reasoning: {
+      thinkingMode: "adaptive",
+      supportsMaxEffort: false
+    }
+  },
+  "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": {
+    reasoning: {
+      thinkingMode: "manual",
+      supportsMaxEffort: false
+    }
+  }
+};
+function getAnthropicModelCapabilities(modelId) {
+  const normalizedModelId = normalizeModelId(modelId);
+  return MODEL_CAPABILITIES[normalizedModelId] ?? DEFAULT_CAPABILITIES;
+}
+function normalizeModelId(modelId) {
+  return modelId.replace(/-\d{8}$/, "");
+}
+function toAnthropicAdaptiveEffort(effort, supportsMaxEffort) {
+  if (effort === "minimal") {
+    return "low";
+  }
+  if (effort === "max") {
+    return supportsMaxEffort ? "max" : "high";
+  }
+  return effort;
+}
+function toAnthropicManualBudget(effort) {
+  if (effort === "minimal") {
+    return 1024;
+  }
+  if (effort === "low") {
+    return 2048;
+  }
+  if (effort === "medium") {
+    return 8192;
+  }
+  if (effort === "high") {
+    return 32768;
+  }
+  return 65536;
+}
+
+// src/chat-adapter.ts
 var UNSUPPORTED_ANTHROPIC_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
   "minimum",
   "maximum",
@@ -44,19 +141,40 @@ function convertMessages(messages) {
     }
     if (message.role === "assistant") {
       const contentBlocks = [];
-      if (message.content) {
-        contentBlocks.push({
-          type: "text",
-          text: message.content
-        });
-      }
-      for (const toolCall of message.toolCalls ?? []) {
-        contentBlocks.push({
-          type: "tool_use",
-          id: toolCall.id,
-          name: toolCall.name,
-          input: toolCall.arguments
-        });
+      for (const part of message.parts) {
+        if (part.type === "text") {
+          contentBlocks.push({
+            type: "text",
+            text: part.text
+          });
+          continue;
+        }
+        if (part.type === "tool-call") {
+          contentBlocks.push({
+            type: "tool_use",
+            id: part.toolCall.id,
+            name: part.toolCall.name,
+            input: part.toolCall.arguments
+          });
+          continue;
+        }
+        const signature = part.providerMetadata?.["signature"];
+        const redactedData = part.providerMetadata?.["redactedData"];
+        if (typeof redactedData === "string") {
+          contentBlocks.push({
+            type: "redacted_thinking",
+            data: redactedData
+          });
+          continue;
+        }
+        const thinkingBlock = {
+          type: "thinking",
+          thinking: part.text
+        };
+        if (typeof signature === "string") {
+          thinkingBlock["signature"] = signature;
+        }
+        contentBlocks.push(thinkingBlock);
       }
       convertedMessages.push({
         role: "assistant",
@@ -163,6 +281,7 @@ function createStructuredOutputOptions(options) {
   }
   return {
     messages: options.messages,
+    reasoning: options.reasoning,
     config: options.config,
     providerOptions: {
       ...options.providerOptions ?? {},
@@ -210,20 +329,20 @@ function isJsonObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function createGenerateRequest(modelId, defaultMaxTokens, options) {
-  return {
-    ...createRequestBase(modelId, defaultMaxTokens, options),
-    ...options.providerOptions
-  };
+  const baseRequest = createRequestBase(modelId, defaultMaxTokens, options);
+  return mergeProviderOptions(baseRequest, options.providerOptions);
 }
 function createStreamRequest(modelId, defaultMaxTokens, options) {
-  return {
+  const baseRequest = {
     ...createRequestBase(modelId, defaultMaxTokens, options),
-    stream: true,
-    ...options.providerOptions
+    stream: true
   };
+  return mergeProviderOptions(baseRequest, options.providerOptions);
 }
 function createRequestBase(modelId, defaultMaxTokens, options) {
+  validateAnthropicReasoningConfig(modelId, options);
   const converted = convertMessages(options.messages);
+  const reasoningFields = mapReasoningToRequestFields(modelId, options);
   return {
     model: modelId,
     messages: converted.messages,
@@ -231,6 +350,7 @@ function createRequestBase(modelId, defaultMaxTokens, options) {
     ...converted.system ? { system: converted.system } : {},
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
+    ...reasoningFields,
     ...mapConfigToRequestFields(options.config)
   };
 }
@@ -241,31 +361,155 @@ function mapConfigToRequestFields(config) {
     ...config?.stopSequences ? { stop_sequences: config.stopSequences } : {}
   };
 }
+function validateAnthropicReasoningConfig(modelId, options) {
+  if (!options.reasoning) {
+    return;
+  }
+  if (options.config?.temperature !== void 0) {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" does not support temperature when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+  if (options.config?.topP !== void 0 && (options.config.topP < 0.95 || options.config.topP > 1)) {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" requires topP between 0.95 and 1 when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+  if (options.toolChoice && options.toolChoice !== "auto" && options.toolChoice !== "none") {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" only supports toolChoice "auto" or "none" when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+  const providerOptions = asObject(options.providerOptions);
+  if (providerOptions["top_k"] !== void 0) {
+    throw new ProviderError(
+      `Anthropic model "${modelId}" does not support top_k when reasoning is enabled`,
+      "anthropic"
+    );
+  }
+}
+function mapReasoningToRequestFields(modelId, options) {
+  if (!options.reasoning) {
+    return {};
+  }
+  const capabilities = getAnthropicModelCapabilities(modelId);
+  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" };
+    baseFields["output_config"] = {
+      effort: toAnthropicAdaptiveEffort(
+        options.reasoning.effort,
+        capabilities.reasoning.supportsMaxEffort
+      )
+    };
+    return baseFields;
+  }
+  baseFields["thinking"] = {
+    type: "enabled",
+    budget_tokens: toAnthropicManualBudget(options.reasoning.effort)
+  };
+  return baseFields;
+}
+function mergeProviderOptions(baseRequest, providerOptions) {
+  if (!providerOptions) {
+    return baseRequest;
+  }
+  const baseOutputConfig = asObject(
+    baseRequest.output_config
+  );
+  const providerOutputConfig = asObject(providerOptions["output_config"]);
+  const mergedOutputConfig = {
+    ...baseOutputConfig,
+    ...providerOutputConfig
+  };
+  const mergedBetas = [
+    ...asStringArray(baseRequest.betas),
+    ...asStringArray(providerOptions["betas"])
+  ];
+  const mergedRequest = {
+    ...baseRequest,
+    ...providerOptions,
+    ...Object.keys(mergedOutputConfig).length > 0 ? { output_config: mergedOutputConfig } : {},
+    ...mergedBetas.length > 0 ? { betas: uniqueStrings(mergedBetas) } : {}
+  };
+  return mergedRequest;
+}
 function mapGenerateResponse(response) {
-  const toolCalls = [];
-  let content = "";
+  const parts = [];
   for (const block of response.content) {
     if (block.type === "text") {
-      content += block.text;
+      parts.push({
+        type: "text",
+        text: block.text
+      });
       continue;
     }
     if (block.type === "tool_use") {
-      toolCalls.push({
-        id: block.id,
-        name: block.name,
-        arguments: asObject(block.input)
+      parts.push({
+        type: "tool-call",
+        toolCall: {
+          id: block.id,
+          name: block.name,
+          arguments: asObject(block.input)
+        }
+      });
+      continue;
+    }
+    if (block.type === "thinking") {
+      const thinkingText = typeof block.thinking === "string" ? block.thinking : extractThinkingText(block.thinking);
+      const signature = typeof block.signature === "string" ? block.signature : void 0;
+      parts.push({
+        type: "reasoning",
+        text: thinkingText,
+        ...signature ? {
+          providerMetadata: {
+            signature
+          }
+        } : {}
+      });
+      continue;
+    }
+    if (block.type === "redacted_thinking") {
+      const redactedData = typeof block.data === "string" ? block.data : void 0;
+      parts.push({
+        type: "reasoning",
+        text: "",
+        ...redactedData ? {
+          providerMetadata: {
+            redactedData
+          }
+        } : {}
       });
     }
   }
+  const cacheReadTokens = response.usage.cache_read_input_tokens ?? 0;
+  const cacheWriteTokens = response.usage.cache_creation_input_tokens ?? 0;
+  const inputTokens = response.usage.input_tokens + cacheReadTokens + cacheWriteTokens;
+  const content = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+  const reasoning = parts.flatMap((part) => part.type === "reasoning" ? [part.text] : []).join("");
+  const toolCalls = parts.flatMap(
+    (part) => part.type === "tool-call" ? [part.toolCall] : []
+  );
   return {
+    parts,
     content: content.length > 0 ? content : null,
+    reasoning: reasoning.length > 0 ? reasoning : null,
     toolCalls,
     finishReason: mapStopReason(response.stop_reason),
     usage: {
-      inputTokens: response.usage.input_tokens,
+      inputTokens,
       outputTokens: response.usage.output_tokens,
-      reasoningTokens: 0,
-      totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      inputTokenDetails: {
+        cacheReadTokens,
+        cacheWriteTokens
+      },
+      outputTokenDetails: {}
     }
   };
 }
@@ -274,22 +518,39 @@ async function* transformStream(stream) {
   let usage = {
     inputTokens: 0,
     outputTokens: 0,
-    reasoningTokens: 0,
-    totalTokens: 0
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {}
   };
   const toolBuffers = /* @__PURE__ */ new Map();
   const emittedToolCalls = /* @__PURE__ */ new Set();
+  const contentBlockTypeByIndex = /* @__PURE__ */ new Map();
   for await (const event of stream) {
     if (event.type === "message_start") {
+      const cacheReadTokens = event.message.usage.cache_read_input_tokens ?? 0;
+      const cacheWriteTokens = event.message.usage.cache_creation_input_tokens ?? 0;
+      const inputTokens = event.message.usage.input_tokens + cacheReadTokens + cacheWriteTokens;
       usage = {
-        inputTokens: event.message.usage.input_tokens,
+        inputTokens,
         outputTokens: event.message.usage.output_tokens,
-        reasoningTokens: 0,
-        totalTokens: event.message.usage.input_tokens + event.message.usage.output_tokens
+        inputTokenDetails: {
+          cacheReadTokens,
+          cacheWriteTokens
+        },
+        outputTokenDetails: {}
       };
       continue;
     }
     if (event.type === "content_block_start") {
+      contentBlockTypeByIndex.set(event.index, event.content_block.type);
+      if (event.content_block.type === "thinking") {
+        yield {
+          type: "reasoning-start"
+        };
+        continue;
+      }
       if (event.content_block.type === "tool_use") {
         const block = event.content_block;
         const initialArguments = block.input && typeof block.input === "object" ? Object.keys(block.input).length > 0 ? JSON.stringify(block.input) : "" : "";
@@ -309,11 +570,22 @@ async function* transformStream(stream) {
     if (event.type === "content_block_delta") {
       if (event.delta.type === "text_delta") {
         yield {
-          type: "content-delta",
+          type: "text-delta",
           text: event.delta.text
         };
         continue;
       }
+      if (event.delta.type === "thinking_delta") {
+        const thinkingDelta = event.delta;
+        const thinkingText = typeof thinkingDelta.thinking === "string" ? thinkingDelta.thinking : typeof thinkingDelta.text === "string" ? thinkingDelta.text : "";
+        if (thinkingText.length > 0) {
+          yield {
+            type: "reasoning-delta",
+            text: thinkingText
+          };
+        }
+        continue;
+      }
       if (event.delta.type === "input_json_delta") {
         const current = toolBuffers.get(event.index);
         if (!current) {
@@ -329,6 +601,12 @@ async function* transformStream(stream) {
       continue;
     }
     if (event.type === "content_block_stop") {
+      if (contentBlockTypeByIndex.get(event.index) === "thinking") {
+        yield {
+          type: "reasoning-end"
+        };
+        continue;
+      }
       const current = toolBuffers.get(event.index);
       if (!current || emittedToolCalls.has(event.index)) {
         continue;
@@ -346,11 +624,17 @@ async function* transformStream(stream) {
     }
     if (event.type === "message_delta") {
       finishReason = mapStopReason(event.delta.stop_reason);
+      const nonCachedInputTokens = event.usage.input_tokens ?? usage.inputTokens - usage.inputTokenDetails.cacheReadTokens - usage.inputTokenDetails.cacheWriteTokens;
+      const cacheReadTokens = event.usage.cache_read_input_tokens ?? usage.inputTokenDetails.cacheReadTokens;
+      const cacheWriteTokens = event.usage.cache_creation_input_tokens ?? usage.inputTokenDetails.cacheWriteTokens;
       usage = {
-        inputTokens: event.usage.input_tokens ?? usage.inputTokens,
+        inputTokens: nonCachedInputTokens + cacheReadTokens + cacheWriteTokens,
         outputTokens: event.usage.output_tokens,
-        reasoningTokens: 0,
-        totalTokens: (event.usage.input_tokens ?? usage.inputTokens) + event.usage.output_tokens
+        inputTokenDetails: {
+          cacheReadTokens,
+          cacheWriteTokens
+        },
+        outputTokenDetails: {}
       };
       continue;
     }
@@ -390,6 +674,30 @@ function asObject(value) {
   }
   return {};
 }
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function extractThinkingText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const text = item.text;
+    return typeof text === "string" ? [text] : [];
+  }).join("");
+}
 function wrapError(error) {
   if (error instanceof APIError) {
     return new ProviderError(
@@ -467,7 +775,7 @@ function extractStructuredObject(result, schema, provider) {
 async function* transformStructuredOutputStream(stream, schema, provider) {
   let contentBuffer = "";
   for await (const event of stream) {
-    if (event.type === "content-delta") {
+    if (event.type === "text-delta") {
       contentBuffer += event.text;
       yield {
         type: "object-delta",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.3.0",
+    "version": "0.5.1",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -38,12 +38,11 @@
         "build": "tsup",
         "lint": "eslint src/ --max-warnings 0",
         "check-types": "tsc --noEmit",
-        "prepublishOnly": "npm run build",
         "test": "vitest run",
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.3.0",
+        "@core-ai/core-ai": "^0.5.1",
         "@anthropic-ai/sdk": "^0.78.0",
         "zod-to-json-schema": "^3.25.1"
     },