@arcote.tech/arc-ai-claude 0.5.0 → 0.5.5

package/package.json

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

package/src/index.ts

@@ -2,8 +2,10 @@ import type {
   LLMProvider,
   CompletionRequest,
   CompletionResult,
+  Conversation,
+  ConversationTurn,
+  AssistantContentBlock,
   StreamChunk,
-  ToolCall,
   TokenUsage,
   FinishReason,
 } from "@arcote.tech/arc-ai";
@@ -44,46 +46,88 @@ export function claude(config: ClaudeConfig): LLMProvider {
     }
   }
 
-  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,
-            },
-          ],
-        };
+  /**
+   * Translate a single ConversationTurn into one Claude Messages API message.
+   * Adapter is a pure translator — caller already decided what to send via the
+   * Conversation discriminated union. Block ordering is preserved 1:1 inside
+   * assistant messages.
+   */
+  function turnToMessage(turn: ConversationTurn): unknown {
+    if (turn.role === "user") {
+      return { role: "user", content: turn.content };
+    }
+    if (turn.role === "tool_result") {
+      return {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: turn.toolCallId,
+            content: turn.content,
+            ...(turn.isError ? { is_error: true } : {}),
+          },
+        ],
+      };
+    }
+    // assistant — emit content blocks in order
+    const content: unknown[] = [];
+    for (const block of turn.blocks) {
+      if (block.type === "text") {
+        if (!block.text) continue;
+        content.push({ type: "text", text: block.text });
+      } else {
+        content.push({
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.arguments,
+        });
       }
-      return { role: m.role as "user" | "assistant", content: m.content };
-    });
+    }
+    return { role: "assistant", content };
+  }
 
-    return { system, messages: claudeMessages };
+  function buildMessages(conversation: Conversation): unknown[] {
+    if (conversation.mode !== "full") {
+      throw new Error(
+        "Claude provider does not support continuation mode — set " +
+          "`supportsContinuation: false` in the listener and pass " +
+          "`Conversation.mode = 'full'` with the full conversation history.",
+      );
+    }
+    return conversation.turns.map(turnToMessage);
   }
 
-  async function complete(request: CompletionRequest): Promise<CompletionResult> {
-    const { system, messages } = buildMessages(request.messages);
+  function buildBody(
+    request: CompletionRequest,
+    stream: boolean,
+  ): Record<string, unknown> {
+    const messages = buildMessages(request.conversation);
 
     const body: Record<string, unknown> = {
       model: request.model,
       messages,
       max_tokens: request.maxTokens ?? 4096,
       temperature: request.temperature,
+      ...(stream ? { stream: true } : {}),
     };
 
-    if (system) body.system = system;
+    // `instructions` is always sent. Empty string means no system prompt.
+    if (request.instructions) body.system = request.instructions;
 
     const tools = translateTools(request.tools);
     if (tools) body.tools = tools;
 
+    return body;
+  }
+
+  // ─── complete ─────────────────────────────────────────────────
+
+  async function complete(
+    request: CompletionRequest,
+  ): Promise<CompletionResult> {
+    const body = buildBody(request, false);
+
     const response = await fetch("https://api.anthropic.com/v1/messages", {
       method: "POST",
       headers: {
@@ -101,24 +145,22 @@ export function claude(config: ClaudeConfig): LLMProvider {
 
     const data = await response.json();
 
-    let content = "";
-    const toolCalls: ToolCall[] = [];
-
-    for (const block of data.content) {
-      if (block.type === "text") {
-        content += block.text;
+    const blocks: AssistantContentBlock[] = [];
+    for (const block of data.content ?? []) {
+      if (block.type === "text" && block.text) {
+        blocks.push({ type: "text", text: block.text });
       } else if (block.type === "tool_use") {
-        toolCalls.push({
+        blocks.push({
+          type: "tool_call",
           id: block.id,
           name: block.name,
-          arguments: block.input,
+          arguments: block.input ?? {},
         });
       }
     }
 
     return {
-      content,
-      toolCalls,
+      blocks,
       usage: {
         inputTokens: data.usage?.input_tokens ?? 0,
         outputTokens: data.usage?.output_tokens ?? 0,
@@ -131,24 +173,13 @@ export function claude(config: ClaudeConfig): LLMProvider {
     };
   }
 
+  // ─── streamComplete ───────────────────────────────────────────
+
   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 body = buildBody(request, true);
 
     const response = await fetch("https://api.anthropic.com/v1/messages", {
       method: "POST",
@@ -165,23 +196,24 @@ export function claude(config: ClaudeConfig): LLMProvider {
       throw new Error(`Claude API error ${response.status}: ${error}`);
     }
 
-    let content = "";
+    // Reconstruct ordered blocks from streamed events. Claude emits
+    // content_block_start/delta/stop events with explicit indices, so we
+    // anchor our blocks by index for deterministic ordering.
+    const orderedBlocks: AssistantContentBlock[] = [];
     let finishReason: FinishReason = "stop";
-    let usage: TokenUsage = {
+    const usage: TokenUsage = {
       inputTokens: 0,
       outputTokens: 0,
       totalTokens: 0,
       cachedTokens: 0,
       reasoningTokens: 0,
     };
-    const toolCalls: ToolCall[] = [];
-    let currentToolId = "";
-    let currentToolName = "";
-    let currentToolArgs = "";
+    const toolArgBuffers = new Map<number, string>();
 
     const reader = response.body!.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
+    let currentEvent = "";
 
     while (true) {
       const { done, value } = await reader.read();
@@ -191,14 +223,11 @@ export function claude(config: ClaudeConfig): LLMProvider {
       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();
 
@@ -216,11 +245,18 @@ export function claude(config: ClaudeConfig): LLMProvider {
             }
 
             case "content_block_start": {
+              const idx = parsed.index;
               const block = parsed.content_block;
-              if (block?.type === "tool_use") {
-                currentToolId = block.id;
-                currentToolName = block.name;
-                currentToolArgs = "";
+              if (block?.type === "text") {
+                orderedBlocks[idx] = { type: "text", text: "" };
+              } else if (block?.type === "tool_use") {
+                orderedBlocks[idx] = {
+                  type: "tool_call",
+                  id: block.id,
+                  name: block.name,
+                  arguments: {},
+                };
+                toolArgBuffers.set(idx, "");
                 onChunk({
                   type: "tool_call_start",
                   toolCall: {
@@ -234,12 +270,15 @@ export function claude(config: ClaudeConfig): LLMProvider {
             }
 
             case "content_block_delta": {
+              const idx = parsed.index;
               const delta = parsed.delta;
-              if (delta?.type === "text_delta") {
-                content += delta.text;
+              const block = orderedBlocks[idx];
+              if (delta?.type === "text_delta" && block?.type === "text") {
+                block.text += delta.text;
                 onChunk({ type: "content_delta", content: delta.text });
               } else if (delta?.type === "input_json_delta") {
-                currentToolArgs += delta.partial_json;
+                const existing = toolArgBuffers.get(idx) ?? "";
+                toolArgBuffers.set(idx, existing + delta.partial_json);
                 onChunk({
                   type: "tool_call_delta",
                   content: delta.partial_json,
@@ -249,23 +288,18 @@ export function claude(config: ClaudeConfig): LLMProvider {
             }
 
             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: {},
-                  });
+              const idx = parsed.index;
+              const buffered = toolArgBuffers.get(idx);
+              if (buffered != null) {
+                const block = orderedBlocks[idx];
+                if (block?.type === "tool_call") {
+                  try {
+                    block.arguments = JSON.parse(buffered);
+                  } catch {
+                    block.arguments = {};
+                  }
                 }
-                currentToolId = "";
-                currentToolName = "";
-                currentToolArgs = "";
+                toolArgBuffers.delete(idx);
               }
               break;
             }
@@ -287,9 +321,12 @@ export function claude(config: ClaudeConfig): LLMProvider {
       }
     }
 
+    const blocks = orderedBlocks.filter(
+      (b): b is AssistantContentBlock => b != null,
+    );
+
     return {
-      content,
-      toolCalls,
+      blocks,
       usage,
       finishReason,
     };
@@ -302,6 +339,7 @@ export function claude(config: ClaudeConfig): LLMProvider {
       "claude-sonnet-4-6",
       "claude-haiku-4-5-20251001",
     ],
+    supportsContinuation: false,
     complete,
     streamComplete,
   };