@strand-js/openai 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,53 @@
+# @strand-js/openai
+
+OpenAI provider adapter for [Strand](https://github.com/strand-js/strand) — AI state management for React.
+
+## Install
+
+```bash
+npm install @strand-js/openai
+```
+
+## Usage
+
+### Express / Fastify / Hono
+
+```ts
+import { createStrandHandler } from '@strand-js/openai'
+
+app.post('/api/strand', createStrandHandler({
+  apiKey: process.env.OPENAI_API_KEY,
+  model: 'gpt-4o',
+  system: 'You are a helpful assistant.',
+}))
+```
+
+### Next.js App Router
+
+```ts
+// app/api/strand/route.ts
+import { createStrandRoute } from '@strand-js/openai'
+
+export const POST = createStrandRoute({
+  apiKey: process.env.OPENAI_API_KEY,
+  model: 'gpt-4o',
+})
+```
+
+### Switching from Anthropic
+
+Only the server changes — the React hooks are identical:
+
+```diff
+- import { createStrandHandler } from '@strand-js/anthropic'
++ import { createStrandHandler } from '@strand-js/openai'
+
+  createStrandHandler({
+-   apiKey: process.env.ANTHROPIC_API_KEY,
+-   model: 'claude-sonnet-4-6',
++   apiKey: process.env.OPENAI_API_KEY,
++   model: 'gpt-4o',
+  })
+```
+
+[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,321 @@
+"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_openai = __toESM(require("openai"));
+var import_core2 = require("@strand-js/core");
+
+// src/format.ts
+var import_core = require("@strand-js/core");
+function toolToOpenAITool(tool) {
+  const schema = (0, import_core.toolToJsonSchema)(tool);
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: schema
+    }
+  };
+}
+
+// src/handler.ts
+function emit(res, eventType, data) {
+  res.write(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandHandler(config) {
+  const client = new import_openai.default({ apiKey: config.apiKey });
+  const openAITools = (config.tools ?? []).map(toolToOpenAITool);
+  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 = [
+        ...system ? [{ role: "system", content: system }] : [],
+        ...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.chat.completions.create({
+          model: config.model,
+          messages: conversation,
+          ...openAITools.length > 0 ? { tools: openAITools } : {},
+          stream: true,
+          stream_options: { include_usage: true }
+        });
+        let finishReason = null;
+        const toolCallAccumulator = /* @__PURE__ */ new Map();
+        for await (const chunk of stream) {
+          const choice = chunk.choices[0];
+          if (!choice) {
+            if (chunk.usage) {
+              totalInput += chunk.usage.prompt_tokens;
+              totalOutput += chunk.usage.completion_tokens;
+            }
+            continue;
+          }
+          const delta = choice.delta;
+          if (delta.content) emit(res, "strand:text-delta", { delta: delta.content });
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              if (tc.id) {
+                toolCallAccumulator.set(tc.index, { id: tc.id, name: tc.function?.name ?? "", argsJson: "" });
+                emit(res, "strand:tool-start", { toolCallId: tc.id, toolName: tc.function?.name ?? "" });
+              }
+              if (tc.function?.arguments) {
+                const acc = toolCallAccumulator.get(tc.index);
+                if (acc) {
+                  acc.argsJson += tc.function.arguments;
+                  emit(res, "strand:tool-input-delta", { toolCallId: acc.id, delta: tc.function.arguments });
+                }
+              }
+            }
+          }
+          if (choice.finish_reason) finishReason = choice.finish_reason;
+        }
+        if (finishReason === "stop") {
+          emit(res, "strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+          res.end();
+          return;
+        }
+        if (finishReason === "tool_calls" && toolCallAccumulator.size > 0) {
+          const completedTools = Array.from(toolCallAccumulator.values()).map((acc) => ({
+            id: acc.id,
+            name: acc.name,
+            input: JSON.parse(acc.argsJson || "{}")
+          }));
+          conversation.push({
+            role: "assistant",
+            content: null,
+            tool_calls: completedTools.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.input) } }))
+          });
+          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 { role: "tool", tool_call_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 { role: "tool", tool_call_id: block.id, content: message };
+              }
+            })
+          );
+          conversation.push(...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_openai2 = __toESM(require("openai"));
+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_openai2.default({ apiKey: config.apiKey });
+  const openAITools = (config.tools ?? []).map(toolToOpenAITool);
+  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 = [
+            ...system ? [{ role: "system", content: system }] : [],
+            ...messages.map((m) => ({ role: m.role, content: m.content }))
+          ];
+          let totalInput = 0;
+          let totalOutput = 0;
+          for (let step = 0; step < maxSteps; step++) {
+            const openAIStream = await client.chat.completions.create({
+              model: config.model,
+              messages: conversation,
+              ...openAITools.length > 0 ? { tools: openAITools } : {},
+              stream: true,
+              stream_options: { include_usage: true }
+            });
+            let finishReason = null;
+            const toolCallAccumulator = /* @__PURE__ */ new Map();
+            for await (const chunk of openAIStream) {
+              const choice = chunk.choices[0];
+              if (!choice) {
+                if (chunk.usage) {
+                  totalInput += chunk.usage.prompt_tokens;
+                  totalOutput += chunk.usage.completion_tokens;
+                }
+                continue;
+              }
+              const delta = choice.delta;
+              if (delta.content) emit2("strand:text-delta", { delta: delta.content });
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  if (tc.id) {
+                    toolCallAccumulator.set(tc.index, { id: tc.id, name: tc.function?.name ?? "", argsJson: "" });
+                    emit2("strand:tool-start", { toolCallId: tc.id, toolName: tc.function?.name ?? "" });
+                  }
+                  if (tc.function?.arguments) {
+                    const acc = toolCallAccumulator.get(tc.index);
+                    if (acc) {
+                      acc.argsJson += tc.function.arguments;
+                      emit2("strand:tool-input-delta", { toolCallId: acc.id, delta: tc.function.arguments });
+                    }
+                  }
+                }
+              }
+              if (choice.finish_reason) finishReason = choice.finish_reason;
+            }
+            if (finishReason === "stop") {
+              emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+              break;
+            }
+            if (finishReason === "tool_calls" && toolCallAccumulator.size > 0) {
+              const completedTools = Array.from(toolCallAccumulator.values()).map((acc) => ({
+                id: acc.id,
+                name: acc.name,
+                input: JSON.parse(acc.argsJson || "{}")
+              }));
+              conversation.push({
+                role: "assistant",
+                content: null,
+                tool_calls: completedTools.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.input) } }))
+              });
+              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 { role: "tool", tool_call_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 { role: "tool", tool_call_id: block.id, content: message };
+                  }
+                })
+              );
+              conversation.push(...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,283 @@
+// src/handler.ts
+import OpenAI from "openai";
+import { generateId, validateMessages } from "@strand-js/core";
+
+// src/format.ts
+import { toolToJsonSchema } from "@strand-js/core";
+function toolToOpenAITool(tool) {
+  const schema = toolToJsonSchema(tool);
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: schema
+    }
+  };
+}
+
+// src/handler.ts
+function emit(res, eventType, data) {
+  res.write(`event: ${eventType}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function createStrandHandler(config) {
+  const client = new OpenAI({ apiKey: config.apiKey });
+  const openAITools = (config.tools ?? []).map(toolToOpenAITool);
+  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 = [
+        ...system ? [{ role: "system", content: system }] : [],
+        ...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.chat.completions.create({
+          model: config.model,
+          messages: conversation,
+          ...openAITools.length > 0 ? { tools: openAITools } : {},
+          stream: true,
+          stream_options: { include_usage: true }
+        });
+        let finishReason = null;
+        const toolCallAccumulator = /* @__PURE__ */ new Map();
+        for await (const chunk of stream) {
+          const choice = chunk.choices[0];
+          if (!choice) {
+            if (chunk.usage) {
+              totalInput += chunk.usage.prompt_tokens;
+              totalOutput += chunk.usage.completion_tokens;
+            }
+            continue;
+          }
+          const delta = choice.delta;
+          if (delta.content) emit(res, "strand:text-delta", { delta: delta.content });
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              if (tc.id) {
+                toolCallAccumulator.set(tc.index, { id: tc.id, name: tc.function?.name ?? "", argsJson: "" });
+                emit(res, "strand:tool-start", { toolCallId: tc.id, toolName: tc.function?.name ?? "" });
+              }
+              if (tc.function?.arguments) {
+                const acc = toolCallAccumulator.get(tc.index);
+                if (acc) {
+                  acc.argsJson += tc.function.arguments;
+                  emit(res, "strand:tool-input-delta", { toolCallId: acc.id, delta: tc.function.arguments });
+                }
+              }
+            }
+          }
+          if (choice.finish_reason) finishReason = choice.finish_reason;
+        }
+        if (finishReason === "stop") {
+          emit(res, "strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+          res.end();
+          return;
+        }
+        if (finishReason === "tool_calls" && toolCallAccumulator.size > 0) {
+          const completedTools = Array.from(toolCallAccumulator.values()).map((acc) => ({
+            id: acc.id,
+            name: acc.name,
+            input: JSON.parse(acc.argsJson || "{}")
+          }));
+          conversation.push({
+            role: "assistant",
+            content: null,
+            tool_calls: completedTools.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.input) } }))
+          });
+          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 { role: "tool", tool_call_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 { role: "tool", tool_call_id: block.id, content: message };
+              }
+            })
+          );
+          conversation.push(...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 OpenAI2 from "openai";
+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 OpenAI2({ apiKey: config.apiKey });
+  const openAITools = (config.tools ?? []).map(toolToOpenAITool);
+  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 = [
+            ...system ? [{ role: "system", content: system }] : [],
+            ...messages.map((m) => ({ role: m.role, content: m.content }))
+          ];
+          let totalInput = 0;
+          let totalOutput = 0;
+          for (let step = 0; step < maxSteps; step++) {
+            const openAIStream = await client.chat.completions.create({
+              model: config.model,
+              messages: conversation,
+              ...openAITools.length > 0 ? { tools: openAITools } : {},
+              stream: true,
+              stream_options: { include_usage: true }
+            });
+            let finishReason = null;
+            const toolCallAccumulator = /* @__PURE__ */ new Map();
+            for await (const chunk of openAIStream) {
+              const choice = chunk.choices[0];
+              if (!choice) {
+                if (chunk.usage) {
+                  totalInput += chunk.usage.prompt_tokens;
+                  totalOutput += chunk.usage.completion_tokens;
+                }
+                continue;
+              }
+              const delta = choice.delta;
+              if (delta.content) emit2("strand:text-delta", { delta: delta.content });
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  if (tc.id) {
+                    toolCallAccumulator.set(tc.index, { id: tc.id, name: tc.function?.name ?? "", argsJson: "" });
+                    emit2("strand:tool-start", { toolCallId: tc.id, toolName: tc.function?.name ?? "" });
+                  }
+                  if (tc.function?.arguments) {
+                    const acc = toolCallAccumulator.get(tc.index);
+                    if (acc) {
+                      acc.argsJson += tc.function.arguments;
+                      emit2("strand:tool-input-delta", { toolCallId: acc.id, delta: tc.function.arguments });
+                    }
+                  }
+                }
+              }
+              if (choice.finish_reason) finishReason = choice.finish_reason;
+            }
+            if (finishReason === "stop") {
+              emit2("strand:done", { usage: { input: totalInput, output: totalOutput, total: totalInput + totalOutput } });
+              break;
+            }
+            if (finishReason === "tool_calls" && toolCallAccumulator.size > 0) {
+              const completedTools = Array.from(toolCallAccumulator.values()).map((acc) => ({
+                id: acc.id,
+                name: acc.name,
+                input: JSON.parse(acc.argsJson || "{}")
+              }));
+              conversation.push({
+                role: "assistant",
+                content: null,
+                tool_calls: completedTools.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.input) } }))
+              });
+              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 { role: "tool", tool_call_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 { role: "tool", tool_call_id: block.id, content: message };
+                  }
+                })
+              );
+              conversation.push(...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/openai",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "license": "MIT",
   "description": "OpenAI 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": {
-    "openai": "^4.77.0",
-    "@strand-js/core": "0.1.0"
+    "@strand-js/core": "workspace:*",
+    "openai": "^4.77.0"
   },
   "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"
   }
-}
+}