@core-ai/anthropic 0.2.1 → 0.4.0

package/README.md

@@ -17,7 +17,7 @@ import { generate } from '@core-ai/core-ai';
 import { createAnthropic } from '@core-ai/anthropic';
 
 const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
-const model = anthropic.chatModel('claude-sonnet-4-20250514');
+const model = anthropic.chatModel('claude-haiku-4-5');
 
 const result = await generate({
     model,

package/dist/index.js

@@ -2,12 +2,28 @@
 import Anthropic from "@anthropic-ai/sdk";
 
 // src/chat-model.ts
-import { createStreamResult } from "@core-ai/core-ai";
+import {
+  StructuredOutputNoObjectGeneratedError,
+  StructuredOutputParseError,
+  StructuredOutputValidationError,
+  createObjectStreamResult,
+  createStreamResult
+} from "@core-ai/core-ai";
 
 // src/chat-adapter.ts
 import { APIError } from "@anthropic-ai/sdk";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { ProviderError } from "@core-ai/core-ai";
+var UNSUPPORTED_ANTHROPIC_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "maxItems"
+]);
 function convertMessages(messages) {
   const systemParts = [];
   const convertedMessages = [];
@@ -115,12 +131,12 @@ function convertUserContentPart(part) {
 }
 function convertTools(tools) {
   return Object.values(tools).map((tool) => {
-    const schema = zodToJsonSchema(tool.parameters);
-    const { $schema: _schema, ...inputSchema } = schema;
+    const schema = toAnthropicJsonSchema(tool.parameters);
     return {
       name: tool.name,
       description: tool.description,
-      input_schema: inputSchema
+      input_schema: schema,
+      strict: true
     };
   });
 }
@@ -139,35 +155,90 @@ function convertToolChoice(choice) {
     name: choice.toolName
   };
 }
+function createStructuredOutputOptions(options) {
+  const schema = toAnthropicJsonSchema(options.schema);
+  const schemaDescription = options.schemaDescription?.trim();
+  if (schemaDescription && schemaDescription.length > 0) {
+    schema.description = schemaDescription;
+  }
+  return {
+    messages: options.messages,
+    config: options.config,
+    providerOptions: {
+      ...options.providerOptions ?? {},
+      output_config: {
+        format: {
+          type: "json_schema",
+          schema
+        }
+      }
+    },
+    signal: options.signal
+  };
+}
+function toAnthropicJsonSchema(schema) {
+  const rawSchema = zodToJsonSchema(schema);
+  return normalizeAnthropicJsonSchema(rawSchema);
+}
+function normalizeAnthropicJsonSchema(value) {
+  const normalized = normalizeAnthropicJsonValue(value);
+  return isJsonObject(normalized) ? normalized : {};
+}
+function normalizeAnthropicJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeAnthropicJsonValue);
+  }
+  if (!isJsonObject(value)) {
+    return value;
+  }
+  const normalized = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "$schema" || UNSUPPORTED_ANTHROPIC_SCHEMA_KEYWORDS.has(key) || key === "minItems" && typeof child === "number" && child > 1) {
+      continue;
+    }
+    normalized[key] = normalizeAnthropicJsonValue(child);
+  }
+  if (isObjectSchema(normalized)) {
+    normalized.additionalProperties = false;
+  }
+  return normalized;
+}
+function isObjectSchema(value) {
+  return value.type === "object" || Object.hasOwn(value, "properties") || Object.hasOwn(value, "required");
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function createGenerateRequest(modelId, defaultMaxTokens, options) {
-  const converted = convertMessages(options.messages);
   return {
-    model: modelId,
-    messages: converted.messages,
-    max_tokens: options.config?.maxTokens ?? defaultMaxTokens,
-    ...converted.system ? { system: converted.system } : {},
-    ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
-    ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
-    ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
-    ...options.config?.topP !== void 0 ? { top_p: options.config.topP } : {},
-    ...options.config?.stopSequences ? { stop_sequences: options.config.stopSequences } : {},
+    ...createRequestBase(modelId, defaultMaxTokens, options),
     ...options.providerOptions
   };
 }
 function createStreamRequest(modelId, defaultMaxTokens, options) {
+  return {
+    ...createRequestBase(modelId, defaultMaxTokens, options),
+    stream: true,
+    ...options.providerOptions
+  };
+}
+function createRequestBase(modelId, defaultMaxTokens, options) {
   const converted = convertMessages(options.messages);
   return {
     model: modelId,
     messages: converted.messages,
-    stream: true,
     max_tokens: options.config?.maxTokens ?? defaultMaxTokens,
     ...converted.system ? { system: converted.system } : {},
     ...options.tools && Object.keys(options.tools).length > 0 ? { tools: convertTools(options.tools) } : {},
     ...options.toolChoice ? { tool_choice: convertToolChoice(options.toolChoice) } : {},
-    ...options.config?.temperature !== void 0 ? { temperature: options.config.temperature } : {},
-    ...options.config?.topP !== void 0 ? { top_p: options.config.topP } : {},
-    ...options.config?.stopSequences ? { stop_sequences: options.config.stopSequences } : {},
-    ...options.providerOptions
+    ...mapConfigToRequestFields(options.config)
+  };
+}
+function mapConfigToRequestFields(config) {
+  return {
+    ...config?.temperature !== void 0 ? { temperature: config.temperature } : {},
+    ...config?.topP !== void 0 ? { top_p: config.topP } : {},
+    ...config?.stopSequences ? { stop_sequences: config.stopSequences } : {}
   };
 }
 function mapGenerateResponse(response) {
@@ -186,15 +257,23 @@ function mapGenerateResponse(response) {
       });
     }
   }
+  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;
   return {
     content: content.length > 0 ? content : 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: {
+        reasoningTokens: 0
+      }
     }
   };
 }
@@ -203,25 +282,38 @@ async function* transformStream(stream) {
   let usage = {
     inputTokens: 0,
     outputTokens: 0,
-    reasoningTokens: 0,
-    totalTokens: 0
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {
+      reasoningTokens: 0
+    }
   };
   const toolBuffers = /* @__PURE__ */ new Map();
   const emittedToolCalls = /* @__PURE__ */ new Set();
   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: {
+          reasoningTokens: 0
+        }
       };
       continue;
     }
     if (event.type === "content_block_start") {
       if (event.content_block.type === "tool_use") {
         const block = event.content_block;
-        const initialArguments = block.input && typeof block.input === "object" ? JSON.stringify(block.input) : "";
+        const initialArguments = block.input && typeof block.input === "object" ? Object.keys(block.input).length > 0 ? JSON.stringify(block.input) : "" : "";
         toolBuffers.set(event.index, {
           id: block.id,
           name: block.name,
@@ -275,11 +367,19 @@ 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: {
+          reasoningTokens: 0
+        }
       };
       continue;
     }
@@ -321,7 +421,12 @@ function asObject(value) {
 }
 function wrapError(error) {
   if (error instanceof APIError) {
-    return new ProviderError(error.message, "anthropic", error.status, error);
+    return new ProviderError(
+      error.message,
+      "anthropic",
+      error.status,
+      error
+    );
   }
   return new ProviderError(
     error instanceof Error ? error.message : String(error),
@@ -333,39 +438,166 @@ function wrapError(error) {
 
 // src/chat-model.ts
 function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
+  const provider = "anthropic";
+  async function callAnthropicMessagesApi(request) {
+    try {
+      return await client.messages.create(request);
+    } catch (error) {
+      throw wrapError(error);
+    }
+  }
+  async function generateChat(options) {
+    const request = createGenerateRequest(modelId, defaultMaxTokens, options);
+    const response = await callAnthropicMessagesApi(request);
+    return mapGenerateResponse(response);
+  }
+  async function streamChat(options) {
+    const request = createStreamRequest(modelId, defaultMaxTokens, options);
+    const stream = await callAnthropicMessagesApi(request);
+    return createStreamResult(transformStream(stream));
+  }
   return {
-    provider: "anthropic",
+    provider,
     modelId,
-    async generate(options) {
-      try {
-        const request = createGenerateRequest(
-          modelId,
-          defaultMaxTokens,
-          options
-        );
-        const response = await client.messages.create(request);
-        return mapGenerateResponse(response);
-      } catch (error) {
-        throw wrapError(error);
-      }
+    generate: generateChat,
+    stream: streamChat,
+    async generateObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const result = await generateChat(structuredOptions);
+      const object = extractStructuredObject(result, options.schema, provider);
+      return {
+        object,
+        finishReason: result.finishReason,
+        usage: result.usage
+      };
     },
-    async stream(options) {
-      try {
-        const request = createStreamRequest(
-          modelId,
-          defaultMaxTokens,
-          options
-        );
-        const stream = await client.messages.create(
-          request
-        );
-        return createStreamResult(transformStream(stream));
-      } catch (error) {
-        throw wrapError(error);
-      }
+    async streamObject(options) {
+      const structuredOptions = createStructuredOutputOptions(options);
+      const stream = await streamChat(structuredOptions);
+      return createObjectStreamResult(
+        transformStructuredOutputStream(
+          stream,
+          options.schema,
+          provider
+        )
+      );
     }
   };
 }
+function extractStructuredObject(result, schema, provider) {
+  const rawOutput = requireStructuredOutputPayload(
+    result.finishReason,
+    result.content?.trim(),
+    provider,
+    "model did not emit a structured object payload"
+  );
+  return parseAndValidateStructuredObject(schema, rawOutput, provider);
+}
+async function* transformStructuredOutputStream(stream, schema, provider) {
+  let contentBuffer = "";
+  for await (const event of stream) {
+    if (event.type === "content-delta") {
+      contentBuffer += event.text;
+      yield {
+        type: "object-delta",
+        text: event.text
+      };
+      continue;
+    }
+    if (event.type === "tool-call-delta") {
+      contentBuffer += event.argumentsDelta;
+      yield {
+        type: "object-delta",
+        text: event.argumentsDelta
+      };
+      continue;
+    }
+    if (event.type === "finish") {
+      const rawOutput = requireStructuredOutputPayload(
+        event.finishReason,
+        contentBuffer.trim(),
+        provider,
+        "structured output stream ended without an object payload"
+      );
+      const validatedObject = parseAndValidateStructuredObject(
+        schema,
+        rawOutput,
+        provider
+      );
+      yield {
+        type: "object",
+        object: validatedObject
+      };
+      yield {
+        type: "finish",
+        finishReason: event.finishReason,
+        usage: event.usage
+      };
+    }
+  }
+}
+function requireStructuredOutputPayload(finishReason, rawOutput, provider, noPayloadMessage) {
+  if (finishReason === "content-filter") {
+    throw new StructuredOutputNoObjectGeneratedError(
+      "model refused to produce a structured output",
+      provider,
+      {
+        rawOutput
+      }
+    );
+  }
+  if (finishReason === "length") {
+    throw new StructuredOutputNoObjectGeneratedError(
+      "structured output was truncated because max tokens were reached",
+      provider,
+      {
+        rawOutput
+      }
+    );
+  }
+  if (!rawOutput || rawOutput.length === 0) {
+    throw new StructuredOutputNoObjectGeneratedError(noPayloadMessage, provider);
+  }
+  return rawOutput;
+}
+function parseAndValidateStructuredObject(schema, rawOutput, provider) {
+  const parsedOutput = parseJson(rawOutput, provider);
+  return validateStructuredObject(schema, parsedOutput, provider, rawOutput);
+}
+function parseJson(rawOutput, provider) {
+  try {
+    return JSON.parse(rawOutput);
+  } catch (error) {
+    throw new StructuredOutputParseError(
+      "failed to parse structured output as JSON",
+      provider,
+      {
+        rawOutput,
+        cause: error
+      }
+    );
+  }
+}
+function validateStructuredObject(schema, value, provider, rawOutput) {
+  const parsed = schema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  throw new StructuredOutputValidationError(
+    "structured output does not match schema",
+    provider,
+    formatZodIssues(parsed.error.issues),
+    {
+      rawOutput
+    }
+  );
+}
+function formatZodIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.map((segment) => String(segment)).join(".") : "<root>";
+    return `${path}: ${issue.message}`;
+  });
+}
 
 // src/provider.ts
 function createAnthropic(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/anthropic",
-    "version": "0.2.1",
+    "version": "0.4.0",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -43,7 +43,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.2.1",
+        "@core-ai/core-ai": "^0.4.0",
         "@anthropic-ai/sdk": "^0.78.0",
         "zod-to-json-schema": "^3.25.1"
     },