bs-agent 0.0.12 → 0.0.16

package/dist/react/index.js

@@ -60,22 +60,22 @@ var useSessionUtils = (agentId, allSessions, setAllSessions, currentSessionId, s
       setAllSessions((prev) => {
         const updatedAgentSessions = { ...prev[agentId] };
         delete updatedAgentSessions[sessionId];
+        if (sessionId === currentSessionId) {
+          const remainingSessions = Object.values(updatedAgentSessions);
+          if (remainingSessions.length > 0) {
+            const mostRecent = remainingSessions.sort((a, b) => b.updatedAt - a.updatedAt)[0];
+            setCurrentSessionId(mostRecent.id);
+          } else {
+            setCurrentSessionId(TEMPORARY_SESSION_ID);
+          }
+        }
         return {
           ...prev,
           [agentId]: updatedAgentSessions
         };
       });
-      if (sessionId === currentSessionId) {
-        const remainingSessions = Object.values(agentSessions).filter((s) => s.id !== sessionId);
-        if (remainingSessions.length > 0) {
-          const mostRecent = remainingSessions.sort((a, b) => b.updatedAt - a.updatedAt)[0];
-          setCurrentSessionId(mostRecent.id);
-        } else {
-          setCurrentSessionId(TEMPORARY_SESSION_ID);
-        }
-      }
     },
-    [agentId, currentSessionId, agentSessions, setAllSessions, setCurrentSessionId]
+    [agentId, currentSessionId, setAllSessions, setCurrentSessionId]
   );
   const sessionsList = useMemo(
     () => Object.values(agentSessions).sort((a, b) => b.updatedAt - a.updatedAt),
@@ -281,15 +281,13 @@ function useClientToolHelpers(agentId, toolContext) {
     const tools = toolContext.getToolsForAgent(agentId);
     const map = /* @__PURE__ */ new Map();
     for (const tool of tools) {
-      if (tool.handler) {
-        map.set(tool.name, {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters,
-          await: tool.await,
-          handler: tool.handler
-        });
-      }
+      map.set(tool.name, {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+        await: tool.await,
+        handler: tool.handler
+      });
     }
     return map;
   }, [agentId, toolContext]);
@@ -306,233 +304,6 @@ function useClientToolHelpers(agentId, toolContext) {
   return { getClientToolsMap, getClientToolDefs };
 }
 
-// src/core/stream.ts
-function tryParseJSON2(value) {
-  if (typeof value === "string") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value;
-    }
-  }
-  return value;
-}
-var FatalStreamError = class extends Error {
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "FatalStreamError";
-  }
-};
-async function executeStream(options) {
-  const {
-    url,
-    body,
-    headers,
-    callbacks,
-    clientTools,
-    signal,
-    onSessionId,
-    onPaused,
-    onAutoResume,
-    onResponse
-  } = options;
-  let fullText = "";
-  const pendingAutoResumes = [];
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "text/event-stream",
-      ...headers
-    },
-    body: JSON.stringify(body),
-    signal
-  });
-  const sessionId = response.headers.get("X-BuildShip-Agent-Session-ID");
-  if (sessionId && onSessionId) {
-    const sessionName = response.headers.get("X-BuildShip-Agent-Session-Name") || void 0;
-    onSessionId(sessionId, sessionName);
-  }
-  onResponse?.(response);
-  if (!response.ok) {
-    let errorBody = "";
-    try {
-      errorBody = await response.text();
-    } catch {
-    }
-    const error = new FatalStreamError(
-      `HTTP ${response.status}: ${errorBody || response.statusText}`,
-      response.status
-    );
-    callbacks.onError?.(error);
-    throw error;
-  }
-  if (!response.body) {
-    callbacks.onComplete?.(fullText);
-    return;
-  }
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split("\n\n");
-      buffer = parts.pop() || "";
-      for (const part of parts) {
-        const trimmedPart = part.trim();
-        if (!trimmedPart) continue;
-        let jsonStr = "";
-        for (const line of trimmedPart.split("\n")) {
-          if (line.startsWith("data: ")) {
-            jsonStr += line.slice(6);
-          } else if (line.startsWith("data:")) {
-            jsonStr += line.slice(5);
-          }
-        }
-        jsonStr = jsonStr.trim();
-        if (!jsonStr) continue;
-        let raw;
-        try {
-          raw = JSON.parse(jsonStr);
-        } catch {
-          continue;
-        }
-        const streamEvent = normalizeEvent(raw);
-        handleEvent(
-          streamEvent,
-          fullText,
-          callbacks,
-          clientTools,
-          onPaused,
-          onAutoResume,
-          pendingAutoResumes
-        );
-        if (streamEvent.type === "text_delta") {
-          fullText += streamEvent.data;
-        }
-      }
-    }
-    if (buffer.trim()) {
-      let jsonStr = "";
-      for (const line of buffer.trim().split("\n")) {
-        if (line.startsWith("data: ")) {
-          jsonStr += line.slice(6);
-        } else if (line.startsWith("data:")) {
-          jsonStr += line.slice(5);
-        }
-      }
-      jsonStr = jsonStr.trim();
-      if (jsonStr) {
-        try {
-          const raw = JSON.parse(jsonStr);
-          const streamEvent = normalizeEvent(raw);
-          handleEvent(
-            streamEvent,
-            fullText,
-            callbacks,
-            clientTools,
-            onPaused,
-            onAutoResume,
-            pendingAutoResumes
-          );
-          if (streamEvent.type === "text_delta") {
-            fullText += streamEvent.data;
-          }
-        } catch {
-        }
-      }
-    }
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw err;
-    }
-    const error = err instanceof Error ? err : new Error(String(err));
-    callbacks.onError?.(error);
-    throw error;
-  }
-  if (pendingAutoResumes.length > 0) {
-    await Promise.allSettled(pendingAutoResumes);
-  }
-  callbacks.onComplete?.(fullText);
-}
-function normalizeEvent(raw) {
-  const typeMap = {
-    llm_text_delta: "text_delta",
-    llm_reasoning_delta: "reasoning_delta"
-  };
-  if (raw && typeof raw.type === "string" && typeMap[raw.type]) {
-    raw.type = typeMap[raw.type];
-  }
-  return raw;
-}
-function handleEvent(event, _fullText, callbacks, clientTools, onPaused, onAutoResume, pendingAutoResumes) {
-  callbacks.onEvent?.(event);
-  switch (event.type) {
-    case "text_delta": {
-      callbacks.onText?.(event.data);
-      break;
-    }
-    case "reasoning_delta": {
-      callbacks.onReasoning?.(event.data.delta, event.data.index);
-      break;
-    }
-    case "agent_handoff": {
-      callbacks.onAgentHandoff?.(event.data.agentName);
-      break;
-    }
-    case "tool_call_start": {
-      const { callId, toolName, toolType, inputs: rawInputs, paused } = event.data;
-      const inputs = tryParseJSON2(rawInputs);
-      callbacks.onToolStart?.(toolName, toolType);
-      if (toolType === "client") {
-        const tool = clientTools.get(toolName);
-        if (tool) {
-          if (paused && tool.handler) {
-            const handlerPromise = (async () => {
-              try {
-                const result = await tool.handler(inputs);
-                await onAutoResume?.(callId, result);
-              } catch {
-                callbacks.onPaused?.(toolName, inputs);
-                onPaused?.({ callId, toolName, args: inputs });
-              }
-            })();
-            pendingAutoResumes.push(handlerPromise);
-          } else if (paused) {
-            callbacks.onPaused?.(toolName, inputs);
-            onPaused?.({ callId, toolName, args: inputs });
-          } else if (tool.handler) {
-            try {
-              tool.handler(inputs);
-            } catch {
-            }
-          }
-        } else if (paused) {
-          callbacks.onPaused?.(toolName, inputs);
-          onPaused?.({ callId, toolName, args: inputs });
-        }
-      }
-      break;
-    }
-    case "tool_call_end": {
-      const { toolName, result, error } = event.data;
-      callbacks.onToolEnd?.(toolName, result, error);
-      break;
-    }
-    case "run_error": {
-      const { message, code } = event.data;
-      const error = new Error(message);
-      if (code != null) error.code = code;
-      callbacks.onError?.(error);
-      break;
-    }
-  }
-}
-
 // src/react/utils/message.ts
 function updateAgentMessageParts(parts, newPart) {
   const last = parts[parts.length - 1];
@@ -552,7 +323,15 @@ function updateAgentMessageParts(parts, newPart) {
 
 // src/react/stream-callbacks.ts
 function buildStreamCallbacks(deps, debugKey) {
-  const { setMessages, setInProgress, syncSessionRef, messagesRef, toolContext, agentId } = deps;
+  const {
+    setMessages,
+    setInProgress,
+    syncSessionRef,
+    messagesRef,
+    toolContext,
+    agentId,
+    textDeltaModifier
+  } = deps;
   return {
     onComplete: () => {
       console.log("Agent closed");
@@ -570,7 +349,7 @@ function buildStreamCallbacks(deps, debugKey) {
     },
     onEvent: (event) => {
       if (event.type === "text_delta") {
-        handleTextDelta(event, setMessages, syncSessionRef);
+        handleTextDelta(event, setMessages, syncSessionRef, textDeltaModifier, agentId);
       } else if (event.type === "tool_call_start" && event.data.toolType === "client") {
         handleClientToolCall(event, setMessages, syncSessionRef, toolContext, agentId);
         if (debugKey) {
@@ -600,82 +379,21 @@ function buildStreamCallbacks(deps, debugKey) {
     }
   };
 }
-var TEMPORARY_SESSION_ID2 = "sess_temp";
-var DEFAULT_SESSION_NAME2 = "New Chat";
-async function executeAgentStream(deps, body, headers, callbacks, debugKey) {
-  const {
-    agentUrl,
-    signal,
-    currentSessionId,
-    lastRequestContextRef,
-    messagesRef,
-    createSessionFromResponse,
-    setMessages,
-    syncSessionRef,
-    runAgentRef
-  } = deps;
-  await executeStream({
-    url: agentUrl,
-    body,
-    headers,
-    callbacks,
-    clientTools: deps.getClientToolsMap(),
-    signal,
-    onSessionId: (sessionId, sessionName) => {
-      lastRequestContextRef.current.sessionId = sessionId;
-      if (!currentSessionId || currentSessionId === TEMPORARY_SESSION_ID2) {
-        createSessionFromResponse(
-          sessionId,
-          sessionName || DEFAULT_SESSION_NAME2,
-          messagesRef.current
-        );
-        deps.setCurrentSessionId(sessionId);
-      }
-    },
-    // Session creation is handled by onSessionId above.
-    onAutoResume: async (callId, result) => {
-      setMessages((prev) => {
-        const updatedMessages = prev.map((msg) => {
-          if (msg.parts) {
-            const updatedParts = msg.parts.map((part) => {
-              if (part.type === "widget" && part.callId === callId) {
-                return { ...part, status: "submitted", result };
-              }
-              return part;
-            });
-            return { ...msg, parts: updatedParts };
-          }
-          return msg;
-        });
-        if (syncSessionRef.current) {
-          syncSessionRef.current(updatedMessages);
-        }
-        return updatedMessages;
-      });
-      if (debugKey) {
-        deps.debugHandlers.handleStreamEvent({
-          type: "tool_call_end",
-          data: { callId, toolName: "", toolType: "client", result },
-          meta: { executionId: debugKey, sequence: 0 }
-        });
-      }
-      try {
-        await runAgentRef.current?.(void 0, {
-          resumeToolCallId: callId,
-          resumeToolResult: result
-        });
-      } catch (error) {
-        console.error("Auto-resume failed", error);
-      }
-    }
-  });
-}
-function handleTextDelta(event, setMessages, syncSessionRef) {
+function handleTextDelta(event, setMessages, syncSessionRef, modifier, agentId) {
   const sequence = event.meta.sequence;
-  const text = event.data;
+  const originalText = event.data;
   const eventExecutionId = event.meta.executionId;
   setMessages((prev) => {
     const lastMessage = prev[prev.length - 1];
+    let text = originalText;
+    if (modifier) {
+      const currentFullText = lastMessage?.role === "agent" ? lastMessage.content : "";
+      text = modifier(originalText, currentFullText, {
+        executionId: eventExecutionId,
+        sequence,
+        agentId: event.meta.agentId || agentId
+      });
+    }
     const newPart = {
       type: "text",
       text,
@@ -743,7 +461,8 @@ function handleClientToolCall(event, setMessages, syncSessionRef, toolContext, a
 }
 
 // src/react/use-agent.ts
-function useAgent(agentId, agentUrl, accessKey) {
+function useAgent(agent, options) {
+  const agentId = agent._agentId;
   const { allSessions, setAllSessions, debugData, setDebugData } = useAgentGlobalState();
   const toolContext = useContext2(AgentToolContext);
   const [inProgress, setInProgress] = useState(false);
@@ -761,7 +480,7 @@ function useAgent(agentId, agentUrl, accessKey) {
   useEffect(() => {
     const initialSessionId = sessionUtils.getInitialSessionId();
     setCurrentSessionId(initialSessionId);
-  }, []);
+  }, [agentId]);
   const debugHandlers = useMemo2(() => createDebugHandlers(setDebugData), [setDebugData]);
   useEffect(() => {
     messagesRef.current = messages;
@@ -774,82 +493,90 @@ function useAgent(agentId, agentUrl, accessKey) {
     } else {
       setMessages([]);
     }
-  }, [currentSessionId, agentId]);
+  }, [currentSessionId, agentId, sessionUtils.agentSessions, inProgress]);
   useEffect(() => {
+    const syncRef = sessionUtils.syncSessionRef;
+    const msgRef = messagesRef;
     return () => {
-      if (messagesRef.current.length > 0 && sessionUtils.syncSessionRef.current) {
-        sessionUtils.syncSessionRef.current();
+      if (msgRef.current.length > 0 && syncRef.current) {
+        syncRef.current();
       }
     };
-  }, []);
-  const controller = useRef2();
-  const lastRequestContextRef = useRef2({});
-  const { getClientToolsMap, getClientToolDefs } = useClientToolHelpers(agentId, toolContext);
-  const runAgentRef = useRef2();
+  }, [sessionUtils.syncSessionRef]);
+  const optionsRef = useRef2(options);
+  useEffect(() => {
+    optionsRef.current = options;
+  }, [options]);
+  const lastRunOptionsRef = useRef2({});
+  const { getClientToolsMap } = useClientToolHelpers(agentId, toolContext);
+  const activeSessionRef = useRef2(null);
   const runAgent = useCallback3(
     async (input, runOptions) => {
-      const realSessionId = currentSessionId && currentSessionId !== TEMPORARY_SESSION_ID ? currentSessionId : lastRequestContextRef.current.sessionId;
-      lastRequestContextRef.current = {
-        additionalHeaders: runOptions?.additionalHeaders ?? lastRequestContextRef.current.additionalHeaders,
-        additionalBody: runOptions?.additionalBody ?? lastRequestContextRef.current.additionalBody,
-        sessionId: realSessionId
-      };
+      const isNewSession = !currentSessionId || currentSessionId === TEMPORARY_SESSION_ID;
       setInProgress(true);
-      if (!runOptions?.resumeToolCallId && controller.current) {
-        controller.current.abort();
-      }
-      controller.current = new AbortController();
-      const headers = {
-        ...lastRequestContextRef.current.additionalHeaders || {},
-        ...accessKey ? { Authorization: `Bearer ${accessKey}` } : {}
-      };
-      if (realSessionId) {
-        headers["x-buildship-agent-session-id"] = realSessionId;
-      }
-      const body = {
-        stream: true,
-        ...lastRequestContextRef.current.additionalBody || {}
-      };
-      if (input !== void 0) {
-        body.input = input;
-      }
-      if (runOptions?.context) {
-        Object.assign(body, { context: runOptions.context });
-      }
-      if (runOptions?.resumeToolCallId) {
-        body.toolCallResult = {
-          callId: runOptions.resumeToolCallId,
-          result: runOptions.resumeToolResult
-        };
-      }
-      const registeredToolDefs = getClientToolDefs() || [];
-      const legacyToolDefs = runOptions?.clientTools || [];
-      const allToolDefs = [...registeredToolDefs, ...legacyToolDefs];
-      if (allToolDefs.length > 0) {
-        body.clientTools = allToolDefs;
-      }
       const debugKey = runOptions?.optimisticExecutionId || messagesRef.current.findLast((m) => m.role === "user")?.executionId;
       const deps = {
-        agentUrl,
         agentId,
-        accessKey,
         currentSessionId,
         messagesRef,
         setMessages,
         setInProgress,
-        setCurrentSessionId,
         syncSessionRef: sessionUtils.syncSessionRef,
-        createSessionFromResponse: sessionUtils.createSessionFromResponse,
         debugHandlers,
         toolContext,
-        lastRequestContextRef,
-        getClientToolsMap,
-        signal: controller.current.signal,
-        runAgentRef
+        textDeltaModifier: optionsRef.current?.textDeltaModifier
       };
       const callbacks = buildStreamCallbacks(deps, debugKey);
+      const executeOptions = {
+        context: runOptions?.context,
+        headers: runOptions?.additionalHeaders,
+        body: runOptions?.additionalBody
+      };
+      const toolsMap = getClientToolsMap();
+      for (const tool of toolsMap.values()) {
+        agent.registerClientTool(tool);
+      }
+      if (runOptions?.clientTools && runOptions.clientTools.length > 0) {
+        executeOptions.body = {
+          ...executeOptions.body || {},
+          clientTools: [
+            ...executeOptions.body?.clientTools || [],
+            ...runOptions.clientTools
+          ]
+        };
+      }
       try {
-        await executeAgentStream(deps, body, headers, callbacks, debugKey);
+        if (runOptions?.resumeToolCallId) {
+          if (isNewSession) throw new Error("Cannot resume a tool call on a temporary session.");
+          const session = agent.session(currentSessionId);
+          activeSessionRef.current = session;
+          await session.resumeWithCallId(
+            runOptions.resumeToolCallId,
+            runOptions.resumeToolResult,
+            callbacks,
+            executeOptions
+          );
+        } else {
+          if (isNewSession) {
+            const extendedOptions = {
+              ...executeOptions,
+              onSessionId: (newSessionId, sessionName) => {
+                sessionUtils.createSessionFromResponse(
+                  newSessionId,
+                  sessionName || DEFAULT_SESSION_NAME,
+                  messagesRef.current
+                );
+                setCurrentSessionId(newSessionId);
+              }
+            };
+            const session = await agent.execute(input || "", callbacks, extendedOptions);
+            activeSessionRef.current = session;
+          } else {
+            const session = agent.session(currentSessionId);
+            activeSessionRef.current = session;
+            await session.execute(input || "", callbacks, executeOptions);
+          }
+        }
       } catch (error) {
         console.log("Agent execution failed", error);
         setInProgress(false);
@@ -857,32 +584,20 @@ function useAgent(agentId, agentUrl, accessKey) {
           sessionUtils.syncSessionRef.current(messagesRef.current);
         }
         throw error;
+      } finally {
+        activeSessionRef.current = null;
       }
     },
-    [
-      agentUrl,
-      accessKey,
-      currentSessionId,
-      sessionUtils.syncSessionRef,
-      sessionUtils.createSessionFromResponse,
-      debugHandlers,
-      getClientToolsMap,
-      getClientToolDefs,
-      agentId,
-      toolContext
-    ]
+    [currentSessionId, sessionUtils, debugHandlers, agentId, toolContext, agent, getClientToolsMap]
   );
-  useEffect(() => {
-    runAgentRef.current = runAgent;
-  }, [runAgent]);
   const handleSend = useCallback3(
-    async (input, options) => {
+    async (input, options2) => {
       const userMessage = {
         role: "user",
         content: input,
         executionId: Date.now().toString()
       };
-      if (!options?.skipUserMessage) {
+      if (!options2?.skipUserMessage) {
         setMessages((prev) => {
           const updatedMessages = [...prev, userMessage];
           if (sessionUtils.syncSessionRef.current) {
@@ -891,14 +606,19 @@ function useAgent(agentId, agentUrl, accessKey) {
           return updatedMessages;
         });
       }
-      const effectiveExecutionId = options?.skipUserMessage ? messagesRef.current.findLast((m) => m.role === "user")?.executionId ?? userMessage.executionId : userMessage.executionId;
+      const effectiveExecutionId = options2?.skipUserMessage ? messagesRef.current.findLast((m) => m.role === "user")?.executionId ?? userMessage.executionId : userMessage.executionId;
+      lastRunOptionsRef.current = {
+        context: options2?.context,
+        additionalHeaders: options2?.additionalHeaders,
+        additionalBody: options2?.additionalBody
+      };
       try {
         await runAgent(input, {
-          ...options,
+          ...options2,
           optimisticExecutionId: effectiveExecutionId
         });
       } catch (error) {
-        if (!options?.skipUserMessage) {
+        if (!options2?.skipUserMessage) {
           setMessages((prev) => {
             const updatedMessages = prev.some((m) => m === userMessage) ? prev : [...prev, userMessage];
             if (sessionUtils.syncSessionRef.current) {
@@ -942,7 +662,8 @@ function useAgent(agentId, agentUrl, accessKey) {
       }
       await runAgent(void 0, {
         resumeToolCallId: callId,
-        resumeToolResult: result
+        resumeToolResult: result,
+        ...lastRunOptionsRef.current
       });
     },
     [runAgent, sessionUtils.syncSessionRef, debugHandlers]
@@ -965,8 +686,8 @@ function useAgent(agentId, agentUrl, accessKey) {
     [sessionUtils.syncSessionRef]
   );
   const abort = useCallback3(() => {
-    if (controller.current) {
-      controller.current.abort();
+    if (activeSessionRef.current) {
+      activeSessionRef.current.abort();
     }
     setInProgress(false);
     if (sessionUtils.syncSessionRef.current) {
@@ -988,6 +709,536 @@ function useAgent(agentId, agentUrl, accessKey) {
   };
 }
 
+// src/core/stream.ts
+function tryParseJSON2(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+var FatalStreamError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "FatalStreamError";
+  }
+};
+async function executeStream(options) {
+  const {
+    url,
+    body,
+    headers,
+    callbacks,
+    clientTools,
+    signal,
+    onSessionId,
+    onPaused,
+    onAutoResume,
+    onResponse
+  } = options;
+  let fullText = "";
+  const pendingAutoResumes = [];
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      ...headers
+    },
+    body: JSON.stringify(body),
+    signal
+  });
+  const sessionId = response.headers.get("X-BuildShip-Agent-Session-ID");
+  if (sessionId && onSessionId) {
+    const sessionName = response.headers.get("X-BuildShip-Agent-Session-Name") || void 0;
+    onSessionId(sessionId, sessionName);
+  }
+  onResponse?.(response);
+  if (!response.ok) {
+    let errorBody = "";
+    try {
+      errorBody = await response.text();
+    } catch {
+    }
+    const error = new FatalStreamError(
+      `HTTP ${response.status}: ${errorBody || response.statusText}`,
+      response.status
+    );
+    callbacks.onError?.(error);
+    throw error;
+  }
+  if (!response.body) {
+    callbacks.onComplete?.(fullText);
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop() || "";
+      for (const part of parts) {
+        const trimmedPart = part.trim();
+        if (!trimmedPart) continue;
+        let jsonStr = "";
+        for (const line of trimmedPart.split("\n")) {
+          if (line.startsWith("data: ")) {
+            jsonStr += line.slice(6);
+          } else if (line.startsWith("data:")) {
+            jsonStr += line.slice(5);
+          }
+        }
+        jsonStr = jsonStr.trim();
+        if (!jsonStr) continue;
+        let raw;
+        try {
+          raw = JSON.parse(jsonStr);
+        } catch {
+          continue;
+        }
+        const streamEvent = normalizeEvent(raw);
+        handleEvent(
+          streamEvent,
+          fullText,
+          callbacks,
+          clientTools,
+          onPaused,
+          onAutoResume,
+          pendingAutoResumes
+        );
+        if (streamEvent.type === "text_delta") {
+          fullText += streamEvent.data;
+        }
+      }
+    }
+    if (buffer.trim()) {
+      let jsonStr = "";
+      for (const line of buffer.trim().split("\n")) {
+        if (line.startsWith("data: ")) {
+          jsonStr += line.slice(6);
+        } else if (line.startsWith("data:")) {
+          jsonStr += line.slice(5);
+        }
+      }
+      jsonStr = jsonStr.trim();
+      if (jsonStr) {
+        try {
+          const raw = JSON.parse(jsonStr);
+          const streamEvent = normalizeEvent(raw);
+          handleEvent(
+            streamEvent,
+            fullText,
+            callbacks,
+            clientTools,
+            onPaused,
+            onAutoResume,
+            pendingAutoResumes
+          );
+          if (streamEvent.type === "text_delta") {
+            fullText += streamEvent.data;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw err;
+    }
+    const error = err instanceof Error ? err : new Error(String(err));
+    callbacks.onError?.(error);
+    throw error;
+  }
+  if (pendingAutoResumes.length > 0) {
+    const handlerResults = await Promise.allSettled(pendingAutoResumes);
+    for (const settled of handlerResults) {
+      if (settled.status === "fulfilled" && settled.value) {
+        const { callId, result } = settled.value;
+        await onAutoResume?.(callId, result);
+      }
+    }
+  }
+  callbacks.onComplete?.(fullText);
+}
+function normalizeEvent(raw) {
+  const typeMap = {
+    llm_text_delta: "text_delta",
+    llm_reasoning_delta: "reasoning_delta"
+  };
+  if (raw && typeof raw.type === "string" && typeMap[raw.type]) {
+    raw.type = typeMap[raw.type];
+  }
+  return raw;
+}
+function handleEvent(event, _fullText, callbacks, clientTools, onPaused, onAutoResume, pendingAutoResumes) {
+  callbacks.onEvent?.(event);
+  switch (event.type) {
+    case "text_delta": {
+      callbacks.onText?.(event.data);
+      break;
+    }
+    case "reasoning_delta": {
+      callbacks.onReasoning?.(event.data.delta, event.data.index);
+      break;
+    }
+    case "agent_handoff": {
+      callbacks.onAgentHandoff?.(event.data.agentName);
+      break;
+    }
+    case "tool_call_start": {
+      const { callId, toolName, toolType, inputs: rawInputs, paused } = event.data;
+      const inputs = tryParseJSON2(rawInputs);
+      callbacks.onToolStart?.(toolName, toolType);
+      if (toolType === "client") {
+        const tool = clientTools.get(toolName);
+        if (tool) {
+          if (paused && tool.handler) {
+            const handlerPromise = (async () => {
+              try {
+                const result = await tool.handler(inputs);
+                callbacks.onEvent?.({
+                  type: "tool_call_end",
+                  data: {
+                    callId,
+                    toolName,
+                    toolType: "client",
+                    result
+                  },
+                  meta: event.meta
+                });
+                return { callId, result };
+              } catch (error) {
+                callbacks.onPaused?.(toolName, inputs);
+                onPaused?.({ callId, toolName, args: inputs });
+                return null;
+              }
+            })();
+            pendingAutoResumes.push(handlerPromise);
+          } else if (paused) {
+            callbacks.onPaused?.(toolName, inputs);
+            onPaused?.({ callId, toolName, args: inputs });
+          } else if (tool.handler) {
+            try {
+              tool.handler(inputs);
+            } catch {
+            }
+          }
+        } else if (paused) {
+          callbacks.onPaused?.(toolName, inputs);
+          onPaused?.({ callId, toolName, args: inputs });
+        }
+      }
+      break;
+    }
+    case "tool_call_end": {
+      const { toolName, result, error } = event.data;
+      callbacks.onToolEnd?.(toolName, result, error);
+      break;
+    }
+    case "run_error": {
+      const { message, code } = event.data;
+      const error = new Error(message);
+      if (code != null) error.code = code;
+      callbacks.onError?.(error);
+      break;
+    }
+  }
+}
+
+// src/core/session.ts
+import { toJSONSchema as toJSONSchema2 } from "zod";
+var AgentSession = class {
+  /** @internal */
+  _agent;
+  /** @internal */
+  _sessionId;
+  /** @internal */
+  _paused = false;
+  /** @internal */
+  _pausedToolInfo = null;
+  /** @internal */
+  _abortController = null;
+  /** @internal */
+  constructor(agent, sessionId) {
+    this._agent = agent;
+    this._sessionId = sessionId;
+  }
+  // ─── Public API ────────────────────────────────────────────────────
+  /**
+   * Send a message in this session.
+   *
+   * @param message   - The message to send
+   * @param callbacks - Event handlers for the stream
+   * @param callbacks - Event handlers for the stream
+   * @param options   - Optional settings like context, headers, or body
+   * @returns This session (for chaining)
+   */
+  async execute(message, callbacks, options) {
+    this._paused = false;
+    this._pausedToolInfo = null;
+    const body = {
+      ...options?.body || {},
+      input: message,
+      stream: true
+    };
+    if (options?.context) {
+      Object.assign(body, { context: options.context });
+    }
+    const clientToolDefs = this._getClientToolDefs();
+    if (clientToolDefs.length > 0) {
+      body.clientTools = clientToolDefs;
+    }
+    await this._run(body, callbacks, options);
+    return this;
+  }
+  /**
+   * Resume a paused session with a tool result.
+   *
+   * @param result    - The result to send back to the agent
+   * @param callbacks - Event handlers for the resumed stream
+   * @param options   - Optional settings like headers or body
+   * @returns This session (for chaining)
+   */
+  async resume(result, callbacks, options) {
+    if (!this._paused || !this._pausedToolInfo) {
+      throw new Error("AgentSession.resume(): session is not paused. Check isPaused() first.");
+    }
+    const body = {
+      ...options?.body || {},
+      stream: true,
+      toolCallResult: {
+        callId: this._pausedToolInfo.callId,
+        result
+      }
+    };
+    const clientToolDefs = this._getClientToolDefs();
+    if (clientToolDefs.length > 0) {
+      body.clientTools = clientToolDefs;
+    }
+    this._paused = false;
+    this._pausedToolInfo = null;
+    await this._run(body, callbacks, options);
+    return this;
+  }
+  /**
+   * Resume a session with an explicit tool call ID and result.
+   *
+   * Unlike `resume()`, this does NOT require the session to be in a paused state,
+   * making it suitable for external resume flows (e.g. React widget submissions)
+   * where the session object may have been re-created.
+   *
+   * @param callId    - The tool call ID to resume
+   * @param result    - The result to send back to the agent
+   * @param callbacks - Event handlers for the resumed stream
+   * @param options   - Optional settings like headers or body
+   * @returns This session (for chaining)
+   */
+  async resumeWithCallId(callId, result, callbacks, options) {
+    const body = {
+      ...options?.body || {},
+      stream: true,
+      toolCallResult: { callId, result }
+    };
+    const clientToolDefs = this._getClientToolDefs();
+    if (clientToolDefs.length > 0) {
+      body.clientTools = clientToolDefs;
+    }
+    this._paused = false;
+    this._pausedToolInfo = null;
+    await this._run(body, callbacks, options);
+    return this;
+  }
+  /**
+   * Check if this session is waiting for a tool result.
+   */
+  isPaused() {
+    return this._paused;
+  }
+  /**
+   * Get information about the paused tool call.
+   * Returns `null` if the session is not paused.
+   */
+  getPausedTool() {
+    return this._pausedToolInfo;
+  }
+  /**
+   * Get the session ID.
+   * May be `undefined` if the session hasn't executed yet.
+   */
+  getSessionId() {
+    if (!this._sessionId) {
+      throw new Error(
+        "AgentSession.getSessionId(): session ID not yet available. Call execute() first."
+      );
+    }
+    return this._sessionId;
+  }
+  /**
+   * Cancel the current streaming operation.
+   */
+  abort() {
+    this._abortController?.abort();
+    this._abortController = null;
+  }
+  // ─── Private helpers ───────────────────────────────────────────────
+  /** @internal */
+  async _run(body, callbacks, options) {
+    this._abortController = new AbortController();
+    const baseHeaders = this._agent._buildHeaders(this._sessionId);
+    const mergedHeaders = { ...baseHeaders, ...options?.headers || {} };
+    await executeStream({
+      url: this._agent._url,
+      body,
+      headers: mergedHeaders,
+      callbacks,
+      clientTools: this._agent._clientTools,
+      signal: this._abortController.signal,
+      onSessionId: (id, name) => {
+        this._sessionId = id;
+        options?.onSessionId?.(id, name);
+      },
+      onPaused: (info) => {
+        this._paused = true;
+        this._pausedToolInfo = info;
+      },
+      onAutoResume: async (callId, result) => {
+        const resumeBody = {
+          ...options?.body || {},
+          stream: true,
+          toolCallResult: { callId, result }
+        };
+        const clientToolDefs = this._getClientToolDefs();
+        if (clientToolDefs.length > 0) {
+          resumeBody.clientTools = clientToolDefs;
+        }
+        await this._run(resumeBody, callbacks, options);
+      }
+    });
+  }
+  /** @internal */
+  _getClientToolDefs() {
+    const defs = [];
+    for (const tool of this._agent._clientTools.values()) {
+      defs.push({
+        name: tool.name,
+        description: tool.description,
+        parameters: resolveParameters2(tool.parameters),
+        await: tool.await
+      });
+    }
+    return defs;
+  }
+};
+function resolveParameters2(params) {
+  let schema;
+  if (params && typeof params === "object" && "_def" in params) {
+    schema = toJSONSchema2(params);
+    delete schema.$schema;
+  } else {
+    schema = { ...params };
+  }
+  if (schema.type === "object") {
+    schema.additionalProperties = false;
+    if (schema.properties) {
+      schema.required = Object.keys(schema.properties);
+    }
+  }
+  return schema;
+}
+
+// src/core/agent.ts
+var DEFAULT_BASE_URL = "https://api.buildship.run";
+var BuildShipAgent = class {
+  /** @internal */
+  _agentId;
+  /** @internal */
+  _accessKey;
+  /** @internal */
+  _baseUrl;
+  /** @internal */
+  _clientTools = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (!config.agentId) {
+      throw new Error("BuildShipAgent: agentId is required");
+    }
+    this._agentId = config.agentId;
+    this._accessKey = config.accessKey;
+    this._baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+  }
+  /**
+   * The URL for the agent's execute endpoint.
+   * @internal
+   */
+  get _url() {
+    return `${this._baseUrl}/executeAgent/${this._agentId}`;
+  }
+  /**
+   * Build the authorization / common headers.
+   * @internal
+   */
+  _buildHeaders(sessionId) {
+    const headers = {};
+    if (this._accessKey) {
+      headers["Authorization"] = `Bearer ${this._accessKey}`;
+    }
+    if (sessionId) {
+      headers["X-BuildShip-Agent-Session-ID"] = sessionId;
+    }
+    return headers;
+  }
+  // ─── Public API ────────────────────────────────────────────────────
+  /**
+   * Start a new conversation.
+   *
+   * Creates a fresh session and sends the first message.
+   *
+   * @param message  - The message to send
+   * @param callbacks - Event handlers for the stream
+   * @param options   - Optional execution settings (context, headers, body, onSessionId)
+   * @returns The new session
+   */
+  async execute(message, callbacks, options) {
+    const session = new AgentSession(this);
+    await session.execute(message, callbacks, options);
+    return session;
+  }
+  /**
+   * Get an existing session by ID to continue a conversation.
+   *
+   * @param sessionId - The session ID from a previous conversation
+   * @returns The session object
+   */
+  session(sessionId) {
+    if (!sessionId) {
+      throw new Error("BuildShipAgent.session(): sessionId is required");
+    }
+    return new AgentSession(this, sessionId);
+  }
+  /**
+   * Register a client-side tool that the agent can call.
+   */
+  registerClientTool(tool) {
+    if (!tool.name) {
+      throw new Error("registerClientTool: tool.name is required");
+    }
+    this._clientTools.set(tool.name, tool);
+  }
+  /**
+   * Remove a registered client tool.
+   */
+  unregisterClientTool(name) {
+    this._clientTools.delete(name);
+  }
+};
+
 // src/react/utils/use-synced-local-storage.ts
 import { useState as useState2, useEffect as useEffect2, useCallback as useCallback4 } from "react";
 function parseJSON(value, defaultValue) {
@@ -1057,16 +1308,21 @@ function AgentContextProvider({ children }) {
     AGENT_DEBUG_DATA_KEY,
     {}
   );
-  const initializeAgent = useCallback5((agentId, agentUrl, accessKey) => {
-    const existing = activeAgentsRef.current.get(agentId);
-    if (!existing) {
-      activeAgentsRef.current.set(agentId, { agentUrl, accessKey });
-      forceUpdate({});
-    } else if (existing.agentUrl !== agentUrl || existing.accessKey !== accessKey) {
-      activeAgentsRef.current.set(agentId, { agentUrl, accessKey });
-      forceUpdate({});
-    }
-  }, []);
+  const initializeAgent = useCallback5(
+    (agentId, agentUrl, accessKey, options) => {
+      const existing = activeAgentsRef.current.get(agentId);
+      if (!existing) {
+        activeAgentsRef.current.set(agentId, { agentUrl, accessKey, options });
+        forceUpdate({});
+      } else if (existing.agentUrl !== agentUrl || existing.accessKey !== accessKey) {
+        activeAgentsRef.current.set(agentId, { agentUrl, accessKey, options });
+        forceUpdate({});
+      } else if (options) {
+        existing.options = options;
+      }
+    },
+    []
+  );
   const registerRunner = useCallback5((agentId, runner) => {
     runnersRef.current.set(agentId, runner);
     const listeners = listenersRef.current.get(agentId);
@@ -1135,41 +1391,53 @@ function AgentContextProvider({ children }) {
   );
   return /* @__PURE__ */ jsx(AgentContext.Provider, { value: agentContextValue, children: /* @__PURE__ */ jsxs(AgentToolContext.Provider, { value: toolContextValue, children: [
     children,
-    Array.from(activeAgentsRef.current.entries()).map(([agentId, { agentUrl, accessKey }]) => /* @__PURE__ */ jsx(
-      AgentRunnerInstance,
-      {
-        agentId,
-        agentUrl,
-        accessKey
-      },
-      agentId
-    ))
+    Array.from(activeAgentsRef.current.entries()).map(
+      ([agentId, { agentUrl, accessKey, options }]) => /* @__PURE__ */ jsx(
+        AgentRunnerInstance,
+        {
+          agentId,
+          agentUrl,
+          accessKey,
+          options
+        },
+        agentId
+      )
+    )
   ] }) });
 }
 function AgentRunnerInstance({
   agentId,
   agentUrl,
-  accessKey
+  accessKey,
+  options
 }) {
-  const agent = useAgent(agentId, agentUrl, accessKey);
+  const agent = useMemo3(
+    () => new BuildShipAgent({ agentId, baseUrl: agentUrl, accessKey }),
+    [agentId, agentUrl, accessKey]
+  );
+  const optionsRef = useRef3(options);
+  optionsRef.current = options;
+  const agentRunner = useAgent(agent, optionsRef.current);
   const context = useContext3(AgentContext);
   useEffect3(() => {
     if (context) {
-      context.registerRunner(agentId, agent);
+      context.registerRunner(agentId, agentRunner);
     }
-  }, [agentId, agent, context]);
+  }, [agentId, agentRunner, context]);
   if (!context) return null;
   return null;
 }
-function useAgentContext(agentId, agentUrl, accessKey) {
+function useAgentContext(agentId, agentUrl, accessKey, options) {
   const context = useContext3(AgentContext);
   if (!context) {
     throw new Error("useAgentContext must be used within AgentContextProvider");
   }
   const { initializeAgent, getRunner, listenersRef } = context;
+  const optionsRef = useRef3(options);
+  optionsRef.current = options;
   useEffect3(() => {
-    initializeAgent(agentId, agentUrl, accessKey);
-  }, [agentId, agentUrl, initializeAgent]);
+    initializeAgent(agentId, agentUrl, accessKey, optionsRef.current);
+  }, [agentId, agentUrl, accessKey, initializeAgent]);
   const [runner, setRunner] = useState3(() => getRunner(agentId));
   useEffect3(() => {
     const currentRunner = getRunner(agentId);