buildship-agent 1.0.0

package/dist/index.js

@@ -0,0 +1,1116 @@
+// src/agent-context.tsx
+import {
+  createContext,
+  useContext,
+  useCallback as useCallback4,
+  useRef as useRef3,
+  useState as useState3,
+  useEffect as useEffect3,
+  useMemo as useMemo2
+} from "react";
+
+// src/use-agent.ts
+import { useCallback as useCallback2, useRef as useRef2, useState, useEffect } from "react";
+import { fetchEventSource } from "@microsoft/fetch-event-source";
+
+// src/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/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/debug-handlers.ts
+var createDebugHandlers = (setDebugData) => {
+  const handleDebugToolExecutionStarted = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    setDebugData((prev) => ({
+      ...prev,
+      [executionId]: [
+        ...prev[executionId] || [],
+        {
+          itemType: "tool_call",
+          toolId: parsed.data.toolId || "unknown",
+          toolCallId: parsed.data.toolCallId,
+          status: "progress"
+        }
+      ]
+    }));
+  };
+  const handleDebugToolExecutionInputs = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    const toolCallId = parsed.data.toolCallId;
+    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.toolCallId === toolCallId) {
+            currentData[i] = {
+              ...toolItem,
+              inputs: parsed.data.value
+            };
+            break;
+          }
+        }
+      }
+      return {
+        ...prev,
+        [executionId]: currentData
+      };
+    });
+  };
+  const handleDebugToolExecutionFinished = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    const toolCallId = parsed.data.toolCallId;
+    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.toolCallId === toolCallId) {
+            currentData[i] = {
+              ...toolItem,
+              status: "complete",
+              output: parsed.data.value
+            };
+            break;
+          }
+        }
+      }
+      return {
+        ...prev,
+        [executionId]: currentData
+      };
+    });
+  };
+  const handleDebugToolExecutionError = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    const toolCallId = parsed.data.toolCallId;
+    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.toolCallId === toolCallId) {
+            currentData[i] = {
+              ...toolItem,
+              status: "error",
+              output: parsed.data.value
+            };
+            break;
+          }
+        }
+      }
+      return {
+        ...prev,
+        [executionId]: currentData
+      };
+    });
+  };
+  const handleDebugToolLog = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    const toolCallId = parsed.data.toolCallId;
+    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.toolCallId === toolCallId) {
+            const currentLogs = toolItem.logs || [];
+            currentData[i] = {
+              ...toolItem,
+              logs: [...currentLogs, parsed.data.value[0]]
+            };
+            break;
+          }
+        }
+      }
+      return {
+        ...prev,
+        [executionId]: currentData
+      };
+    });
+  };
+  let lastReasoningIndex = -1;
+  const handleDebugReasoningStep = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    const { delta, index } = parsed.data;
+    setDebugData((prev) => {
+      const currentData = [...prev[executionId] || []];
+      if (lastReasoningIndex < index) {
+        currentData.push({ itemType: "reasoning", reasoning: "" });
+        lastReasoningIndex = index;
+      }
+      for (let i = currentData.length - 1; i >= 0; i--) {
+        if (currentData[i].itemType === "reasoning") {
+          currentData[i] = {
+            itemType: "reasoning",
+            reasoning: currentData[i].reasoning + delta
+          };
+          break;
+        }
+      }
+      return {
+        ...prev,
+        [executionId]: currentData
+      };
+    });
+  };
+  const handleAgentHandoff = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    setDebugData((prev) => ({
+      ...prev,
+      [executionId]: [
+        ...prev[executionId] || [],
+        {
+          itemType: "handoff",
+          agentName: parsed.data.agentName
+        }
+      ]
+    }));
+  };
+  const handleMCPToolCallStart = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    setDebugData((prev) => ({
+      ...prev,
+      [executionId]: [
+        ...prev[executionId] || [],
+        {
+          itemType: "mcp_tool_call",
+          toolName: parsed.data.toolName,
+          serverName: parsed.data.serverName,
+          callId: parsed.data.callId,
+          status: "progress",
+          inputs: parsed.data.inputs
+        }
+      ]
+    }));
+  };
+  const handleMCPToolCallEnd = (parsed) => {
+    const executionId = parsed.meta.executionId;
+    const callId = parsed.data.callId;
+    setDebugData((prev) => {
+      const currentData = [...prev[executionId] || []];
+      for (let i = currentData.length - 1; i >= 0; i--) {
+        if (currentData[i].itemType === "mcp_tool_call") {
+          const mcpToolItem = currentData[i];
+          if (mcpToolItem.callId === callId) {
+            currentData[i] = {
+              ...mcpToolItem,
+              status: parsed.data.error ? "error" : "complete",
+              output: parsed.data.result,
+              error: parsed.data.error
+            };
+            break;
+          }
+        }
+      }
+      return {
+        ...prev,
+        [executionId]: currentData
+      };
+    });
+  };
+  const handleDebugEvent = (parsed) => {
+    switch (parsed.type) {
+      case "debug_tool_execution_started":
+        handleDebugToolExecutionStarted(parsed);
+        break;
+      case "debug_tool_execution_inputs":
+        handleDebugToolExecutionInputs(parsed);
+        break;
+      case "debug_tool_execution_finished":
+        handleDebugToolExecutionFinished(parsed);
+        break;
+      case "debug_tool_execution_error":
+        handleDebugToolExecutionError(parsed);
+        break;
+      case "debug_tool_log":
+        handleDebugToolLog(parsed);
+        break;
+      case "llm_reasoning_delta":
+        handleDebugReasoningStep(parsed);
+        break;
+      case "agent_handoff":
+        handleAgentHandoff(parsed);
+        break;
+      case "mcp_tool_call_start":
+        handleMCPToolCallStart(parsed);
+        break;
+      case "mcp_tool_call_end":
+        handleMCPToolCallEnd(parsed);
+        break;
+    }
+  };
+  return {
+    handleDebugEvent
+  };
+};
+
+// src/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/utils/message.ts
+function updateAgentMessageParts(parts, newPart) {
+  const sorted = [...parts, newPart].sort((a, b) => {
+    const aStart = a.type === "text" ? a.firstSequence : a.sequence;
+    const bStart = b.type === "text" ? b.firstSequence : b.sequence;
+    return aStart - bStart;
+  });
+  return sorted.reduce((acc, current) => {
+    const last = acc[acc.length - 1];
+    const canMerge = last?.type === "text" && current.type === "text" && current.firstSequence === last.lastSequence + 1;
+    if (canMerge) {
+      acc[acc.length - 1] = {
+        ...last,
+        text: last.text + current.text,
+        lastSequence: current.lastSequence
+      };
+      return acc;
+    }
+    acc.push(current);
+    return acc;
+  }, []);
+}
+
+// src/use-agent.ts
+function useAgent(agentId, agentUrl, accessKey) {
+  const { allSessions, setAllSessions, debugData, setDebugData } = useAgentGlobalState();
+  const [inProgress, setInProgress] = useState(false);
+  const [messages, setMessages] = useState([]);
+  const [pendingToolCalls, setPendingToolCalls] = useState(/* @__PURE__ */ new Map());
+  const [isPaused, setIsPaused] = useState(false);
+  const messagesRef = useRef2([]);
+  const clientToolsRef = 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 = createDebugHandlers(setDebugData);
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  useEffect(() => {
+    if (inProgress) {
+      return;
+    }
+    const session = sessionUtils.agentSessions[currentSessionId];
+    if (session) {
+      setMessages(session.messages);
+    } else {
+      setMessages([]);
+    }
+  }, [currentSessionId, sessionUtils.agentSessions, agentId, inProgress]);
+  useEffect(() => {
+    return () => {
+      if (messagesRef.current.length > 0 && sessionUtils.syncSessionRef.current) {
+        sessionUtils.syncSessionRef.current();
+      }
+    };
+  }, []);
+  const controller = useRef2();
+  const runAgent = useCallback2(
+    async (input, options) => {
+      setInProgress(true);
+      if (controller.current) {
+        controller.current.abort();
+      }
+      controller.current = new AbortController();
+      const headers = {
+        "Content-Type": "application/json",
+        ...options?.additionalHeaders || {},
+        ...accessKey ? { Authorization: `Bearer ${accessKey}` } : {}
+      };
+      if (currentSessionId) {
+        headers["x-buildship-agent-session-id"] = currentSessionId;
+      }
+      const body = {
+        stream: true,
+        input,
+        context: options?.context || {},
+        testBuildId: options?.testBuildId,
+        tools: options?.tools?.map((t) => ({
+          ...t,
+          parameters: cleanSchema(t.parameters)
+        })),
+        clientTools: options?.clientTools?.map((t) => ({
+          ...t,
+          parameters: cleanSchema(t.parameters)
+        }))
+      };
+      try {
+        await fetchEventSource(agentUrl, {
+          method: "POST",
+          headers,
+          signal: controller.current.signal,
+          openWhenHidden: true,
+          body: JSON.stringify(body),
+          onopen: async (resp) => {
+            if (resp.status >= 400) {
+              console.log(`AI onopen error with status: ${resp.status}`);
+              if (resp.status === 404) {
+                throw new Error(`Not Found (${resp.statusText})`);
+              }
+              throw new Error(`Error status ${resp.status}`);
+            }
+            if (!currentSessionId || currentSessionId === TEMPORARY_SESSION_ID) {
+              const sessionId = resp.headers.get("x-buildship-agent-session-id");
+              if (sessionId) {
+                const currentMessages = messagesRef.current;
+                const sessionName = resp.headers.get("x-buildship-agent-session-name") || DEFAULT_SESSION_NAME;
+                sessionUtils.createSessionFromResponse(sessionId, sessionName, currentMessages);
+                setCurrentSessionId(sessionId);
+              }
+            }
+            const executionId = resp.headers.get("x-buildship-agent-execution-id");
+            if (executionId) {
+              setMessages((prev) => {
+                const lastMessage = prev[prev.length - 1];
+                if (lastMessage?.role === "user") {
+                  const updatedMessage = {
+                    ...lastMessage,
+                    executionId
+                  };
+                  const updatedMessages = [...prev.slice(0, -1), updatedMessage];
+                  if (sessionUtils.syncSessionRef.current) {
+                    sessionUtils.syncSessionRef.current(updatedMessages);
+                  }
+                  return updatedMessages;
+                }
+                return prev;
+              });
+            }
+          },
+          onmessage: (event) => {
+            try {
+              const parsed = JSON.parse(event.data);
+              if (parsed.type === "llm_text_delta") {
+                setMessages((prev) => {
+                  const lastMessage = prev[prev.length - 1];
+                  const sequence = parsed.meta.sequence;
+                  const newPart = {
+                    type: "text",
+                    text: parsed.data,
+                    firstSequence: sequence,
+                    lastSequence: sequence
+                  };
+                  let updatedMessages;
+                  if (lastMessage?.role === "agent") {
+                    const updatedMessage = {
+                      ...lastMessage,
+                      content: lastMessage.content + parsed.data,
+                      // content is still useful for simple displays
+                      parts: updateAgentMessageParts(lastMessage.parts || [], newPart)
+                    };
+                    updatedMessages = [...prev.slice(0, -1), updatedMessage];
+                  } else {
+                    const updatedMessage = {
+                      role: "agent",
+                      content: parsed.data,
+                      parts: [newPart],
+                      executionId: parsed.meta.executionId
+                    };
+                    updatedMessages = [...prev, updatedMessage];
+                  }
+                  if (sessionUtils.syncSessionRef.current) {
+                    sessionUtils.syncSessionRef.current(updatedMessages);
+                  }
+                  return updatedMessages;
+                });
+              } else if (parsed.type === "client_tool_call") {
+                const { toolName, callId, inputs } = parsed.data;
+                const toolDefinition = clientToolsRef.current.find((t) => t.name === toolName);
+                const requiresResult = toolDefinition?.requiresResult ?? false;
+                if (requiresResult) {
+                  setPendingToolCalls((prev) => {
+                    const updated = new Map(prev);
+                    updated.set(callId, {
+                      toolName,
+                      callId,
+                      inputs: tryParseJSON(inputs),
+                      requiresResult
+                    });
+                    return updated;
+                  });
+                }
+                setMessages((prev) => {
+                  const lastMessage = prev[prev.length - 1];
+                  const newPart = {
+                    type: "widget",
+                    toolName,
+                    callId,
+                    inputs: tryParseJSON(inputs),
+                    sequence: parsed.meta.sequence
+                  };
+                  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: parsed.meta.executionId
+                    };
+                    updatedMessages = [...prev, updatedMessage];
+                  }
+                  if (sessionUtils.syncSessionRef.current) {
+                    sessionUtils.syncSessionRef.current(updatedMessages);
+                  }
+                  return updatedMessages;
+                });
+              } else if (parsed.type.startsWith("debug_") || parsed.type === "llm_reasoning_delta" || parsed.type === "agent_handoff" || parsed.type === "mcp_tool_call_start" || parsed.type === "mcp_tool_call_end") {
+                debugHandlers.handleDebugEvent(parsed);
+              }
+            } catch (e) {
+              console.log("Failed to parse agent message", e);
+            }
+          },
+          onclose: () => {
+            console.log("Agent closed");
+            setInProgress(false);
+            setPendingToolCalls((currentPending) => {
+              if (currentPending.size > 0) {
+                setIsPaused(true);
+              }
+              return currentPending;
+            });
+            if (sessionUtils.syncSessionRef.current) {
+              sessionUtils.syncSessionRef.current();
+            }
+          },
+          onerror: (e) => {
+            console.log("Agent error", e);
+            setInProgress(false);
+            if (sessionUtils.syncSessionRef.current) {
+              sessionUtils.syncSessionRef.current(messagesRef.current);
+            }
+            throw new Error("Failed to execute agent");
+          }
+        });
+      } 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, debugHandlers]
+  );
+  const resumeAgent = useCallback2(
+    async (toolResults, options) => {
+      if (!currentSessionId || currentSessionId === TEMPORARY_SESSION_ID) {
+        throw new Error("Cannot resume: no active session");
+      }
+      setInProgress(true);
+      setIsPaused(false);
+      if (controller.current) {
+        controller.current.abort();
+      }
+      controller.current = new AbortController();
+      const headers = {
+        "Content-Type": "application/json",
+        ...options?.additionalHeaders || {},
+        ...accessKey ? { Authorization: `Bearer ${accessKey}` } : {}
+      };
+      const baseUrl = agentUrl.replace(/\/executeAgent\/.*$/, "");
+      const resumeUrl = `${baseUrl}/resumeAgent/${currentSessionId}`;
+      const body = {
+        stream: true,
+        input: options?.input || "",
+        context: options?.context || {},
+        clientToolResults: toolResults
+      };
+      try {
+        await fetchEventSource(resumeUrl, {
+          method: "POST",
+          headers,
+          signal: controller.current.signal,
+          openWhenHidden: true,
+          body: JSON.stringify(body),
+          onopen: async (resp) => {
+            if (resp.status >= 400) {
+              console.log(`AI onopen error with status: ${resp.status}`);
+              if (resp.status === 404) {
+                throw new Error(`Session not found (${resp.statusText})`);
+              }
+              throw new Error(`Error status ${resp.status}`);
+            }
+            const executionId = resp.headers.get("x-buildship-agent-execution-id");
+            if (executionId && options?.input) {
+              setMessages((prev) => {
+                const userMessage = {
+                  role: "user",
+                  content: options.input || "",
+                  executionId
+                };
+                const updatedMessages = [...prev, userMessage];
+                if (sessionUtils.syncSessionRef.current) {
+                  sessionUtils.syncSessionRef.current(updatedMessages);
+                }
+                return updatedMessages;
+              });
+            }
+          },
+          onmessage: (event) => {
+            try {
+              const parsed = JSON.parse(event.data);
+              if (parsed.type === "llm_text_delta") {
+                setMessages((prev) => {
+                  const lastMessage = prev[prev.length - 1];
+                  const sequence = parsed.meta.sequence;
+                  const newPart = {
+                    type: "text",
+                    text: parsed.data,
+                    firstSequence: sequence,
+                    lastSequence: sequence
+                  };
+                  let updatedMessages;
+                  if (lastMessage?.role === "agent") {
+                    const updatedMessage = {
+                      ...lastMessage,
+                      content: lastMessage.content + parsed.data,
+                      parts: updateAgentMessageParts(lastMessage.parts || [], newPart)
+                    };
+                    updatedMessages = [...prev.slice(0, -1), updatedMessage];
+                  } else {
+                    const updatedMessage = {
+                      role: "agent",
+                      content: parsed.data,
+                      parts: [newPart],
+                      executionId: parsed.meta.executionId
+                    };
+                    updatedMessages = [...prev, updatedMessage];
+                  }
+                  if (sessionUtils.syncSessionRef.current) {
+                    sessionUtils.syncSessionRef.current(updatedMessages);
+                  }
+                  return updatedMessages;
+                });
+              } else if (parsed.type === "client_tool_call") {
+                const { toolName, callId, inputs } = parsed.data;
+                const toolDefinition = clientToolsRef.current.find((t) => t.name === toolName);
+                const requiresResult = toolDefinition?.requiresResult ?? false;
+                if (requiresResult) {
+                  setPendingToolCalls((prev) => {
+                    const updated = new Map(prev);
+                    updated.set(callId, {
+                      toolName,
+                      callId,
+                      inputs: tryParseJSON(inputs),
+                      requiresResult
+                    });
+                    return updated;
+                  });
+                }
+                setMessages((prev) => {
+                  const lastMessage = prev[prev.length - 1];
+                  const newPart = {
+                    type: "widget",
+                    toolName,
+                    callId,
+                    inputs: tryParseJSON(inputs),
+                    sequence: parsed.meta.sequence
+                  };
+                  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: parsed.meta.executionId
+                    };
+                    updatedMessages = [...prev, updatedMessage];
+                  }
+                  if (sessionUtils.syncSessionRef.current) {
+                    sessionUtils.syncSessionRef.current(updatedMessages);
+                  }
+                  return updatedMessages;
+                });
+              } else if (parsed.type.startsWith("debug_") || parsed.type === "llm_reasoning_delta" || parsed.type === "agent_handoff" || parsed.type === "mcp_tool_call_start" || parsed.type === "mcp_tool_call_end") {
+                debugHandlers.handleDebugEvent(parsed);
+              }
+            } catch (e) {
+              console.log("Failed to parse agent message", e);
+            }
+          },
+          onclose: () => {
+            console.log("Agent resume closed");
+            setInProgress(false);
+            setPendingToolCalls((currentPending) => {
+              if (currentPending.size > 0) {
+                setIsPaused(true);
+              }
+              return currentPending;
+            });
+            if (sessionUtils.syncSessionRef.current) {
+              sessionUtils.syncSessionRef.current();
+            }
+          },
+          onerror: (e) => {
+            console.log("Agent resume error", e);
+            setInProgress(false);
+            if (sessionUtils.syncSessionRef.current) {
+              sessionUtils.syncSessionRef.current(messagesRef.current);
+            }
+            throw new Error("Failed to resume agent");
+          }
+        });
+      } catch (error) {
+        console.log("Agent resume execution failed", error);
+        setInProgress(false);
+        if (sessionUtils.syncSessionRef.current) {
+          sessionUtils.syncSessionRef.current(messagesRef.current);
+        }
+        throw error;
+      }
+    },
+    [agentUrl, accessKey, currentSessionId, sessionUtils, debugHandlers]
+  );
+  const handleSend = useCallback2(
+    async (input, options) => {
+      if (options?.clientTools) {
+        clientToolsRef.current = options.clientTools;
+      }
+      setPendingToolCalls(/* @__PURE__ */ new Map());
+      setIsPaused(false);
+      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;
+        });
+      }
+      try {
+        await runAgent(input, options);
+      } 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 addOptimisticMessage = useCallback2(
+    (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 submitToolResults = useCallback2(
+    async (toolResults, options) => {
+      setPendingToolCalls((prev) => {
+        const updated = new Map(prev);
+        toolResults.forEach((result) => {
+          updated.delete(result.callId);
+        });
+        return updated;
+      });
+      try {
+        await resumeAgent(toolResults, options);
+      } catch (error) {
+        console.error("Failed to submit tool results:", error);
+        throw error;
+      }
+    },
+    [resumeAgent]
+  );
+  const abort = useCallback2(() => {
+    if (controller.current) {
+      controller.current.abort();
+    }
+    setInProgress(false);
+    if (sessionUtils.syncSessionRef.current) {
+      sessionUtils.syncSessionRef.current(messagesRef.current);
+    }
+  }, [sessionUtils.syncSessionRef]);
+  return {
+    inProgress,
+    messages,
+    handleSend,
+    addOptimisticMessage,
+    submitToolResults,
+    abort,
+    sessionId: currentSessionId,
+    switchSession: sessionUtils.switchSession,
+    deleteSession: sessionUtils.deleteSession,
+    sessions: sessionUtils.sessionsList,
+    debugData,
+    pendingToolCalls: Array.from(pendingToolCalls.values()),
+    isPaused
+  };
+}
+
+// src/utils/use-synced-local-storage.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback3 } 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 = useCallback3(
+    (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/agent-context.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+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 [, forceUpdate] = useState3({});
+  const [allSessions, setAllSessions] = useSyncedLocalStorage(AGENT_SESSIONS_KEY, {});
+  const [debugData, setDebugData] = useSyncedLocalStorage(
+    AGENT_DEBUG_DATA_KEY,
+    {}
+  );
+  const initializeAgent = useCallback4((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 = useCallback4((agentId, runner) => {
+    runnersRef.current.set(agentId, runner);
+    const listeners = listenersRef.current.get(agentId);
+    if (listeners) {
+      listeners.forEach((callback) => callback());
+    }
+  }, []);
+  const getRunner = useCallback4((agentId) => {
+    return runnersRef.current.get(agentId) || null;
+  }, []);
+  const contextValue = useMemo2(
+    () => ({
+      initializeAgent,
+      registerRunner,
+      getRunner,
+      allSessions,
+      setAllSessions,
+      debugData,
+      setDebugData,
+      runnersRef,
+      listenersRef
+    }),
+    [
+      initializeAgent,
+      registerRunner,
+      getRunner,
+      allSessions,
+      setAllSessions,
+      debugData,
+      setDebugData
+    ]
+  );
+  return /* @__PURE__ */ jsxs(AgentContext.Provider, { value: contextValue, 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 = useContext(AgentContext);
+  if (!context) return null;
+  useEffect3(() => {
+    context.registerRunner(agentId, agent);
+  }, [agentId, agent, context]);
+  return null;
+}
+function useAgentContext(agentId, agentUrl, accessKey) {
+  const context = useContext(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 = useMemo2(
+    () => ({
+      messages: [],
+      inProgress: false,
+      sessionId: "",
+      sessions: [],
+      debugData: {},
+      pendingToolCalls: [],
+      isPaused: false,
+      handleSend: async () => {
+      },
+      submitToolResults: async () => {
+      },
+      switchSession: () => {
+      },
+      deleteSession: () => {
+      },
+      addOptimisticMessage: () => {
+      },
+      abort: () => {
+      }
+    }),
+    []
+  );
+  return runner || placeholder;
+}
+function useAgentGlobalState() {
+  const context = useContext(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
+  };
+}
+export {
+  AGENT_DEBUG_DATA_KEY,
+  AGENT_SESSIONS_KEY,
+  AgentContextProvider,
+  DEFAULT_SESSION_NAME,
+  TEMPORARY_SESSION_ID,
+  cleanSchema,
+  tryParseJSON,
+  updateAgentMessageParts,
+  useAgent,
+  useAgentContext,
+  useAgentGlobalState
+};
+//# sourceMappingURL=index.js.map