@dexto/core 1.6.25 → 1.6.27

package/dist/tools/tool-manager.cjs

@@ -81,6 +81,24 @@ _ToolManager_decorators = [(0, import_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(import_types2.DextoLogComponent.TOOLS);
+    this.setTools(tools);
+    this.toolExecutionContextFactory = () => {
+      throw import_errors.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;
@@ -113,6 +131,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;
@@ -136,22 +156,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(import_types2.DextoLogComponent.TOOLS);
-    this.setTools(tools);
-    this.toolExecutionContextFactory = () => {
-      throw import_errors.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
@@ -308,15 +382,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`
     );
@@ -325,9 +403,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}'`);
     }
@@ -368,12 +451,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
@@ -387,9 +474,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 });
     }
@@ -585,7 +677,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;
@@ -597,7 +689,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;
@@ -631,7 +723,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;
@@ -642,7 +734,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 {
@@ -657,7 +749,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;
     }
@@ -666,7 +758,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;
@@ -789,7 +881,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
@@ -820,7 +912,10 @@ let _ToolManager = class _ToolManager {
         if (!directoryAccess) {
           return false;
         }
-        return this.approvalManager.isDirectorySessionApproved(directoryAccess.parentDir);
+        return this.approvalManager.isDirectorySessionApproved(
+          directoryAccess.parentDir,
+          sessionId
+        );
       },
       { rememberDirectory: false }
     );
@@ -897,14 +992,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;
@@ -929,7 +1043,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}`);
@@ -939,7 +1053,12 @@ let _ToolManager = class _ToolManager {
       throw import_errors.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) {
@@ -1036,10 +1155,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 } = (0, import_tool_call_metadata.extractToolCallMeta)(args);
     const eventMeta = Object.keys(meta).length > 0 ? meta : void 0;
     let toolArgs = rawToolArgs;
@@ -1052,7 +1173,8 @@ let _ToolManager = class _ToolManager {
         toolName,
         toolArgs,
         toolCallId,
-        sessionId
+        sessionId,
+        runContext
       );
       this.agentEventBus.emit("llm:tool-call", {
         toolName,
@@ -1061,7 +1183,8 @@ let _ToolManager = class _ToolManager {
         ...eventMeta !== void 0 ? { meta: eventMeta } : {},
         ...callDescription !== void 0 && { callDescription },
         callId: toolCallId,
-        sessionId
+        sessionId,
+        ...hostRuntime !== void 0 && { hostRuntime }
       });
     }
     const {
@@ -1074,6 +1197,7 @@ let _ToolManager = class _ToolManager {
       toolArgs,
       toolCallId,
       sessionId,
+      runContext,
       callDescription
     );
     toolArgs = validatedToolArgs;
@@ -1085,7 +1209,8 @@ let _ToolManager = class _ToolManager {
       this.agentEventBus.emit("tool:running", {
         toolName,
         toolCallId,
-        sessionId
+        sessionId,
+        ...hostRuntime !== void 0 && { hostRuntime }
       });
     }
     const startTime = Date.now();
@@ -1103,6 +1228,7 @@ let _ToolManager = class _ToolManager {
           mcpManager: this.mcpManager,
           toolManager: this,
           stateManager: this.stateManager,
+          ...runContext !== void 0 && { runContext },
           ...sessionId !== void 0 && { sessionId }
         }
       );
@@ -1137,6 +1263,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.",
@@ -1146,7 +1278,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", {
@@ -1155,6 +1287,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
@@ -1162,7 +1295,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;
@@ -1175,13 +1308,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", {
@@ -1190,6 +1322,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
@@ -1197,13 +1330,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;
@@ -1226,6 +1358,7 @@ let _ToolManager = class _ToolManager {
             mcpManager: this.mcpManager,
             toolManager: this,
             stateManager: this.stateManager,
+            ...runContext !== void 0 && { runContext },
             ...sessionId !== void 0 && { sessionId }
           }
         );
@@ -1237,7 +1370,8 @@ let _ToolManager = class _ToolManager {
         result,
         toolArgs,
         toolCallId,
-        sessionId
+        sessionId,
+        runContext
       );
       return {
         result,
@@ -1262,6 +1396,7 @@ let _ToolManager = class _ToolManager {
           mcpManager: this.mcpManager,
           toolManager: this,
           stateManager: this.stateManager,
+          ...runContext !== void 0 && { runContext },
           ...sessionId !== void 0 && { sessionId }
         });
       }
@@ -1370,7 +1505,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"})`
@@ -1382,14 +1517,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 === import_types3.ApprovalType.DIRECTORY_ACCESS) {
@@ -1408,6 +1548,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 === import_types3.ApprovalStatus.APPROVED) {
               const onGranted = this.getToolApprovalOnGrantedFn(toolName);
@@ -1448,6 +1591,7 @@ let _ToolManager = class _ToolManager {
       validatedArgs,
       toolCallId,
       sessionId,
+      runContext,
       directoryAccess,
       directoryAccessApprovalRequest,
       callDescription,
@@ -1470,7 +1614,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;
@@ -1494,7 +1642,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.`
       );
@@ -1514,7 +1662,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"}`
     );
@@ -1523,8 +1671,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,
@@ -1533,6 +1683,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 }
@@ -1540,7 +1691,11 @@ let _ToolManager = class _ToolManager {
       if (response.status === import_types3.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)
           );
@@ -1566,13 +1721,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;
@@ -1604,7 +1759,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) {