@dexto/core 1.6.25 → 1.6.27

package/dist/tools/tool-manager.js

@@ -21,6 +21,24 @@ _ToolManager_decorators = [InstrumentClass({
   excludeMethods: ["setHookSupport", "getApprovalManager", "getAllowedToolsProvider"]
 })];
 let _ToolManager = class _ToolManager {
+  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, tools, logger, sessionToolPreferencesStore) {
+    this.sessionToolPreferencesStore = sessionToolPreferencesStore;
+    this.mcpManager = mcpManager;
+    this.approvalManager = approvalManager;
+    this.allowedToolsProvider = allowedToolsProvider;
+    this.approvalMode = approvalMode;
+    this.agentEventBus = agentEventBus;
+    this.toolPolicies = toolPolicies;
+    this.logger = logger.createChild(DextoLogComponent.TOOLS);
+    this.setTools(tools);
+    this.toolExecutionContextFactory = () => {
+      throw ToolError.configInvalid(
+        "ToolExecutionContextFactory not configured. DextoAgent.start() must configure tool execution context before tools can run."
+      );
+    };
+    this.setupNotificationListeners();
+    this.logger.debug("ToolManager initialized");
+  }
   mcpManager;
   agentTools = /* @__PURE__ */ new Map();
   approvalManager;
@@ -53,6 +71,8 @@ let _ToolManager = class _ToolManager {
   // Session-level auto-approve tools set by users (UI)
   sessionUserAutoApproveTools = /* @__PURE__ */ new Map();
   sessionDisabledTools = /* @__PURE__ */ new Map();
+  restoredSessionPreferences = /* @__PURE__ */ new Set();
+  sessionPreferenceLocks = /* @__PURE__ */ new Map();
   globalDisabledTools = [];
   cleanupHandlers = /* @__PURE__ */ new Set();
   cleanupStarted = false;
@@ -76,22 +96,76 @@ let _ToolManager = class _ToolManager {
     }
     return this.resolveLocalToolIdOrAlias(pattern) ?? pattern;
   }
-  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, tools, logger) {
-    this.mcpManager = mcpManager;
-    this.approvalManager = approvalManager;
-    this.allowedToolsProvider = allowedToolsProvider;
-    this.approvalMode = approvalMode;
-    this.agentEventBus = agentEventBus;
-    this.toolPolicies = toolPolicies;
-    this.logger = logger.createChild(DextoLogComponent.TOOLS);
-    this.setTools(tools);
-    this.toolExecutionContextFactory = () => {
-      throw ToolError.configInvalid(
-        "ToolExecutionContextFactory not configured. DextoAgent.start() must configure tool execution context before tools can run."
-      );
+  async runWithSessionPreferenceLock(sessionId, fn) {
+    const previousLock = this.sessionPreferenceLocks.get(sessionId) ?? Promise.resolve();
+    const currentResult = previousLock.catch(() => {
+    }).then(() => fn());
+    const currentLock = currentResult.then(
+      () => void 0,
+      () => void 0
+    );
+    this.sessionPreferenceLocks.set(sessionId, currentLock);
+    try {
+      return await currentResult;
+    } finally {
+      if (this.sessionPreferenceLocks.get(sessionId) === currentLock) {
+        this.sessionPreferenceLocks.delete(sessionId);
+      }
+    }
+  }
+  applySessionToolPreferences(sessionId, preferences) {
+    if (preferences.userAutoApproveTools.length > 0) {
+      this.sessionUserAutoApproveTools.set(sessionId, [...preferences.userAutoApproveTools]);
+    } else {
+      this.sessionUserAutoApproveTools.delete(sessionId);
+    }
+    if (preferences.disabledTools.length > 0) {
+      this.sessionDisabledTools.set(sessionId, [...preferences.disabledTools]);
+    } else {
+      this.sessionDisabledTools.delete(sessionId);
+    }
+  }
+  getSessionToolPreferencesSnapshot(sessionId) {
+    return {
+      userAutoApproveTools: [...this.sessionUserAutoApproveTools.get(sessionId) ?? []],
+      disabledTools: [...this.sessionDisabledTools.get(sessionId) ?? []]
     };
-    this.setupNotificationListeners();
-    this.logger.debug("ToolManager initialized");
+  }
+  async restoreSessionState(sessionId) {
+    if (this.restoredSessionPreferences.has(sessionId)) {
+      return;
+    }
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      if (this.restoredSessionPreferences.has(sessionId)) {
+        return;
+      }
+      const preferences = await this.sessionToolPreferencesStore.load(sessionId);
+      this.applySessionToolPreferences(sessionId, preferences);
+      this.restoredSessionPreferences.add(sessionId);
+      this.logger.debug("Restored persisted session tool preferences", {
+        sessionId,
+        autoApproveCount: preferences.userAutoApproveTools.length,
+        disabledCount: preferences.disabledTools.length
+      });
+    });
+  }
+  evictSessionState(sessionId) {
+    this.sessionAutoApproveTools.delete(sessionId);
+    this.sessionUserAutoApproveTools.delete(sessionId);
+    this.sessionDisabledTools.delete(sessionId);
+    this.restoredSessionPreferences.delete(sessionId);
+  }
+  async deleteSessionState(sessionId) {
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      this.evictSessionState(sessionId);
+      await this.sessionToolPreferencesStore.delete(sessionId);
+    });
+  }
+  async persistSessionToolPreferences(sessionId) {
+    await this.sessionToolPreferencesStore.save(
+      sessionId,
+      this.getSessionToolPreferencesSnapshot(sessionId)
+    );
   }
   /**
    * Initialize the ToolManager and its components
@@ -248,15 +322,19 @@ let _ToolManager = class _ToolManager {
   /**
    * Set session-level auto-approve tools chosen by the user.
    */
-  setSessionUserAutoApproveTools(sessionId, autoApproveTools) {
+  async setSessionUserAutoApproveTools(sessionId, autoApproveTools) {
+    await this.restoreSessionState(sessionId);
     if (autoApproveTools.length === 0) {
-      this.clearSessionUserAutoApproveTools(sessionId);
+      await this.clearSessionUserAutoApproveTools(sessionId);
       return;
     }
     const normalized = autoApproveTools.map(
       (pattern) => this.normalizeToolPolicyPattern(pattern)
     );
-    this.sessionUserAutoApproveTools.set(sessionId, normalized);
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      this.sessionUserAutoApproveTools.set(sessionId, normalized);
+      await this.persistSessionToolPreferences(sessionId);
+    });
     this.logger.info(
       `Session user auto-approve tools set for '${sessionId}': ${autoApproveTools.length} tools`
     );
@@ -265,9 +343,14 @@ let _ToolManager = class _ToolManager {
   /**
    * Clear session-level auto-approve tools chosen by the user.
    */
-  clearSessionUserAutoApproveTools(sessionId) {
-    const hadAutoApprove = this.sessionUserAutoApproveTools.has(sessionId);
-    this.sessionUserAutoApproveTools.delete(sessionId);
+  async clearSessionUserAutoApproveTools(sessionId) {
+    await this.restoreSessionState(sessionId);
+    let hadAutoApprove = false;
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      hadAutoApprove = this.sessionUserAutoApproveTools.has(sessionId);
+      this.sessionUserAutoApproveTools.delete(sessionId);
+      await this.persistSessionToolPreferences(sessionId);
+    });
     if (hadAutoApprove) {
       this.logger.info(`Session user auto-approve tools cleared for '${sessionId}'`);
     }
@@ -308,12 +391,16 @@ let _ToolManager = class _ToolManager {
   /**
    * Set session-level disabled tools (overrides global list).
    */
-  setSessionDisabledTools(sessionId, toolNames) {
+  async setSessionDisabledTools(sessionId, toolNames) {
+    await this.restoreSessionState(sessionId);
     if (toolNames.length === 0) {
-      this.clearSessionDisabledTools(sessionId);
+      await this.clearSessionDisabledTools(sessionId);
       return;
     }
-    this.sessionDisabledTools.set(sessionId, [...toolNames]);
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      this.sessionDisabledTools.set(sessionId, [...toolNames]);
+      await this.persistSessionToolPreferences(sessionId);
+    });
     this.logger.info("Session disabled tools updated", {
       sessionId,
       count: toolNames.length
@@ -327,9 +414,14 @@ let _ToolManager = class _ToolManager {
   /**
    * Clear session-level disabled tools.
    */
-  clearSessionDisabledTools(sessionId) {
-    const hadOverrides = this.sessionDisabledTools.has(sessionId);
-    this.sessionDisabledTools.delete(sessionId);
+  async clearSessionDisabledTools(sessionId) {
+    await this.restoreSessionState(sessionId);
+    let hadOverrides = false;
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      hadOverrides = this.sessionDisabledTools.has(sessionId);
+      this.sessionDisabledTools.delete(sessionId);
+      await this.persistSessionToolPreferences(sessionId);
+    });
     if (hadOverrides) {
       this.logger.info("Session disabled tools cleared", { sessionId });
     }
@@ -525,7 +617,7 @@ let _ToolManager = class _ToolManager {
     }
     return snapshot;
   }
-  getToolPresentationSnapshotForToolCallEvent(toolName, args, toolCallId, sessionId) {
+  getToolPresentationSnapshotForToolCallEvent(toolName, args, toolCallId, sessionId, runContext) {
     const fallback = this.buildGenericToolPresentationSnapshot(toolName);
     if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
       return fallback;
@@ -537,7 +629,7 @@ let _ToolManager = class _ToolManager {
     }
     try {
       const validatedArgs = this.validateLocalToolArgs(toolName, args);
-      const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+      const context = this.buildToolExecutionContext({ sessionId, toolCallId, runContext });
       const isPromiseLike = (value) => {
         if (typeof value !== "object" || value === null) {
           return false;
@@ -571,7 +663,7 @@ let _ToolManager = class _ToolManager {
       return fallback;
     }
   }
-  async getToolPresentationSnapshotForCall(toolName, args, toolCallId, sessionId) {
+  async getToolPresentationSnapshotForCall(toolName, args, toolCallId, sessionId, runContext) {
     const fallback = this.buildGenericToolPresentationSnapshot(toolName);
     if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
       return fallback;
@@ -582,7 +674,7 @@ let _ToolManager = class _ToolManager {
       return fallback;
     }
     try {
-      const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+      const context = this.buildToolExecutionContext({ sessionId, toolCallId, runContext });
       const describedHeader = describeHeader ? await Promise.resolve(describeHeader(args, context)) : null;
       const describedArgs = describeArgs ? await Promise.resolve(describeArgs(args, context)) : null;
       return {
@@ -597,7 +689,7 @@ let _ToolManager = class _ToolManager {
       return fallback;
     }
   }
-  async augmentSnapshotWithResult(toolName, snapshot, result, args, toolCallId, sessionId) {
+  async augmentSnapshotWithResult(toolName, snapshot, result, args, toolCallId, sessionId, runContext) {
     if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
       return snapshot;
     }
@@ -606,7 +698,7 @@ let _ToolManager = class _ToolManager {
       return snapshot;
     }
     try {
-      const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+      const context = this.buildToolExecutionContext({ sessionId, toolCallId, runContext });
       const resultPresentation = await Promise.resolve(describeResult(result, args, context));
       if (!resultPresentation) {
         return snapshot;
@@ -729,7 +821,7 @@ let _ToolManager = class _ToolManager {
           return false;
         }
         if (!patternKey) return false;
-        return this.approvalManager.matchesPattern(toolName, patternKey);
+        return this.approvalManager.matchesPattern(toolName, patternKey, sessionId);
       },
       { rememberPattern: void 0 }
       // Don't propagate pattern choice to auto-approved requests
@@ -760,7 +852,10 @@ let _ToolManager = class _ToolManager {
         if (!directoryAccess) {
           return false;
         }
-        return this.approvalManager.isDirectorySessionApproved(directoryAccess.parentDir);
+        return this.approvalManager.isDirectorySessionApproved(
+          directoryAccess.parentDir,
+          sessionId
+        );
       },
       { rememberDirectory: false }
     );
@@ -837,14 +932,33 @@ let _ToolManager = class _ToolManager {
     const workspace = this.currentWorkspace;
     const baseContext = {
       sessionId: options.sessionId,
+      runContext: options.runContext,
       workspaceId: workspace?.id,
       workspace,
       abortSignal: options.abortSignal,
       toolCallId: options.toolCallId,
+      hostRuntime: options.runContext?.hostRuntime,
       logger: this.logger
     };
     return this.toolExecutionContextFactory(baseContext);
   }
+  resolveToolExecutionInvocation(invocationOrSessionId, legacyAbortSignal) {
+    if (typeof invocationOrSessionId === "string") {
+      return {
+        sessionId: invocationOrSessionId,
+        abortSignal: legacyAbortSignal,
+        hostRuntime: void 0
+      };
+    }
+    const invocation = invocationOrSessionId ?? {};
+    const sessionId = invocation.runContext?.sessionId ?? invocation.sessionId;
+    return {
+      ...invocation,
+      ...invocation.abortSignal === void 0 && legacyAbortSignal !== void 0 ? { abortSignal: legacyAbortSignal } : {},
+      sessionId,
+      hostRuntime: invocation.runContext?.hostRuntime
+    };
+  }
   validateLocalToolArgs(toolName, args) {
     if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
       return args;
@@ -869,7 +983,7 @@ let _ToolManager = class _ToolManager {
     }
     return validated;
   }
-  async executeLocalTool(toolName, args, sessionId, abortSignal, toolCallId) {
+  async executeLocalTool(toolName, args, options) {
     const tool = this.agentTools.get(toolName);
     if (!tool) {
       this.logger.error(`\u274C No local tool found: ${toolName}`);
@@ -879,7 +993,12 @@ let _ToolManager = class _ToolManager {
       throw ToolError.notFound(toolName);
     }
     try {
-      const context = this.buildToolExecutionContext({ sessionId, abortSignal, toolCallId });
+      const context = this.buildToolExecutionContext({
+        sessionId: options?.sessionId,
+        abortSignal: options?.abortSignal,
+        toolCallId: options?.toolCallId,
+        runContext: options?.runContext
+      });
       const result = await tool.execute(args, context);
       return result;
     } catch (error) {
@@ -976,10 +1095,12 @@ let _ToolManager = class _ToolManager {
    * @param toolName Tool name (e.g., "edit_file", "mcp--filesystem--read_file")
    * @param args The arguments for the tool
    * @param toolCallId The unique tool call ID for tracking (from LLM or generated for direct calls)
-   * @param sessionId Optional session ID for context
-   * @param abortSignal Optional abort signal for cancellation support
+   * @param invocationOrSessionId Optional execution-scoped context for this tool call,
+   * or the legacy positional sessionId
+   * @param legacyAbortSignal Optional legacy positional abort signal
    */
-  async executeTool(toolName, args, toolCallId, sessionId, abortSignal) {
+  async executeTool(toolName, args, toolCallId, invocationOrSessionId, legacyAbortSignal) {
+    const { sessionId, abortSignal, runContext, hostRuntime } = this.resolveToolExecutionInvocation(invocationOrSessionId, legacyAbortSignal);
     const { toolArgs: rawToolArgs, meta } = extractToolCallMeta(args);
     const eventMeta = Object.keys(meta).length > 0 ? meta : void 0;
     let toolArgs = rawToolArgs;
@@ -992,7 +1113,8 @@ let _ToolManager = class _ToolManager {
         toolName,
         toolArgs,
         toolCallId,
-        sessionId
+        sessionId,
+        runContext
       );
       this.agentEventBus.emit("llm:tool-call", {
         toolName,
@@ -1001,7 +1123,8 @@ let _ToolManager = class _ToolManager {
         ...eventMeta !== void 0 ? { meta: eventMeta } : {},
         ...callDescription !== void 0 && { callDescription },
         callId: toolCallId,
-        sessionId
+        sessionId,
+        ...hostRuntime !== void 0 && { hostRuntime }
       });
     }
     const {
@@ -1014,6 +1137,7 @@ let _ToolManager = class _ToolManager {
       toolArgs,
       toolCallId,
       sessionId,
+      runContext,
       callDescription
     );
     toolArgs = validatedToolArgs;
@@ -1025,7 +1149,8 @@ let _ToolManager = class _ToolManager {
       this.agentEventBus.emit("tool:running", {
         toolName,
         toolCallId,
-        sessionId
+        sessionId,
+        ...hostRuntime !== void 0 && { hostRuntime }
       });
     }
     const startTime = Date.now();
@@ -1043,6 +1168,7 @@ let _ToolManager = class _ToolManager {
           mcpManager: this.mcpManager,
           toolManager: this,
           stateManager: this.stateManager,
+          ...runContext !== void 0 && { runContext },
           ...sessionId !== void 0 && { sessionId }
         }
       );
@@ -1077,6 +1203,12 @@ let _ToolManager = class _ToolManager {
         }
         this.logger.debug(`\u{1F3AF} MCP routing: '${toolName}' -> '${actualToolName}'`);
         const runInBackground = backgroundTasksEnabled && meta.runInBackground === true && sessionId !== void 0;
+        const executeMcpTool = () => runContext === void 0 ? this.mcpManager.executeTool(actualToolName, toolArgs, sessionId) : this.mcpManager.executeTool(
+          actualToolName,
+          toolArgs,
+          sessionId,
+          runContext
+        );
         if (meta.runInBackground === true && !backgroundTasksEnabled) {
           this.logger.debug(
             "Background tool execution disabled; running synchronously instead.",
@@ -1086,7 +1218,7 @@ let _ToolManager = class _ToolManager {
         if (runInBackground) {
           const backgroundSessionId = sessionId;
           const { result: backgroundResult, promise } = registerBackgroundTask(
-            this.mcpManager.executeTool(actualToolName, toolArgs, backgroundSessionId),
+            executeMcpTool(),
             `MCP tool ${actualToolName}`
           );
           this.agentEventBus.emit("tool:background", {
@@ -1095,6 +1227,7 @@ let _ToolManager = class _ToolManager {
             sessionId: backgroundSessionId,
             description: backgroundResult.description,
             promise,
+            ...hostRuntime !== void 0 && { hostRuntime },
             ...meta.timeoutMs !== void 0 && { timeoutMs: meta.timeoutMs },
             ...meta.notifyOnComplete !== void 0 && {
               notifyOnComplete: meta.notifyOnComplete
@@ -1102,7 +1235,7 @@ let _ToolManager = class _ToolManager {
           });
           result = backgroundResult;
         } else {
-          result = await this.mcpManager.executeTool(actualToolName, toolArgs, sessionId);
+          result = await executeMcpTool();
         }
       } else {
         const runInBackground = backgroundTasksEnabled && meta.runInBackground === true && sessionId !== void 0;
@@ -1115,13 +1248,12 @@ let _ToolManager = class _ToolManager {
         if (runInBackground) {
           const backgroundSessionId = sessionId;
           const { result: backgroundResult, promise } = registerBackgroundTask(
-            this.executeLocalTool(
-              toolName,
-              toolArgs,
-              backgroundSessionId,
+            this.executeLocalTool(toolName, toolArgs, {
+              sessionId: backgroundSessionId,
               abortSignal,
-              toolCallId
-            ),
+              toolCallId,
+              runContext
+            }),
             `Tool ${toolName}`
           );
           this.agentEventBus.emit("tool:background", {
@@ -1130,6 +1262,7 @@ let _ToolManager = class _ToolManager {
             sessionId: backgroundSessionId,
             description: backgroundResult.description,
             promise,
+            ...hostRuntime !== void 0 && { hostRuntime },
             ...meta.timeoutMs !== void 0 && { timeoutMs: meta.timeoutMs },
             ...meta.notifyOnComplete !== void 0 && {
               notifyOnComplete: meta.notifyOnComplete
@@ -1137,13 +1270,12 @@ let _ToolManager = class _ToolManager {
           });
           result = backgroundResult;
         } else {
-          result = await this.executeLocalTool(
-            toolName,
-            toolArgs,
+          result = await this.executeLocalTool(toolName, toolArgs, {
             sessionId,
             abortSignal,
-            toolCallId
-          );
+            toolCallId,
+            runContext
+          });
         }
       }
       const duration = Date.now() - startTime;
@@ -1166,6 +1298,7 @@ let _ToolManager = class _ToolManager {
             mcpManager: this.mcpManager,
             toolManager: this,
             stateManager: this.stateManager,
+            ...runContext !== void 0 && { runContext },
             ...sessionId !== void 0 && { sessionId }
           }
         );
@@ -1177,7 +1310,8 @@ let _ToolManager = class _ToolManager {
         result,
         toolArgs,
         toolCallId,
-        sessionId
+        sessionId,
+        runContext
       );
       return {
         result,
@@ -1202,6 +1336,7 @@ let _ToolManager = class _ToolManager {
           mcpManager: this.mcpManager,
           toolManager: this,
           stateManager: this.stateManager,
+          ...runContext !== void 0 && { runContext },
           ...sessionId !== void 0 && { sessionId }
         });
       }
@@ -1310,7 +1445,7 @@ let _ToolManager = class _ToolManager {
    * Handle tool approval flow. Checks various precedence levels to determine
    * if a tool should be auto-approved, denied, or requires manual approval.
    */
-  async handleToolApproval(toolName, args, toolCallId, sessionId, callDescription) {
+  async handleToolApproval(toolName, args, toolCallId, sessionId, runContext, callDescription) {
     if (this.isInAlwaysDenyList(toolName)) {
       this.logger.info(
         `Tool '${toolName}' is in static deny list \u2013 blocking execution (session: ${sessionId ?? "global"})`
@@ -1322,14 +1457,19 @@ let _ToolManager = class _ToolManager {
       toolName,
       validatedArgs,
       toolCallId,
-      sessionId
+      sessionId,
+      runContext
     );
     let directoryAccess;
     let directoryAccessApprovalRequest;
     if (!toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
       const getApprovalOverride = this.getToolApprovalOverrideFn(toolName);
       if (getApprovalOverride) {
-        const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+        const context = this.buildToolExecutionContext({
+          sessionId,
+          toolCallId,
+          runContext
+        });
         const approvalRequest = await getApprovalOverride(validatedArgs, context);
         if (approvalRequest) {
           if (approvalRequest.type === ApprovalType.DIRECTORY_ACCESS) {
@@ -1348,6 +1488,9 @@ let _ToolManager = class _ToolManager {
             if (sessionId && !approvalRequest.sessionId) {
               approvalRequest.sessionId = sessionId;
             }
+            if (runContext?.hostRuntime !== void 0 && approvalRequest.hostRuntime === void 0) {
+              approvalRequest.hostRuntime = runContext.hostRuntime;
+            }
             const response = await this.approvalManager.requestApproval(approvalRequest);
             if (response.status === ApprovalStatus.APPROVED) {
               const onGranted = this.getToolApprovalOnGrantedFn(toolName);
@@ -1388,6 +1531,7 @@ let _ToolManager = class _ToolManager {
       validatedArgs,
       toolCallId,
       sessionId,
+      runContext,
       directoryAccess,
       directoryAccessApprovalRequest,
       callDescription,
@@ -1410,7 +1554,11 @@ let _ToolManager = class _ToolManager {
   async tryQuickApprovalResolution(toolName, args, sessionId, directoryAccess) {
     if (directoryAccess) {
       if (this.approvalMode === "auto-approve") {
-        this.approvalManager.addApprovedDirectory(directoryAccess.parentDir, "once");
+        await this.approvalManager.addApprovedDirectory(
+          directoryAccess.parentDir,
+          "once",
+          sessionId
+        );
         return { requireApproval: false };
       }
       return null;
@@ -1434,7 +1582,7 @@ let _ToolManager = class _ToolManager {
       return { requireApproval: false };
     }
     const patternKey = this.getToolPatternKey(toolName, args);
-    if (patternKey && this.approvalManager.matchesPattern(toolName, patternKey)) {
+    if (patternKey && this.approvalManager.matchesPattern(toolName, patternKey, sessionId)) {
       this.logger.info(
         `Tool '${toolName}' matched approved pattern key '${patternKey}' \u2013 skipping confirmation.`
       );
@@ -1454,7 +1602,7 @@ let _ToolManager = class _ToolManager {
    * Request manual approval from the user for a tool execution.
    * Generates preview, sends approval request, and handles the response.
    */
-  async requestManualApproval(toolName, args, toolCallId, sessionId, directoryAccess, directoryAccessApprovalRequest, callDescription, presentationSnapshot) {
+  async requestManualApproval(toolName, args, toolCallId, sessionId, runContext, directoryAccess, directoryAccessApprovalRequest, callDescription, presentationSnapshot) {
     this.logger.info(
       `Tool approval requested for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
@@ -1463,8 +1611,10 @@ let _ToolManager = class _ToolManager {
         toolName,
         args,
         toolCallId,
-        sessionId
+        sessionId,
+        runContext
       );
+      const hostRuntime = runContext?.hostRuntime ?? directoryAccessApprovalRequest?.hostRuntime;
       const suggestedPatterns = this.getToolSuggestedPatterns(toolName, args);
       const response = await this.approvalManager.requestToolApproval({
         toolName,
@@ -1473,6 +1623,7 @@ let _ToolManager = class _ToolManager {
         args,
         ...callDescription !== void 0 && { description: callDescription },
         ...sessionId !== void 0 && { sessionId },
+        ...hostRuntime !== void 0 && { hostRuntime },
         ...displayPreview !== void 0 && { displayPreview },
         ...directoryAccess !== void 0 && { directoryAccess },
         ...suggestedPatterns !== void 0 && { suggestedPatterns }
@@ -1480,7 +1631,11 @@ let _ToolManager = class _ToolManager {
       if (response.status === ApprovalStatus.APPROVED && directoryAccessApprovalRequest !== void 0) {
         const onGranted = this.getToolApprovalOnGrantedFn(toolName);
         if (onGranted) {
-          const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+          const context = this.buildToolExecutionContext({
+            sessionId,
+            toolCallId,
+            runContext
+          });
           await Promise.resolve(
             onGranted(response, context, directoryAccessApprovalRequest)
           );
@@ -1506,13 +1661,13 @@ let _ToolManager = class _ToolManager {
   /**
    * Generate a preview for the tool approval UI if the tool supports it.
    */
-  async generateToolPreview(toolName, args, toolCallId, sessionId) {
+  async generateToolPreview(toolName, args, toolCallId, sessionId, runContext) {
     const previewFn = this.getToolPreviewFn(toolName);
     if (!previewFn) {
       return void 0;
     }
     try {
-      const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+      const context = this.buildToolExecutionContext({ sessionId, toolCallId, runContext });
       const preview = await previewFn(args, context);
       this.logger.debug(`Generated preview for ${toolName}`);
       return preview ?? void 0;
@@ -1544,7 +1699,7 @@ let _ToolManager = class _ToolManager {
       );
       this.autoApprovePendingToolRequests(toolName, allowSessionId);
     } else if (rememberPattern && this.getToolApprovalPatternKeyFn(toolName)) {
-      this.approvalManager.addPattern(toolName, rememberPattern);
+      await this.approvalManager.addPattern(toolName, rememberPattern, sessionId);
       this.logger.info(`Pattern '${rememberPattern}' added for tool '${toolName}' approval`);
       this.autoApprovePendingPatternRequests(toolName, sessionId);
     } else if (rememberDirectory) {

package/dist/tools/types.d.ts

@@ -13,6 +13,8 @@ import type { PromptManager } from '../prompts/prompt-manager.js';
 import type { ResourceManager } from '../resources/manager.js';
 import type { SearchService } from '../search/search-service.js';
 import type { Logger } from '../logger/v2/types.js';
+import type { HostRuntimeContext } from '../runtime/index.js';
+import type { AgentRunContext } from '../runtime/run-context.js';
 /**
  * Interface for forking execution to an isolated sub-agent context.
  *
@@ -48,6 +50,8 @@ export interface ToolServices {
 export interface ToolExecutionContextBase {
     /** Session ID if available */
     sessionId?: string | undefined;
+    /** Internal run-scoped execution context for this tool invocation */
+    runContext?: AgentRunContext | undefined;
     /** Workspace ID if available */
     workspaceId?: string | undefined;
     /** Workspace context if available */
@@ -56,6 +60,8 @@ export interface ToolExecutionContextBase {
     abortSignal?: AbortSignal | undefined;
     /** Unique tool call ID for tracking parallel tool calls */
     toolCallId?: string | undefined;
+    /** Host-owned runtime IDs for orchestration and correlation */
+    hostRuntime?: HostRuntimeContext | undefined;
     /**
      * Logger scoped to the tool execution.
      */
@@ -294,6 +300,6 @@ export interface ToolResult {
  */
 export interface ToolProvider {
     getTools(): Promise<ToolSet>;
-    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    callTool(toolName: string, args: Record<string, unknown>, context?: Pick<ToolExecutionContextBase, 'sessionId' | 'runContext'>): Promise<unknown>;
 }
 //# sourceMappingURL=types.d.ts.map