bs-agent 0.0.9 → 0.0.12

package/dist/index.js

@@ -1,886 +0,0 @@
-// 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 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 = 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") {
-                setMessages((prev) => {
-                  const lastMessage = prev[prev.length - 1];
-                  const newPart = {
-                    type: "widget",
-                    toolName: parsed.data.toolName,
-                    callId: parsed.data.callId,
-                    inputs: tryParseJSON(parsed.data.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);
-            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 handleSend = useCallback2(
-    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;
-        });
-      }
-      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 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,
-    abort,
-    sessionId: currentSessionId,
-    switchSession: sessionUtils.switchSession,
-    deleteSession: sessionUtils.deleteSession,
-    sessions: sessionUtils.sessionsList,
-    debugData
-  };
-}
-
-// 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: {},
-      handleSend: 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