@strand-js/anthropic 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,70 @@
+# @strand-js/anthropic
+
+Anthropic provider adapter for [Strand](https://github.com/strand-js/strand) — AI state management for React.
+
+## Install
+
+```bash
+npm install @strand-js/anthropic
+```
+
+## Usage
+
+### Express / Fastify / Hono
+
+```ts
+import { createStrandHandler } from '@strand-js/anthropic'
+
+app.post('/api/strand', createStrandHandler({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-6',
+  system: 'You are a helpful assistant.',
+}))
+```
+
+### Next.js App Router
+
+```ts
+// app/api/strand/route.ts
+import { createStrandRoute } from '@strand-js/anthropic'
+
+export const POST = createStrandRoute({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-6',
+})
+```
+
+### With tools
+
+```ts
+import { z } from 'zod'
+import { tool } from '@strand-js/core'
+
+const weatherTool = tool({
+  name: 'get_weather',
+  description: 'Get weather for a city',
+  parameters: z.object({ location: z.string() }),
+})
+
+createStrandHandler({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-6',
+  tools: [weatherTool],
+  onToolCall: async (name, args) => fetchWeather(args.location),
+})
+```
+
+### With auth
+
+```ts
+createStrandHandler({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-6',
+  authorize: async (request) => {
+    const user = await verifyToken(request.headers.get('authorization'))
+    if (!user) throw new Error('Unauthorized')
+  },
+})
+```
+
+[Full documentation →](https://github.com/strand-js/strand)

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { ToolDefinition, Session } from '@strand-js/core';
+
+interface StrandHandlerConfig {
+    apiKey: string;
+    model: string;
+    system?: string | ((request: Request) => string | Promise<string>);
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>, ctx: {
+        request: Request;
+    }) => Promise<unknown>;
+    authorize?: (request: Request) => Promise<unknown> | unknown;
+    maxMessages?: number;
+    maxMessageLength?: number;
+    maxSteps?: number;
+    onRequest?: (req: Request) => void;
+    onFinish?: (session: Session) => void;
+}
+type AnyReq = Record<string, unknown>;
+type AnyRes = {
+    setHeader(name: string, value: string): void;
+    status(code: number): AnyRes;
+    json(body: unknown): void;
+    write(chunk: string): void;
+    end(): void;
+};
+declare function createStrandHandler(config: StrandHandlerConfig): (req: AnyReq, res: AnyRes) => Promise<void>;
+
+declare function createStrandRoute(config: StrandHandlerConfig): (req: Request) => Promise<Response>;
+
+export { type StrandHandlerConfig, createStrandHandler, createStrandRoute };

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { ToolDefinition, Session } from '@strand-js/core';
+
+interface StrandHandlerConfig {
+    apiKey: string;
+    model: string;
+    system?: string | ((request: Request) => string | Promise<string>);
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>, ctx: {
+        request: Request;
+    }) => Promise<unknown>;
+    authorize?: (request: Request) => Promise<unknown> | unknown;
+    maxMessages?: number;
+    maxMessageLength?: number;
+    maxSteps?: number;
+    onRequest?: (req: Request) => void;
+    onFinish?: (session: Session) => void;
+}
+type AnyReq = Record<string, unknown>;
+type AnyRes = {
+    setHeader(name: string, value: string): void;
+    status(code: number): AnyRes;
+    json(body: unknown): void;
+    write(chunk: string): void;
+    end(): void;
+};
+declare function createStrandHandler(config: StrandHandlerConfig): (req: AnyReq, res: AnyRes) => Promise<void>;
+
+declare function createStrandRoute(config: StrandHandlerConfig): (req: Request) => Promise<Response>;
+
+export { type StrandHandlerConfig, createStrandHandler, createStrandRoute };

package/dist/index.js

@@ -0,0 +1,322 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createStrandHandler: () => createStrandHandler,
+  createStrandRoute: () => createStrandRoute
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/handler.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var import_core2 = require("@strand-js/core");
+
+// src/format.ts
+var import_core = require("@strand-js/core");
+function toolToAnthropicTool(tool) {
+  const schema = (0, import_core.toolToJsonSchema)(tool);
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: schema
+  };
+}
+
+// src/handler.ts
+function emit(res, eventType, data) {
+  res.write(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandHandler(config) {
+  const client = new import_sdk.default({ apiKey: config.apiKey });
+  const anthropicTools = (config.tools ?? []).map(toolToAnthropicTool);
+  const maxSteps = config.maxSteps ?? 10;
+  return async (req, res) => {
+    const body = req.body;
+    const validation = (0, import_core2.validateMessages)(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      res.status(validation.status).json({ error: validation.error });
+      return;
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(req);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        res.status(401).json({ error: message });
+        return;
+      }
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    emit(res, "strand:start", { sessionId: (0, import_core2.generateId)(), requestId: (0, import_core2.generateId)() });
+    try {
+      const messages = body.messages;
+      const system = typeof config.system === "function" ? await config.system(req) : config.system ?? "";
+      const conversation = messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      let totalInput = 0;
+      let totalOutput = 0;
+      for (let step = 0; step < maxSteps; step++) {
+        const stream = await client.messages.create({
+          model: config.model,
+          max_tokens: 8192,
+          ...system ? { system } : {},
+          messages: conversation,
+          ...anthropicTools.length > 0 ? { tools: anthropicTools } : {},
+          stream: true
+        });
+        let stopReason = null;
+        let currentTool = null;
+        const completedTools = [];
+        const assistantContent = [];
+        for await (const event of stream) {
+          if (event.type === "message_start" && event.message.usage) {
+            totalInput += event.message.usage.input_tokens;
+          }
+          if (event.type === "content_block_start") {
+            const block = event.content_block;
+            if (block.type === "text") assistantContent.push({ type: "text", text: "", citations: null });
+            if (block.type === "tool_use") {
+              currentTool = { id: block.id, name: block.name, inputJson: "" };
+              emit(res, "strand:tool-start", { toolCallId: block.id, toolName: block.name });
+            }
+          }
+          if (event.type === "content_block_delta") {
+            const delta = event.delta;
+            if (delta.type === "text_delta") {
+              const last = assistantContent.at(-1);
+              if (last?.type === "text") last.text += delta.text;
+              emit(res, "strand:text-delta", { delta: delta.text });
+            }
+            if (delta.type === "input_json_delta" && currentTool) {
+              currentTool.inputJson += delta.partial_json;
+              emit(res, "strand:tool-input-delta", { toolCallId: currentTool.id, delta: delta.partial_json });
+            }
+          }
+          if (event.type === "content_block_stop" && currentTool) {
+            const input = JSON.parse(currentTool.inputJson || "{}");
+            completedTools.push({ id: currentTool.id, name: currentTool.name, input });
+            assistantContent.push({ type: "tool_use", id: currentTool.id, name: currentTool.name, input });
+            currentTool = null;
+          }
+          if (event.type === "message_delta") {
+            stopReason = event.delta.stop_reason ?? null;
+            if (event.usage) totalOutput += event.usage.output_tokens;
+          }
+        }
+        if (stopReason === "end_turn" || stopReason === "max_tokens") {
+          emit(res, "strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+          res.end();
+          return;
+        }
+        if (stopReason === "tool_use" && completedTools.length > 0) {
+          conversation.push({ role: "assistant", content: assistantContent });
+          const toolResults = await Promise.all(
+            completedTools.map(async (block) => {
+              emit(res, "strand:tool-input-done", { toolCallId: block.id, input: block.input });
+              try {
+                const result = await config.onToolCall?.(block.name, block.input, { request: req });
+                emit(res, "strand:tool-result", { toolCallId: block.id, result });
+                return { type: "tool_result", tool_use_id: block.id, content: JSON.stringify(result ?? null) };
+              } catch (err) {
+                const message = err instanceof Error ? err.message : "Tool execution failed";
+                emit(res, "strand:tool-error", { toolCallId: block.id, error: message });
+                return { type: "tool_result", tool_use_id: block.id, content: message, is_error: true };
+              }
+            })
+          );
+          conversation.push({ role: "user", content: toolResults });
+          continue;
+        }
+        break;
+      }
+      emit(res, "strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+      res.end();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      emit(res, "strand:error", { code: "server_error", message });
+      res.end();
+    }
+  };
+}
+
+// src/route.ts
+var import_sdk2 = __toESM(require("@anthropic-ai/sdk"));
+var import_core3 = require("@strand-js/core");
+function sseChunk(eventType, data) {
+  return new TextEncoder().encode(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandRoute(config) {
+  const client = new import_sdk2.default({ apiKey: config.apiKey });
+  const anthropicTools = (config.tools ?? []).map(toolToAnthropicTool);
+  const maxSteps = config.maxSteps ?? 10;
+  return async (req) => {
+    const body = await req.json();
+    const validation = (0, import_core3.validateMessages)(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      return new Response(JSON.stringify({ error: validation.error }), {
+        status: validation.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(req);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    const messages = body.messages;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const emit2 = (eventType, data) => controller.enqueue(sseChunk(eventType, data));
+        emit2("strand:start", { sessionId: (0, import_core3.generateId)(), requestId: (0, import_core3.generateId)() });
+        try {
+          const system = typeof config.system === "function" ? await config.system(req) : config.system ?? "";
+          const conversation = messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          }));
+          let totalInput = 0;
+          let totalOutput = 0;
+          for (let step = 0; step < maxSteps; step++) {
+            const anthropicStream = await client.messages.create({
+              model: config.model,
+              max_tokens: 8192,
+              ...system ? { system } : {},
+              messages: conversation,
+              ...anthropicTools.length > 0 ? { tools: anthropicTools } : {},
+              stream: true
+            });
+            let stopReason = null;
+            let currentTool = null;
+            const completedTools = [];
+            const assistantContent = [];
+            for await (const event of anthropicStream) {
+              if (event.type === "message_start" && event.message.usage) totalInput += event.message.usage.input_tokens;
+              if (event.type === "content_block_start") {
+                const block = event.content_block;
+                if (block.type === "text") assistantContent.push({ type: "text", text: "", citations: null });
+                if (block.type === "tool_use") {
+                  currentTool = { id: block.id, name: block.name, inputJson: "" };
+                  emit2("strand:tool-start", { toolCallId: block.id, toolName: block.name });
+                }
+              }
+              if (event.type === "content_block_delta") {
+                const delta = event.delta;
+                if (delta.type === "text_delta") {
+                  const last = assistantContent.at(-1);
+                  if (last?.type === "text") last.text += delta.text;
+                  emit2("strand:text-delta", { delta: delta.text });
+                }
+                if (delta.type === "input_json_delta" && currentTool) {
+                  currentTool.inputJson += delta.partial_json;
+                  emit2("strand:tool-input-delta", { toolCallId: currentTool.id, delta: delta.partial_json });
+                }
+              }
+              if (event.type === "content_block_stop" && currentTool) {
+                const input = JSON.parse(currentTool.inputJson || "{}");
+                completedTools.push({ id: currentTool.id, name: currentTool.name, input });
+                assistantContent.push({ type: "tool_use", id: currentTool.id, name: currentTool.name, input });
+                currentTool = null;
+              }
+              if (event.type === "message_delta") {
+                stopReason = event.delta.stop_reason ?? null;
+                if (event.usage) totalOutput += event.usage.output_tokens;
+              }
+            }
+            if (stopReason === "end_turn" || stopReason === "max_tokens") {
+              emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+              break;
+            }
+            if (stopReason === "tool_use" && completedTools.length > 0) {
+              conversation.push({ role: "assistant", content: assistantContent });
+              const results = await Promise.all(
+                completedTools.map(async (block) => {
+                  emit2("strand:tool-input-done", { toolCallId: block.id, input: block.input });
+                  try {
+                    const result = await config.onToolCall?.(block.name, block.input, { request: req });
+                    emit2("strand:tool-result", { toolCallId: block.id, result });
+                    return { type: "tool_result", tool_use_id: block.id, content: JSON.stringify(result ?? null) };
+                  } catch (err) {
+                    const message = err instanceof Error ? err.message : "Tool execution failed";
+                    emit2("strand:tool-error", { toolCallId: block.id, error: message });
+                    return { type: "tool_result", tool_use_id: block.id, content: message, is_error: true };
+                  }
+                })
+              );
+              conversation.push({ role: "user", content: results });
+              continue;
+            }
+            emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+            break;
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          emit2("strand:error", { code: "server_error", message });
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStrandHandler,
+  createStrandRoute
+});

package/dist/index.mjs

@@ -0,0 +1,284 @@
+// src/handler.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { generateId, validateMessages } from "@strand-js/core";
+
+// src/format.ts
+import { toolToJsonSchema } from "@strand-js/core";
+function toolToAnthropicTool(tool) {
+  const schema = toolToJsonSchema(tool);
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: schema
+  };
+}
+
+// src/handler.ts
+function emit(res, eventType, data) {
+  res.write(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandHandler(config) {
+  const client = new Anthropic({ apiKey: config.apiKey });
+  const anthropicTools = (config.tools ?? []).map(toolToAnthropicTool);
+  const maxSteps = config.maxSteps ?? 10;
+  return async (req, res) => {
+    const body = req.body;
+    const validation = validateMessages(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      res.status(validation.status).json({ error: validation.error });
+      return;
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(req);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        res.status(401).json({ error: message });
+        return;
+      }
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    emit(res, "strand:start", { sessionId: generateId(), requestId: generateId() });
+    try {
+      const messages = body.messages;
+      const system = typeof config.system === "function" ? await config.system(req) : config.system ?? "";
+      const conversation = messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      let totalInput = 0;
+      let totalOutput = 0;
+      for (let step = 0; step < maxSteps; step++) {
+        const stream = await client.messages.create({
+          model: config.model,
+          max_tokens: 8192,
+          ...system ? { system } : {},
+          messages: conversation,
+          ...anthropicTools.length > 0 ? { tools: anthropicTools } : {},
+          stream: true
+        });
+        let stopReason = null;
+        let currentTool = null;
+        const completedTools = [];
+        const assistantContent = [];
+        for await (const event of stream) {
+          if (event.type === "message_start" && event.message.usage) {
+            totalInput += event.message.usage.input_tokens;
+          }
+          if (event.type === "content_block_start") {
+            const block = event.content_block;
+            if (block.type === "text") assistantContent.push({ type: "text", text: "", citations: null });
+            if (block.type === "tool_use") {
+              currentTool = { id: block.id, name: block.name, inputJson: "" };
+              emit(res, "strand:tool-start", { toolCallId: block.id, toolName: block.name });
+            }
+          }
+          if (event.type === "content_block_delta") {
+            const delta = event.delta;
+            if (delta.type === "text_delta") {
+              const last = assistantContent.at(-1);
+              if (last?.type === "text") last.text += delta.text;
+              emit(res, "strand:text-delta", { delta: delta.text });
+            }
+            if (delta.type === "input_json_delta" && currentTool) {
+              currentTool.inputJson += delta.partial_json;
+              emit(res, "strand:tool-input-delta", { toolCallId: currentTool.id, delta: delta.partial_json });
+            }
+          }
+          if (event.type === "content_block_stop" && currentTool) {
+            const input = JSON.parse(currentTool.inputJson || "{}");
+            completedTools.push({ id: currentTool.id, name: currentTool.name, input });
+            assistantContent.push({ type: "tool_use", id: currentTool.id, name: currentTool.name, input });
+            currentTool = null;
+          }
+          if (event.type === "message_delta") {
+            stopReason = event.delta.stop_reason ?? null;
+            if (event.usage) totalOutput += event.usage.output_tokens;
+          }
+        }
+        if (stopReason === "end_turn" || stopReason === "max_tokens") {
+          emit(res, "strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+          res.end();
+          return;
+        }
+        if (stopReason === "tool_use" && completedTools.length > 0) {
+          conversation.push({ role: "assistant", content: assistantContent });
+          const toolResults = await Promise.all(
+            completedTools.map(async (block) => {
+              emit(res, "strand:tool-input-done", { toolCallId: block.id, input: block.input });
+              try {
+                const result = await config.onToolCall?.(block.name, block.input, { request: req });
+                emit(res, "strand:tool-result", { toolCallId: block.id, result });
+                return { type: "tool_result", tool_use_id: block.id, content: JSON.stringify(result ?? null) };
+              } catch (err) {
+                const message = err instanceof Error ? err.message : "Tool execution failed";
+                emit(res, "strand:tool-error", { toolCallId: block.id, error: message });
+                return { type: "tool_result", tool_use_id: block.id, content: message, is_error: true };
+              }
+            })
+          );
+          conversation.push({ role: "user", content: toolResults });
+          continue;
+        }
+        break;
+      }
+      emit(res, "strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+      res.end();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      emit(res, "strand:error", { code: "server_error", message });
+      res.end();
+    }
+  };
+}
+
+// src/route.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+import { generateId as generateId2, validateMessages as validateMessages2 } from "@strand-js/core";
+function sseChunk(eventType, data) {
+  return new TextEncoder().encode(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandRoute(config) {
+  const client = new Anthropic2({ apiKey: config.apiKey });
+  const anthropicTools = (config.tools ?? []).map(toolToAnthropicTool);
+  const maxSteps = config.maxSteps ?? 10;
+  return async (req) => {
+    const body = await req.json();
+    const validation = validateMessages2(body?.messages, {
+      maxMessages: config.maxMessages,
+      maxMessageLength: config.maxMessageLength
+    });
+    if (!validation.ok) {
+      return new Response(JSON.stringify({ error: validation.error }), {
+        status: validation.status,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (config.authorize) {
+      try {
+        await config.authorize(req);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unauthorized";
+        return new Response(JSON.stringify({ error: message }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    const messages = body.messages;
+    const stream = new ReadableStream({
+      async start(controller) {
+        const emit2 = (eventType, data) => controller.enqueue(sseChunk(eventType, data));
+        emit2("strand:start", { sessionId: generateId2(), requestId: generateId2() });
+        try {
+          const system = typeof config.system === "function" ? await config.system(req) : config.system ?? "";
+          const conversation = messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          }));
+          let totalInput = 0;
+          let totalOutput = 0;
+          for (let step = 0; step < maxSteps; step++) {
+            const anthropicStream = await client.messages.create({
+              model: config.model,
+              max_tokens: 8192,
+              ...system ? { system } : {},
+              messages: conversation,
+              ...anthropicTools.length > 0 ? { tools: anthropicTools } : {},
+              stream: true
+            });
+            let stopReason = null;
+            let currentTool = null;
+            const completedTools = [];
+            const assistantContent = [];
+            for await (const event of anthropicStream) {
+              if (event.type === "message_start" && event.message.usage) totalInput += event.message.usage.input_tokens;
+              if (event.type === "content_block_start") {
+                const block = event.content_block;
+                if (block.type === "text") assistantContent.push({ type: "text", text: "", citations: null });
+                if (block.type === "tool_use") {
+                  currentTool = { id: block.id, name: block.name, inputJson: "" };
+                  emit2("strand:tool-start", { toolCallId: block.id, toolName: block.name });
+                }
+              }
+              if (event.type === "content_block_delta") {
+                const delta = event.delta;
+                if (delta.type === "text_delta") {
+                  const last = assistantContent.at(-1);
+                  if (last?.type === "text") last.text += delta.text;
+                  emit2("strand:text-delta", { delta: delta.text });
+                }
+                if (delta.type === "input_json_delta" && currentTool) {
+                  currentTool.inputJson += delta.partial_json;
+                  emit2("strand:tool-input-delta", { toolCallId: currentTool.id, delta: delta.partial_json });
+                }
+              }
+              if (event.type === "content_block_stop" && currentTool) {
+                const input = JSON.parse(currentTool.inputJson || "{}");
+                completedTools.push({ id: currentTool.id, name: currentTool.name, input });
+                assistantContent.push({ type: "tool_use", id: currentTool.id, name: currentTool.name, input });
+                currentTool = null;
+              }
+              if (event.type === "message_delta") {
+                stopReason = event.delta.stop_reason ?? null;
+                if (event.usage) totalOutput += event.usage.output_tokens;
+              }
+            }
+            if (stopReason === "end_turn" || stopReason === "max_tokens") {
+              emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+              break;
+            }
+            if (stopReason === "tool_use" && completedTools.length > 0) {
+              conversation.push({ role: "assistant", content: assistantContent });
+              const results = await Promise.all(
+                completedTools.map(async (block) => {
+                  emit2("strand:tool-input-done", { toolCallId: block.id, input: block.input });
+                  try {
+                    const result = await config.onToolCall?.(block.name, block.input, { request: req });
+                    emit2("strand:tool-result", { toolCallId: block.id, result });
+                    return { type: "tool_result", tool_use_id: block.id, content: JSON.stringify(result ?? null) };
+                  } catch (err) {
+                    const message = err instanceof Error ? err.message : "Tool execution failed";
+                    emit2("strand:tool-error", { toolCallId: block.id, error: message });
+                    return { type: "tool_result", tool_use_id: block.id, content: message, is_error: true };
+                  }
+                })
+              );
+              conversation.push({ role: "user", content: results });
+              continue;
+            }
+            emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+            break;
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Internal server error";
+          emit2("strand:error", { code: "server_error", message });
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    });
+  };
+}
+export {
+  createStrandHandler,
+  createStrandRoute
+};

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@strand-js/anthropic",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "license": "MIT",
   "description": "Anthropic provider adapter for Strand",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -15,9 +16,16 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src"
+  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.40.0",
-    "@strand-js/core": "0.1.0"
+    "@strand-js/core": "workspace:*"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
@@ -28,12 +36,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
-    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "lint": "eslint src"
   }
-}
+}