@core-ai/anthropic 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omnifact (https://omnifact.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# @core-ai/anthropic
+
+Anthropic provider package for `@core-ai/core-ai`.
+
+## Installation
+
+```bash
+npm install @core-ai/core-ai @core-ai/anthropic zod
+```
+
+## Usage
+
+```ts
+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 result = await generate({
+    model,
+    messages: [{ role: 'user', content: 'Hello!' }],
+});
+
+console.log(result.content);
+```

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { ChatModel } from '@core-ai/core-ai';
+
+type AnthropicProviderOptions = {
+    apiKey?: string;
+    baseURL?: string;
+    client?: Anthropic;
+    defaultMaxTokens?: number;
+};
+type AnthropicProvider = {
+    chatModel(modelId: string): ChatModel;
+};
+declare function createAnthropic(options?: AnthropicProviderOptions): AnthropicProvider;
+
+export { type AnthropicProvider, type AnthropicProviderOptions, createAnthropic };

package/dist/index.js

@@ -0,0 +1,383 @@
+// src/provider.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/chat-model.ts
+import { 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";
+function convertMessages(messages) {
+  const systemParts = [];
+  const convertedMessages = [];
+  let previousInputWasTool = false;
+  for (const message of messages) {
+    if (message.role === "system") {
+      systemParts.push(message.content);
+      previousInputWasTool = false;
+      continue;
+    }
+    if (message.role === "user") {
+      convertedMessages.push({
+        role: "user",
+        content: typeof message.content === "string" ? message.content : message.content.map(convertUserContentPart)
+      });
+      previousInputWasTool = false;
+      continue;
+    }
+    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
+        });
+      }
+      convertedMessages.push({
+        role: "assistant",
+        content: contentBlocks.length === 0 ? "" : contentBlocks.length === 1 && contentBlocks[0]?.type === "text" ? contentBlocks[0].text : contentBlocks
+      });
+      previousInputWasTool = false;
+      continue;
+    }
+    const toolResultBlock = {
+      type: "tool_result",
+      tool_use_id: message.toolCallId,
+      content: message.content,
+      ...message.isError ? { is_error: true } : {}
+    };
+    if (previousInputWasTool && convertedMessages.at(-1)?.role === "user" && Array.isArray(convertedMessages.at(-1)?.content)) {
+      const lastMessage = convertedMessages.at(-1);
+      if (lastMessage && Array.isArray(lastMessage.content)) {
+        lastMessage.content.push(toolResultBlock);
+      }
+    } else {
+      convertedMessages.push({
+        role: "user",
+        content: [toolResultBlock]
+      });
+    }
+    previousInputWasTool = true;
+  }
+  return {
+    system: systemParts.length > 0 ? systemParts.join("\n") : void 0,
+    messages: convertedMessages
+  };
+}
+function convertUserContentPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text
+    };
+  }
+  if (part.type === "image") {
+    if (part.source.type === "url") {
+      return {
+        type: "image",
+        source: {
+          type: "url",
+          url: part.source.url
+        }
+      };
+    }
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: part.source.mediaType,
+        data: part.source.data
+      }
+    };
+  }
+  if (part.mimeType !== "application/pdf") {
+    throw new Error(
+      "Anthropic only supports PDF file content in this abstraction"
+    );
+  }
+  return {
+    type: "document",
+    source: {
+      type: "base64",
+      media_type: "application/pdf",
+      data: part.data
+    }
+  };
+}
+function convertTools(tools) {
+  return Object.values(tools).map((tool) => {
+    const schema = zodToJsonSchema(tool.parameters);
+    const { $schema: _schema, ...inputSchema } = schema;
+    return {
+      name: tool.name,
+      description: tool.description,
+      input_schema: inputSchema
+    };
+  });
+}
+function convertToolChoice(choice) {
+  if (choice === "auto") {
+    return { type: "auto" };
+  }
+  if (choice === "none") {
+    return { type: "none" };
+  }
+  if (choice === "required") {
+    return { type: "any" };
+  }
+  return {
+    type: "tool",
+    name: choice.toolName
+  };
+}
+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 } : {},
+    ...options.providerOptions
+  };
+}
+function createStreamRequest(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
+  };
+}
+function mapGenerateResponse(response) {
+  const toolCalls = [];
+  let content = "";
+  for (const block of response.content) {
+    if (block.type === "text") {
+      content += block.text;
+      continue;
+    }
+    if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: asObject(block.input)
+      });
+    }
+  }
+  return {
+    content: content.length > 0 ? content : null,
+    toolCalls,
+    finishReason: mapStopReason(response.stop_reason),
+    usage: {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens,
+      reasoningTokens: 0,
+      totalTokens: response.usage.input_tokens + response.usage.output_tokens
+    }
+  };
+}
+async function* transformStream(stream) {
+  let finishReason = "unknown";
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0
+  };
+  const toolBuffers = /* @__PURE__ */ new Map();
+  const emittedToolCalls = /* @__PURE__ */ new Set();
+  for await (const event of stream) {
+    if (event.type === "message_start") {
+      usage = {
+        inputTokens: event.message.usage.input_tokens,
+        outputTokens: event.message.usage.output_tokens,
+        reasoningTokens: 0,
+        totalTokens: event.message.usage.input_tokens + event.message.usage.output_tokens
+      };
+      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) : "";
+        toolBuffers.set(event.index, {
+          id: block.id,
+          name: block.name,
+          arguments: initialArguments
+        });
+        yield {
+          type: "tool-call-start",
+          toolCallId: block.id,
+          toolName: block.name
+        };
+      }
+      continue;
+    }
+    if (event.type === "content_block_delta") {
+      if (event.delta.type === "text_delta") {
+        yield {
+          type: "content-delta",
+          text: event.delta.text
+        };
+        continue;
+      }
+      if (event.delta.type === "input_json_delta") {
+        const current = toolBuffers.get(event.index);
+        if (!current) {
+          continue;
+        }
+        current.arguments += event.delta.partial_json;
+        yield {
+          type: "tool-call-delta",
+          toolCallId: current.id,
+          argumentsDelta: event.delta.partial_json
+        };
+      }
+      continue;
+    }
+    if (event.type === "content_block_stop") {
+      const current = toolBuffers.get(event.index);
+      if (!current || emittedToolCalls.has(event.index)) {
+        continue;
+      }
+      emittedToolCalls.add(event.index);
+      yield {
+        type: "tool-call-end",
+        toolCall: {
+          id: current.id,
+          name: current.name,
+          arguments: safeParseJsonObject(current.arguments)
+        }
+      };
+      continue;
+    }
+    if (event.type === "message_delta") {
+      finishReason = mapStopReason(event.delta.stop_reason);
+      usage = {
+        inputTokens: event.usage.input_tokens ?? usage.inputTokens,
+        outputTokens: event.usage.output_tokens,
+        reasoningTokens: 0,
+        totalTokens: (event.usage.input_tokens ?? usage.inputTokens) + event.usage.output_tokens
+      };
+      continue;
+    }
+  }
+  yield {
+    type: "finish",
+    finishReason,
+    usage
+  };
+}
+function mapStopReason(reason) {
+  if (reason === "end_turn" || reason === "stop_sequence") {
+    return "stop";
+  }
+  if (reason === "max_tokens") {
+    return "length";
+  }
+  if (reason === "tool_use") {
+    return "tool-calls";
+  }
+  if (reason === "refusal") {
+    return "content-filter";
+  }
+  return "unknown";
+}
+function safeParseJsonObject(json) {
+  try {
+    const parsed = JSON.parse(json);
+    return asObject(parsed);
+  } catch {
+    return {};
+  }
+}
+function asObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+function wrapError(error) {
+  if (error instanceof APIError) {
+    return new ProviderError(error.message, "anthropic", error.status, error);
+  }
+  return new ProviderError(
+    error instanceof Error ? error.message : String(error),
+    "anthropic",
+    void 0,
+    error
+  );
+}
+
+// src/chat-model.ts
+function createAnthropicChatModel(client, modelId, defaultMaxTokens) {
+  return {
+    provider: "anthropic",
+    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);
+      }
+    },
+    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);
+      }
+    }
+  };
+}
+
+// src/provider.ts
+function createAnthropic(options = {}) {
+  const client = options.client ?? new Anthropic({
+    apiKey: options.apiKey,
+    baseURL: options.baseURL
+  });
+  const defaultMaxTokens = options.defaultMaxTokens ?? 4096;
+  return {
+    chatModel: (modelId) => createAnthropicChatModel(client, modelId, defaultMaxTokens)
+  };
+}
+export {
+  createAnthropic
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "@core-ai/anthropic",
+    "version": "0.1.0",
+    "description": "Anthropic provider package for @core-ai/core-ai",
+    "license": "MIT",
+    "author": "Omnifact (https://omnifact.ai)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/agdevhq/ai-core.git",
+        "directory": "packages/anthropic"
+    },
+    "keywords": ["llm", "ai", "anthropic", "provider", "sdk"],
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "files": ["dist", "README.md", "LICENSE"],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "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.1.0",
+        "@anthropic-ai/sdk": "^0.78.0",
+        "zod-to-json-schema": "^3.24.5"
+    },
+    "peerDependencies": {
+        "zod": "^3.25.76"
+    },
+    "devDependencies": {
+        "@core-ai/eslint-config": "^0.0.0",
+        "@core-ai/typescript-config": "^0.0.0",
+        "typescript": "^5.7.3",
+        "vitest": "^3.2.4"
+    }
+}