@meetsmore-oss/use-ai-client 1.7.0 → 1.9.0

package/dist/index.js

@@ -4,13 +4,10 @@ import {
 } from "./chunk-STF3H6F5.js";
 
 // src/useAI.ts
-import { useState as useState14, useEffect as useEffect11, useRef as useRef13, useCallback as useCallback12, useMemo as useMemo6 } from "react";
+import { useState as useState14, useEffect as useEffect12, useLayoutEffect, useRef as useRef14, useCallback as useCallback13, useMemo as useMemo6 } from "react";
 
 // src/providers/useAIProvider.tsx
-import { createContext as createContext4, useContext as useContext4, useState as useState13, useEffect as useEffect10, useCallback as useCallback11, useRef as useRef11 } from "react";
-
-// src/types.ts
-import { EventType, ErrorCode, TOOL_APPROVAL_REQUEST } from "@meetsmore-oss/use-ai-core";
+import { createContext as createContext4, useContext as useContext4, useState as useState13, useEffect as useEffect11, useCallback as useCallback12, useRef as useRef12 } from "react";
 
 // src/theme/strings.ts
 import { createContext, useContext } from "react";
@@ -1641,7 +1638,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",
@@ -3051,7 +3049,7 @@ function UseAIChat({ floating = false }) {
 
 // src/client.ts
 import { io } from "socket.io-client";
-import { EventType as EventType2 } from "@meetsmore-oss/use-ai-core";
+import { EventType } from "@meetsmore-oss/use-ai-core";
 import { v4 as uuidv42 } from "uuid";
 var UseAIClient = class {
   /**
@@ -3146,7 +3144,7 @@ var UseAIClient = class {
     });
   }
   handleEvent(event) {
-    if (event.type === EventType2.RUN_STARTED) {
+    if (event.type === EventType.RUN_STARTED) {
       this._currentAssistantMessage = {
         id: uuidv42(),
         role: "assistant",
@@ -3154,31 +3152,31 @@ var UseAIClient = class {
       };
       this._currentAssistantToolCalls = [];
     }
-    if (event.type === EventType2.TEXT_MESSAGE_START) {
+    if (event.type === EventType.TEXT_MESSAGE_START) {
       const e = event;
       this._currentMessageId = e.messageId;
       this._currentMessageContent = "";
-    } else if (event.type === EventType2.TEXT_MESSAGE_CONTENT) {
+    } else if (event.type === EventType.TEXT_MESSAGE_CONTENT) {
       const e = event;
       this._currentMessageContent += e.delta;
-    } else if (event.type === EventType2.TEXT_MESSAGE_END) {
+    } else if (event.type === EventType.TEXT_MESSAGE_END) {
       if (this._currentAssistantMessage) {
         this._currentAssistantMessage.content = this._currentMessageContent;
       }
       this._currentMessageId = null;
-    } else if (event.type === EventType2.TOOL_CALL_START) {
+    } else if (event.type === EventType.TOOL_CALL_START) {
       const e = event;
       this.currentToolCalls.set(e.toolCallId, {
         name: e.toolCallName,
         args: ""
       });
-    } else if (event.type === EventType2.TOOL_CALL_ARGS) {
+    } else if (event.type === EventType.TOOL_CALL_ARGS) {
       const e = event;
       const toolCall = this.currentToolCalls.get(e.toolCallId);
       if (toolCall) {
         toolCall.args += e.delta;
       }
-    } else if (event.type === EventType2.TOOL_CALL_END) {
+    } else if (event.type === EventType.TOOL_CALL_END) {
       const e = event;
       const toolCall = this.currentToolCalls.get(e.toolCallId);
       if (toolCall) {
@@ -3191,7 +3189,7 @@ var UseAIClient = class {
           }
         });
       }
-    } else if (event.type === EventType2.RUN_FINISHED) {
+    } else if (event.type === EventType.RUN_FINISHED) {
       if (this._currentAssistantMessage) {
         const assistantMessage = {
           id: this._currentAssistantMessage.id,
@@ -3308,7 +3306,13 @@ var UseAIClient = class {
         messageId: uuidv42(),
         toolCallId,
         content: JSON.stringify(result),
-        role: "tool"
+        role: "tool",
+        // use-ai extension: include current tools and state for mid-run updates
+        // (e.g., when navigation causes new components to mount)
+        forwardedProps: {
+          tools: this._tools,
+          state: this._state
+        }
       }
     };
     const toolResultMsg = {
@@ -3371,7 +3375,7 @@ var UseAIClient = class {
    */
   onTextMessage(handler) {
     return this.onEvent("text-message-handler", (event) => {
-      if (event.type === EventType2.TEXT_MESSAGE_END && this._currentMessageContent) {
+      if (event.type === EventType.TEXT_MESSAGE_END && this._currentMessageContent) {
         handler(this._currentMessageContent);
       }
     });
@@ -3385,7 +3389,7 @@ var UseAIClient = class {
    */
   onToolCall(handler) {
     return this.onEvent("tool-call-handler", (event) => {
-      if (event.type === EventType2.TOOL_CALL_END) {
+      if (event.type === EventType.TOOL_CALL_END) {
         const e = event;
         const toolCall = this.currentToolCalls.get(e.toolCallId);
         if (toolCall) {
@@ -3602,7 +3606,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;
@@ -3636,21 +3641,21 @@ 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/LocalStorageChatRepository.ts
@@ -3850,11 +3855,7 @@ function useChatManagement({
   clientRef,
   messages,
   setMessages,
-  onSendMessage,
-  setOpen,
-  connected,
-  loading,
-  hasPendingApproval
+  connected
 }) {
   const [currentChatId, setCurrentChatId] = useState6(null);
   const [pendingChatId, setPendingChatId] = useState6(null);
@@ -3885,7 +3886,7 @@ function useChatManagement({
   const reloadMessages = useCallback4(async (chatId) => {
     const loadedMessages = await loadChatMessages(chatId);
     setMessages(loadedMessages);
-  }, [loadChatMessages]);
+  }, [loadChatMessages, setMessages]);
   const createNewChat = useCallback4(async (options) => {
     console.log("[ChatManagement] createNewChat called - currentChatId:", currentChatId, "pendingChatId:", pendingChatId, "messages.length:", messages.length);
     if (pendingChatId && messages.length === 0) {
@@ -3906,7 +3907,7 @@ function useChatManagement({
     }
     console.log("[ChatManagement] Created pending chat:", chatId, "(will activate on first message)");
     return chatId;
-  }, [currentChatId, pendingChatId, messages, repository, clientRef]);
+  }, [currentChatId, pendingChatId, messages, repository, clientRef, setMessages]);
   const loadChat = useCallback4(async (chatId) => {
     setPendingChatId(chatId);
     await reloadMessages(chatId);
@@ -3927,7 +3928,7 @@ function useChatManagement({
       setMessages([]);
     }
     console.log("[ChatManagement] Deleted chat:", chatId);
-  }, [currentChatId, pendingChatId, repository]);
+  }, [currentChatId, pendingChatId, repository, setMessages]);
   const listChats = useCallback4(async () => {
     return await repository.listChats();
   }, [repository]);
@@ -3941,7 +3942,7 @@ function useChatManagement({
         console.log("[ChatManagement] Cleared current chat:", currentChatId);
       }
     }
-  }, [currentChatId, repository]);
+  }, [currentChatId, repository, setMessages]);
   const getCurrentChat = useCallback4(async () => {
     const chatId = pendingChatId || currentChatId;
     if (!chatId) return null;
@@ -4068,76 +4069,8 @@ function useChatManagement({
         }
       })();
     }
-  }, [currentChatId, pendingChatId, createNewChat, repository, loadChatMessages, clientRef]);
+  }, [currentChatId, pendingChatId, createNewChat, repository, loadChatMessages, clientRef, setMessages]);
   const displayedChatId = pendingChatId || currentChatId;
-  const pendingMessagesRef = useRef5([]);
-  const isProcessingQueueRef = useRef5(false);
-  const loadingRef = useRef5(loading);
-  useEffect5(() => {
-    loadingRef.current = loading;
-  }, [loading]);
-  const hasPendingApprovalRef = useRef5(hasPendingApproval);
-  useEffect5(() => {
-    hasPendingApprovalRef.current = hasPendingApproval;
-  }, [hasPendingApproval]);
-  const processMessageQueue = useCallback4(async () => {
-    if (isProcessingQueueRef.current || pendingMessagesRef.current.length === 0 || !onSendMessage) {
-      return;
-    }
-    isProcessingQueueRef.current = true;
-    while (pendingMessagesRef.current.length > 0) {
-      const { message, options } = pendingMessagesRef.current.shift();
-      const { newChat = false, attachments = [], openChat = true, metadata, forwardedProps } = options ?? {};
-      if (newChat) {
-        await createNewChat({ metadata });
-      }
-      const fileAttachments = await Promise.all(
-        attachments.map(async (file) => {
-          let preview;
-          if (file.type.startsWith("image/")) {
-            preview = await new Promise((resolve) => {
-              const reader = new FileReader();
-              reader.onload = () => resolve(typeof reader.result === "string" ? reader.result : void 0);
-              reader.onerror = () => resolve(void 0);
-              reader.readAsDataURL(file);
-            });
-          }
-          return {
-            id: crypto.randomUUID(),
-            file,
-            preview
-          };
-        })
-      );
-      await onSendMessage(message, fileAttachments.length > 0 ? fileAttachments : void 0, forwardedProps);
-      if (openChat && setOpen) {
-        setOpen(true);
-      }
-      await new Promise((resolve) => {
-        const checkReady = () => {
-          setTimeout(() => {
-            if (!loadingRef.current && !hasPendingApprovalRef.current) {
-              resolve();
-            } else {
-              checkReady();
-            }
-          }, 100);
-        };
-        checkReady();
-      });
-    }
-    isProcessingQueueRef.current = false;
-  }, [onSendMessage, createNewChat, setOpen]);
-  const sendMessage = useCallback4(async (message, options) => {
-    if (!onSendMessage) {
-      throw new Error("sendMessage is not available (onSendMessage callback not provided)");
-    }
-    if (!connected) {
-      throw new Error("Not connected to UseAI server");
-    }
-    pendingMessagesRef.current.push({ message, options });
-    await processMessageQueue();
-  }, [onSendMessage, connected, processMessageQueue]);
   return {
     currentChatId,
     pendingChatId,
@@ -4151,7 +4084,6 @@ function useChatManagement({
     saveUserMessage,
     saveAIResponse,
     reloadMessages,
-    sendMessage,
     getCurrentChat,
     updateMetadata,
     currentChatIdSnapshot,
@@ -4399,16 +4331,26 @@ function useCommandManagement({
   };
 }
 
-// src/hooks/useToolRegistry.ts
+// src/hooks/useToolSystem.ts
 import { useState as useState9, useCallback as useCallback7, useRef as useRef7, useMemo as useMemo4 } from "react";
-function useToolRegistry() {
+function useToolSystem({
+  clientRef,
+  buildState
+}) {
   const toolRegistryRef = useRef7(/* @__PURE__ */ new Map());
   const [toolRegistryVersion, setToolRegistryVersion] = useState9(0);
   const toolOwnershipRef = useRef7(/* @__PURE__ */ new Map());
   const invisibleRef = useRef7(/* @__PURE__ */ new Set());
+  const readyStateRef = useRef7(/* @__PURE__ */ new Map());
+  const readyListenersRef = useRef7(/* @__PURE__ */ new Set());
+  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);
+    readyStateRef.current.set(id, false);
     if (existingTools) {
       const existingKeys = Object.keys(existingTools).sort().join(",");
       const newKeys = Object.keys(tools).sort().join(",");
@@ -4427,6 +4369,13 @@ function useToolRegistry() {
       invisibleRef.current.delete(id);
     }
   }, []);
+  const signalReady = useCallback7((id) => {
+    if (!toolRegistryRef.current.has(id)) {
+      return;
+    }
+    readyStateRef.current.set(id, true);
+    readyListenersRef.current.forEach((listener) => listener());
+  }, []);
   const unregisterTools = useCallback7((id) => {
     const tools = toolRegistryRef.current.get(id);
     if (tools) {
@@ -4435,8 +4384,10 @@ function useToolRegistry() {
       });
     }
     toolRegistryRef.current.delete(id);
+    readyStateRef.current.delete(id);
     setToolRegistryVersion((v) => v + 1);
     invisibleRef.current.delete(id);
+    readyListenersRef.current.forEach((listener) => listener());
   }, []);
   const isInvisible = useCallback7((id) => {
     return invisibleRef.current.has(id);
@@ -4451,14 +4402,187 @@ function useToolRegistry() {
   const hasTools = toolRegistryRef.current.size > 0;
   const aggregatedToolsRef = useRef7(aggregatedTools);
   aggregatedToolsRef.current = aggregatedTools;
+  const waitForToolsToStabilize = useCallback7(async () => {
+    const maxWaitMs = 500;
+    const checkAllReady = () => {
+      if (readyStateRef.current.size === 0) return true;
+      for (const ready of readyStateRef.current.values()) {
+        if (!ready) return false;
+      }
+      return true;
+    };
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    if (checkAllReady()) {
+      return;
+    }
+    return new Promise((resolve) => {
+      let safetyTimeout = null;
+      let resolved = false;
+      const cleanup = () => {
+        if (resolved) return;
+        resolved = true;
+        if (safetyTimeout) clearTimeout(safetyTimeout);
+        readyListenersRef.current.delete(onReadyChange);
+      };
+      const onReadyChange = () => {
+        if (resolved) return;
+        if (checkAllReady()) {
+          cleanup();
+          resolve();
+        }
+      };
+      safetyTimeout = setTimeout(() => {
+        cleanup();
+        resolve();
+      }, maxWaitMs);
+      readyListenersRef.current.add(onReadyChange);
+      onReadyChange();
+    });
+  }, []);
+  const registerWaiter = useCallback7((id, waiter) => {
+    waitersRef.current.set(id, waiter);
+  }, []);
+  const unregisterWaiter = useCallback7((id) => {
+    waitersRef.current.delete(id);
+  }, []);
+  const getWaiter = useCallback7((id) => {
+    return waitersRef.current.get(id);
+  }, []);
+  const handleApprovalRequest = useCallback7((event) => {
+    console.log("[useToolSystem] Tool approval requested:", event.toolCallName, event.toolCallId);
+    setPendingApprovals((prev) => [
+      ...prev,
+      {
+        toolCallId: event.toolCallId,
+        toolCallName: event.toolCallName,
+        toolCallArgs: event.toolCallArgs,
+        annotations: event.annotations,
+        message: event.message,
+        metadata: event.metadata
+      }
+    ]);
+  }, []);
+  const executeToolCall = useCallback7(async (toolCallId, name, input) => {
+    const client = clientRef.current;
+    if (!client) {
+      console.error("[useToolSystem] No client available for tool execution");
+      return;
+    }
+    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, ctx);
+      const isErrorResult = result && typeof result === "object" && ("error" in result || result.success === false);
+      const ownerIsInvisible = ownerId ? isInvisible(ownerId) : false;
+      if (ownerId && !isErrorResult && !ownerIsInvisible) {
+        const waiter = getWaiter(ownerId);
+        if (waiter) {
+          console.log(`[useToolSystem] Waiting for prompt change from ${ownerId}...`);
+          await waiter();
+          console.log("[useToolSystem] Prompt change wait complete");
+        }
+      } else if (isErrorResult) {
+        console.log("[useToolSystem] Tool returned error, skipping prompt wait");
+      } else if (ownerIsInvisible) {
+        console.log("[useToolSystem] Component is invisible, skipping prompt wait");
+      }
+      console.log("[useToolSystem] Waiting for tools to stabilize...");
+      await waitForToolsToStabilize();
+      console.log("[useToolSystem] Tools stabilized");
+      const updatedState = buildState();
+      console.log(`[useToolSystem] Updated state (aggregated from all hooks)`);
+      client.sendToolResponse(toolCallId, result, updatedState);
+    } catch (err) {
+      console.error("Tool execution error:", err);
+      client.sendToolResponse(toolCallId, {
+        error: err instanceof Error ? err.message : "Unknown error"
+      });
+    }
+  }, [clientRef, isInvisible, getWaiter, waitForToolsToStabilize, buildState]);
+  const storePendingToolCall = useCallback7((toolCallId, name, input, toolCallData) => {
+    console.log(`[useToolSystem] Storing pending tool call "${name}" for approval`);
+    pendingApprovalToolCallsRef.current.set(toolCallId, { name, input, toolCallData });
+  }, []);
+  const executePendingToolAfterApproval = useCallback7(async (toolCallId) => {
+    const pendingTool = pendingApprovalToolCallsRef.current.get(toolCallId);
+    if (!pendingTool) {
+      console.warn(`[useToolSystem] No pending tool found for ${toolCallId}`);
+      return;
+    }
+    pendingApprovalToolCallsRef.current.delete(toolCallId);
+    await executeToolCall(toolCallId, pendingTool.name, pendingTool.input);
+  }, [executeToolCall]);
+  const approveAll = useCallback7(async () => {
+    if (!clientRef.current) return;
+    console.log("[useToolSystem] Approving all tool calls:", pendingApprovals.length);
+    const pendingTools = [...pendingApprovals];
+    setPendingApprovals([]);
+    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];
+    setPendingApprovals([]);
+    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 {
+    // Registry
     registerTools,
     unregisterTools,
     isInvisible,
     aggregatedTools,
     hasTools,
     aggregatedToolsRef,
-    toolOwnershipRef
+    signalReady,
+    toolRegistryVersion,
+    // Waiters
+    registerWaiter,
+    unregisterWaiter,
+    // Execution
+    pendingApprovals,
+    handleApprovalRequest,
+    executeToolCall,
+    storePendingToolCall,
+    approveAll,
+    rejectAll
   };
 }
 
@@ -4471,7 +4595,6 @@ function usePromptState({
 }) {
   const promptsRef = useRef8(/* @__PURE__ */ new Map());
   const suggestionsRef = useRef8(/* @__PURE__ */ new Map());
-  const waitersRef = useRef8(/* @__PURE__ */ new Map());
   const [suggestionsVersion, setSuggestionsVersion] = useState10(0);
   const buildStateFromPrompts = useCallback8(() => {
     const promptParts = [];
@@ -4508,15 +4631,6 @@ function usePromptState({
       clientRef.current.updateState(buildStateFromPrompts());
     }
   }, [buildStateFromPrompts, clientRef, connected]);
-  const registerWaiter = useCallback8((id, waiter) => {
-    waitersRef.current.set(id, waiter);
-  }, []);
-  const unregisterWaiter = useCallback8((id) => {
-    waitersRef.current.delete(id);
-  }, []);
-  const getWaiter = useCallback8((id) => {
-    return waitersRef.current.get(id);
-  }, []);
   const aggregatedSuggestions = useMemo5(() => {
     const allSuggestions = [];
     suggestionsRef.current.forEach((suggestions) => {
@@ -4526,11 +4640,8 @@ function usePromptState({
   }, [suggestionsVersion]);
   return {
     updatePrompt,
-    registerWaiter,
-    unregisterWaiter,
-    getWaiter,
     aggregatedSuggestions,
-    promptsRef
+    buildStateFromPrompts
   };
 }
 
@@ -4596,116 +4707,190 @@ function useFeedback({
   };
 }
 
-// src/hooks/useToolExecution.ts
+// src/hooks/useServerEvents.ts
 import { useState as useState12, useCallback as useCallback10, useRef as useRef10 } from "react";
-function useToolExecution({
-  clientRef,
-  aggregatedToolsRef,
-  toolOwnershipRef,
-  promptsRef,
-  isInvisible,
-  getWaiter
+
+// src/types.ts
+import { EventType as EventType2, ErrorCode, TOOL_APPROVAL_REQUEST } from "@meetsmore-oss/use-ai-core";
+
+// src/hooks/useServerEvents.ts
+function useServerEvents({
+  toolSystem,
+  saveAIResponse,
+  strings
 }) {
-  const [pendingApprovals, setPendingApprovals] = useState12([]);
-  const pendingApprovalToolCallsRef = useRef10(/* @__PURE__ */ new Map());
-  const handleApprovalRequest = useCallback10((event) => {
-    console.log("[useToolExecution] Tool approval requested:", event.toolCallName, event.toolCallId);
-    setPendingApprovals((prev) => [
-      ...prev,
-      {
-        toolCallId: event.toolCallId,
-        toolCallName: event.toolCallName,
-        toolCallArgs: event.toolCallArgs,
-        annotations: event.annotations
+  const [loading, setLoading] = useState12(false);
+  const [streamingText, setStreamingText] = useState12("");
+  const streamingChatIdRef = useRef10(null);
+  const [executingToolRaw, setExecutingTool] = useState12(null);
+  const executingToolFallbackRef = useRef10(null);
+  const clearStreamingText = useCallback10(() => {
+    setStreamingText("");
+  }, []);
+  const toolSystemRef = useRef10(toolSystem);
+  toolSystemRef.current = toolSystem;
+  const saveAIResponseRef = useRef10(saveAIResponse);
+  saveAIResponseRef.current = saveAIResponse;
+  const stringsRef = useRef10(strings);
+  stringsRef.current = strings;
+  const handleServerEvent = useCallback10(async (client, event) => {
+    const ts = toolSystemRef.current;
+    const strs = stringsRef.current;
+    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;
+      if (!title) {
+        const fallbacks = strs.toolExecution.fallbackMessages;
+        executingToolFallbackRef.current = fallbacks[Math.floor(Math.random() * fallbacks.length)];
       }
-    ]);
+      setExecutingTool({ toolCallId: e.toolCallId, title });
+    } else if (event.type === EventType2.TOOL_CALL_END) {
+      const toolCallEnd = event;
+      const toolCallId = toolCallEnd.toolCallId;
+      setExecutingTool((prev) => prev?.toolCallId === toolCallId ? null : prev);
+      const toolCallData = client.currentToolCalls.get(toolCallId);
+      if (!toolCallData) {
+        console.error(`[ServerEvents] Tool call ${toolCallId} not found`);
+        return;
+      }
+      const name = toolCallData.name;
+      const input = JSON.parse(toolCallData.args);
+      const tool = ts.aggregatedToolsRef.current[name];
+      if (!tool) {
+        console.log(`[ServerEvents] Tool "${name}" not found in useAI tools, skipping (likely a workflow tool)`);
+        return;
+      }
+      if (tool._options?.annotations?.destructiveHint === true) {
+        console.log(`[ServerEvents] Tool "${name}" requires approval, deferring execution`);
+        ts.storePendingToolCall(toolCallId, name, input, toolCallData);
+        return;
+      }
+      await ts.executeToolCall(toolCallId, name, input);
+    } else if (event.type === TOOL_APPROVAL_REQUEST) {
+      const e = event;
+      ts.handleApprovalRequest(e);
+    } else if (event.type === EventType2.TEXT_MESSAGE_CONTENT) {
+      const contentEvent = event;
+      setStreamingText((prev) => prev + contentEvent.delta);
+    } else if (event.type === EventType2.TEXT_MESSAGE_END) {
+      setStreamingText("");
+      streamingChatIdRef.current = null;
+    } else if (event.type === EventType2.RUN_FINISHED) {
+      const content = client.currentMessageContent;
+      if (content) {
+        const finishedEvent = event;
+        const traceId = finishedEvent.runId;
+        saveAIResponseRef.current(content, void 0, traceId);
+      }
+      setLoading(false);
+    } else if (event.type === EventType2.RUN_ERROR) {
+      const errorEvent = event;
+      const errorCode = errorEvent.message;
+      console.error("[ServerEvents] Run error:", errorCode);
+      const userMessage = strs.errors[errorCode] || strs.errors[ErrorCode.UNKNOWN_ERROR];
+      saveAIResponseRef.current(userMessage, "error");
+      setStreamingText("");
+      streamingChatIdRef.current = null;
+      setLoading(false);
+    }
   }, []);
-  const executeToolCall = useCallback10(async (toolCallId, name, input) => {
-    const client = clientRef.current;
-    if (!client) {
-      console.error("[useToolExecution] No client available for tool execution");
+  const executingTool = executingToolRaw ? {
+    displayText: executingToolRaw.title ?? executingToolFallbackRef.current ?? strings.toolExecution.fallbackMessages[0]
+  } : null;
+  return {
+    loading,
+    setLoading,
+    streamingText,
+    clearStreamingText,
+    executingTool,
+    streamingChatIdRef,
+    handleServerEvent
+  };
+}
+
+// src/hooks/useMessageQueue.ts
+import { useCallback as useCallback11, useRef as useRef11, useEffect as useEffect10 } from "react";
+function useMessageQueue({
+  sendFn,
+  createNewChat,
+  setOpen,
+  connected,
+  loading,
+  hasPendingApproval
+}) {
+  const pendingMessagesRef = useRef11([]);
+  const isProcessingQueueRef = useRef11(false);
+  const sendFnRef = useRef11(sendFn);
+  sendFnRef.current = sendFn;
+  const createNewChatRef = useRef11(createNewChat);
+  createNewChatRef.current = createNewChat;
+  const setOpenRef = useRef11(setOpen);
+  setOpenRef.current = setOpen;
+  const loadingRef = useRef11(loading);
+  useEffect10(() => {
+    loadingRef.current = loading;
+  }, [loading]);
+  const hasPendingApprovalRef = useRef11(hasPendingApproval);
+  useEffect10(() => {
+    hasPendingApprovalRef.current = hasPendingApproval;
+  }, [hasPendingApproval]);
+  const processMessageQueue = useCallback11(async () => {
+    if (isProcessingQueueRef.current || pendingMessagesRef.current.length === 0) {
       return;
     }
-    try {
-      const ownerId = toolOwnershipRef.current.get(name);
-      console.log(`[useToolExecution] Tool "${name}" owned by component:`, ownerId);
-      console.log("[useToolExecution] Executing tool...");
-      const result = await executeDefinedTool(aggregatedToolsRef.current, name, input);
-      const isErrorResult = result && typeof result === "object" && ("error" in result || result.success === false);
-      const ownerIsInvisible = ownerId ? isInvisible(ownerId) : false;
-      if (ownerId && !isErrorResult && !ownerIsInvisible) {
-        const waiter = getWaiter(ownerId);
-        if (waiter) {
-          console.log(`[useToolExecution] Waiting for prompt change from ${ownerId}...`);
-          await waiter();
-          console.log("[useToolExecution] Prompt change wait complete");
-        }
-      } else if (isErrorResult) {
-        console.log("[useToolExecution] Tool returned error, skipping prompt wait");
-      } else if (ownerIsInvisible) {
-        console.log("[useToolExecution] Component is invisible, skipping prompt wait");
+    isProcessingQueueRef.current = true;
+    while (pendingMessagesRef.current.length > 0) {
+      const { message, options } = pendingMessagesRef.current.shift();
+      const { newChat = false, attachments = [], openChat = true, metadata, forwardedProps } = options ?? {};
+      if (newChat) {
+        await createNewChatRef.current({ metadata });
       }
-      let updatedState = null;
-      if (ownerId) {
-        const prompt = promptsRef.current.get(ownerId);
-        if (prompt) {
-          updatedState = { context: prompt };
-          console.log(`[useToolExecution] Updated state from ${ownerId}`);
-        }
+      const fileAttachments = await Promise.all(
+        attachments.map(async (file) => {
+          let preview;
+          if (file.type.startsWith("image/")) {
+            preview = await new Promise((resolve) => {
+              const reader = new FileReader();
+              reader.onload = () => resolve(typeof reader.result === "string" ? reader.result : void 0);
+              reader.onerror = () => resolve(void 0);
+              reader.readAsDataURL(file);
+            });
+          }
+          return {
+            id: crypto.randomUUID(),
+            file,
+            preview
+          };
+        })
+      );
+      await sendFnRef.current(message, fileAttachments.length > 0 ? fileAttachments : void 0, forwardedProps);
+      if (openChat && setOpenRef.current) {
+        setOpenRef.current(true);
       }
-      client.sendToolResponse(toolCallId, result, updatedState);
-    } catch (err) {
-      console.error("Tool execution error:", err);
-      client.sendToolResponse(toolCallId, {
-        error: err instanceof Error ? err.message : "Unknown error"
+      await new Promise((resolve) => {
+        const checkReady = () => {
+          setTimeout(() => {
+            if (!loadingRef.current && !hasPendingApprovalRef.current) {
+              resolve();
+            } else {
+              checkReady();
+            }
+          }, 100);
+        };
+        checkReady();
       });
     }
-  }, [clientRef, aggregatedToolsRef, toolOwnershipRef, promptsRef, isInvisible, getWaiter]);
-  const storePendingToolCall = useCallback10((toolCallId, name, input, toolCallData) => {
-    console.log(`[useToolExecution] Storing pending tool call "${name}" for approval`);
-    pendingApprovalToolCallsRef.current.set(toolCallId, { name, input, toolCallData });
+    isProcessingQueueRef.current = false;
   }, []);
-  const executePendingToolAfterApproval = useCallback10(async (toolCallId) => {
-    const pendingTool = pendingApprovalToolCallsRef.current.get(toolCallId);
-    if (!pendingTool) {
-      console.warn(`[useToolExecution] No pending tool found for ${toolCallId}`);
-      return;
-    }
-    pendingApprovalToolCallsRef.current.delete(toolCallId);
-    await executeToolCall(toolCallId, pendingTool.name, pendingTool.input);
-  }, [executeToolCall]);
-  const approveAll = useCallback10(async () => {
-    if (!clientRef.current) return;
-    console.log("[useToolExecution] 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);
-    }
-  }, [clientRef, pendingApprovals, executePendingToolAfterApproval]);
-  const rejectAll = useCallback10((reason) => {
-    if (!clientRef.current) return;
-    console.log("[useToolExecution] 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);
+  const sendMessage = useCallback11(async (message, options) => {
+    if (!connected) {
+      throw new Error("Not connected to UseAI server");
     }
-  }, [clientRef, pendingApprovals]);
-  return {
-    pendingApprovals,
-    handleApprovalRequest,
-    executeToolCall,
-    storePendingToolCall,
-    approveAll,
-    rejectAll
-  };
+    pendingMessagesRef.current.push({ message, options });
+    await processMessageQueue();
+  }, [connected, processMessageQueue]);
+  return { sendMessage };
 }
 
 // src/providers/useAIProvider.tsx
@@ -4720,16 +4905,18 @@ var noOpContextValue = {
     register: () => {
     },
     unregister: () => {
-    }
-  },
-  prompts: {
-    update: () => {
+    },
+    signalReady: () => {
     },
     registerWaiter: () => {
     },
     unregisterWaiter: () => {
     }
   },
+  prompts: {
+    update: () => {
+    }
+  },
   chat: {
     currentId: null,
     create: async () => "",
@@ -4791,87 +4978,41 @@ function UseAIProvider({
   const strings = { ...defaultStrings, ...customStrings };
   const [connected, setConnected] = useState13(false);
   const [isChatOpen, setIsChatOpen] = useState13(false);
-  const [loading, setLoading] = useState13(false);
   const [messages, setMessages] = useState13([]);
   const [fileProcessingState, setFileProcessingState] = useState13(null);
-  const handleSetChatOpen = useCallback11((open) => {
+  const handleSetChatOpen = useCallback12((open) => {
     setIsChatOpen(open);
     onOpenChange?.(open);
   }, [onOpenChange]);
-  const [streamingText, setStreamingText] = useState13("");
-  const streamingChatIdRef = useRef11(null);
-  const [executingTool, setExecutingTool] = useState13(null);
-  const executingToolFallbackRef = useRef11(null);
-  const clientRef = useRef11(null);
-  const repositoryRef = useRef11(
+  const clientRef = useRef12(null);
+  const repositoryRef = useRef12(
     chatRepository || new LocalStorageChatRepository()
   );
-  const handleSendMessageRef = useRef11(null);
-  const {
-    registerTools,
-    unregisterTools,
-    isInvisible,
-    aggregatedTools,
-    hasTools,
-    aggregatedToolsRef,
-    toolOwnershipRef
-  } = useToolRegistry();
-  const {
-    updatePrompt,
-    registerWaiter,
-    unregisterWaiter,
-    getWaiter,
-    aggregatedSuggestions,
-    promptsRef
-  } = usePromptState({
+  const promptState = usePromptState({
     systemPrompt,
     clientRef,
     connected
   });
-  const stableSendMessage = useCallback11(async (message, attachments, forwardedProps) => {
-    if (handleSendMessageRef.current) {
-      await handleSendMessageRef.current(message, attachments, forwardedProps);
-    }
-  }, []);
-  const toolExecution = useToolExecution({
+  const toolSystem = useToolSystem({
     clientRef,
-    aggregatedToolsRef,
-    toolOwnershipRef,
-    promptsRef,
-    isInvisible,
-    getWaiter
+    buildState: promptState.buildStateFromPrompts
   });
   const chatManagement = useChatManagement({
     repository: repositoryRef.current,
     clientRef,
     messages,
     setMessages,
-    onSendMessage: stableSendMessage,
-    setOpen: handleSetChatOpen,
-    connected,
-    loading,
-    hasPendingApproval: toolExecution.pendingApprovals.length > 0
+    connected
+  });
+  const serverEvents = useServerEvents({
+    toolSystem,
+    saveAIResponse: chatManagement.saveAIResponse,
+    strings
   });
-  const {
-    currentChatId,
-    pendingChatId,
-    displayedChatId,
-    createNewChat,
-    loadChat,
-    deleteChat,
-    listChats,
-    clearCurrentChat,
-    activatePendingChat,
-    saveUserMessage,
-    saveAIResponse,
-    sendMessage,
-    getCurrentChat,
-    updateMetadata
-  } = chatManagement;
   const feedback = useFeedback({
     clientRef,
     repository: repositoryRef.current,
-    getDisplayedChatId: () => displayedChatId,
+    getDisplayedChatId: () => chatManagement.displayedChatId,
     setMessages
   });
   const {
@@ -4887,7 +5028,9 @@ function UseAIProvider({
     renameCommand,
     deleteCommand
   } = useCommandManagement({ repository: commandRepository });
-  useEffect10(() => {
+  const handleServerEventRef = useRef12(serverEvents.handleServerEvent);
+  handleServerEventRef.current = serverEvents.handleServerEvent;
+  useEffect11(() => {
     console.log("[UseAIProvider] Initializing client with serverUrl:", serverUrl);
     const client = new UseAIClient(serverUrl);
     const unsubscribeConnection = client.onConnectionStateChange((isConnected) => {
@@ -4897,64 +5040,7 @@ function UseAIProvider({
     console.log("[UseAIProvider] Connecting...");
     client.connect();
     const unsubscribe = client.onEvent("globalChat", async (event) => {
-      if (event.type === EventType.TOOL_CALL_START) {
-        const e = event;
-        const tool = aggregatedToolsRef.current[e.toolCallName];
-        const title = e.annotations?.title ?? tool?._options?.annotations?.title ?? null;
-        if (!title) {
-          const fallbacks = strings.toolExecution.fallbackMessages;
-          executingToolFallbackRef.current = fallbacks[Math.floor(Math.random() * fallbacks.length)];
-        }
-        setExecutingTool({ toolCallId: e.toolCallId, title });
-      } else if (event.type === EventType.TOOL_CALL_END) {
-        const toolCallEnd = event;
-        const toolCallId = toolCallEnd.toolCallId;
-        setExecutingTool((prev) => prev?.toolCallId === toolCallId ? null : prev);
-        const toolCallData = client["currentToolCalls"].get(toolCallId);
-        if (!toolCallData) {
-          console.error(`[Provider] Tool call ${toolCallId} not found`);
-          return;
-        }
-        const name = toolCallData.name;
-        const input = JSON.parse(toolCallData.args);
-        const tool = aggregatedToolsRef.current[name];
-        if (!tool) {
-          console.log(`[Provider] Tool "${name}" not found in useAI tools, skipping (likely a workflow tool)`);
-          return;
-        }
-        if (tool._options?.annotations?.destructiveHint === true) {
-          console.log(`[Provider] Tool "${name}" requires approval, deferring execution`);
-          toolExecution.storePendingToolCall(toolCallId, name, input, toolCallData);
-          return;
-        }
-        await toolExecution.executeToolCall(toolCallId, name, input);
-      } else if (event.type === TOOL_APPROVAL_REQUEST) {
-        const e = event;
-        toolExecution.handleApprovalRequest(e);
-      } else if (event.type === EventType.TEXT_MESSAGE_CONTENT) {
-        const contentEvent = event;
-        setStreamingText((prev) => prev + contentEvent.delta);
-      } else if (event.type === EventType.TEXT_MESSAGE_END) {
-        setStreamingText("");
-        streamingChatIdRef.current = null;
-      } else if (event.type === EventType.RUN_FINISHED) {
-        const content = client.currentMessageContent;
-        if (content) {
-          const finishedEvent = event;
-          const traceId = finishedEvent.runId;
-          saveAIResponse(content, void 0, traceId);
-        }
-        setLoading(false);
-      } else if (event.type === EventType.RUN_ERROR) {
-        const errorEvent = event;
-        const errorCode = errorEvent.message;
-        console.error("[Provider] Run error:", errorCode);
-        const userMessage = strings.errors[errorCode] || strings.errors[ErrorCode.UNKNOWN_ERROR];
-        saveAIResponse(userMessage, "error");
-        setStreamingText("");
-        streamingChatIdRef.current = null;
-        setLoading(false);
-      }
+      await handleServerEventRef.current(client, event);
     });
     clientRef.current = client;
     return () => {
@@ -4963,11 +5049,11 @@ function UseAIProvider({
       client.disconnect();
     };
   }, [serverUrl]);
-  const lastRegisteredToolsRef = useRef11("");
-  useEffect10(() => {
+  const lastRegisteredToolsRef = useRef12("");
+  useEffect11(() => {
     const client = clientRef.current;
-    if (!client || !client.isConnected() || !hasTools) return;
-    const toolKeys = Object.keys(aggregatedTools).sort().join(",");
+    if (!client || !client.isConnected() || !toolSystem.hasTools) return;
+    const toolKeys = Object.keys(toolSystem.aggregatedTools).sort().join(",");
     if (toolKeys === lastRegisteredToolsRef.current) {
       console.log("[Provider] Skipping re-registration, tools unchanged");
       return;
@@ -4975,19 +5061,19 @@ function UseAIProvider({
     lastRegisteredToolsRef.current = toolKeys;
     console.log("[Provider] Registering tools:", toolKeys);
     try {
-      const toolDefinitions = convertToolsToDefinitions(aggregatedTools);
+      const toolDefinitions = convertToolsToDefinitions(toolSystem.aggregatedTools);
       console.log(`[Provider] Registering ${toolDefinitions.length} tools`);
       client.registerTools(toolDefinitions);
     } catch (err) {
       console.error("Failed to register tools:", err);
     }
-  }, [hasTools, aggregatedTools, connected]);
-  const handleSendMessage = useCallback11(async (message, attachments, messageForwardedProps) => {
+  }, [toolSystem.hasTools, toolSystem.aggregatedTools, connected]);
+  const handleSendMessage = useCallback12(async (message, attachments, messageForwardedProps) => {
     if (!clientRef.current) return;
-    setStreamingText("");
-    const activatedChatId = activatePendingChat();
-    const activeChatId = activatedChatId || currentChatId;
-    streamingChatIdRef.current = activeChatId;
+    serverEvents.clearStreamingText();
+    const activatedChatId = chatManagement.activatePendingChat();
+    const activeChatId = activatedChatId || chatManagement.currentChatId;
+    serverEvents.streamingChatIdRef.current = activeChatId;
     let persistedContent = message;
     let multimodalContent;
     if (attachments && attachments.length > 0) {
@@ -5007,12 +5093,12 @@ function UseAIProvider({
       }
       persistedContent = persistedParts;
       if (activeChatId) {
-        await saveUserMessage(activeChatId, persistedContent);
+        await chatManagement.saveUserMessage(activeChatId, persistedContent);
       }
-      setLoading(true);
+      serverEvents.setLoading(true);
       try {
         const fileContent = await processAttachments(attachments, {
-          getCurrentChat,
+          getCurrentChat: chatManagement.getCurrentChat,
           backend: fileUploadConfig?.backend,
           transformers: fileUploadConfig?.transformers,
           onFileProgress: (_fileId, state) => {
@@ -5025,16 +5111,16 @@ function UseAIProvider({
         }
         multimodalContent.push(...fileContent);
       } catch (error) {
-        setLoading(false);
+        serverEvents.setLoading(false);
         throw error;
       } finally {
         setFileProcessingState(null);
       }
     } else {
       if (activeChatId) {
-        await saveUserMessage(activeChatId, persistedContent);
+        await chatManagement.saveUserMessage(activeChatId, persistedContent);
       }
-      setLoading(true);
+      serverEvents.setLoading(true);
     }
     const providerResult = forwardedPropsProvider ? forwardedPropsProvider() : {};
     const providerProps = providerResult instanceof Promise ? await providerResult : providerResult;
@@ -5047,31 +5133,39 @@ function UseAIProvider({
       multimodalContent,
       Object.keys(mergedForwardedProps).length > 0 ? mergedForwardedProps : void 0
     );
-  }, [activatePendingChat, currentChatId, saveUserMessage, fileUploadConfig, getCurrentChat, forwardedPropsProvider]);
-  handleSendMessageRef.current = handleSendMessage;
+  }, [chatManagement, serverEvents, fileUploadConfig, forwardedPropsProvider]);
+  const messageQueue = useMessageQueue({
+    sendFn: handleSendMessage,
+    createNewChat: chatManagement.createNewChat,
+    setOpen: handleSetChatOpen,
+    connected,
+    loading: serverEvents.loading,
+    hasPendingApproval: toolSystem.pendingApprovals.length > 0
+  });
   const value = {
     serverUrl,
     connected,
     client: clientRef.current,
     tools: {
-      register: registerTools,
-      unregister: unregisterTools
+      register: toolSystem.registerTools,
+      unregister: toolSystem.unregisterTools,
+      signalReady: toolSystem.signalReady,
+      registerWaiter: toolSystem.registerWaiter,
+      unregisterWaiter: toolSystem.unregisterWaiter
     },
     prompts: {
-      update: updatePrompt,
-      registerWaiter,
-      unregisterWaiter
+      update: promptState.updatePrompt
     },
     chat: {
-      currentId: currentChatId,
-      create: createNewChat,
-      load: loadChat,
-      delete: deleteChat,
-      list: listChats,
-      clear: clearCurrentChat,
-      sendMessage,
-      get: getCurrentChat,
-      updateMetadata
+      currentId: chatManagement.currentChatId,
+      create: chatManagement.createNewChat,
+      load: chatManagement.loadChat,
+      delete: chatManagement.deleteChat,
+      list: chatManagement.listChats,
+      clear: chatManagement.clearCurrentChat,
+      sendMessage: messageQueue.sendMessage,
+      get: chatManagement.getCurrentChat,
+      updateMetadata: chatManagement.updateMetadata
     },
     agents: {
       available: availableAgents,
@@ -5087,26 +5181,23 @@ function UseAIProvider({
       delete: deleteCommand
     }
   };
-  const effectiveStreamingText = streamingChatIdRef.current === displayedChatId ? streamingText : "";
-  const executingToolDisplay = executingTool ? {
-    displayText: executingTool.title ?? executingToolFallbackRef.current ?? strings.toolExecution.fallbackMessages[0]
-  } : null;
+  const effectiveStreamingText = serverEvents.streamingChatIdRef.current === chatManagement.displayedChatId ? serverEvents.streamingText : "";
   const chatUIContextValue = {
     connected,
-    loading,
+    loading: serverEvents.loading,
     sendMessage: handleSendMessage,
     messages,
     streamingText: effectiveStreamingText,
-    suggestions: aggregatedSuggestions,
+    suggestions: promptState.aggregatedSuggestions,
     fileUploadConfig,
     fileProcessing: fileProcessingState,
     history: {
-      currentId: displayedChatId,
-      create: createNewChat,
-      load: loadChat,
-      delete: deleteChat,
-      list: listChats,
-      get: getCurrentChat
+      currentId: chatManagement.displayedChatId,
+      create: chatManagement.createNewChat,
+      load: chatManagement.loadChat,
+      delete: chatManagement.deleteChat,
+      list: chatManagement.listChats,
+      get: chatManagement.getCurrentChat
     },
     agents: {
       available: availableAgents,
@@ -5125,11 +5216,11 @@ function UseAIProvider({
       setOpen: handleSetChatOpen
     },
     tools: {
-      executing: executingToolDisplay,
+      executing: serverEvents.executingTool,
       pending: {
-        tools: toolExecution.pendingApprovals,
-        approveAll: toolExecution.approveAll,
-        rejectAll: toolExecution.rejectAll
+        tools: toolSystem.pendingApprovals,
+        approveAll: toolSystem.approveAll,
+        rejectAll: toolSystem.rejectAll
       }
     },
     feedback: {
@@ -5143,15 +5234,15 @@ function UseAIProvider({
   const chatPanelProps = {
     onSendMessage: handleSendMessage,
     messages,
-    loading,
+    loading: serverEvents.loading,
     connected,
     streamingText: effectiveStreamingText,
-    currentChatId: displayedChatId,
-    onNewChat: createNewChat,
-    onLoadChat: loadChat,
-    onDeleteChat: deleteChat,
-    onListChats: listChats,
-    suggestions: aggregatedSuggestions,
+    currentChatId: chatManagement.displayedChatId,
+    onNewChat: chatManagement.createNewChat,
+    onLoadChat: chatManagement.loadChat,
+    onDeleteChat: chatManagement.deleteChat,
+    onListChats: chatManagement.listChats,
+    suggestions: promptState.aggregatedSuggestions,
     availableAgents,
     defaultAgent,
     selectedAgent,
@@ -5162,12 +5253,12 @@ function UseAIProvider({
     onSaveCommand: saveCommand,
     onRenameCommand: renameCommand,
     onDeleteCommand: deleteCommand,
-    executingTool: executingToolDisplay,
+    executingTool: serverEvents.executingTool,
     feedbackEnabled: feedback.enabled,
     onFeedback: feedback.submitFeedback,
-    pendingApprovals: toolExecution.pendingApprovals,
-    onApproveToolCall: toolExecution.pendingApprovals.length > 0 ? toolExecution.approveAll : void 0,
-    onRejectToolCall: toolExecution.pendingApprovals.length > 0 ? toolExecution.rejectAll : void 0
+    pendingApprovals: toolSystem.pendingApprovals,
+    onApproveToolCall: toolSystem.pendingApprovals.length > 0 ? toolSystem.approveAll : void 0,
+    onRejectToolCall: toolSystem.pendingApprovals.length > 0 ? toolSystem.rejectAll : void 0
   };
   const renderDefaultChat = () => {
     if (isUIDisabled) return null;
@@ -5188,9 +5279,9 @@ function UseAIProvider({
         onClose: () => handleSetChatOpen(false),
         onSendMessage: handleSendMessage,
         messages,
-        loading,
+        loading: serverEvents.loading,
         connected,
-        suggestions: aggregatedSuggestions,
+        suggestions: promptState.aggregatedSuggestions,
         availableAgents,
         defaultAgent,
         selectedAgent,
@@ -5231,11 +5322,11 @@ function useAIContext() {
 }
 
 // src/hooks/useStableTools.ts
-import { useRef as useRef12 } from "react";
+import { useRef as useRef13 } from "react";
 function useStableTools(tools) {
-  const latestToolsRef = useRef12({});
-  const stableToolsRef = useRef12({});
-  const prevToolNamesRef = useRef12("");
+  const latestToolsRef = useRef13({});
+  const stableToolsRef = useRef13({});
+  const prevToolNamesRef = useRef13("");
   if (!tools) {
     latestToolsRef.current = {};
     return void 0;
@@ -5266,19 +5357,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,
@@ -5303,27 +5394,27 @@ function namespaceTools(tools, namespace) {
 function useAI(options = {}) {
   const { enabled = true } = options;
   const { connected, tools, client, prompts } = useAIContext();
-  const { register: registerTools, unregister: unregisterTools } = tools;
-  const { update: updatePrompt, registerWaiter, unregisterWaiter } = prompts;
+  const { register: registerTools, unregister: unregisterTools, signalReady, registerWaiter, unregisterWaiter } = tools;
+  const { update: updatePrompt } = prompts;
   const [response, setResponse] = useState14(null);
   const [loading, setLoading] = useState14(false);
   const [error, setError] = useState14(null);
-  const hookId = useRef13(`useAI-${Math.random().toString(36).substr(2, 9)}`);
-  const toolsRef = useRef13({});
-  const componentRef = useRef13(null);
-  const promptChangeResolvers = useRef13([]);
+  const hookId = useRef14(`useAI-${Math.random().toString(36).substr(2, 9)}`);
+  const toolsRef = useRef14({});
+  const componentRef = useRef14(null);
+  const promptChangeResolvers = useRef14([]);
   const stableTools = useStableTools(options.tools);
   const toolsKey = useMemo6(() => {
     if (!options.tools) return "";
     return Object.keys(options.tools).sort().join(",");
   }, [options.tools]);
   const memoizedSuggestions = useMemo6(() => options.suggestions, [options.suggestions]);
-  useEffect11(() => {
+  useEffect12(() => {
     if (componentRef.current) {
       componentRef.current.setAttribute("data-useai-context", "true");
     }
   }, []);
-  const waitForPromptChange = useCallback12(() => {
+  const waitForPromptChange = useCallback13(() => {
     return new Promise((resolve) => {
       const timeoutMs = 100;
       const timeoutId = setTimeout(() => {
@@ -5340,14 +5431,14 @@ function useAI(options = {}) {
       promptChangeResolvers.current.push(resolveAndCleanup);
     });
   }, []);
-  useEffect11(() => {
+  useEffect12(() => {
     if (!enabled || options.invisible) return;
     registerWaiter(hookId.current, waitForPromptChange);
     return () => {
       unregisterWaiter(hookId.current);
     };
   }, [enabled, options.invisible, registerWaiter, unregisterWaiter, waitForPromptChange]);
-  useEffect11(() => {
+  useEffect12(() => {
     if (!enabled) return;
     updatePrompt(hookId.current, options.prompt, memoizedSuggestions);
     if (promptChangeResolvers.current.length > 0) {
@@ -5355,29 +5446,30 @@ function useAI(options = {}) {
       promptChangeResolvers.current = [];
     }
   }, [enabled, options.prompt, memoizedSuggestions, updatePrompt]);
-  const updatePromptRef = useRef13(updatePrompt);
+  const updatePromptRef = useRef14(updatePrompt);
   updatePromptRef.current = updatePrompt;
-  useEffect11(() => {
+  useEffect12(() => {
     const id = hookId.current;
     return () => {
       updatePromptRef.current(id, void 0, void 0);
     };
   }, []);
-  useEffect11(() => {
+  useLayoutEffect(() => {
     if (!enabled) return;
     if (stableTools) {
       const componentId = options.id || componentRef.current?.id;
       const toolsToRegister = componentId ? namespaceTools(stableTools, componentId) : stableTools;
       registerTools(hookId.current, toolsToRegister, { invisible: options.invisible });
       toolsRef.current = toolsToRegister;
+      signalReady(hookId.current);
     }
     return () => {
       if (stableTools) {
         unregisterTools(hookId.current);
       }
     };
-  }, [enabled, toolsKey, stableTools, options.id, options.invisible, registerTools, unregisterTools]);
-  useEffect11(() => {
+  }, [enabled, toolsKey, stableTools, options.id, options.invisible, registerTools, unregisterTools, signalReady]);
+  useEffect12(() => {
     if (!enabled || !client) return;
     const unsubscribe = client.onEvent(hookId.current, (event) => {
       handleAGUIEvent(event);
@@ -5386,9 +5478,9 @@ function useAI(options = {}) {
       unsubscribe();
     };
   }, [enabled, client]);
-  const handleAGUIEvent = useCallback12(async (event) => {
+  const handleAGUIEvent = useCallback13(async (event) => {
     switch (event.type) {
-      case EventType.TEXT_MESSAGE_END: {
+      case EventType2.TEXT_MESSAGE_END: {
         const content = client?.currentMessageContent;
         if (content) {
           setResponse(content);
@@ -5396,7 +5488,7 @@ function useAI(options = {}) {
         }
         break;
       }
-      case EventType.RUN_ERROR: {
+      case EventType2.RUN_ERROR: {
         const errorEvent = event;
         const error2 = new Error(errorEvent.message);
         setError(error2);
@@ -5406,7 +5498,7 @@ function useAI(options = {}) {
       }
     }
   }, [client, options.onError]);
-  const generate = useCallback12(async (prompt) => {
+  const generate = useCallback13(async (prompt) => {
     if (!enabled) {
       const error2 = new Error("AI features are disabled");
       setError(error2);
@@ -5442,7 +5534,7 @@ function useAI(options = {}) {
 }
 
 // src/useAIWorkflow.ts
-import { useState as useState15, useCallback as useCallback13, useRef as useRef14, useEffect as useEffect12 } from "react";
+import { useState as useState15, useCallback as useCallback14, useRef as useRef15, useEffect as useEffect13 } from "react";
 import { EventType as EventType3 } from "@meetsmore-oss/use-ai-core";
 import { v4 as uuidv43 } from "uuid";
 function useAIWorkflow(runner, workflowId) {
@@ -5450,9 +5542,9 @@ function useAIWorkflow(runner, workflowId) {
   const [status, setStatus] = useState15("idle");
   const [text, setText] = useState15(null);
   const [error, setError] = useState15(null);
-  const currentWorkflowRef = useRef14(null);
-  const eventListenerIdRef = useRef14(`useAIWorkflow-${Math.random().toString(36).substr(2, 9)}`);
-  const handleWorkflowEvent = useCallback13(async (event) => {
+  const currentWorkflowRef = useRef15(null);
+  const eventListenerIdRef = useRef15(`useAIWorkflow-${Math.random().toString(36).substr(2, 9)}`);
+  const handleWorkflowEvent = useCallback14(async (event) => {
     const currentWorkflow = currentWorkflowRef.current;
     if (!currentWorkflow) return;
     if (event.type === EventType3.RUN_STARTED) {
@@ -5485,7 +5577,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,
@@ -5537,14 +5632,14 @@ function useAIWorkflow(runner, workflowId) {
       }
     }
   }, [client]);
-  useEffect12(() => {
+  useEffect13(() => {
     if (!client) return;
     const unsubscribe = client.onEvent(eventListenerIdRef.current, handleWorkflowEvent);
     return () => {
       unsubscribe();
     };
   }, [client, handleWorkflowEvent]);
-  const trigger = useCallback13(async (options) => {
+  const trigger = useCallback14(async (options) => {
     if (!client?.isConnected()) {
       const err = new Error("Not connected to server");
       setError(err);
@@ -5635,12 +5730,14 @@ export {
   useDropdownState,
   useFeedback,
   useFileUpload,
+  useMessageQueue,
   usePromptState,
+  useServerEvents,
   useSlashCommands,
   useStableTools,
   useStrings,
   useTheme,
-  useToolRegistry,
+  useToolSystem,
   validateCommandName,
   z2 as z
 };