@meetsmore-oss/use-ai-client 1.8.0 → 1.9.1

package/dist/index.js

@@ -1,8 +1,3 @@
-import {
-  generateChatId,
-  generateMessageId
-} from "./chunk-STF3H6F5.js";
-
 // src/useAI.ts
 import { useState as useState14, useEffect as useEffect12, useLayoutEffect, useRef as useRef14, useCallback as useCallback13, useMemo as useMemo6 } from "react";
 
@@ -273,13 +268,23 @@ function UseAIFloatingButton({
 // src/components/UseAIChatPanel.tsx
 import { useState as useState5, useRef as useRef4, useEffect as useEffect4 } from "react";
 
+// src/utils/messageContent.ts
+function getTextFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+
 // src/components/MarkdownContent.tsx
 import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function MarkdownContent({ content }) {
   return /* @__PURE__ */ jsx2(
     ReactMarkdown,
     {
+      remarkPlugins: [remarkGfm],
       components: {
         // Override default element rendering for better chat styling
         p: ({ children }) => /* @__PURE__ */ jsx2("p", { style: { margin: "0 0 0.5em 0" }, children }),
@@ -394,6 +399,23 @@ function MarkdownContent({ content }) {
             },
             children
           }
+        ),
+        // Render images as links to prevent automatic HTTP requests.
+        // <img> tags fire GET requests on render, which could be exploited
+        // via prompt injection to exfiltrate sensitive data through URLs.
+        img: ({ src, alt }) => /* @__PURE__ */ jsx2(
+          "a",
+          {
+            href: src,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            style: {
+              color: "inherit",
+              textDecoration: "underline",
+              textUnderlineOffset: "2px"
+            },
+            children: alt || "Image"
+          }
         )
       },
       children: content
@@ -1638,7 +1660,8 @@ function ToolApprovalDialog({
   const [showDetails, setShowDetails] = useState4(false);
   const displayName = annotations?.title || toolCallName;
   const isBatch = toolCount > 1;
-  const message = isBatch ? strings.toolApproval.batchMessage?.replace("{count}", String(toolCount)) ?? `${toolCount} actions are waiting for your approval` : strings.toolApproval.message.replace("{toolName}", displayName);
+  const runtimeMessage = pendingTools.find((t) => t.message)?.message;
+  const message = runtimeMessage ? runtimeMessage : isBatch ? strings.toolApproval.batchMessage?.replace("{count}", String(toolCount)) ?? `${toolCount} actions are waiting for your approval` : strings.toolApproval.message.replace("{toolName}", displayName);
   const getToolDisplayName = (tool) => tool.annotations?.title || tool.toolCallName;
   return /* @__PURE__ */ jsxs7(
     "div",
@@ -1890,12 +1913,6 @@ function FeedbackButton({ type, isSelected, onClick, selectedColor, unselectedCo
     }
   );
 }
-function getTextContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-}
 function hasFileContent(content) {
   return Array.isArray(content) && content.some((part) => part.type === "file");
 }
@@ -1932,6 +1949,11 @@ function UseAIChatPanel({
 }) {
   const strings = useStrings();
   const theme = useTheme();
+  const displayMessages = messages.filter((m) => {
+    if (m.role === "tool") return false;
+    if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0 && !getTextFromContent(m.content)) return false;
+    return true;
+  });
   const [input, setInput] = useState5("");
   const chatHistoryDropdown = useDropdownState();
   const agentDropdown = useDropdownState();
@@ -2097,10 +2119,10 @@ function UseAIChatPanel({
                       flex: 1,
                       minWidth: 0
                     }, children: (() => {
-                      if (messages.length > 0) {
-                        const firstUserMsg = messages.find((m) => m.role === "user");
+                      if (displayMessages.length > 0) {
+                        const firstUserMsg = displayMessages.find((m) => m.role === "user");
                         if (firstUserMsg) {
-                          const textContent = getTextContent(firstUserMsg.content);
+                          const textContent = getTextFromContent(firstUserMsg.content);
                           const maxLength = 30;
                           return textContent.length > maxLength ? textContent.substring(0, maxLength) + "..." : textContent || strings.header.newChat;
                         }
@@ -2259,7 +2281,7 @@ function UseAIChatPanel({
                     children: /* @__PURE__ */ jsx11("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", children: /* @__PURE__ */ jsx11("path", { d: "M8 3.5V12.5M3.5 8H12.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round" }) })
                   }
                 ),
-                onDeleteChat && messages.length > 0 && /* @__PURE__ */ jsx11(
+                onDeleteChat && displayMessages.length > 0 && /* @__PURE__ */ jsx11(
                   "button",
                   {
                     "data-testid": "delete-chat-button",
@@ -2385,7 +2407,7 @@ function UseAIChatPanel({
               gap: "12px"
             },
             children: [
-              messages.length === 0 && /* @__PURE__ */ jsxs8(
+              displayMessages.length === 0 && /* @__PURE__ */ jsxs8(
                 "div",
                 {
                   style: {
@@ -2455,7 +2477,7 @@ function UseAIChatPanel({
                   ]
                 }
               ),
-              messages.map((message) => /* @__PURE__ */ jsxs8(
+              displayMessages.map((message) => /* @__PURE__ */ jsxs8(
                 "div",
                 {
                   "data-testid": `chat-message-${message.role}`,
@@ -2482,7 +2504,7 @@ function UseAIChatPanel({
                               "data-testid": "save-command-button",
                               onClick: (e) => {
                                 e.stopPropagation();
-                                const messageText = getTextContent(message.content);
+                                const messageText = getTextFromContent(message.content);
                                 slashCommands.startSavingCommand(message.id, messageText);
                               },
                               title: "Save as slash command",
@@ -2542,13 +2564,13 @@ function UseAIChatPanel({
                                   },
                                   idx
                                 )) }),
-                                message.role === "assistant" ? /* @__PURE__ */ jsx11(MarkdownContent, { content: getTextContent(message.content) }) : getTextContent(message.content)
+                                message.role === "assistant" ? /* @__PURE__ */ jsx11(MarkdownContent, { content: getTextFromContent(message.content) }) : getTextFromContent(message.content)
                               ]
                             }
                           ),
                           slashCommands.renderInlineSaveUI({
                             messageId: message.id,
-                            messageText: getTextContent(message.content)
+                            messageText: getTextFromContent(message.content)
                           })
                         ]
                       }
@@ -2602,7 +2624,7 @@ function UseAIChatPanel({
                           marginTop: "4px",
                           padding: "0 4px"
                         },
-                        children: message.timestamp.toLocaleTimeString([], {
+                        children: message.createdAt.toLocaleTimeString([], {
                           hour: "2-digit",
                           minute: "2-digit"
                         })
@@ -3082,6 +3104,8 @@ var UseAIClient = class {
   // Assistant message assembly (for tracking full conversation history)
   _currentAssistantMessage = null;
   _currentAssistantToolCalls = [];
+  // Tool results collected during a turn, pushed to _messages in correct order at RUN_FINISHED
+  _pendingToolResults = [];
   // Tool call assembly
   currentToolCalls = /* @__PURE__ */ new Map();
   // Feedback tracking
@@ -3150,6 +3174,7 @@ var UseAIClient = class {
         content: ""
       };
       this._currentAssistantToolCalls = [];
+      this._pendingToolResults = [];
     }
     if (event.type === EventType.TEXT_MESSAGE_START) {
       const e = event;
@@ -3190,17 +3215,32 @@ var UseAIClient = class {
       }
     } else if (event.type === EventType.RUN_FINISHED) {
       if (this._currentAssistantMessage) {
-        const assistantMessage = {
-          id: this._currentAssistantMessage.id,
-          role: "assistant",
-          content: this._currentAssistantMessage.content || ""
-        };
         if (this._currentAssistantToolCalls.length > 0) {
-          assistantMessage.toolCalls = this._currentAssistantToolCalls;
+          const toolCallMessage = {
+            id: uuidv42(),
+            role: "assistant",
+            content: "",
+            toolCalls: this._currentAssistantToolCalls
+          };
+          this._messages.push(toolCallMessage);
+          this._messages.push(...this._pendingToolResults);
+          const textMessage = {
+            id: this._currentAssistantMessage.id,
+            role: "assistant",
+            content: this._currentAssistantMessage.content || ""
+          };
+          this._messages.push(textMessage);
+        } else {
+          const assistantMessage = {
+            id: this._currentAssistantMessage.id,
+            role: "assistant",
+            content: this._currentAssistantMessage.content || ""
+          };
+          this._messages.push(assistantMessage);
         }
-        this._messages.push(assistantMessage);
         this._currentAssistantMessage = null;
         this._currentAssistantToolCalls = [];
+        this._pendingToolResults = [];
       }
     }
     this.eventHandlers.forEach((handler) => handler(event));
@@ -3320,7 +3360,7 @@ var UseAIClient = class {
       content: toolResultMessage.data.content,
       toolCallId
     };
-    this._messages.push(toolResultMsg);
+    this._pendingToolResults.push(toolResultMsg);
     this.send(toolResultMessage);
   }
   /**
@@ -3339,6 +3379,14 @@ var UseAIClient = class {
         reason
       }
     };
+    if (!approved) {
+      this._pendingToolResults.push({
+        id: uuidv42(),
+        role: "tool",
+        content: JSON.stringify({ rejected: true, reason: reason || "User rejected tool execution" }),
+        toolCallId
+      });
+    }
     this.send(message);
   }
   /**
@@ -3535,6 +3583,7 @@ var UseAIClient = class {
     this.currentToolCalls.clear();
     this._currentAssistantMessage = null;
     this._currentAssistantToolCalls = [];
+    this._pendingToolResults = [];
   }
   send(message) {
     if (this.socket && this.socket.connected) {
@@ -3605,7 +3654,8 @@ function defineTool(description, schemaOrFn, fnOrOptions, options) {
   let actualFn;
   let actualOptions;
   if (isNoParamFunction) {
-    actualFn = schemaOrFn;
+    const noParamFn = schemaOrFn;
+    actualFn = (_input, ctx) => noParamFn(ctx);
     actualOptions = fnOrOptions || {};
   } else {
     actualFn = fnOrOptions;
@@ -3639,21 +3689,29 @@ function defineTool(description, schemaOrFn, fnOrOptions, options) {
       }
       return toolDef;
     },
-    async _execute(input) {
+    async _execute(input, ctx) {
       const validated = this._zodSchema.parse(input);
-      return await actualFn(validated);
+      return await actualFn(validated, ctx);
     }
   };
 }
 function convertToolsToDefinitions(tools) {
   return Object.entries(tools).map(([name, tool]) => tool._toToolDefinition(name));
 }
-async function executeDefinedTool(tools, toolName, input) {
+async function executeDefinedTool(tools, toolName, input, ctx) {
   const tool = tools[toolName];
   if (!tool) {
     throw new Error(`Tool "${toolName}" not found`);
   }
-  return await tool._execute(input);
+  return await tool._execute(input, ctx);
+}
+
+// src/providers/chatRepository/types.ts
+function generateChatId() {
+  return `chat_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateMessageId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
 
 // src/providers/chatRepository/LocalStorageChatRepository.ts
@@ -3821,31 +3879,31 @@ function deepEquals(a, b) {
 function generateChatTitle(message) {
   return message.length > CHAT_TITLE_MAX_LENGTH ? message.substring(0, CHAT_TITLE_MAX_LENGTH) + "..." : message;
 }
-function getTextFromContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  return content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-}
-function transformMessagesToUI(storageMessages) {
-  return storageMessages.map((msg) => ({
-    id: msg.id,
-    role: msg.role,
-    content: msg.content,
-    timestamp: msg.createdAt,
-    displayMode: msg.displayMode,
-    traceId: msg.traceId,
-    feedback: msg.feedback
-  }));
-}
-function transformMessagesToClientFormat(uiMessages) {
-  return uiMessages.map((msg) => {
+function transformMessagesToClientFormat(persistedMessages) {
+  return persistedMessages.map((msg) => {
     const textContent = getTextFromContent(msg.content);
-    return {
-      id: msg.id,
-      role: msg.role,
-      content: textContent
-    };
+    switch (msg.role) {
+      case "tool":
+        return {
+          id: msg.id,
+          role: "tool",
+          content: textContent,
+          toolCallId: msg.toolCallId || ""
+        };
+      case "assistant":
+        return {
+          id: msg.id,
+          role: "assistant",
+          content: textContent,
+          ...msg.toolCalls && msg.toolCalls.length > 0 ? { toolCalls: msg.toolCalls } : {}
+        };
+      case "user":
+        return {
+          id: msg.id,
+          role: "user",
+          content: textContent
+        };
+    }
   });
 }
 function useChatManagement({
@@ -3869,9 +3927,8 @@ function useChatManagement({
     try {
       const chat = await repository.loadChat(chatId);
       if (chat) {
-        const loadedMessages = transformMessagesToUI(chat.messages);
-        console.log("[ChatManagement] Loaded", loadedMessages.length, "messages from storage for chat:", chatId);
-        return loadedMessages;
+        console.log("[ChatManagement] Loaded", chat.messages.length, "messages from storage for chat:", chatId);
+        return chat.messages;
       } else {
         console.log("[ChatManagement] Chat not found in storage:", chatId);
         return [];
@@ -3967,7 +4024,7 @@ function useChatManagement({
     setCurrentChatId(pendingChatId);
     setPendingChatId(null);
     return pendingChatId;
-  }, [pendingChatId, messages, clientRef]);
+  }, [pendingChatId, clientRef, messages]);
   const saveUserMessage = useCallback4(async (chatId, content) => {
     try {
       const chat = await repository.loadChat(chatId);
@@ -3975,13 +4032,13 @@ function useChatManagement({
         console.error("[ChatManagement] Chat not found:", chatId);
         return false;
       }
-      const { generateMessageId: generateMessageId2 } = await import("./types-GWPQMSYT.js");
-      chat.messages.push({
-        id: generateMessageId2(),
+      const newMessage = {
+        id: generateMessageId(),
         role: "user",
         content,
         createdAt: /* @__PURE__ */ new Date()
-      });
+      };
+      chat.messages.push(newMessage);
       if (!chat.title) {
         const text = getTextFromContent(content);
         if (text) {
@@ -3990,14 +4047,14 @@ function useChatManagement({
       }
       await repository.saveChat(chat);
       console.log("[ChatManagement] Saved user message to storage");
-      await reloadMessages(chatId);
+      setMessages((prev) => [...prev, newMessage]);
       return true;
     } catch (error) {
       console.error("[ChatManagement] Failed to save user message:", error);
       return false;
     }
-  }, [repository, reloadMessages]);
-  const saveAIResponse = useCallback4(async (content, displayMode, traceId) => {
+  }, [repository, setMessages]);
+  const saveAIResponse = useCallback4(async (content, displayMode, traceId, turnMessages) => {
     const currentChatIdValue = currentChatIdSnapshot.current;
     const pendingChatIdValue = pendingChatIdSnapshot.current;
     const displayedChatId2 = pendingChatIdValue || currentChatIdValue;
@@ -4011,15 +4068,18 @@ function useChatManagement({
         console.error("[ChatManagement] Chat not found:", currentChatIdValue);
         return;
       }
-      const { generateMessageId: generateMessageId2 } = await import("./types-GWPQMSYT.js");
-      chat.messages.push({
-        id: generateMessageId2(),
+      if (turnMessages && turnMessages.length > 0) {
+        chat.messages.push(...turnMessages);
+      }
+      const finalMessage = {
+        id: generateMessageId(),
         role: "assistant",
         content,
         createdAt: /* @__PURE__ */ new Date(),
         displayMode,
         traceId
-      });
+      };
+      chat.messages.push(finalMessage);
       if (!chat.title) {
         const firstUserMessage = chat.messages.find((msg) => msg.role === "user");
         if (firstUserMessage) {
@@ -4032,12 +4092,16 @@ function useChatManagement({
       await repository.saveChat(chat);
       console.log("[ChatManagement] Saved AI response to storage for chatId:", currentChatIdValue);
       if (displayedChatId2 === currentChatIdValue) {
-        await reloadMessages(currentChatIdValue);
+        const newMessages = [
+          ...turnMessages ?? [],
+          finalMessage
+        ];
+        setMessages((prev) => [...prev, ...newMessages]);
       }
     } catch (error) {
       console.error("[ChatManagement] Failed to save AI response:", error);
     }
-  }, [repository, reloadMessages]);
+  }, [repository, setMessages]);
   const initializedRef = useRef5(false);
   useEffect5(() => {
     if (currentChatId === null && pendingChatId === null && !initializedRef.current) {
@@ -4068,6 +4132,26 @@ function useChatManagement({
       })();
     }
   }, [currentChatId, pendingChatId, createNewChat, repository, loadChatMessages, clientRef, setMessages]);
+  const connectionPhaseRef = useRef5("initial");
+  useEffect5(() => {
+    if (connected) {
+      const isReconnect = connectionPhaseRef.current === "disconnected";
+      connectionPhaseRef.current = "connected";
+      if (isReconnect && currentChatId && clientRef.current) {
+        (async () => {
+          const loadedMessages = await loadChatMessages(currentChatId);
+          if (loadedMessages.length > 0) {
+            clientRef.current?.loadMessages(transformMessagesToClientFormat(loadedMessages));
+            console.log("[ChatManagement] Reloaded", loadedMessages.length, "messages from storage on reconnect");
+          }
+        })();
+      }
+    } else {
+      if (connectionPhaseRef.current === "connected") {
+        connectionPhaseRef.current = "disconnected";
+      }
+    }
+  }, [connected, currentChatId, loadChatMessages, clientRef]);
   const displayedChatId = pendingChatId || currentChatId;
   return {
     currentChatId,
@@ -4344,6 +4428,7 @@ function useToolSystem({
   const waitersRef = useRef7(/* @__PURE__ */ new Map());
   const [pendingApprovals, setPendingApprovals] = useState9([]);
   const pendingApprovalToolCallsRef = useRef7(/* @__PURE__ */ new Map());
+  const runtimeApprovalResolversRef = useRef7(/* @__PURE__ */ new Map());
   const registerTools = useCallback7((id, tools, options) => {
     const existingTools = toolRegistryRef.current.get(id);
     toolRegistryRef.current.set(id, tools);
@@ -4453,7 +4538,9 @@ function useToolSystem({
         toolCallId: event.toolCallId,
         toolCallName: event.toolCallName,
         toolCallArgs: event.toolCallArgs,
-        annotations: event.annotations
+        annotations: event.annotations,
+        message: event.message,
+        metadata: event.metadata
       }
     ]);
   }, []);
@@ -4466,8 +4553,26 @@ function useToolSystem({
     try {
       const ownerId = toolOwnershipRef.current.get(name);
       console.log(`[useToolSystem] Tool "${name}" owned by component:`, ownerId);
+      const ctx = {
+        requestApproval: ({ message, metadata }) => {
+          return new Promise((resolve) => {
+            const approvalId = `${toolCallId}-runtime-${Date.now()}`;
+            runtimeApprovalResolversRef.current.set(approvalId, resolve);
+            setPendingApprovals((prev) => [
+              ...prev,
+              {
+                toolCallId: approvalId,
+                toolCallName: name,
+                toolCallArgs: input || {},
+                message,
+                metadata
+              }
+            ]);
+          });
+        }
+      };
       console.log("[useToolSystem] Executing tool...");
-      const result = await executeDefinedTool(aggregatedToolsRef.current, name, input);
+      const result = await executeDefinedTool(aggregatedToolsRef.current, name, input, ctx);
       const isErrorResult = result && typeof result === "object" && ("error" in result || result.success === false);
       const ownerIsInvisible = ownerId ? isInvisible(ownerId) : false;
       if (ownerId && !isErrorResult && !ownerIsInvisible) {
@@ -4512,24 +4617,32 @@ function useToolSystem({
     if (!clientRef.current) return;
     console.log("[useToolSystem] Approving all tool calls:", pendingApprovals.length);
     const pendingTools = [...pendingApprovals];
-    for (const pending of pendingTools) {
-      clientRef.current.sendToolApprovalResponse(pending.toolCallId, true);
-    }
     setPendingApprovals([]);
-    for (const tool of pendingTools) {
-      await executePendingToolAfterApproval(tool.toolCallId);
+    for (const pending of pendingTools) {
+      const runtimeResolver = runtimeApprovalResolversRef.current.get(pending.toolCallId);
+      if (runtimeResolver) {
+        runtimeApprovalResolversRef.current.delete(pending.toolCallId);
+        runtimeResolver({ approved: true });
+      } else {
+        clientRef.current.sendToolApprovalResponse(pending.toolCallId, true);
+        await executePendingToolAfterApproval(pending.toolCallId);
+      }
     }
   }, [clientRef, pendingApprovals, executePendingToolAfterApproval]);
   const rejectAll = useCallback7((reason) => {
     if (!clientRef.current) return;
     console.log("[useToolSystem] Rejecting all tool calls:", pendingApprovals.length, reason);
     const pendingTools = [...pendingApprovals];
-    for (const pending of pendingTools) {
-      clientRef.current.sendToolApprovalResponse(pending.toolCallId, false, reason);
-    }
     setPendingApprovals([]);
-    for (const tool of pendingTools) {
-      pendingApprovalToolCallsRef.current.delete(tool.toolCallId);
+    for (const pending of pendingTools) {
+      const runtimeResolver = runtimeApprovalResolversRef.current.get(pending.toolCallId);
+      if (runtimeResolver) {
+        runtimeApprovalResolversRef.current.delete(pending.toolCallId);
+        runtimeResolver({ approved: false, reason });
+      } else {
+        clientRef.current.sendToolApprovalResponse(pending.toolCallId, false, reason);
+        pendingApprovalToolCallsRef.current.delete(pending.toolCallId);
+      }
     }
   }, [clientRef, pendingApprovals]);
   return {
@@ -4683,6 +4796,30 @@ import { useState as useState12, useCallback as useCallback10, useRef as useRef1
 import { EventType as EventType2, ErrorCode, TOOL_APPROVAL_REQUEST } from "@meetsmore-oss/use-ai-core";
 
 // src/hooks/useServerEvents.ts
+function extractTurnMessages(messages, startIndex) {
+  const turnSlice = messages.slice(startIndex);
+  const result = [];
+  for (const msg of turnSlice) {
+    if (msg.role === "assistant" && "toolCalls" in msg && msg.toolCalls) {
+      result.push({
+        id: msg.id,
+        role: "assistant",
+        content: "",
+        createdAt: /* @__PURE__ */ new Date(),
+        toolCalls: msg.toolCalls
+      });
+    } else if (msg.role === "tool") {
+      result.push({
+        id: msg.id,
+        role: "tool",
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        createdAt: /* @__PURE__ */ new Date(),
+        toolCallId: "toolCallId" in msg && msg.toolCallId ? msg.toolCallId : void 0
+      });
+    }
+  }
+  return result;
+}
 function useServerEvents({
   toolSystem,
   saveAIResponse,
@@ -4691,6 +4828,7 @@ function useServerEvents({
   const [loading, setLoading] = useState12(false);
   const [streamingText, setStreamingText] = useState12("");
   const streamingChatIdRef = useRef10(null);
+  const messageCountAtRunStartRef = useRef10(0);
   const [executingToolRaw, setExecutingTool] = useState12(null);
   const executingToolFallbackRef = useRef10(null);
   const clearStreamingText = useCallback10(() => {
@@ -4705,7 +4843,9 @@ function useServerEvents({
   const handleServerEvent = useCallback10(async (client, event) => {
     const ts = toolSystemRef.current;
     const strs = stringsRef.current;
-    if (event.type === EventType2.TOOL_CALL_START) {
+    if (event.type === EventType2.RUN_STARTED) {
+      messageCountAtRunStartRef.current = client.messages.length;
+    } else if (event.type === EventType2.TOOL_CALL_START) {
       const e = event;
       const tool = ts.aggregatedToolsRef.current[e.toolCallName];
       const title = e.annotations?.title ?? tool?._options?.annotations?.title ?? null;
@@ -4750,7 +4890,8 @@ function useServerEvents({
       if (content) {
         const finishedEvent = event;
         const traceId = finishedEvent.runId;
-        saveAIResponseRef.current(content, void 0, traceId);
+        const turnMessages = extractTurnMessages(client.messages, messageCountAtRunStartRef.current);
+        saveAIResponseRef.current(content, void 0, traceId, turnMessages);
       }
       setLoading(false);
     } else if (event.type === EventType2.RUN_ERROR) {
@@ -5326,19 +5467,19 @@ function useStableTools(tools) {
   return stableToolsRef.current;
 }
 function createStableToolWrapper(name, tool, latestToolsRef) {
-  const stableHandler = (input) => {
+  const stableHandler = (input, ctx) => {
     const currentTool = latestToolsRef.current[name];
     if (!currentTool) {
       throw new Error(`Tool "${name}" no longer exists`);
     }
-    return currentTool.fn(input);
+    return currentTool.fn(input, ctx);
   };
-  const stableExecute = async (input) => {
+  const stableExecute = async (input, ctx) => {
     const currentTool = latestToolsRef.current[name];
     if (!currentTool) {
       throw new Error(`Tool "${name}" no longer exists`);
     }
-    return await currentTool._execute(input);
+    return await currentTool._execute(input, ctx);
   };
   return {
     description: tool.description,
@@ -5546,7 +5687,10 @@ function useAIWorkflow(runner, workflowId) {
         console.log(`[useAIWorkflow] Executing tool: ${toolName}`, toolArgs);
         console.log(`[useAIWorkflow] Available tools:`, Object.keys(currentWorkflow.tools));
         try {
-          const result = await executeDefinedTool(currentWorkflow.tools, toolName, toolArgs);
+          const noopCtx = {
+            requestApproval: async () => ({ approved: true })
+          };
+          const result = await executeDefinedTool(currentWorkflow.tools, toolName, toolArgs, noopCtx);
           currentWorkflow.toolCalls.push({
             toolName,
             args: toolArgs,