bs-agent 0.0.9 → 0.0.12

package/dist/react/index.js

@@ -0,0 +1,1286 @@
+// src/react/agent-context.tsx
+import {
+  createContext,
+  useContext as useContext3,
+  useCallback as useCallback5,
+  useRef as useRef3,
+  useState as useState3,
+  useEffect as useEffect3,
+  useMemo as useMemo3
+} from "react";
+
+// src/react/use-agent.ts
+import { useCallback as useCallback3, useRef as useRef2, useState, useEffect, useContext as useContext2, useMemo as useMemo2 } from "react";
+
+// src/react/constants.ts
+var AGENT_SESSIONS_KEY = "buildship:agent:conversations";
+var AGENT_DEBUG_DATA_KEY = "buildship:agent:debug";
+var DEFAULT_SESSION_NAME = "New Chat";
+var TEMPORARY_SESSION_ID = "sess_temp";
+
+// src/react/session-utils.ts
+import { useCallback, useMemo, useRef } from "react";
+var useSessionUtils = (agentId, allSessions, setAllSessions, currentSessionId, setCurrentSessionId, messagesRef) => {
+  const agentSessions = useMemo(() => allSessions[agentId] || {}, [agentId, allSessions]);
+  const syncSessionRef = useRef();
+  syncSessionRef.current = (updatedMessages) => {
+    if (!currentSessionId || currentSessionId === TEMPORARY_SESSION_ID) {
+      return;
+    }
+    setAllSessions((prev) => ({
+      ...prev,
+      [agentId]: {
+        ...prev[agentId],
+        [currentSessionId]: {
+          ...prev[agentId]?.[currentSessionId],
+          messages: updatedMessages ?? messagesRef.current,
+          updatedAt: Date.now()
+        }
+      }
+    }));
+  };
+  const getInitialSessionId = () => {
+    const sessions = Object.values(agentSessions);
+    if (sessions.length > 0) {
+      return sessions.sort((a, b) => b.updatedAt - a.updatedAt)[0].id;
+    }
+    return TEMPORARY_SESSION_ID;
+  };
+  const switchSession = useCallback(
+    (sessionId = TEMPORARY_SESSION_ID) => {
+      setCurrentSessionId(sessionId);
+    },
+    [setCurrentSessionId]
+  );
+  const deleteSession = useCallback(
+    (sessionId) => {
+      if (!sessionId || sessionId === TEMPORARY_SESSION_ID) {
+        return;
+      }
+      setAllSessions((prev) => {
+        const updatedAgentSessions = { ...prev[agentId] };
+        delete updatedAgentSessions[sessionId];
+        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]
+  );
+  const sessionsList = useMemo(
+    () => Object.values(agentSessions).sort((a, b) => b.updatedAt - a.updatedAt),
+    [agentSessions]
+  );
+  const createSessionFromResponse = (sessionId, sessionName, currentMessages) => {
+    setAllSessions((prev) => ({
+      ...prev,
+      [agentId]: {
+        ...prev[agentId],
+        [sessionId]: {
+          id: sessionId,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          messages: currentMessages,
+          name: sessionName
+        }
+      }
+    }));
+  };
+  return {
+    agentSessions,
+    syncSessionRef,
+    getInitialSessionId,
+    switchSession,
+    deleteSession,
+    sessionsList,
+    createSessionFromResponse
+  };
+};
+
+// src/react/debug-handlers.ts
+var createDebugHandlers = (setDebugData) => {
+  const handleStreamEvent = (event) => {
+    const executionId = event.meta.executionId;
+    switch (event.type) {
+      case "tool_call_start": {
+        const { callId, toolName, toolType, inputs, serverName } = event.data;
+        setDebugData((prev) => ({
+          ...prev,
+          [executionId]: [
+            ...prev[executionId] || [],
+            {
+              itemType: "tool_call",
+              toolName,
+              callId,
+              toolType,
+              status: "progress",
+              inputs,
+              serverName
+            }
+          ]
+        }));
+        break;
+      }
+      case "tool_call_end": {
+        const { callId, result, error } = event.data;
+        setDebugData((prev) => {
+          const currentData = [...prev[executionId] || []];
+          for (let i = currentData.length - 1; i >= 0; i--) {
+            if (currentData[i].itemType === "tool_call") {
+              const toolItem = currentData[i];
+              if (toolItem.callId === callId) {
+                currentData[i] = {
+                  ...toolItem,
+                  status: error ? "error" : "complete",
+                  output: result,
+                  error
+                };
+                break;
+              }
+            }
+          }
+          return {
+            ...prev,
+            [executionId]: currentData
+          };
+        });
+        break;
+      }
+      case "reasoning_delta": {
+        const { delta, index } = event.data;
+        setDebugData((prev) => {
+          const currentData = [...prev[executionId] || []];
+          let existingItemIndex = -1;
+          for (let i = currentData.length - 1; i >= 0; i--) {
+            const item = currentData[i];
+            if (item.itemType === "reasoning" && item.index === index) {
+              existingItemIndex = i;
+              break;
+            }
+          }
+          if (existingItemIndex === -1) {
+            currentData.push({ itemType: "reasoning", reasoning: delta, index });
+          } else {
+            currentData[existingItemIndex] = {
+              itemType: "reasoning",
+              reasoning: currentData[existingItemIndex].reasoning + delta,
+              index
+            };
+          }
+          return {
+            ...prev,
+            [executionId]: currentData
+          };
+        });
+        break;
+      }
+      case "agent_handoff": {
+        setDebugData((prev) => ({
+          ...prev,
+          [executionId]: [
+            ...prev[executionId] || [],
+            {
+              itemType: "handoff",
+              agentName: event.data.agentName
+            }
+          ]
+        }));
+        break;
+      }
+      case "run_error": {
+        setDebugData((prev) => ({
+          ...prev,
+          [executionId]: [
+            ...prev[executionId] || [],
+            {
+              itemType: "run_error",
+              message: event.data.message,
+              code: event.data.code
+            }
+          ]
+        }));
+        break;
+      }
+    }
+  };
+  return {
+    handleStreamEvent
+  };
+};
+
+// src/react/client-tools.ts
+import { useCallback as useCallback2 } from "react";
+import { toJSONSchema } from "zod";
+
+// src/react/utils/schema.ts
+function cleanSchema(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(cleanSchema);
+  } else if (obj !== null && typeof obj === "object") {
+    const newObj = {};
+    const currentObj = obj;
+    for (const key in currentObj) {
+      if (key === "propertyNames" || key === "$schema") {
+        continue;
+      }
+      newObj[key] = cleanSchema(currentObj[key]);
+    }
+    if (newObj.type === "object") {
+      if (newObj.additionalProperties === void 0 || newObj.additionalProperties && typeof newObj.additionalProperties === "object" && Object.keys(newObj.additionalProperties).length === 0) {
+        newObj.additionalProperties = false;
+      }
+      if (newObj.additionalProperties === false && newObj.properties) {
+        newObj.required = Object.keys(newObj.properties);
+      }
+    }
+    return newObj;
+  }
+  return obj;
+}
+function tryParseJSON(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+
+// src/react/client-tools.ts
+function resolveParameters(params) {
+  let schema;
+  if (params && typeof params === "object" && "_def" in params) {
+    schema = toJSONSchema(params);
+    delete schema.$schema;
+  } else {
+    schema = cleanSchema(params);
+  }
+  if (schema.type === "object") {
+    schema.additionalProperties = false;
+    if (schema.properties) {
+      schema.required = Object.keys(schema.properties);
+    }
+  }
+  return schema;
+}
+function useClientToolHelpers(agentId, toolContext) {
+  const getClientToolsMap = useCallback2(() => {
+    if (!toolContext) return /* @__PURE__ */ new Map();
+    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
+        });
+      }
+    }
+    return map;
+  }, [agentId, toolContext]);
+  const getClientToolDefs = useCallback2(() => {
+    if (!toolContext) return [];
+    const tools = toolContext.getToolsForAgent(agentId);
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: resolveParameters(tool.parameters),
+      await: tool.await
+    }));
+  }, [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];
+  const canMerge = last?.type === "text" && newPart.type === "text" && newPart.firstSequence === last.lastSequence + 1;
+  if (canMerge) {
+    return [
+      ...parts.slice(0, -1),
+      {
+        ...last,
+        text: last.text + newPart.text,
+        lastSequence: newPart.lastSequence
+      }
+    ];
+  }
+  return [...parts, newPart];
+}
+
+// src/react/stream-callbacks.ts
+function buildStreamCallbacks(deps, debugKey) {
+  const { setMessages, setInProgress, syncSessionRef, messagesRef, toolContext, agentId } = deps;
+  return {
+    onComplete: () => {
+      console.log("Agent closed");
+      setInProgress(false);
+      if (syncSessionRef.current) {
+        syncSessionRef.current(messagesRef.current);
+      }
+    },
+    onError: (error) => {
+      console.log("Agent error", error);
+      setInProgress(false);
+      if (syncSessionRef.current) {
+        syncSessionRef.current(messagesRef.current);
+      }
+    },
+    onEvent: (event) => {
+      if (event.type === "text_delta") {
+        handleTextDelta(event, setMessages, syncSessionRef);
+      } else if (event.type === "tool_call_start" && event.data.toolType === "client") {
+        handleClientToolCall(event, setMessages, syncSessionRef, toolContext, agentId);
+        if (debugKey) {
+          const debugMeta = { ...event.meta, executionId: debugKey };
+          deps.debugHandlers.handleStreamEvent({
+            ...event,
+            meta: debugMeta
+          });
+          if (!event.data.paused) {
+            deps.debugHandlers.handleStreamEvent({
+              type: "tool_call_end",
+              data: {
+                callId: event.data.callId,
+                toolName: event.data.toolName,
+                toolType: event.data.toolType
+              },
+              meta: debugMeta
+            });
+          }
+        }
+      } else if (debugKey) {
+        deps.debugHandlers.handleStreamEvent({
+          ...event,
+          meta: { ...event.meta, executionId: 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) {
+  const sequence = event.meta.sequence;
+  const text = event.data;
+  const eventExecutionId = event.meta.executionId;
+  setMessages((prev) => {
+    const lastMessage = prev[prev.length - 1];
+    const newPart = {
+      type: "text",
+      text,
+      firstSequence: sequence,
+      lastSequence: sequence
+    };
+    let updatedMessages;
+    if (lastMessage?.role === "agent") {
+      const updatedMessage = {
+        ...lastMessage,
+        content: lastMessage.content + text,
+        parts: updateAgentMessageParts(lastMessage.parts || [], newPart)
+      };
+      updatedMessages = [...prev.slice(0, -1), updatedMessage];
+    } else {
+      const updatedMessage = {
+        role: "agent",
+        content: text,
+        parts: [newPart],
+        executionId: eventExecutionId
+      };
+      updatedMessages = [...prev, updatedMessage];
+    }
+    if (syncSessionRef.current) {
+      syncSessionRef.current(updatedMessages);
+    }
+    return updatedMessages;
+  });
+}
+function handleClientToolCall(event, setMessages, syncSessionRef, toolContext, agentId) {
+  const tool = toolContext?.getTool(agentId, event.data.toolName);
+  if (!tool?.render) return;
+  setMessages((prev) => {
+    const lastMessage = prev[prev.length - 1];
+    const newPart = {
+      type: "widget",
+      toolName: event.data.toolName,
+      callId: event.data.callId,
+      inputs: tryParseJSON(event.data.inputs),
+      sequence: event.meta.sequence,
+      paused: event.data.paused,
+      status: "pending"
+    };
+    let updatedMessages;
+    if (lastMessage?.role === "agent") {
+      const updatedMessage = {
+        ...lastMessage,
+        parts: updateAgentMessageParts(lastMessage.parts || [], newPart)
+      };
+      updatedMessages = [...prev.slice(0, -1), updatedMessage];
+    } else {
+      const updatedMessage = {
+        role: "agent",
+        content: "",
+        parts: [newPart],
+        executionId: event.meta.executionId
+      };
+      updatedMessages = [...prev, updatedMessage];
+    }
+    if (syncSessionRef.current) {
+      syncSessionRef.current(updatedMessages);
+    }
+    return updatedMessages;
+  });
+}
+
+// src/react/use-agent.ts
+function useAgent(agentId, agentUrl, accessKey) {
+  const { allSessions, setAllSessions, debugData, setDebugData } = useAgentGlobalState();
+  const toolContext = useContext2(AgentToolContext);
+  const [inProgress, setInProgress] = useState(false);
+  const [messages, setMessages] = useState([]);
+  const messagesRef = useRef2([]);
+  const [currentSessionId, setCurrentSessionId] = useState(TEMPORARY_SESSION_ID);
+  const sessionUtils = useSessionUtils(
+    agentId,
+    allSessions,
+    setAllSessions,
+    currentSessionId,
+    setCurrentSessionId,
+    messagesRef
+  );
+  useEffect(() => {
+    const initialSessionId = sessionUtils.getInitialSessionId();
+    setCurrentSessionId(initialSessionId);
+  }, []);
+  const debugHandlers = useMemo2(() => createDebugHandlers(setDebugData), [setDebugData]);
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  useEffect(() => {
+    if (inProgress) return;
+    const session = sessionUtils.agentSessions[currentSessionId];
+    if (session) {
+      setMessages(session.messages);
+    } else {
+      setMessages([]);
+    }
+  }, [currentSessionId, agentId]);
+  useEffect(() => {
+    return () => {
+      if (messagesRef.current.length > 0 && sessionUtils.syncSessionRef.current) {
+        sessionUtils.syncSessionRef.current();
+      }
+    };
+  }, []);
+  const controller = useRef2();
+  const lastRequestContextRef = useRef2({});
+  const { getClientToolsMap, getClientToolDefs } = useClientToolHelpers(agentId, toolContext);
+  const runAgentRef = useRef2();
+  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
+      };
+      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
+      };
+      const callbacks = buildStreamCallbacks(deps, debugKey);
+      try {
+        await executeAgentStream(deps, body, headers, callbacks, debugKey);
+      } catch (error) {
+        console.log("Agent execution failed", error);
+        setInProgress(false);
+        if (sessionUtils.syncSessionRef.current) {
+          sessionUtils.syncSessionRef.current(messagesRef.current);
+        }
+        throw error;
+      }
+    },
+    [
+      agentUrl,
+      accessKey,
+      currentSessionId,
+      sessionUtils.syncSessionRef,
+      sessionUtils.createSessionFromResponse,
+      debugHandlers,
+      getClientToolsMap,
+      getClientToolDefs,
+      agentId,
+      toolContext
+    ]
+  );
+  useEffect(() => {
+    runAgentRef.current = runAgent;
+  }, [runAgent]);
+  const handleSend = useCallback3(
+    async (input, options) => {
+      const userMessage = {
+        role: "user",
+        content: input,
+        executionId: Date.now().toString()
+      };
+      if (!options?.skipUserMessage) {
+        setMessages((prev) => {
+          const updatedMessages = [...prev, userMessage];
+          if (sessionUtils.syncSessionRef.current) {
+            sessionUtils.syncSessionRef.current(updatedMessages);
+          }
+          return updatedMessages;
+        });
+      }
+      const effectiveExecutionId = options?.skipUserMessage ? messagesRef.current.findLast((m) => m.role === "user")?.executionId ?? userMessage.executionId : userMessage.executionId;
+      try {
+        await runAgent(input, {
+          ...options,
+          optimisticExecutionId: effectiveExecutionId
+        });
+      } catch (error) {
+        if (!options?.skipUserMessage) {
+          setMessages((prev) => {
+            const updatedMessages = prev.some((m) => m === userMessage) ? prev : [...prev, userMessage];
+            if (sessionUtils.syncSessionRef.current) {
+              sessionUtils.syncSessionRef.current(updatedMessages);
+            }
+            return updatedMessages;
+          });
+        }
+        throw error;
+      }
+    },
+    [runAgent, sessionUtils.syncSessionRef]
+  );
+  const resumeTool = useCallback3(
+    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 (sessionUtils.syncSessionRef.current) {
+          sessionUtils.syncSessionRef.current(updatedMessages);
+        }
+        return updatedMessages;
+      });
+      const debugKey = messagesRef.current.findLast((m) => m.role === "user")?.executionId;
+      if (debugKey) {
+        debugHandlers.handleStreamEvent({
+          type: "tool_call_end",
+          data: { callId, toolName: "", toolType: "client", result },
+          meta: { executionId: debugKey, sequence: 0 }
+        });
+      }
+      await runAgent(void 0, {
+        resumeToolCallId: callId,
+        resumeToolResult: result
+      });
+    },
+    [runAgent, sessionUtils.syncSessionRef, debugHandlers]
+  );
+  const addOptimisticMessage = useCallback3(
+    (input) => {
+      const userMessage = {
+        role: "user",
+        content: input,
+        executionId: Date.now().toString()
+      };
+      setMessages((prev) => {
+        const updatedMessages = [...prev, userMessage];
+        if (sessionUtils.syncSessionRef.current) {
+          sessionUtils.syncSessionRef.current(updatedMessages);
+        }
+        return updatedMessages;
+      });
+    },
+    [sessionUtils.syncSessionRef]
+  );
+  const abort = useCallback3(() => {
+    if (controller.current) {
+      controller.current.abort();
+    }
+    setInProgress(false);
+    if (sessionUtils.syncSessionRef.current) {
+      sessionUtils.syncSessionRef.current(messagesRef.current);
+    }
+  }, [sessionUtils.syncSessionRef]);
+  return {
+    inProgress,
+    messages,
+    handleSend,
+    resumeTool,
+    addOptimisticMessage,
+    abort,
+    sessionId: currentSessionId,
+    switchSession: sessionUtils.switchSession,
+    deleteSession: sessionUtils.deleteSession,
+    sessions: sessionUtils.sessionsList,
+    debugData
+  };
+}
+
+// src/react/utils/use-synced-local-storage.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback4 } from "react";
+function parseJSON(value, defaultValue) {
+  if (value === null) return defaultValue;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return defaultValue;
+  }
+}
+function useSyncedLocalStorage(key, initialValue) {
+  const [storedValue, setStoredValue] = useState2(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return parseJSON(item, initialValue);
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+  const setValue = useCallback4(
+    (value) => {
+      try {
+        setStoredValue((prev) => {
+          const valueToStore = value instanceof Function ? value(prev) : value;
+          if (typeof window !== "undefined") {
+            window.localStorage.setItem(key, JSON.stringify(valueToStore));
+            window.dispatchEvent(
+              new StorageEvent("storage", { key, newValue: JSON.stringify(valueToStore) })
+            );
+          }
+          return valueToStore;
+        });
+      } catch (error) {
+        console.warn(`Error setting localStorage key "${key}":`, error);
+      }
+    },
+    [key]
+  );
+  useEffect2(() => {
+    const handleStorageChange = (event) => {
+      if (event.key === key) {
+        setStoredValue(parseJSON(event.newValue, initialValue));
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [key, initialValue]);
+  return [storedValue, setValue];
+}
+
+// src/react/agent-context.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var AgentToolContext = createContext(null);
+var AgentContext = createContext(null);
+function AgentContextProvider({ children }) {
+  const activeAgentsRef = useRef3(/* @__PURE__ */ new Map());
+  const runnersRef = useRef3(/* @__PURE__ */ new Map());
+  const listenersRef = useRef3(/* @__PURE__ */ new Map());
+  const toolRegistryRef = useRef3(/* @__PURE__ */ new Map());
+  const [, forceUpdate] = useState3({});
+  const [allSessions, setAllSessions] = useSyncedLocalStorage(AGENT_SESSIONS_KEY, {});
+  const [debugData, setDebugData] = useSyncedLocalStorage(
+    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 registerRunner = useCallback5((agentId, runner) => {
+    runnersRef.current.set(agentId, runner);
+    const listeners = listenersRef.current.get(agentId);
+    if (listeners) {
+      listeners.forEach((callback) => callback());
+    }
+  }, []);
+  const getRunner = useCallback5((agentId) => {
+    return runnersRef.current.get(agentId) || null;
+  }, []);
+  const registerTool = useCallback5((agentId, config) => {
+    if (!toolRegistryRef.current.has(agentId)) {
+      toolRegistryRef.current.set(agentId, /* @__PURE__ */ new Map());
+    }
+    toolRegistryRef.current.get(agentId).set(config.name, config);
+  }, []);
+  const unregisterTool = useCallback5((agentId, toolName) => {
+    toolRegistryRef.current.get(agentId)?.delete(toolName);
+  }, []);
+  const getTool = useCallback5((agentId, toolName) => {
+    return toolRegistryRef.current.get(agentId)?.get(toolName);
+  }, []);
+  const getToolsForAgent = useCallback5((agentId) => {
+    const toolMap = toolRegistryRef.current.get(agentId);
+    return toolMap ? Array.from(toolMap.values()) : [];
+  }, []);
+  const resumeToolFromContext = useCallback5((agentId, callId, result) => {
+    const runner = runnersRef.current.get(agentId);
+    if (runner) {
+      runner.resumeTool(callId, result);
+    } else {
+      console.warn(`Cannot resume tool: no runner found for agent "${agentId}"`);
+    }
+  }, []);
+  const agentContextValue = useMemo3(
+    () => ({
+      initializeAgent,
+      registerRunner,
+      getRunner,
+      allSessions,
+      setAllSessions,
+      debugData,
+      setDebugData,
+      runnersRef,
+      listenersRef
+    }),
+    [
+      initializeAgent,
+      registerRunner,
+      getRunner,
+      allSessions,
+      setAllSessions,
+      debugData,
+      setDebugData
+    ]
+  );
+  const toolContextValue = useMemo3(
+    () => ({
+      registerTool,
+      unregisterTool,
+      getTool,
+      getToolsForAgent,
+      resumeTool: resumeToolFromContext
+    }),
+    [registerTool, unregisterTool, getTool, getToolsForAgent, resumeToolFromContext]
+  );
+  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
+    ))
+  ] }) });
+}
+function AgentRunnerInstance({
+  agentId,
+  agentUrl,
+  accessKey
+}) {
+  const agent = useAgent(agentId, agentUrl, accessKey);
+  const context = useContext3(AgentContext);
+  useEffect3(() => {
+    if (context) {
+      context.registerRunner(agentId, agent);
+    }
+  }, [agentId, agent, context]);
+  if (!context) return null;
+  return null;
+}
+function useAgentContext(agentId, agentUrl, accessKey) {
+  const context = useContext3(AgentContext);
+  if (!context) {
+    throw new Error("useAgentContext must be used within AgentContextProvider");
+  }
+  const { initializeAgent, getRunner, listenersRef } = context;
+  useEffect3(() => {
+    initializeAgent(agentId, agentUrl, accessKey);
+  }, [agentId, agentUrl, initializeAgent]);
+  const [runner, setRunner] = useState3(() => getRunner(agentId));
+  useEffect3(() => {
+    const currentRunner = getRunner(agentId);
+    if (currentRunner !== runner) {
+      setRunner(currentRunner);
+    }
+    const callback = () => {
+      setRunner(getRunner(agentId));
+    };
+    if (!listenersRef.current.has(agentId)) {
+      listenersRef.current.set(agentId, /* @__PURE__ */ new Set());
+    }
+    listenersRef.current.get(agentId)?.add(callback);
+    return () => {
+      listenersRef.current.get(agentId)?.delete(callback);
+    };
+  }, [agentId, getRunner]);
+  const placeholder = useMemo3(
+    () => ({
+      messages: [],
+      inProgress: false,
+      sessionId: "",
+      sessions: [],
+      debugData: {},
+      handleSend: async () => {
+      },
+      resumeTool: async () => {
+      },
+      switchSession: () => {
+      },
+      deleteSession: () => {
+      },
+      addOptimisticMessage: () => {
+      },
+      abort: () => {
+      }
+    }),
+    []
+  );
+  return runner || placeholder;
+}
+function useAgentGlobalState() {
+  const context = useContext3(AgentContext);
+  if (!context) {
+    throw new Error("useAgentGlobalState must be used within AgentContextProvider");
+  }
+  return {
+    allSessions: context.allSessions,
+    setAllSessions: context.setAllSessions,
+    debugData: context.debugData,
+    setDebugData: context.setDebugData
+  };
+}
+
+// src/react/use-client-tool.ts
+import { useContext as useContext4, useEffect as useEffect4, useState as useState4, useCallback as useCallback6 } from "react";
+function useClientTool(agentId, config) {
+  const context = useContext4(AgentToolContext);
+  if (!context) {
+    throw new Error("useClientTool must be used within <AgentContextProvider>");
+  }
+  useEffect4(() => {
+    context.registerTool(agentId, config);
+    return () => {
+      context.unregisterTool(agentId, config.name);
+    };
+  }, [agentId, config.name, config.handler, config.render, config.parameters]);
+}
+function ToolRenderer({ agentId, part }) {
+  const context = useContext4(AgentToolContext);
+  const [localStatus, setLocalStatus] = useState4(part.status || "pending");
+  useEffect4(() => {
+    setLocalStatus(part.status || "pending");
+  }, [part.status]);
+  if (!context) {
+    throw new Error("ToolRenderer must be used within <AgentContextProvider>");
+  }
+  const tool = context.getTool(agentId, part.toolName);
+  const handleSubmit = useCallback6(
+    (result) => {
+      if (localStatus === "submitted") return;
+      setLocalStatus("submitted");
+      context.resumeTool(agentId, part.callId, result);
+    },
+    [agentId, part.callId, localStatus, context]
+  );
+  if (!tool?.render) {
+    return null;
+  }
+  return tool.render({
+    inputs: part.inputs,
+    submit: part.paused ? handleSubmit : () => {
+    },
+    status: localStatus,
+    result: part.result
+  });
+}
+export {
+  AGENT_DEBUG_DATA_KEY,
+  AGENT_SESSIONS_KEY,
+  AgentContextProvider,
+  AgentToolContext,
+  DEFAULT_SESSION_NAME,
+  TEMPORARY_SESSION_ID,
+  ToolRenderer,
+  cleanSchema,
+  tryParseJSON,
+  updateAgentMessageParts,
+  useAgent,
+  useAgentContext,
+  useAgentGlobalState,
+  useClientTool
+};
+//# sourceMappingURL=index.js.map