@arcote.tech/arc-ai-claude 0.4.6

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@arcote.tech/arc-ai-claude",
+  "type": "module",
+  "version": "0.4.6",
+  "private": false,
+  "description": "Claude (Anthropic) adapter for Arc AI framework",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc-ai": "^0.4.6",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,308 @@
+import type {
+  LLMProvider,
+  CompletionRequest,
+  CompletionResult,
+  StreamChunk,
+  ToolCall,
+  TokenUsage,
+  FinishReason,
+} from "@arcote.tech/arc-ai";
+
+// ─── Config ──────────────────────────────────────────────────────
+
+export interface ClaudeConfig {
+  apiKey: string;
+  apiVersion?: string;
+}
+
+// ─── Adapter ─────────────────────────────────────────────────────
+
+export function claude(config: ClaudeConfig): LLMProvider {
+  const apiVersion = config.apiVersion ?? "2023-06-01";
+
+  function translateTools(
+    tools: CompletionRequest["tools"],
+  ): unknown[] | undefined {
+    if (!tools || tools.length === 0) return undefined;
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters,
+    }));
+  }
+
+  function mapFinishReason(stopReason: string): FinishReason {
+    switch (stopReason) {
+      case "end_turn":
+        return "stop";
+      case "tool_use":
+        return "tool_call";
+      case "max_tokens":
+        return "max_tokens";
+      default:
+        return "stop";
+    }
+  }
+
+  function buildMessages(messages: CompletionRequest["messages"]) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystemMessages = messages.filter((m) => m.role !== "system");
+
+    const system = systemMessages.map((m) => m.content).join("\n\n") || undefined;
+
+    const claudeMessages = nonSystemMessages.map((m) => {
+      if (m.role === "tool") {
+        return {
+          role: "user" as const,
+          content: [
+            {
+              type: "tool_result" as const,
+              tool_use_id: m.toolCallId,
+              content: m.content,
+            },
+          ],
+        };
+      }
+      return { role: m.role as "user" | "assistant", content: m.content };
+    });
+
+    return { system, messages: claudeMessages };
+  }
+
+  async function complete(request: CompletionRequest): Promise<CompletionResult> {
+    const { system, messages } = buildMessages(request.messages);
+
+    const body: Record<string, unknown> = {
+      model: request.model,
+      messages,
+      max_tokens: request.maxTokens ?? 4096,
+      temperature: request.temperature,
+    };
+
+    if (system) body.system = system;
+
+    const tools = translateTools(request.tools);
+    if (tools) body.tools = tools;
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey,
+        "anthropic-version": apiVersion,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Claude API error ${response.status}: ${error}`);
+    }
+
+    const data = await response.json() as any;
+
+    let content = "";
+    const toolCalls: ToolCall[] = [];
+
+    for (const block of data.content) {
+      if (block.type === "text") {
+        content += block.text;
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input,
+        });
+      }
+    }
+
+    return {
+      content,
+      toolCalls,
+      usage: {
+        inputTokens: data.usage?.input_tokens ?? 0,
+        outputTokens: data.usage?.output_tokens ?? 0,
+        totalTokens:
+          (data.usage?.input_tokens ?? 0) + (data.usage?.output_tokens ?? 0),
+        cachedTokens: data.usage?.cache_read_input_tokens ?? 0,
+        reasoningTokens: 0,
+      },
+      finishReason: mapFinishReason(data.stop_reason),
+    };
+  }
+
+  async function streamComplete(
+    request: CompletionRequest,
+    onChunk: (chunk: StreamChunk) => void,
+  ): Promise<CompletionResult> {
+    const { system, messages } = buildMessages(request.messages);
+
+    const body: Record<string, unknown> = {
+      model: request.model,
+      messages,
+      max_tokens: request.maxTokens ?? 4096,
+      temperature: request.temperature,
+      stream: true,
+    };
+
+    if (system) body.system = system;
+
+    const tools = translateTools(request.tools);
+    if (tools) body.tools = tools;
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey,
+        "anthropic-version": apiVersion,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Claude API error ${response.status}: ${error}`);
+    }
+
+    let content = "";
+    let finishReason: FinishReason = "stop";
+    let usage: TokenUsage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      cachedTokens: 0,
+      reasoningTokens: 0,
+    };
+    const toolCalls: ToolCall[] = [];
+    let currentToolId = "";
+    let currentToolName = "";
+    let currentToolArgs = "";
+
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop()!;
+
+      let currentEvent = "";
+
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7).trim();
+          continue;
+        }
+
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+
+        try {
+          const parsed = JSON.parse(data);
+
+          switch (currentEvent) {
+            case "message_start": {
+              const u = parsed.message?.usage;
+              if (u) {
+                usage.inputTokens = u.input_tokens ?? 0;
+                usage.cachedTokens = u.cache_read_input_tokens ?? 0;
+              }
+              break;
+            }
+
+            case "content_block_start": {
+              const block = parsed.content_block;
+              if (block?.type === "tool_use") {
+                currentToolId = block.id;
+                currentToolName = block.name;
+                currentToolArgs = "";
+                onChunk({
+                  type: "tool_call_start",
+                  toolCall: {
+                    id: block.id,
+                    name: block.name,
+                    arguments: {},
+                  },
+                });
+              }
+              break;
+            }
+
+            case "content_block_delta": {
+              const delta = parsed.delta;
+              if (delta?.type === "text_delta") {
+                content += delta.text;
+                onChunk({ type: "content_delta", content: delta.text });
+              } else if (delta?.type === "input_json_delta") {
+                currentToolArgs += delta.partial_json;
+                onChunk({
+                  type: "tool_call_delta",
+                  content: delta.partial_json,
+                });
+              }
+              break;
+            }
+
+            case "content_block_stop": {
+              if (currentToolId) {
+                try {
+                  toolCalls.push({
+                    id: currentToolId,
+                    name: currentToolName,
+                    arguments: JSON.parse(currentToolArgs),
+                  });
+                } catch {
+                  toolCalls.push({
+                    id: currentToolId,
+                    name: currentToolName,
+                    arguments: {},
+                  });
+                }
+                currentToolId = "";
+                currentToolName = "";
+                currentToolArgs = "";
+              }
+              break;
+            }
+
+            case "message_delta": {
+              if (parsed.delta?.stop_reason) {
+                finishReason = mapFinishReason(parsed.delta.stop_reason);
+              }
+              if (parsed.usage) {
+                usage.outputTokens = parsed.usage.output_tokens ?? 0;
+                usage.totalTokens = usage.inputTokens + usage.outputTokens;
+              }
+              break;
+            }
+          }
+        } catch {
+          // Skip malformed JSON
+        }
+      }
+    }
+
+    return {
+      content,
+      toolCalls,
+      usage,
+      finishReason,
+    };
+  }
+
+  return {
+    name: "claude",
+    models: [
+      "claude-opus-4-6",
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5-20251001",
+    ],
+    complete,
+    streamComplete,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../../../tsconfig.json",
+  "include": ["src/**/*"]
+}