@strand-js/react 0.1.1 → 0.1.3

package/dist/index.d.mts

@@ -0,0 +1,86 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { StrandClient, ToolDefinition, Message, StreamingStatus, TokenUsage } from '@strand-js/core';
+
+interface StrandProviderProps {
+    client: StrandClient;
+    children: ReactNode;
+}
+declare function StrandProvider({ client, children }: StrandProviderProps): react.JSX.Element;
+
+interface ConversationOptions {
+    system?: string;
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>, output: unknown) => void;
+    context?: Record<string, unknown>;
+    sessionId?: string;
+    onFinish?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    client?: StrandClient;
+}
+interface ConversationResult {
+    messages: Message[];
+    send: (content: string) => void;
+    status: StreamingStatus;
+    isPending: boolean;
+    isStreaming: boolean;
+    isIdle: boolean;
+    isDone: boolean;
+    error: Error | null;
+    cancel: () => void;
+    clear: () => void;
+    tokenUsage: TokenUsage;
+}
+declare function useConversation(options?: ConversationOptions): ConversationResult;
+
+interface ToolCallResult<TInput = unknown, TOutput = unknown> {
+    status: 'idle' | 'pending' | 'running' | 'done' | 'failed';
+    input: TInput | null;
+    output: TOutput | null;
+    error: Error | null;
+    isRunning: boolean;
+}
+declare function useToolCall<TInput = unknown, TOutput = unknown>(toolName: string, options?: {
+    client?: StrandClient;
+}): ToolCallResult<TInput, TOutput>;
+
+interface AgentStep {
+    index: number;
+    toolName: string;
+    input: Record<string, unknown> | null;
+    output: unknown | null;
+    status: 'running' | 'done' | 'failed';
+}
+type AgentStatus = 'idle' | 'running' | 'paused' | 'done' | 'failed';
+interface AgentSessionOptions {
+    system?: string;
+    maxSteps?: number;
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+    onStep?: (step: AgentStep) => void;
+    onComplete?: (result: string) => void;
+    client?: StrandClient;
+}
+interface AgentSessionResult {
+    status: AgentStatus;
+    steps: AgentStep[];
+    currentStep: AgentStep | null;
+    stepCount: number;
+    run: (goal: string) => void;
+    pause: () => void;
+    resume: () => void;
+    cancel: () => void;
+    result: string | null;
+    error: Error | null;
+}
+declare function useAgentSession(options?: AgentSessionOptions): AgentSessionResult;
+
+interface StreamingTextResult {
+    text: string;
+    delta: string;
+    isDone: boolean;
+    isStreaming: boolean;
+}
+declare function useStreamingText(stream: ReadableStream<string> | null): StreamingTextResult;
+
+export { type AgentSessionOptions, type AgentSessionResult, type ConversationOptions, type ConversationResult, StrandProvider, type StreamingTextResult, type ToolCallResult, useAgentSession, useConversation, useStreamingText, useToolCall };

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { StrandClient, ToolDefinition, Message, StreamingStatus, TokenUsage } from '@strand-js/core';
+
+interface StrandProviderProps {
+    client: StrandClient;
+    children: ReactNode;
+}
+declare function StrandProvider({ client, children }: StrandProviderProps): react.JSX.Element;
+
+interface ConversationOptions {
+    system?: string;
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>, output: unknown) => void;
+    context?: Record<string, unknown>;
+    sessionId?: string;
+    onFinish?: (message: Message) => void;
+    onError?: (error: Error) => void;
+    client?: StrandClient;
+}
+interface ConversationResult {
+    messages: Message[];
+    send: (content: string) => void;
+    status: StreamingStatus;
+    isPending: boolean;
+    isStreaming: boolean;
+    isIdle: boolean;
+    isDone: boolean;
+    error: Error | null;
+    cancel: () => void;
+    clear: () => void;
+    tokenUsage: TokenUsage;
+}
+declare function useConversation(options?: ConversationOptions): ConversationResult;
+
+interface ToolCallResult<TInput = unknown, TOutput = unknown> {
+    status: 'idle' | 'pending' | 'running' | 'done' | 'failed';
+    input: TInput | null;
+    output: TOutput | null;
+    error: Error | null;
+    isRunning: boolean;
+}
+declare function useToolCall<TInput = unknown, TOutput = unknown>(toolName: string, options?: {
+    client?: StrandClient;
+}): ToolCallResult<TInput, TOutput>;
+
+interface AgentStep {
+    index: number;
+    toolName: string;
+    input: Record<string, unknown> | null;
+    output: unknown | null;
+    status: 'running' | 'done' | 'failed';
+}
+type AgentStatus = 'idle' | 'running' | 'paused' | 'done' | 'failed';
+interface AgentSessionOptions {
+    system?: string;
+    maxSteps?: number;
+    tools?: ToolDefinition[];
+    onToolCall?: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+    onStep?: (step: AgentStep) => void;
+    onComplete?: (result: string) => void;
+    client?: StrandClient;
+}
+interface AgentSessionResult {
+    status: AgentStatus;
+    steps: AgentStep[];
+    currentStep: AgentStep | null;
+    stepCount: number;
+    run: (goal: string) => void;
+    pause: () => void;
+    resume: () => void;
+    cancel: () => void;
+    result: string | null;
+    error: Error | null;
+}
+declare function useAgentSession(options?: AgentSessionOptions): AgentSessionResult;
+
+interface StreamingTextResult {
+    text: string;
+    delta: string;
+    isDone: boolean;
+    isStreaming: boolean;
+}
+declare function useStreamingText(stream: ReadableStream<string> | null): StreamingTextResult;
+
+export { type AgentSessionOptions, type AgentSessionResult, type ConversationOptions, type ConversationResult, StrandProvider, type StreamingTextResult, type ToolCallResult, useAgentSession, useConversation, useStreamingText, useToolCall };

package/dist/index.js

@@ -0,0 +1,310 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StrandProvider: () => StrandProvider,
+  useAgentSession: () => useAgentSession,
+  useConversation: () => useConversation,
+  useStreamingText: () => useStreamingText,
+  useToolCall: () => useToolCall
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/StrandProvider.tsx
+var import_react = require("react");
+var import_core = require("@strand-js/core");
+var import_jsx_runtime = require("react/jsx-runtime");
+var StrandContext = (0, import_react.createContext)(null);
+function StrandProvider({ client, children }) {
+  const [toolStore] = (0, import_react.useState)(() => new import_core.ToolCallStore());
+  const value = (0, import_react.useMemo)(() => ({ client, toolStore }), [client, toolStore]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StrandContext.Provider, { value, children });
+}
+function useStrandContext(explicitClient) {
+  const ctx = (0, import_react.useContext)(StrandContext);
+  if (ctx) {
+    return explicitClient ? { client: explicitClient, toolStore: ctx.toolStore } : ctx;
+  }
+  if (explicitClient) {
+    return { client: explicitClient, toolStore: new import_core.ToolCallStore() };
+  }
+  throw new Error(
+    "[strand] No StrandClient found. Wrap your app in <StrandProvider client={client}> or pass a client prop to the hook."
+  );
+}
+
+// src/useConversation.ts
+var import_react2 = require("react");
+var import_core2 = require("@strand-js/core");
+function useConversation(options = {}) {
+  const { client, toolStore } = useStrandContext(options.client);
+  const machineRef = (0, import_react2.useRef)(null);
+  if (!machineRef.current) {
+    machineRef.current = new import_core2.SessionStateMachine(options.sessionId);
+  }
+  const machine = machineRef.current;
+  const [session, setSession] = (0, import_react2.useState)(() => ({ ...machine.session }));
+  (0, import_react2.useEffect)(() => {
+    setSession({ ...machine.session });
+    return machine.subscribe((s) => setSession({ ...s }));
+  }, [machine]);
+  const optionsRef = (0, import_react2.useRef)(options);
+  (0, import_react2.useEffect)(() => {
+    optionsRef.current = options;
+  });
+  const abortRef = (0, import_react2.useRef)(null);
+  const send = (0, import_react2.useCallback)((content) => {
+    const { context, onFinish, onError, onToolCall } = optionsRef.current;
+    machine.addUserMessage(content);
+    machine.transition("submitting");
+    const abort = new AbortController();
+    abortRef.current = abort;
+    (async () => {
+      try {
+        const generator = client.send(machine.session.messages, {
+          context,
+          signal: abort.signal
+        });
+        for await (const event of generator) {
+          if (abort.signal.aborted) break;
+          (0, import_core2.processWireEvent)(event, machine, toolStore);
+          if (event.type === "strand:tool-result" && onToolCall) {
+            const tc = machine.session.messages.flatMap((m) => m.toolCalls ?? []).find((t) => t.id === event.toolCallId);
+            if (tc) onToolCall(tc.name, tc.input, event.result);
+          }
+        }
+        if (abort.signal.aborted) {
+          machine.transition("idle");
+          return;
+        }
+        if (onFinish) {
+          const last = machine.session.messages.at(-1);
+          if (last?.role === "assistant") onFinish(last);
+        }
+      } catch (err) {
+        if (abort.signal.aborted) {
+          machine.transition("idle");
+          return;
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        machine.transition("error", error);
+        onError?.(error);
+      }
+    })();
+  }, [client, machine, toolStore]);
+  const cancel = (0, import_react2.useCallback)(() => {
+    abortRef.current?.abort();
+  }, []);
+  const clear = (0, import_react2.useCallback)(() => {
+    machine.clear();
+    toolStore.resetAll();
+  }, [machine, toolStore]);
+  return {
+    messages: session.messages,
+    status: session.status,
+    isPending: session.status === "submitting",
+    isStreaming: session.status === "streaming",
+    isIdle: session.status === "idle",
+    isDone: session.status === "done",
+    error: session.error,
+    tokenUsage: session.tokenUsage,
+    send,
+    cancel,
+    clear
+  };
+}
+
+// src/useToolCall.ts
+var import_react3 = require("react");
+function useToolCall(toolName, options) {
+  const { toolStore } = useStrandContext(options?.client);
+  const [state, setState] = (0, import_react3.useState)(
+    () => toolStore.getState(toolName)
+  );
+  (0, import_react3.useEffect)(() => {
+    setState(toolStore.getState(toolName));
+    return toolStore.subscribe(toolName, (s) => setState(s));
+  }, [toolStore, toolName]);
+  return {
+    status: state.status,
+    input: state.input,
+    output: state.output,
+    error: state.error,
+    isRunning: state.status === "running"
+  };
+}
+
+// src/useAgentSession.ts
+var import_react4 = require("react");
+var import_core3 = require("@strand-js/core");
+function useAgentSession(options = {}) {
+  const { client, toolStore } = useStrandContext(options.client);
+  const machineRef = (0, import_react4.useRef)(null);
+  if (!machineRef.current) machineRef.current = new import_core3.SessionStateMachine();
+  const machine = machineRef.current;
+  const [agentStatus, setAgentStatus] = (0, import_react4.useState)("idle");
+  const [steps, setSteps] = (0, import_react4.useState)([]);
+  const [result, setResult] = (0, import_react4.useState)(null);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const abortRef = (0, import_react4.useRef)(null);
+  const optionsRef = (0, import_react4.useRef)(options);
+  (0, import_react4.useEffect)(() => {
+    optionsRef.current = options;
+  });
+  const activeStepsRef = (0, import_react4.useRef)(/* @__PURE__ */ new Map());
+  const run = (0, import_react4.useCallback)((goal) => {
+    setAgentStatus("running");
+    setSteps([]);
+    setResult(null);
+    setError(null);
+    activeStepsRef.current.clear();
+    machine.clear();
+    machine.addUserMessage(goal);
+    const abort = new AbortController();
+    abortRef.current = abort;
+    (async () => {
+      try {
+        const generator = client.send(machine.session.messages, {
+          context: void 0,
+          signal: abort.signal
+        });
+        for await (const event of generator) {
+          if (abort.signal.aborted) break;
+          (0, import_core3.processWireEvent)(event, machine, toolStore);
+          if (event.type === "strand:tool-start") {
+            const idx = activeStepsRef.current.size;
+            activeStepsRef.current.set(event.toolCallId, idx);
+            const step = {
+              index: idx,
+              toolName: event.toolName,
+              input: null,
+              output: null,
+              status: "running"
+            };
+            setSteps((prev) => {
+              const next = [...prev];
+              next[idx] = step;
+              return next;
+            });
+            optionsRef.current.onStep?.(step);
+          }
+          if (event.type === "strand:tool-input-done") {
+            const idx = activeStepsRef.current.get(event.toolCallId);
+            if (idx !== void 0) {
+              setSteps((prev) => {
+                const next = [...prev];
+                next[idx] = { ...next[idx], input: event.input };
+                return next;
+              });
+            }
+          }
+          if (event.type === "strand:tool-result") {
+            const idx = activeStepsRef.current.get(event.toolCallId);
+            if (idx !== void 0) {
+              setSteps((prev) => {
+                const next = [...prev];
+                next[idx] = { ...next[idx], output: event.result, status: "done" };
+                return next;
+              });
+            }
+          }
+        }
+        if (abort.signal.aborted) {
+          setAgentStatus("idle");
+          return;
+        }
+        const finalText = machine.session.messages.filter((m) => m.role === "assistant" && m.content).map((m) => m.content).join("");
+        setResult(finalText);
+        setAgentStatus("idle");
+        optionsRef.current.onComplete?.(finalText);
+      } catch (err) {
+        if (abort.signal.aborted) {
+          setAgentStatus("idle");
+          return;
+        }
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        setAgentStatus("failed");
+      }
+    })();
+  }, [client, machine, toolStore]);
+  const cancel = (0, import_react4.useCallback)(() => {
+    abortRef.current?.abort();
+  }, []);
+  const pause = (0, import_react4.useCallback)(() => {
+    abortRef.current?.abort();
+    setAgentStatus("paused");
+  }, []);
+  const resume = (0, import_react4.useCallback)(() => {
+  }, []);
+  const currentStep = steps.find((s) => s.status === "running") ?? null;
+  return { status: agentStatus, steps, currentStep, stepCount: steps.length, run, pause, resume, cancel, result, error };
+}
+
+// src/useStreamingText.ts
+var import_react5 = require("react");
+function useStreamingText(stream) {
+  const [state, setState] = (0, import_react5.useState)({
+    text: "",
+    delta: "",
+    isDone: false,
+    isStreaming: false
+  });
+  const streamRef = (0, import_react5.useRef)(stream);
+  (0, import_react5.useEffect)(() => {
+    streamRef.current = stream;
+    if (!stream) return;
+    let cancelled = false;
+    setState({ text: "", delta: "", isDone: false, isStreaming: true });
+    (async () => {
+      const reader = stream.getReader();
+      let accumulated = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (cancelled) break;
+          if (done) {
+            setState((s) => ({ ...s, isDone: true, isStreaming: false }));
+            break;
+          }
+          accumulated += value;
+          setState({ text: accumulated, delta: value, isDone: false, isStreaming: true });
+        }
+      } catch {
+        if (!cancelled) setState((s) => ({ ...s, isDone: true, isStreaming: false }));
+      } finally {
+        reader.releaseLock();
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [stream]);
+  return state;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StrandProvider,
+  useAgentSession,
+  useConversation,
+  useStreamingText,
+  useToolCall
+});

package/dist/index.mjs

@@ -0,0 +1,279 @@
+// src/StrandProvider.tsx
+import { createContext, useContext, useState, useMemo } from "react";
+import { ToolCallStore } from "@strand-js/core";
+import { jsx } from "react/jsx-runtime";
+var StrandContext = createContext(null);
+function StrandProvider({ client, children }) {
+  const [toolStore] = useState(() => new ToolCallStore());
+  const value = useMemo(() => ({ client, toolStore }), [client, toolStore]);
+  return /* @__PURE__ */ jsx(StrandContext.Provider, { value, children });
+}
+function useStrandContext(explicitClient) {
+  const ctx = useContext(StrandContext);
+  if (ctx) {
+    return explicitClient ? { client: explicitClient, toolStore: ctx.toolStore } : ctx;
+  }
+  if (explicitClient) {
+    return { client: explicitClient, toolStore: new ToolCallStore() };
+  }
+  throw new Error(
+    "[strand] No StrandClient found. Wrap your app in <StrandProvider client={client}> or pass a client prop to the hook."
+  );
+}
+
+// src/useConversation.ts
+import { useState as useState2, useCallback, useRef, useEffect } from "react";
+import { SessionStateMachine, processWireEvent } from "@strand-js/core";
+function useConversation(options = {}) {
+  const { client, toolStore } = useStrandContext(options.client);
+  const machineRef = useRef(null);
+  if (!machineRef.current) {
+    machineRef.current = new SessionStateMachine(options.sessionId);
+  }
+  const machine = machineRef.current;
+  const [session, setSession] = useState2(() => ({ ...machine.session }));
+  useEffect(() => {
+    setSession({ ...machine.session });
+    return machine.subscribe((s) => setSession({ ...s }));
+  }, [machine]);
+  const optionsRef = useRef(options);
+  useEffect(() => {
+    optionsRef.current = options;
+  });
+  const abortRef = useRef(null);
+  const send = useCallback((content) => {
+    const { context, onFinish, onError, onToolCall } = optionsRef.current;
+    machine.addUserMessage(content);
+    machine.transition("submitting");
+    const abort = new AbortController();
+    abortRef.current = abort;
+    (async () => {
+      try {
+        const generator = client.send(machine.session.messages, {
+          context,
+          signal: abort.signal
+        });
+        for await (const event of generator) {
+          if (abort.signal.aborted) break;
+          processWireEvent(event, machine, toolStore);
+          if (event.type === "strand:tool-result" && onToolCall) {
+            const tc = machine.session.messages.flatMap((m) => m.toolCalls ?? []).find((t) => t.id === event.toolCallId);
+            if (tc) onToolCall(tc.name, tc.input, event.result);
+          }
+        }
+        if (abort.signal.aborted) {
+          machine.transition("idle");
+          return;
+        }
+        if (onFinish) {
+          const last = machine.session.messages.at(-1);
+          if (last?.role === "assistant") onFinish(last);
+        }
+      } catch (err) {
+        if (abort.signal.aborted) {
+          machine.transition("idle");
+          return;
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        machine.transition("error", error);
+        onError?.(error);
+      }
+    })();
+  }, [client, machine, toolStore]);
+  const cancel = useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+  const clear = useCallback(() => {
+    machine.clear();
+    toolStore.resetAll();
+  }, [machine, toolStore]);
+  return {
+    messages: session.messages,
+    status: session.status,
+    isPending: session.status === "submitting",
+    isStreaming: session.status === "streaming",
+    isIdle: session.status === "idle",
+    isDone: session.status === "done",
+    error: session.error,
+    tokenUsage: session.tokenUsage,
+    send,
+    cancel,
+    clear
+  };
+}
+
+// src/useToolCall.ts
+import { useState as useState3, useEffect as useEffect2 } from "react";
+function useToolCall(toolName, options) {
+  const { toolStore } = useStrandContext(options?.client);
+  const [state, setState] = useState3(
+    () => toolStore.getState(toolName)
+  );
+  useEffect2(() => {
+    setState(toolStore.getState(toolName));
+    return toolStore.subscribe(toolName, (s) => setState(s));
+  }, [toolStore, toolName]);
+  return {
+    status: state.status,
+    input: state.input,
+    output: state.output,
+    error: state.error,
+    isRunning: state.status === "running"
+  };
+}
+
+// src/useAgentSession.ts
+import { useState as useState4, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect3 } from "react";
+import { SessionStateMachine as SessionStateMachine2, processWireEvent as processWireEvent2 } from "@strand-js/core";
+function useAgentSession(options = {}) {
+  const { client, toolStore } = useStrandContext(options.client);
+  const machineRef = useRef2(null);
+  if (!machineRef.current) machineRef.current = new SessionStateMachine2();
+  const machine = machineRef.current;
+  const [agentStatus, setAgentStatus] = useState4("idle");
+  const [steps, setSteps] = useState4([]);
+  const [result, setResult] = useState4(null);
+  const [error, setError] = useState4(null);
+  const abortRef = useRef2(null);
+  const optionsRef = useRef2(options);
+  useEffect3(() => {
+    optionsRef.current = options;
+  });
+  const activeStepsRef = useRef2(/* @__PURE__ */ new Map());
+  const run = useCallback2((goal) => {
+    setAgentStatus("running");
+    setSteps([]);
+    setResult(null);
+    setError(null);
+    activeStepsRef.current.clear();
+    machine.clear();
+    machine.addUserMessage(goal);
+    const abort = new AbortController();
+    abortRef.current = abort;
+    (async () => {
+      try {
+        const generator = client.send(machine.session.messages, {
+          context: void 0,
+          signal: abort.signal
+        });
+        for await (const event of generator) {
+          if (abort.signal.aborted) break;
+          processWireEvent2(event, machine, toolStore);
+          if (event.type === "strand:tool-start") {
+            const idx = activeStepsRef.current.size;
+            activeStepsRef.current.set(event.toolCallId, idx);
+            const step = {
+              index: idx,
+              toolName: event.toolName,
+              input: null,
+              output: null,
+              status: "running"
+            };
+            setSteps((prev) => {
+              const next = [...prev];
+              next[idx] = step;
+              return next;
+            });
+            optionsRef.current.onStep?.(step);
+          }
+          if (event.type === "strand:tool-input-done") {
+            const idx = activeStepsRef.current.get(event.toolCallId);
+            if (idx !== void 0) {
+              setSteps((prev) => {
+                const next = [...prev];
+                next[idx] = { ...next[idx], input: event.input };
+                return next;
+              });
+            }
+          }
+          if (event.type === "strand:tool-result") {
+            const idx = activeStepsRef.current.get(event.toolCallId);
+            if (idx !== void 0) {
+              setSteps((prev) => {
+                const next = [...prev];
+                next[idx] = { ...next[idx], output: event.result, status: "done" };
+                return next;
+              });
+            }
+          }
+        }
+        if (abort.signal.aborted) {
+          setAgentStatus("idle");
+          return;
+        }
+        const finalText = machine.session.messages.filter((m) => m.role === "assistant" && m.content).map((m) => m.content).join("");
+        setResult(finalText);
+        setAgentStatus("idle");
+        optionsRef.current.onComplete?.(finalText);
+      } catch (err) {
+        if (abort.signal.aborted) {
+          setAgentStatus("idle");
+          return;
+        }
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        setAgentStatus("failed");
+      }
+    })();
+  }, [client, machine, toolStore]);
+  const cancel = useCallback2(() => {
+    abortRef.current?.abort();
+  }, []);
+  const pause = useCallback2(() => {
+    abortRef.current?.abort();
+    setAgentStatus("paused");
+  }, []);
+  const resume = useCallback2(() => {
+  }, []);
+  const currentStep = steps.find((s) => s.status === "running") ?? null;
+  return { status: agentStatus, steps, currentStep, stepCount: steps.length, run, pause, resume, cancel, result, error };
+}
+
+// src/useStreamingText.ts
+import { useState as useState5, useEffect as useEffect4, useRef as useRef3 } from "react";
+function useStreamingText(stream) {
+  const [state, setState] = useState5({
+    text: "",
+    delta: "",
+    isDone: false,
+    isStreaming: false
+  });
+  const streamRef = useRef3(stream);
+  useEffect4(() => {
+    streamRef.current = stream;
+    if (!stream) return;
+    let cancelled = false;
+    setState({ text: "", delta: "", isDone: false, isStreaming: true });
+    (async () => {
+      const reader = stream.getReader();
+      let accumulated = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (cancelled) break;
+          if (done) {
+            setState((s) => ({ ...s, isDone: true, isStreaming: false }));
+            break;
+          }
+          accumulated += value;
+          setState({ text: accumulated, delta: value, isDone: false, isStreaming: true });
+        }
+      } catch {
+        if (!cancelled) setState((s) => ({ ...s, isDone: true, isStreaming: false }));
+      } finally {
+        reader.releaseLock();
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [stream]);
+  return state;
+}
+export {
+  StrandProvider,
+  useAgentSession,
+  useConversation,
+  useStreamingText,
+  useToolCall
+};

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@strand-js/react",
-  "version": "0.1.1",
+  "version": "0.1.3",
+  "license": "MIT",
   "description": "React hooks for Strand — useConversation, useToolCall, useAgentSession, useStreamingText",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -16,7 +17,7 @@
     "dist"
   ],
   "dependencies": {
-    "@strand-js/core": "0.1.1"
+    "@strand-js/core": "0.1.3"
   },
   "peerDependencies": {
     "react": "^18.0.0",