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

package/dist/bundled.js

@@ -11539,7 +11539,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",
@@ -35134,7 +35135,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;
@@ -35168,21 +35170,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
@@ -35873,6 +35875,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);
@@ -35982,7 +35985,9 @@ function useToolSystem({
         toolCallId: event.toolCallId,
         toolCallName: event.toolCallName,
         toolCallArgs: event.toolCallArgs,
-        annotations: event.annotations
+        annotations: event.annotations,
+        message: event.message,
+        metadata: event.metadata
       }
     ]);
   }, []);
@@ -35995,8 +36000,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) {
@@ -36041,24 +36064,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 {
@@ -36850,19 +36881,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,
@@ -37068,7 +37099,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,