@dexto/core 1.7.1 → 1.8.0

package/dist/tools/approval/session-tool-policy.cjs

@@ -0,0 +1,269 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var session_tool_policy_exports = {};
+__export(session_tool_policy_exports, {
+  SessionToolPolicy: () => SessionToolPolicy,
+  matchesToolPolicyPattern: () => matchesToolPolicyPattern
+});
+module.exports = __toCommonJS(session_tool_policy_exports);
+const MCP_TOOL_PREFIX = "mcp--";
+function matchesToolPolicyPattern(toolName, policyPattern) {
+  if (toolName === policyPattern) {
+    return true;
+  }
+  if (!policyPattern.startsWith(MCP_TOOL_PREFIX)) {
+    return false;
+  }
+  const baseName = policyPattern.substring(MCP_TOOL_PREFIX.length);
+  return toolName.endsWith(`--${baseName}`) && toolName.startsWith(MCP_TOOL_PREFIX);
+}
+class SessionToolPolicy {
+  constructor(preferencesStore, logger, normalizePattern) {
+    this.preferencesStore = preferencesStore;
+    this.logger = logger;
+    this.normalizePattern = normalizePattern;
+  }
+  sessionAutoApproveTools = /* @__PURE__ */ new Map();
+  sessionUserAutoApproveTools = /* @__PURE__ */ new Map();
+  sessionDisabledTools = /* @__PURE__ */ new Map();
+  restoredSessionPreferences = /* @__PURE__ */ new Set();
+  sessionPreferenceLocks = /* @__PURE__ */ new Map();
+  globalDisabledTools = [];
+  async restoreSessionState(sessionId) {
+    if (this.restoredSessionPreferences.has(sessionId)) {
+      return;
+    }
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      if (this.restoredSessionPreferences.has(sessionId)) {
+        return;
+      }
+      const preferences = await this.preferencesStore.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.preferencesStore.delete(sessionId);
+    });
+  }
+  setSessionAutoApproveTools(sessionId, autoApproveTools) {
+    if (autoApproveTools.length === 0) {
+      this.clearSessionAutoApproveTools(sessionId);
+      return;
+    }
+    const normalized = autoApproveTools.map(this.normalizePattern);
+    this.sessionAutoApproveTools.set(sessionId, normalized);
+    this.logger.info(
+      `Session auto-approve tools set for '${sessionId}': ${autoApproveTools.length} tools`
+    );
+    this.logger.debug(`Auto-approve tools: ${normalized.join(", ")}`);
+  }
+  addSessionAutoApproveTools(sessionId, autoApproveTools) {
+    if (autoApproveTools.length === 0) {
+      return;
+    }
+    const normalized = autoApproveTools.map(this.normalizePattern);
+    const existing = this.sessionAutoApproveTools.get(sessionId) ?? [];
+    const merged = [...existing];
+    const seen = new Set(existing);
+    for (const toolName of normalized) {
+      if (seen.has(toolName)) {
+        continue;
+      }
+      merged.push(toolName);
+      seen.add(toolName);
+    }
+    const actuallyAdded = Math.max(0, merged.length - existing.length);
+    this.sessionAutoApproveTools.set(sessionId, merged);
+    this.logger.info(
+      `Session auto-approve tools updated for '${sessionId}': +${actuallyAdded} tools`
+    );
+    this.logger.debug(`Auto-approve tools: ${merged.join(", ")}`);
+  }
+  async setSessionUserAutoApproveTools(sessionId, autoApproveTools) {
+    await this.restoreSessionState(sessionId);
+    if (autoApproveTools.length === 0) {
+      await this.clearSessionUserAutoApproveTools(sessionId);
+      return;
+    }
+    const normalized = autoApproveTools.map(this.normalizePattern);
+    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`
+    );
+    this.logger.debug(`User auto-approve tools: ${normalized.join(", ")}`);
+  }
+  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}'`);
+    }
+  }
+  clearSessionAutoApproveTools(sessionId) {
+    const hadAutoApprove = this.sessionAutoApproveTools.has(sessionId);
+    this.sessionAutoApproveTools.delete(sessionId);
+    if (hadAutoApprove) {
+      this.logger.info(`Session auto-approve tools cleared for '${sessionId}'`);
+    }
+  }
+  hasSessionUserAutoApproveTools(sessionId) {
+    return this.sessionUserAutoApproveTools.has(sessionId);
+  }
+  setGlobalDisabledTools(toolNames) {
+    this.globalDisabledTools = [...toolNames];
+    this.logger.info("Global disabled tools updated", {
+      count: toolNames.length
+    });
+  }
+  getGlobalDisabledTools() {
+    return [...this.globalDisabledTools];
+  }
+  async setSessionDisabledTools(sessionId, toolNames) {
+    await this.restoreSessionState(sessionId);
+    if (toolNames.length === 0) {
+      await this.clearSessionDisabledTools(sessionId);
+      return;
+    }
+    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
+    });
+  }
+  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 });
+    }
+  }
+  getDisabledTools(sessionId) {
+    if (sessionId && this.sessionDisabledTools.has(sessionId)) {
+      return this.sessionDisabledTools.get(sessionId) ?? [];
+    }
+    return this.globalDisabledTools;
+  }
+  filterToolsForSession(toolSet, sessionId) {
+    const disabled = new Set(this.getDisabledTools(sessionId));
+    if (disabled.size === 0) {
+      return toolSet;
+    }
+    return Object.fromEntries(
+      Object.entries(toolSet).filter(([toolName]) => !disabled.has(toolName))
+    );
+  }
+  hasSessionAutoApproveTools(sessionId) {
+    return this.sessionAutoApproveTools.has(sessionId);
+  }
+  getSessionAutoApproveTools(sessionId) {
+    return this.sessionAutoApproveTools.get(sessionId);
+  }
+  getSessionUserAutoApproveTools(sessionId) {
+    return this.sessionUserAutoApproveTools.get(sessionId);
+  }
+  getCombinedSessionAutoApproveTools(sessionId) {
+    return [
+      ...this.sessionAutoApproveTools.get(sessionId) ?? [],
+      ...this.sessionUserAutoApproveTools.get(sessionId) ?? []
+    ];
+  }
+  isToolAutoApprovedForSession(sessionId, toolName) {
+    const autoApproveTools = this.getCombinedSessionAutoApproveTools(sessionId);
+    if (autoApproveTools.length === 0) {
+      return false;
+    }
+    return autoApproveTools.some((pattern) => matchesToolPolicyPattern(toolName, pattern));
+  }
+  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) ?? []]
+    };
+  }
+  async persistSessionToolPreferences(sessionId) {
+    await this.preferencesStore.save(
+      sessionId,
+      this.getSessionToolPreferencesSnapshot(sessionId)
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionToolPolicy,
+  matchesToolPolicyPattern
+});

package/dist/tools/approval/session-tool-policy.d.ts

@@ -0,0 +1,43 @@
+import type { Logger } from '../../logger/v2/types.js';
+import type { SessionToolPreferencesStore } from '../session-tool-preferences-store.js';
+import type { ToolSet } from '../types.js';
+type SessionToolPreferencesStorage = Pick<SessionToolPreferencesStore, 'load' | 'save' | 'delete'>;
+export declare function matchesToolPolicyPattern(toolName: string, policyPattern: string): boolean;
+export declare class SessionToolPolicy {
+    private readonly preferencesStore;
+    private readonly logger;
+    private readonly normalizePattern;
+    private sessionAutoApproveTools;
+    private sessionUserAutoApproveTools;
+    private sessionDisabledTools;
+    private readonly restoredSessionPreferences;
+    private readonly sessionPreferenceLocks;
+    private globalDisabledTools;
+    constructor(preferencesStore: SessionToolPreferencesStorage, logger: Logger, normalizePattern: (pattern: string) => string);
+    restoreSessionState(sessionId: string): Promise<void>;
+    evictSessionState(sessionId: string): void;
+    deleteSessionState(sessionId: string): Promise<void>;
+    setSessionAutoApproveTools(sessionId: string, autoApproveTools: string[]): void;
+    addSessionAutoApproveTools(sessionId: string, autoApproveTools: string[]): void;
+    setSessionUserAutoApproveTools(sessionId: string, autoApproveTools: string[]): Promise<void>;
+    clearSessionUserAutoApproveTools(sessionId: string): Promise<void>;
+    clearSessionAutoApproveTools(sessionId: string): void;
+    hasSessionUserAutoApproveTools(sessionId: string): boolean;
+    setGlobalDisabledTools(toolNames: string[]): void;
+    getGlobalDisabledTools(): string[];
+    setSessionDisabledTools(sessionId: string, toolNames: string[]): Promise<void>;
+    clearSessionDisabledTools(sessionId: string): Promise<void>;
+    getDisabledTools(sessionId?: string): string[];
+    filterToolsForSession(toolSet: ToolSet, sessionId?: string): ToolSet;
+    hasSessionAutoApproveTools(sessionId: string): boolean;
+    getSessionAutoApproveTools(sessionId: string): string[] | undefined;
+    getSessionUserAutoApproveTools(sessionId: string): string[] | undefined;
+    getCombinedSessionAutoApproveTools(sessionId: string): string[];
+    isToolAutoApprovedForSession(sessionId: string, toolName: string): boolean;
+    private runWithSessionPreferenceLock;
+    private applySessionToolPreferences;
+    private getSessionToolPreferencesSnapshot;
+    private persistSessionToolPreferences;
+}
+export {};
+//# sourceMappingURL=session-tool-policy.d.ts.map

package/dist/tools/approval/session-tool-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tool-policy.d.ts","sourceRoot":"","sources":["../../../src/tools/approval/session-tool-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAER,2BAA2B,EAC9B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAG3C,KAAK,6BAA6B,GAAG,IAAI,CAAC,2BAA2B,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;AAEnG,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAWzF;AAED,qBAAa,iBAAiB;IAStB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAVrC,OAAO,CAAC,uBAAuB,CAAoC;IACnE,OAAO,CAAC,2BAA2B,CAAoC;IACvE,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAqB;IAChE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAoC;IAC3E,OAAO,CAAC,mBAAmB,CAAgB;gBAGtB,gBAAgB,EAAE,6BAA6B,EAC/C,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM;IAG5D,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB3D,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAOpC,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO1D,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IAc/E,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,GAAG,IAAI;IA0BzE,8BAA8B,CAChC,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,MAAM,EAAE,GAC3B,OAAO,CAAC,IAAI,CAAC;IAoBV,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAexE,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQrD,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI1D,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;IAOjD,sBAAsB,IAAI,MAAM,EAAE;IAI5B,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9E,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAejE,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAQ9C,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAWpE,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAItD,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAInE,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAIvE,kCAAkC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAO/D,4BAA4B,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;YAS5D,4BAA4B;IAsB1C,OAAO,CAAC,2BAA2B;IAgBnC,OAAO,CAAC,iCAAiC;YAO3B,6BAA6B;CAM9C"}

package/dist/tools/approval/session-tool-policy.js

@@ -0,0 +1,245 @@
+import "../../chunk-C6A6W6XS.js";
+const MCP_TOOL_PREFIX = "mcp--";
+function matchesToolPolicyPattern(toolName, policyPattern) {
+  if (toolName === policyPattern) {
+    return true;
+  }
+  if (!policyPattern.startsWith(MCP_TOOL_PREFIX)) {
+    return false;
+  }
+  const baseName = policyPattern.substring(MCP_TOOL_PREFIX.length);
+  return toolName.endsWith(`--${baseName}`) && toolName.startsWith(MCP_TOOL_PREFIX);
+}
+class SessionToolPolicy {
+  constructor(preferencesStore, logger, normalizePattern) {
+    this.preferencesStore = preferencesStore;
+    this.logger = logger;
+    this.normalizePattern = normalizePattern;
+  }
+  sessionAutoApproveTools = /* @__PURE__ */ new Map();
+  sessionUserAutoApproveTools = /* @__PURE__ */ new Map();
+  sessionDisabledTools = /* @__PURE__ */ new Map();
+  restoredSessionPreferences = /* @__PURE__ */ new Set();
+  sessionPreferenceLocks = /* @__PURE__ */ new Map();
+  globalDisabledTools = [];
+  async restoreSessionState(sessionId) {
+    if (this.restoredSessionPreferences.has(sessionId)) {
+      return;
+    }
+    await this.runWithSessionPreferenceLock(sessionId, async () => {
+      if (this.restoredSessionPreferences.has(sessionId)) {
+        return;
+      }
+      const preferences = await this.preferencesStore.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.preferencesStore.delete(sessionId);
+    });
+  }
+  setSessionAutoApproveTools(sessionId, autoApproveTools) {
+    if (autoApproveTools.length === 0) {
+      this.clearSessionAutoApproveTools(sessionId);
+      return;
+    }
+    const normalized = autoApproveTools.map(this.normalizePattern);
+    this.sessionAutoApproveTools.set(sessionId, normalized);
+    this.logger.info(
+      `Session auto-approve tools set for '${sessionId}': ${autoApproveTools.length} tools`
+    );
+    this.logger.debug(`Auto-approve tools: ${normalized.join(", ")}`);
+  }
+  addSessionAutoApproveTools(sessionId, autoApproveTools) {
+    if (autoApproveTools.length === 0) {
+      return;
+    }
+    const normalized = autoApproveTools.map(this.normalizePattern);
+    const existing = this.sessionAutoApproveTools.get(sessionId) ?? [];
+    const merged = [...existing];
+    const seen = new Set(existing);
+    for (const toolName of normalized) {
+      if (seen.has(toolName)) {
+        continue;
+      }
+      merged.push(toolName);
+      seen.add(toolName);
+    }
+    const actuallyAdded = Math.max(0, merged.length - existing.length);
+    this.sessionAutoApproveTools.set(sessionId, merged);
+    this.logger.info(
+      `Session auto-approve tools updated for '${sessionId}': +${actuallyAdded} tools`
+    );
+    this.logger.debug(`Auto-approve tools: ${merged.join(", ")}`);
+  }
+  async setSessionUserAutoApproveTools(sessionId, autoApproveTools) {
+    await this.restoreSessionState(sessionId);
+    if (autoApproveTools.length === 0) {
+      await this.clearSessionUserAutoApproveTools(sessionId);
+      return;
+    }
+    const normalized = autoApproveTools.map(this.normalizePattern);
+    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`
+    );
+    this.logger.debug(`User auto-approve tools: ${normalized.join(", ")}`);
+  }
+  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}'`);
+    }
+  }
+  clearSessionAutoApproveTools(sessionId) {
+    const hadAutoApprove = this.sessionAutoApproveTools.has(sessionId);
+    this.sessionAutoApproveTools.delete(sessionId);
+    if (hadAutoApprove) {
+      this.logger.info(`Session auto-approve tools cleared for '${sessionId}'`);
+    }
+  }
+  hasSessionUserAutoApproveTools(sessionId) {
+    return this.sessionUserAutoApproveTools.has(sessionId);
+  }
+  setGlobalDisabledTools(toolNames) {
+    this.globalDisabledTools = [...toolNames];
+    this.logger.info("Global disabled tools updated", {
+      count: toolNames.length
+    });
+  }
+  getGlobalDisabledTools() {
+    return [...this.globalDisabledTools];
+  }
+  async setSessionDisabledTools(sessionId, toolNames) {
+    await this.restoreSessionState(sessionId);
+    if (toolNames.length === 0) {
+      await this.clearSessionDisabledTools(sessionId);
+      return;
+    }
+    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
+    });
+  }
+  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 });
+    }
+  }
+  getDisabledTools(sessionId) {
+    if (sessionId && this.sessionDisabledTools.has(sessionId)) {
+      return this.sessionDisabledTools.get(sessionId) ?? [];
+    }
+    return this.globalDisabledTools;
+  }
+  filterToolsForSession(toolSet, sessionId) {
+    const disabled = new Set(this.getDisabledTools(sessionId));
+    if (disabled.size === 0) {
+      return toolSet;
+    }
+    return Object.fromEntries(
+      Object.entries(toolSet).filter(([toolName]) => !disabled.has(toolName))
+    );
+  }
+  hasSessionAutoApproveTools(sessionId) {
+    return this.sessionAutoApproveTools.has(sessionId);
+  }
+  getSessionAutoApproveTools(sessionId) {
+    return this.sessionAutoApproveTools.get(sessionId);
+  }
+  getSessionUserAutoApproveTools(sessionId) {
+    return this.sessionUserAutoApproveTools.get(sessionId);
+  }
+  getCombinedSessionAutoApproveTools(sessionId) {
+    return [
+      ...this.sessionAutoApproveTools.get(sessionId) ?? [],
+      ...this.sessionUserAutoApproveTools.get(sessionId) ?? []
+    ];
+  }
+  isToolAutoApprovedForSession(sessionId, toolName) {
+    const autoApproveTools = this.getCombinedSessionAutoApproveTools(sessionId);
+    if (autoApproveTools.length === 0) {
+      return false;
+    }
+    return autoApproveTools.some((pattern) => matchesToolPolicyPattern(toolName, pattern));
+  }
+  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) ?? []]
+    };
+  }
+  async persistSessionToolPreferences(sessionId) {
+    await this.preferencesStore.save(
+      sessionId,
+      this.getSessionToolPreferencesSnapshot(sessionId)
+    );
+  }
+}
+export {
+  SessionToolPolicy,
+  matchesToolPolicyPattern
+};

package/dist/tools/define-tool.js

@@ -1,4 +1,4 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 function defineTool(tool) {
   return tool;
 }

package/dist/tools/display-types.js

@@ -1,4 +1,4 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 function isDiffDisplay(d) {
   return d.type === "diff";
 }

package/dist/tools/error-codes.cjs

@@ -28,9 +28,9 @@ var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
   ToolErrorCode2["DIRECTORY_ACCESS_DENIED"] = "tools_directory_access_denied";
   ToolErrorCode2["VALIDATION_FAILED"] = "tools_validation_failed";
   ToolErrorCode2["FILE_MODIFIED_SINCE_PREVIEW"] = "tools_file_modified_since_preview";
-  ToolErrorCode2["CONFIRMATION_HANDLER_MISSING"] = "tools_confirmation_handler_missing";
-  ToolErrorCode2["CONFIRMATION_TIMEOUT"] = "tools_confirmation_timeout";
-  ToolErrorCode2["CONFIRMATION_CANCELLED"] = "tools_confirmation_cancelled";
+  ToolErrorCode2["APPROVAL_HANDLER_MISSING"] = "tools_approval_handler_missing";
+  ToolErrorCode2["APPROVAL_TIMEOUT"] = "tools_approval_timeout";
+  ToolErrorCode2["APPROVAL_CANCELLED"] = "tools_approval_cancelled";
   ToolErrorCode2["TOOL_NOT_FOUND"] = "tools_tool_not_found";
   ToolErrorCode2["TOOL_INVALID_ARGS"] = "tools_invalid_args";
   ToolErrorCode2["TOOL_UNAUTHORIZED"] = "tools_unauthorized";

package/dist/tools/error-codes.d.ts

@@ -1,6 +1,6 @@
 /**
  * Tools-specific error codes
- * Includes tool execution, confirmation, and authorization errors
+ * Includes tool execution, approval, and authorization errors
  */
 export declare enum ToolErrorCode {
     EXECUTION_DENIED = "tools_execution_denied",
@@ -9,9 +9,9 @@ export declare enum ToolErrorCode {
     DIRECTORY_ACCESS_DENIED = "tools_directory_access_denied",
     VALIDATION_FAILED = "tools_validation_failed",
     FILE_MODIFIED_SINCE_PREVIEW = "tools_file_modified_since_preview",
-    CONFIRMATION_HANDLER_MISSING = "tools_confirmation_handler_missing",
-    CONFIRMATION_TIMEOUT = "tools_confirmation_timeout",
-    CONFIRMATION_CANCELLED = "tools_confirmation_cancelled",
+    APPROVAL_HANDLER_MISSING = "tools_approval_handler_missing",
+    APPROVAL_TIMEOUT = "tools_approval_timeout",
+    APPROVAL_CANCELLED = "tools_approval_cancelled",
     TOOL_NOT_FOUND = "tools_tool_not_found",
     TOOL_INVALID_ARGS = "tools_invalid_args",
     TOOL_UNAUTHORIZED = "tools_unauthorized",

package/dist/tools/error-codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/tools/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,aAAa;IAErB,gBAAgB,2BAA2B;IAC3C,iBAAiB,4BAA4B;IAC7C,gBAAgB,2BAA2B;IAC3C,uBAAuB,kCAAkC;IAGzD,iBAAiB,4BAA4B;IAC7C,2BAA2B,sCAAsC;IAGjE,4BAA4B,uCAAuC;IACnE,oBAAoB,+BAA+B;IACnD,sBAAsB,iCAAiC;IAGvD,cAAc,yBAAyB;IACvC,iBAAiB,uBAAuB;IACxC,iBAAiB,uBAAuB;IAGxC,cAAc,yBAAyB;IACvC,gBAAgB,2BAA2B;IAG3C,2BAA2B,iCAAiC;IAC5D,sCAAsC,4CAA4C;CACrF"}
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/tools/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,aAAa;IAErB,gBAAgB,2BAA2B;IAC3C,iBAAiB,4BAA4B;IAC7C,gBAAgB,2BAA2B;IAC3C,uBAAuB,kCAAkC;IAGzD,iBAAiB,4BAA4B;IAC7C,2BAA2B,sCAAsC;IAGjE,wBAAwB,mCAAmC;IAC3D,gBAAgB,2BAA2B;IAC3C,kBAAkB,6BAA6B;IAG/C,cAAc,yBAAyB;IACvC,iBAAiB,uBAAuB;IACxC,iBAAiB,uBAAuB;IAGxC,cAAc,yBAAyB;IACvC,gBAAgB,2BAA2B;IAG3C,2BAA2B,iCAAiC;IAC5D,sCAAsC,4CAA4C;CACrF"}

package/dist/tools/error-codes.js

@@ -1,4 +1,4 @@
-import "../chunk-PTJYTZNU.js";
+import "../chunk-C6A6W6XS.js";
 var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
   ToolErrorCode2["EXECUTION_DENIED"] = "tools_execution_denied";
   ToolErrorCode2["EXECUTION_TIMEOUT"] = "tools_execution_timeout";
@@ -6,9 +6,9 @@ var ToolErrorCode = /* @__PURE__ */ ((ToolErrorCode2) => {
   ToolErrorCode2["DIRECTORY_ACCESS_DENIED"] = "tools_directory_access_denied";
   ToolErrorCode2["VALIDATION_FAILED"] = "tools_validation_failed";
   ToolErrorCode2["FILE_MODIFIED_SINCE_PREVIEW"] = "tools_file_modified_since_preview";
-  ToolErrorCode2["CONFIRMATION_HANDLER_MISSING"] = "tools_confirmation_handler_missing";
-  ToolErrorCode2["CONFIRMATION_TIMEOUT"] = "tools_confirmation_timeout";
-  ToolErrorCode2["CONFIRMATION_CANCELLED"] = "tools_confirmation_cancelled";
+  ToolErrorCode2["APPROVAL_HANDLER_MISSING"] = "tools_approval_handler_missing";
+  ToolErrorCode2["APPROVAL_TIMEOUT"] = "tools_approval_timeout";
+  ToolErrorCode2["APPROVAL_CANCELLED"] = "tools_approval_cancelled";
   ToolErrorCode2["TOOL_NOT_FOUND"] = "tools_tool_not_found";
   ToolErrorCode2["TOOL_INVALID_ARGS"] = "tools_invalid_args";
   ToolErrorCode2["TOOL_UNAUTHORIZED"] = "tools_unauthorized";