@core-ai/anthropic 0.2.0 → 0.3.0

package/README.md

@@ -1,5 +1,7 @@
 # @core-ai/anthropic
 
+[![npm](https://img.shields.io/npm/v/@core-ai/anthropic.svg)](https://www.npmjs.com/package/@core-ai/anthropic)
+
 Anthropic provider package for `@core-ai/core-ai`.
 
 ## Installation
@@ -15,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) {
@@ -221,7 +292,7 @@ async function* transformStream(stream) {
     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,
@@ -321,7 +392,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 +409,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.0",
+    "version": "0.3.0",
     "description": "Anthropic provider package for @core-ai/core-ai",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -43,12 +43,12 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@core-ai/core-ai": "^0.2.0",
+        "@core-ai/core-ai": "^0.3.0",
         "@anthropic-ai/sdk": "^0.78.0",
-        "zod-to-json-schema": "^3.24.5"
+        "zod-to-json-schema": "^3.25.1"
     },
     "peerDependencies": {
-        "zod": "^3.25.76"
+        "zod": "^3.25.0 || ^4.0.0"
     },
     "devDependencies": {
         "@core-ai/eslint-config": "^0.0.0",