bs-agent 0.0.28 → 0.0.30

package/dist/react/index.js

@@ -10,11 +10,10 @@ import {
 } from "react";
 
 // src/react/use-agent.ts
-import { useCallback as useCallback3, useRef as useRef2, useState, useEffect, useContext as useContext2, useMemo as useMemo2 } from "react";
+import { useCallback as useCallback3, useRef as useRef2, useState, useEffect, useContext as useContext2 } 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";
 
@@ -120,122 +119,6 @@ var useSessionUtils = (agentId, allSessions, setAllSessions, currentSessionId, s
   };
 };
 
-// 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 {
-            const hasInterleavedItems = currentData.slice(existingItemIndex + 1).some((item) => item.itemType !== "reasoning");
-            if (hasInterleavedItems) {
-              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";
@@ -340,7 +223,7 @@ function updateAgentMessageParts(parts, newPart) {
 }
 
 // src/react/stream-callbacks.ts
-function buildStreamCallbacks(deps, debugKey) {
+function buildStreamCallbacks(deps) {
   const {
     setMessages,
     setInProgress,
@@ -355,16 +238,10 @@ function buildStreamCallbacks(deps, debugKey) {
     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") {
@@ -378,33 +255,36 @@ function buildStreamCallbacks(deps, debugKey) {
         );
       } 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 }
-        });
+      } else if (event.type === "tool_call_start") {
+        handleToolCallStart(event, setMessages, syncSessionRef);
+      } else if (event.type === "tool_call_end") {
+        handleToolCallEnd(event, setMessages, syncSessionRef);
+      } else if (event.type === "reasoning_delta") {
+        handleReasoningDelta(event, setMessages, syncSessionRef);
+      } else if (event.type === "agent_handoff") {
+        handleAgentHandoff(event, setMessages, syncSessionRef);
+      } else if (event.type === "run_error") {
+        handleRunError(event, setMessages, syncSessionRef);
       }
     }
   };
 }
+function ensureAgentMessage(prev, executionId) {
+  const last = prev[prev.length - 1];
+  if (last?.role === "agent") {
+    return [prev, last];
+  }
+  const newMsg = {
+    role: "agent",
+    content: "",
+    parts: [],
+    executionId
+  };
+  return [[...prev, newMsg], newMsg];
+}
+function replaceLastAgent(prev, updated) {
+  return [...prev.slice(0, -1), updated];
+}
 function handleTextDelta(event, setMessages, syncSessionRef, modifier, fullTextModifier, agentId) {
   const sequence = event.meta.sequence;
   const originalText = event.data;
@@ -525,11 +405,138 @@ function handleClientToolCall(event, setMessages, syncSessionRef, toolContext, a
     return updatedMessages;
   });
 }
+function handleToolCallStart(event, setMessages, syncSessionRef) {
+  const { callId, toolName, toolType, inputs, serverName } = event.data;
+  setMessages((prev) => {
+    const [msgs, agentMsg] = ensureAgentMessage(prev, event.meta.executionId);
+    const newPart = {
+      type: "tool_call",
+      toolName,
+      callId,
+      toolType,
+      status: "progress",
+      inputs,
+      serverName,
+      sequence: event.meta.sequence
+    };
+    const updated = {
+      ...agentMsg,
+      parts: [...agentMsg.parts || [], newPart]
+    };
+    const updatedMessages = replaceLastAgent(msgs, updated);
+    if (syncSessionRef.current) syncSessionRef.current(updatedMessages);
+    return updatedMessages;
+  });
+}
+function handleToolCallEnd(event, setMessages, syncSessionRef) {
+  const { callId, result, error } = event.data;
+  setMessages((prev) => {
+    const last = prev[prev.length - 1];
+    if (last?.role !== "agent" || !last.parts) return prev;
+    const updatedParts = [...last.parts];
+    for (let i = updatedParts.length - 1; i >= 0; i--) {
+      const part = updatedParts[i];
+      if (part.type === "tool_call" && part.callId === callId) {
+        updatedParts[i] = {
+          ...part,
+          status: error ? "error" : "complete",
+          output: result,
+          error
+        };
+        break;
+      }
+    }
+    for (let i = updatedParts.length - 1; i >= 0; i--) {
+      const part = updatedParts[i];
+      if (part.type === "widget" && part.callId === callId) {
+        updatedParts[i] = {
+          ...part,
+          status: error ? "error" : "submitted",
+          ...result !== void 0 ? { result } : {},
+          ...error ? { error } : {}
+        };
+        break;
+      }
+    }
+    const updated = { ...last, parts: updatedParts };
+    const updatedMessages = replaceLastAgent(prev, updated);
+    if (syncSessionRef.current) syncSessionRef.current(updatedMessages);
+    return updatedMessages;
+  });
+}
+function handleReasoningDelta(event, setMessages, syncSessionRef) {
+  const { delta, index } = event.data;
+  setMessages((prev) => {
+    const [msgs, agentMsg] = ensureAgentMessage(prev, event.meta.executionId);
+    const parts = [...agentMsg.parts || []];
+    let existingIdx = -1;
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const p = parts[i];
+      if (p.type === "reasoning" && p.index === index) {
+        existingIdx = i;
+        break;
+      }
+    }
+    if (existingIdx === -1) {
+      parts.push({ type: "reasoning", reasoning: delta, index, sequence: event.meta.sequence });
+    } else {
+      const hasInterleavedItems = parts.slice(existingIdx + 1).some((p) => p.type !== "reasoning");
+      if (hasInterleavedItems) {
+        parts.push({ type: "reasoning", reasoning: delta, index, sequence: event.meta.sequence });
+      } else {
+        const existing = parts[existingIdx];
+        parts[existingIdx] = {
+          ...existing,
+          reasoning: existing.reasoning + delta
+        };
+      }
+    }
+    const updated = { ...agentMsg, parts };
+    const updatedMessages = replaceLastAgent(msgs, updated);
+    if (syncSessionRef.current) syncSessionRef.current(updatedMessages);
+    return updatedMessages;
+  });
+}
+function handleAgentHandoff(event, setMessages, syncSessionRef) {
+  setMessages((prev) => {
+    const [msgs, agentMsg] = ensureAgentMessage(prev, event.meta.executionId);
+    const newPart = {
+      type: "handoff",
+      agentName: event.data.agentName,
+      sequence: event.meta.sequence
+    };
+    const updated = {
+      ...agentMsg,
+      parts: [...agentMsg.parts || [], newPart]
+    };
+    const updatedMessages = replaceLastAgent(msgs, updated);
+    if (syncSessionRef.current) syncSessionRef.current(updatedMessages);
+    return updatedMessages;
+  });
+}
+function handleRunError(event, setMessages, syncSessionRef) {
+  setMessages((prev) => {
+    const [msgs, agentMsg] = ensureAgentMessage(prev, event.meta.executionId);
+    const newPart = {
+      type: "run_error",
+      message: event.data.message,
+      code: event.data.code,
+      sequence: event.meta.sequence
+    };
+    const updated = {
+      ...agentMsg,
+      parts: [...agentMsg.parts || [], newPart]
+    };
+    const updatedMessages = replaceLastAgent(msgs, updated);
+    if (syncSessionRef.current) syncSessionRef.current(updatedMessages);
+    return updatedMessages;
+  });
+}
 
 // src/react/use-agent.ts
 function useAgent(agent, options) {
   const agentId = agent._agentId;
-  const { allSessions, setAllSessions, debugData, setDebugData } = useAgentGlobalState();
+  const { allSessions, setAllSessions } = useAgentGlobalState();
   const toolContext = useContext2(AgentToolContext);
   const [inProgress, setInProgress] = useState(false);
   const [messages, setMessages] = useState([]);
@@ -547,7 +554,6 @@ function useAgent(agent, options) {
     const initialSessionId = sessionUtils.getInitialSessionId();
     setCurrentSessionId(initialSessionId);
   }, [agentId]);
-  const debugHandlers = useMemo2(() => createDebugHandlers(setDebugData), [setDebugData]);
   useEffect(() => {
     messagesRef.current = messages;
   }, [messages]);
@@ -580,7 +586,6 @@ function useAgent(agent, options) {
     async (input, runOptions) => {
       const isNewSession = !currentSessionId || currentSessionId === TEMPORARY_SESSION_ID;
       setInProgress(true);
-      const debugKey = runOptions?.optimisticExecutionId || messagesRef.current.findLast((m) => m.role === "user")?.executionId;
       const deps = {
         agentId,
         currentSessionId,
@@ -588,12 +593,11 @@ function useAgent(agent, options) {
         setMessages,
         setInProgress,
         syncSessionRef: sessionUtils.syncSessionRef,
-        debugHandlers,
         toolContext,
         textDeltaModifier: optionsRef.current?.textDeltaModifier,
         fullTextModifier: optionsRef.current?.fullTextModifier
       };
-      const callbacks = buildStreamCallbacks(deps, debugKey);
+      const callbacks = buildStreamCallbacks(deps);
       const executeOptions = {
         context: runOptions?.context,
         headers: runOptions?.additionalHeaders,
@@ -655,7 +659,7 @@ function useAgent(agent, options) {
         activeSessionRef.current = null;
       }
     },
-    [currentSessionId, sessionUtils, debugHandlers, agentId, toolContext, agent, getClientToolsMap]
+    [currentSessionId, sessionUtils, agentId, toolContext, agent, getClientToolsMap]
   );
   const handleSend = useCallback3(
     async (input, options2) => {
@@ -754,14 +758,6 @@ function useAgent(agent, options) {
         return updatedMessages;
       });
       const lastUserMessage = messagesRef.current.findLast((m) => m.role === "user");
-      const debugKey = lastUserMessage?.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,
@@ -770,7 +766,7 @@ function useAgent(agent, options) {
         context: lastUserMessage?.context ?? lastRunOptionsRef.current.context
       });
     },
-    [runAgent, sessionUtils.syncSessionRef, debugHandlers]
+    [runAgent, sessionUtils.syncSessionRef]
   );
   const addOptimisticMessage = useCallback3(
     (input) => {
@@ -826,8 +822,7 @@ function useAgent(agent, options) {
     sessionId: currentSessionId,
     switchSession: sessionUtils.switchSession,
     deleteSession: sessionUtils.deleteSession,
-    sessions: sessionUtils.sessionsList,
-    debugData
+    sessions: sessionUtils.sessionsList
   };
 }
 
@@ -1037,7 +1032,17 @@ function handleEvent(event, _fullText, callbacks, clientTools, onPaused, onAutoR
                   meta: event.meta
                 });
                 return { callId, result };
-              } catch (error) {
+              } catch (handlerError) {
+                callbacks.onEvent?.({
+                  type: "tool_call_end",
+                  data: {
+                    callId,
+                    toolName,
+                    toolType: "client",
+                    error: handlerError instanceof Error ? handlerError.message : String(handlerError)
+                  },
+                  meta: event.meta
+                });
                 callbacks.onPaused?.(toolName, inputs);
                 onPaused?.({ callId, toolName, args: inputs });
                 return null;
@@ -1435,10 +1440,6 @@ function AgentContextProvider({ children }) {
   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, options) => {
       const existing = activeAgentsRef.current.get(agentId);
@@ -1495,8 +1496,6 @@ function AgentContextProvider({ children }) {
       getRunner,
       allSessions,
       setAllSessions,
-      debugData,
-      setDebugData,
       runnersRef,
       listenersRef
     }),
@@ -1505,9 +1504,7 @@ function AgentContextProvider({ children }) {
       registerRunner,
       getRunner,
       allSessions,
-      setAllSessions,
-      debugData,
-      setDebugData
+      setAllSessions
     ]
   );
   const toolContextValue = useMemo3(
@@ -1592,7 +1589,6 @@ function useAgentContext(agentId, agentUrl, accessKey, options) {
       inProgress: false,
       sessionId: "",
       sessions: [],
-      debugData: {},
       handleSend: async () => {
       },
       resumeTool: async () => {
@@ -1617,9 +1613,7 @@ function useAgentGlobalState() {
   }
   return {
     allSessions: context.allSessions,
-    setAllSessions: context.setAllSessions,
-    debugData: context.debugData,
-    setDebugData: context.setDebugData
+    setAllSessions: context.setAllSessions
   };
 }
 
@@ -1663,11 +1657,11 @@ function ToolRenderer({ agentId, part }) {
     submit: part.paused ? handleSubmit : () => {
     },
     status: localStatus,
-    result: part.result
+    result: part.result,
+    error: part.error
   });
 }
 export {
-  AGENT_DEBUG_DATA_KEY,
   AGENT_SESSIONS_KEY,
   AgentContextProvider,
   AgentToolContext,