@agentier/anthropic 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Anthropic provider for the agenti framework.
+ *
+ * @packageDocumentation
+ */
+export { anthropic } from './provider';
+export type { AnthropicProviderConfig } from './types';

package/dist/index.js

@@ -0,0 +1,250 @@
+// src/mapper.ts
+function toAnthropicMessages(messages) {
+  let system;
+  const result = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      system = msg.content ?? undefined;
+      continue;
+    }
+    if (msg.role === "user") {
+      result.push({ role: "user", content: msg.content ?? "" });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const content = [];
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
+      }
+      if (msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          content.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.arguments
+          });
+        }
+      }
+      result.push({
+        role: "assistant",
+        content: content.length === 1 && content[0].type === "text" ? content[0].text : content
+      });
+      continue;
+    }
+    if (msg.role === "tool") {
+      const lastMsg = result[result.length - 1];
+      const toolResultBlock = {
+        type: "tool_result",
+        tool_use_id: msg.toolCallId ?? "",
+        content: msg.content ?? ""
+      };
+      if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
+        lastMsg.content.push(toolResultBlock);
+      } else {
+        result.push({ role: "user", content: [toolResultBlock] });
+      }
+    }
+  }
+  return { system, messages: result };
+}
+function toAnthropicTools(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+}
+function fromAnthropicResponse(content) {
+  let text = "";
+  const toolCalls = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      text += block.text;
+    } else if (block.type === "tool_use") {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: block.input
+      });
+    }
+  }
+  return {
+    text: text || null,
+    toolCalls
+  };
+}
+
+// src/provider.ts
+function anthropic(config) {
+  const baseUrl = (config.baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "");
+  const apiVersion = config.apiVersion ?? "2023-06-01";
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  function buildHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": apiVersion,
+      ...config.defaultHeaders
+    };
+  }
+  function buildBody(params, stream = false) {
+    const { system, messages } = toAnthropicMessages(params.messages);
+    const body = {
+      model: params.model,
+      messages,
+      max_tokens: params.maxOutputTokens ?? 4096,
+      stream
+    };
+    if (system)
+      body.system = system;
+    if (params.tools && params.tools.length > 0) {
+      body.tools = toAnthropicTools(params.tools);
+    }
+    if (params.temperature !== undefined)
+      body.temperature = params.temperature;
+    if (params.topP !== undefined)
+      body.top_p = params.topP;
+    return body;
+  }
+  const provider = {
+    name: "anthropic",
+    async chat(params) {
+      const response = await fetchFn(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(params, false)),
+        signal: params.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Anthropic API error (${response.status}): ${errorBody}`);
+      }
+      const data = await response.json();
+      const { text, toolCalls } = fromAnthropicResponse(data.content);
+      return {
+        content: text,
+        toolCalls,
+        usage: {
+          inputTokens: data.usage?.input_tokens ?? 0,
+          outputTokens: data.usage?.output_tokens ?? 0
+        },
+        raw: data
+      };
+    },
+    async* stream(params) {
+      const response = await fetchFn(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify(buildBody(params, true)),
+        signal: params.signal
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Anthropic API error (${response.status}): ${errorBody}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader)
+        throw new Error("No response body");
+      const decoder = new TextDecoder;
+      let buffer = "";
+      let fullContent = "";
+      const toolCalls = [];
+      let currentToolUse = null;
+      let inputTokens = 0;
+      let outputTokens = 0;
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data: "))
+              continue;
+            const data = trimmed.slice(6);
+            try {
+              const event = JSON.parse(data);
+              switch (event.type) {
+                case "content_block_start": {
+                  const block = event.content_block;
+                  if (block.type === "tool_use") {
+                    currentToolUse = {
+                      id: block.id,
+                      name: block.name,
+                      inputJson: ""
+                    };
+                    yield {
+                      type: "tool_call_start",
+                      id: block.id,
+                      name: block.name
+                    };
+                  }
+                  break;
+                }
+                case "content_block_delta": {
+                  const delta = event.delta;
+                  if (delta.type === "text_delta") {
+                    fullContent += delta.text;
+                    yield { type: "token", text: delta.text };
+                  } else if (delta.type === "input_json_delta" && currentToolUse) {
+                    currentToolUse.inputJson += delta.partial_json;
+                    yield {
+                      type: "tool_call_delta",
+                      id: currentToolUse.id,
+                      argumentsDelta: delta.partial_json
+                    };
+                  }
+                  break;
+                }
+                case "content_block_stop": {
+                  if (currentToolUse) {
+                    const call = {
+                      id: currentToolUse.id,
+                      name: currentToolUse.name,
+                      arguments: currentToolUse.inputJson ? JSON.parse(currentToolUse.inputJson) : {}
+                    };
+                    toolCalls.push(call);
+                    yield { type: "tool_call_end", id: currentToolUse.id, call };
+                    currentToolUse = null;
+                  }
+                  break;
+                }
+                case "message_delta": {
+                  if (event.usage) {
+                    outputTokens = event.usage.output_tokens ?? outputTokens;
+                  }
+                  break;
+                }
+                case "message_start": {
+                  if (event.message?.usage) {
+                    inputTokens = event.message.usage.input_tokens ?? 0;
+                  }
+                  break;
+                }
+              }
+            } catch {}
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      yield {
+        type: "done",
+        response: {
+          content: fullContent || null,
+          toolCalls,
+          usage: { inputTokens, outputTokens }
+        }
+      };
+    }
+  };
+  return provider;
+}
+export {
+  anthropic
+};

package/dist/mapper.d.ts

@@ -0,0 +1,66 @@
+import type { Message, ToolCall, ToolJsonSchema } from '@agentier/core';
+/** Valid roles in the Anthropic Messages API (system is handled separately). */
+export type AnthropicRole = 'user' | 'assistant';
+/** A plain text content block. */
+export interface AnthropicTextBlock {
+    type: 'text';
+    text: string;
+}
+/** A tool-use content block representing an assistant's request to invoke a tool. */
+export interface AnthropicToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+/** A tool-result content block carrying the output of a previously invoked tool. */
+export interface AnthropicToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+}
+/** Union of all content block types used in Anthropic messages. */
+export type AnthropicContentBlock = AnthropicTextBlock | AnthropicToolUseBlock | AnthropicToolResultBlock;
+/** Wire format for an Anthropic message (role + mixed content blocks). */
+export interface AnthropicMessage {
+    role: AnthropicRole;
+    content: string | AnthropicContentBlock[];
+}
+/** Wire format for an Anthropic tool definition. */
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+/**
+ * Converts agenti `Message` objects into the Anthropic Messages API format.
+ *
+ * System messages are extracted into a separate `system` string (Anthropic
+ * treats system prompts as a top-level parameter, not a message). Tool result
+ * messages are folded into the preceding `user` turn when possible, matching
+ * the Anthropic expectation that tool results appear inside user messages.
+ *
+ * @param messages - Array of provider-agnostic messages.
+ * @returns An object with an optional `system` prompt and an array of Anthropic messages.
+ */
+export declare function toAnthropicMessages(messages: Message[]): {
+    system?: string;
+    messages: AnthropicMessage[];
+};
+/**
+ * Converts agenti tool schemas into the Anthropic tool definition format.
+ *
+ * @param tools - Array of provider-agnostic tool JSON schemas.
+ * @returns Array of Anthropic tool definitions with `input_schema`.
+ */
+export declare function toAnthropicTools(tools: ToolJsonSchema[]): AnthropicTool[];
+/**
+ * Extracts text and tool calls from Anthropic response content blocks.
+ *
+ * @param content - Array of content blocks from the Anthropic API response.
+ * @returns Parsed text (or `null` if empty) and an array of agenti `ToolCall` objects.
+ */
+export declare function fromAnthropicResponse(content: AnthropicContentBlock[]): {
+    text: string | null;
+    toolCalls: ToolCall[];
+};

package/dist/provider.d.ts

@@ -0,0 +1,24 @@
+import type { ModelProvider } from '@agentier/core';
+import type { AnthropicProviderConfig } from './types';
+/**
+ * Creates an Anthropic {@link ModelProvider}.
+ *
+ * Supports both blocking `chat` and streaming `stream` completions via the
+ * Anthropic Messages API (`/v1/messages`). Handles the Anthropic-specific
+ * SSE event protocol (`content_block_start`, `content_block_delta`, etc.).
+ *
+ * @param config - Provider configuration including API key and optional overrides.
+ * @returns A `ModelProvider` wired to the Anthropic Messages API.
+ *
+ * @example
+ * ```ts
+ * import { anthropic } from '@agentier/provider-anthropic'
+ *
+ * const provider = anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! })
+ * const response = await provider.chat({
+ *   model: 'claude-sonnet-4-20250514',
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ * })
+ * ```
+ */
+export declare function anthropic(config: AnthropicProviderConfig): ModelProvider;

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Configuration for the Anthropic provider.
+ *
+ * @example
+ * ```ts
+ * const config: AnthropicProviderConfig = {
+ *   apiKey: process.env.ANTHROPIC_API_KEY!,
+ *   apiVersion: '2023-06-01',
+ * }
+ * ```
+ */
+export interface AnthropicProviderConfig {
+    /** Anthropic API key sent via the `x-api-key` header. */
+    apiKey: string;
+    /** Base URL for API requests. Defaults to `https://api.anthropic.com`. */
+    baseUrl?: string;
+    /** Anthropic API version sent via the `anthropic-version` header. Defaults to `'2023-06-01'`. */
+    apiVersion?: string;
+    /** Additional headers merged into every request. */
+    defaultHeaders?: Record<string, string>;
+    /** Custom `fetch` implementation, useful for proxies or test doubles. */
+    fetch?: typeof globalThis.fetch;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@agentier/anthropic",
+    "version": "0.1.0",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir ./dist --target node",
+        "test": "bun test",
+        "typecheck": "tsc --noEmit"
+    },
+    "peerDependencies": {
+        "@agentier/core": "^0.1.0"
+    },
+    "devDependencies": {
+        "@agentier/core": "workspace:*",
+        "typescript": "^5.5.0",
+        "@types/bun": "latest"
+    }
+}