@dexto/core 1.5.8 → 1.6.1

package/dist/approval/manager.js

@@ -1,20 +1,46 @@
 import "../chunk-PTJYTZNU.js";
 import path from "node:path";
+import { realpathSync } from "node:fs";
 import { ApprovalType, ApprovalStatus, DenialReason } from "./types.js";
 import { createApprovalRequest } from "./factory.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { ApprovalError } from "./errors.js";
-import { patternCovers } from "../tools/bash-pattern-utils.js";
+import { patternCovers } from "../tools/pattern-utils.js";
+function tryRealpathSync(targetPath) {
+  try {
+    return realpathSync(targetPath);
+  } catch {
+    return null;
+  }
+}
+function tryRealpathSyncWithExistingParent(resolvedPath) {
+  const direct = tryRealpathSync(resolvedPath);
+  if (direct) return direct;
+  let currentDir = path.dirname(resolvedPath);
+  while (true) {
+    const realDir = tryRealpathSync(currentDir);
+    if (realDir) {
+      const suffix = path.relative(currentDir, resolvedPath);
+      return path.join(realDir, suffix);
+    }
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) {
+      return null;
+    }
+    currentDir = parent;
+  }
+}
 class ApprovalManager {
   handler;
   config;
   logger;
   /**
-   * Bash command patterns approved for the current session.
-   * Patterns use simple glob syntax (e.g., "git *", "npm install *").
-   * Cleared when session ends.
+   * Tool approval patterns, keyed by tool id.
+   *
+   * Patterns use simple glob syntax (e.g. "git *", "npm install *") and are matched
+   * using pattern-to-pattern covering (see {@link patternCovers}).
    */
-  bashPatterns = /* @__PURE__ */ new Set();
+  toolPatterns = /* @__PURE__ */ new Map();
   /**
    * Directories approved for file access for the current session.
    * Stores normalized absolute paths mapped to their approval type:
@@ -27,36 +53,37 @@ class ApprovalManager {
     this.config = config;
     this.logger = logger.createChild(DextoLogComponent.APPROVAL);
     this.logger.debug(
-      `ApprovalManager initialized with toolConfirmation.mode: ${config.toolConfirmation.mode}, elicitation.enabled: ${config.elicitation.enabled}`
+      `ApprovalManager initialized with permissions.mode: ${config.permissions.mode}, elicitation.enabled: ${config.elicitation.enabled}`
     );
   }
-  // ==================== Bash Pattern Methods ====================
+  // ==================== Pattern Methods ====================
+  getOrCreateToolPatternSet(toolName) {
+    const existing = this.toolPatterns.get(toolName);
+    if (existing) return existing;
+    const created = /* @__PURE__ */ new Set();
+    this.toolPatterns.set(toolName, created);
+    return created;
+  }
   /**
-   * Add a bash command pattern to the approved list for this session.
-   * Patterns use simple glob syntax with * as wildcard.
-   *
-   * @example
-   * ```typescript
-   * manager.addBashPattern("git *");        // Approves all git commands
-   * manager.addBashPattern("npm install *"); // Approves npm install with any package
-   * ```
+   * Add an approval pattern for a tool.
    */
-  addBashPattern(pattern) {
-    this.bashPatterns.add(pattern);
-    this.logger.debug(`Added bash pattern: "${pattern}"`);
+  addPattern(toolName, pattern) {
+    this.getOrCreateToolPatternSet(toolName).add(pattern);
+    this.logger.debug(`Added pattern for '${toolName}': "${pattern}"`);
   }
   /**
-   * Check if a bash pattern key is covered by any approved pattern.
-   * Uses pattern-to-pattern covering for broader pattern support.
+   * Check if a pattern key is covered by any approved pattern for a tool.
    *
-   * @param patternKey The pattern key generated from the command (e.g., "git push *")
-   * @returns true if the pattern key is covered by an approved pattern
+   * Note: This expects a pattern key (e.g. "git push *"), not raw arguments.
+   * Tools are responsible for generating the key via `tool.approval.patternKey()`.
    */
-  matchesBashPattern(patternKey) {
-    for (const storedPattern of this.bashPatterns) {
+  matchesPattern(toolName, patternKey) {
+    const patterns = this.toolPatterns.get(toolName);
+    if (!patterns || patterns.size === 0) return false;
+    for (const storedPattern of patterns) {
       if (patternCovers(storedPattern, patternKey)) {
         this.logger.debug(
-          `Pattern key "${patternKey}" is covered by approved pattern "${storedPattern}"`
+          `Pattern key "${patternKey}" is covered by approved pattern "${storedPattern}" (tool: ${toolName})`
         );
         return true;
       }
@@ -64,23 +91,64 @@ class ApprovalManager {
     return false;
   }
   /**
-   * Clear all approved bash patterns.
-   * Should be called when session ends.
+   * Clear all patterns for a tool (or all tools when omitted).
    */
-  clearBashPatterns() {
-    const count = this.bashPatterns.size;
-    this.bashPatterns.clear();
+  clearPatterns(toolName) {
+    if (toolName) {
+      const patterns = this.toolPatterns.get(toolName);
+      if (!patterns) return;
+      const count2 = patterns.size;
+      patterns.clear();
+      if (count2 > 0) {
+        this.logger.debug(`Cleared ${count2} pattern(s) for '${toolName}'`);
+      }
+      return;
+    }
+    const count = Array.from(this.toolPatterns.values()).reduce(
+      (sum, set) => sum + set.size,
+      0
+    );
+    this.toolPatterns.clear();
     if (count > 0) {
-      this.logger.debug(`Cleared ${count} bash patterns`);
+      this.logger.debug(`Cleared ${count} total tool pattern(s)`);
     }
   }
   /**
-   * Get the current set of approved bash patterns (for debugging/display).
+   * Get patterns for a tool (for debugging/display).
    */
-  getBashPatterns() {
-    return this.bashPatterns;
+  getToolPatterns(toolName) {
+    return this.toolPatterns.get(toolName) ?? /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get all tool patterns (for debugging/display).
+   */
+  getAllToolPatterns() {
+    return this.toolPatterns;
   }
   // ==================== Directory Access Methods ====================
+  /**
+   * Resolve a directory path for use as an approval key.
+   *
+   * We store BOTH the resolved path and (when available) its realpath, so approvals
+   * continue to work even when other subsystems canonicalize paths via realpath
+   * (e.g. macOS /tmp -> /private/tmp or custom symlinked directories).
+   */
+  getDirectoryApprovalKeys(directory) {
+    const resolved = path.resolve(directory);
+    const real = tryRealpathSyncWithExistingParent(resolved);
+    if (real && real !== resolved) {
+      return [resolved, real];
+    }
+    return [resolved];
+  }
+  getFileApprovalKeys(filePath) {
+    const resolved = path.resolve(filePath);
+    const real = tryRealpathSyncWithExistingParent(resolved);
+    if (real && real !== resolved) {
+      return [resolved, real];
+    }
+    return [resolved];
+  }
   /**
    * Initialize the working directory as a session-approved directory.
    * This should be called once during setup to ensure the working directory
@@ -89,9 +157,7 @@ class ApprovalManager {
    * @param workingDir The working directory path
    */
   initializeWorkingDirectory(workingDir) {
-    const normalized = path.resolve(workingDir);
-    this.approvedDirectories.set(normalized, "session");
-    this.logger.debug(`Initialized working directory as session-approved: "${normalized}"`);
+    this.addApprovedDirectory(workingDir, "session");
   }
   /**
    * Add a directory to the approved list for this session.
@@ -111,16 +177,28 @@ class ApprovalManager {
    * ```
    */
   addApprovedDirectory(directory, type = "session") {
-    const normalized = path.resolve(directory);
-    const existing = this.approvedDirectories.get(normalized);
-    if (existing === "session") {
+    const keys = this.getDirectoryApprovalKeys(directory);
+    const existingTypes = keys.map((key) => this.approvedDirectories.get(key)).filter((value) => value !== void 0);
+    const hasSessionApproval = existingTypes.includes("session");
+    const effectiveType = type === "session" || hasSessionApproval ? "session" : "once";
+    for (const key of keys) {
+      const existing = this.approvedDirectories.get(key);
+      if (existing === "session") {
+        continue;
+      }
+      this.approvedDirectories.set(key, effectiveType);
+    }
+    const resolvedKey = keys[0];
+    if (effectiveType === "session" && type === "once" && hasSessionApproval) {
       this.logger.debug(
-        `Directory "${normalized}" already approved as 'session', not downgrading to '${type}'`
+        `Directory "${resolvedKey}" already approved as 'session', not downgrading to 'once'`
       );
       return;
     }
-    this.approvedDirectories.set(normalized, type);
-    this.logger.debug(`Added approved directory: "${normalized}" (type: ${type})`);
+    const realKey = keys.length > 1 ? keys[1] : null;
+    this.logger.debug(
+      `Added approved directory: "${resolvedKey}" (type: ${effectiveType})${realKey ? `, realpath: "${realKey}"` : ""}`
+    );
   }
   /**
    * Check if a file path is within any session-approved directory.
@@ -131,15 +209,16 @@ class ApprovalManager {
    * @returns true if the path is within a session-approved directory
    */
   isDirectorySessionApproved(filePath) {
-    const normalized = path.resolve(filePath);
-    for (const [approvedDir, type] of this.approvedDirectories) {
-      if (type !== "session") continue;
-      const relative = path.relative(approvedDir, normalized);
-      if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
-        this.logger.debug(
-          `Path "${normalized}" is within session-approved directory "${approvedDir}"`
-        );
-        return true;
+    for (const normalized of this.getFileApprovalKeys(filePath)) {
+      for (const [approvedDir, type] of this.approvedDirectories) {
+        if (type !== "session") continue;
+        const relative = path.relative(approvedDir, normalized);
+        if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+          this.logger.debug(
+            `Path "${normalized}" is within session-approved directory "${approvedDir}"`
+          );
+          return true;
+        }
       }
     }
     return false;
@@ -153,14 +232,15 @@ class ApprovalManager {
    * @returns true if the path is within any approved directory
    */
   isDirectoryApproved(filePath) {
-    const normalized = path.resolve(filePath);
-    for (const [approvedDir] of this.approvedDirectories) {
-      const relative = path.relative(approvedDir, normalized);
-      if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
-        this.logger.debug(
-          `Path "${normalized}" is within approved directory "${approvedDir}"`
-        );
-        return true;
+    for (const normalized of this.getFileApprovalKeys(filePath)) {
+      for (const [approvedDir] of this.approvedDirectories) {
+        const relative = path.relative(approvedDir, normalized);
+        if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+          this.logger.debug(
+            `Path "${normalized}" is within approved directory "${approvedDir}"`
+          );
+          return true;
+        }
       }
     }
     return false;
@@ -189,11 +269,11 @@ class ApprovalManager {
     return Array.from(this.approvedDirectories.keys());
   }
   /**
-   * Clear all session-scoped approvals (bash patterns and directories).
+   * Clear all session-scoped approvals (tool patterns and directories).
    * Convenience method for clearing all session state at once.
    */
   clearSessionApprovals() {
-    this.clearBashPatterns();
+    this.clearPatterns();
     this.clearApprovedDirectories();
     this.logger.debug("Cleared all session approvals");
   }
@@ -217,7 +297,7 @@ class ApprovalManager {
     const details = {
       type: ApprovalType.DIRECTORY_ACCESS,
       // Use provided timeout, fallback to config timeout, or undefined (no timeout)
-      timeout: timeout !== void 0 ? timeout : this.config.toolConfirmation.timeout,
+      timeout: timeout !== void 0 ? timeout : this.config.permissions.timeout,
       metadata: directoryMetadata
     };
     if (sessionId !== void 0) {
@@ -238,7 +318,7 @@ class ApprovalManager {
     return this.handleApproval(request);
   }
   /**
-   * Handle approval requests (tool confirmation, elicitation, command confirmation, directory access, custom)
+   * Handle approval requests (tool approval, elicitation, command confirmation, directory access, custom)
    * @private
    */
   async handleApproval(request) {
@@ -249,7 +329,7 @@ class ApprovalManager {
       );
       return handler2(request);
     }
-    const mode = this.config.toolConfirmation.mode;
+    const mode = this.config.permissions.mode;
     if (mode === "auto-approve") {
       this.logger.info(
         `Auto-approve approval '${request.type}', approvalId: ${request.approvalId}`
@@ -285,18 +365,18 @@ class ApprovalManager {
     return handler(request);
   }
   /**
-   * Request tool confirmation approval
-   * Convenience method for tool execution confirmation
+   * Request tool approval
+   * Convenience method for tool execution approval
    *
    * TODO: Make sessionId required once all callers are updated to pass it
    * Tool confirmations always happen in session context during LLM execution
    */
-  async requestToolConfirmation(metadata) {
+  async requestToolApproval(metadata) {
     const { sessionId, timeout, ...toolMetadata } = metadata;
     const details = {
-      type: ApprovalType.TOOL_CONFIRMATION,
+      type: ApprovalType.TOOL_APPROVAL,
       // Use provided timeout, fallback to config timeout, or undefined (no timeout)
-      timeout: timeout !== void 0 ? timeout : this.config.toolConfirmation.timeout,
+      timeout: timeout !== void 0 ? timeout : this.config.permissions.timeout,
       metadata: toolMetadata
     };
     if (sessionId !== void 0) {
@@ -308,7 +388,7 @@ class ApprovalManager {
    * Request command confirmation approval
    * Convenience method for dangerous command execution within an already-approved tool
    *
-   * This is different from tool confirmation - it's for per-command approval
+   * This is different from tool approval - it's for per-command approval
    * of dangerous operations (like rm, git push) within tools that are already approved.
    *
    * TODO: Make sessionId required once all callers are updated to pass it
@@ -330,7 +410,7 @@ class ApprovalManager {
     const details = {
       type: ApprovalType.COMMAND_CONFIRMATION,
       // Use provided timeout, fallback to config timeout, or undefined (no timeout)
-      timeout: timeout !== void 0 ? timeout : this.config.toolConfirmation.timeout,
+      timeout: timeout !== void 0 ? timeout : this.config.permissions.timeout,
       metadata: commandMetadata
     };
     if (sessionId !== void 0) {
@@ -359,15 +439,15 @@ class ApprovalManager {
     return this.requestApproval(details);
   }
   /**
-   * Check if tool confirmation was approved
+   * Check if tool approval was approved
    * Throws appropriate error if denied
    */
-  async checkToolConfirmation(metadata) {
-    const response = await this.requestToolConfirmation(metadata);
+  async checkToolApproval(metadata) {
+    const response = await this.requestToolApproval(metadata);
     if (response.status === ApprovalStatus.APPROVED) {
       return true;
     } else if (response.status === ApprovalStatus.DENIED) {
-      throw ApprovalError.toolConfirmationDenied(
+      throw ApprovalError.toolApprovalDenied(
         metadata.toolName,
         response.reason,
         response.message,
@@ -376,7 +456,7 @@ class ApprovalManager {
     } else {
       throw ApprovalError.cancelled(
         response.approvalId,
-        ApprovalType.TOOL_CONFIRMATION,
+        ApprovalType.TOOL_APPROVAL,
         response.message ?? response.reason
       );
     }
@@ -457,11 +537,11 @@ class ApprovalManager {
    * Set the approval handler for manual approval mode.
    *
    * The handler will be called for:
-   * - Tool confirmation requests when toolConfirmation.mode is 'manual'
-   * - All elicitation requests (when elicitation is enabled, regardless of toolConfirmation.mode)
+   * - Tool confirmation requests when permissions.mode is 'manual'
+   * - All elicitation requests (when elicitation is enabled, regardless of permissions.mode)
    *
    * A handler must be set before processing requests if:
-   * - toolConfirmation.mode is 'manual', or
+   * - permissions.mode is 'manual', or
    * - elicitation is enabled (elicitation.enabled is true)
    *
    * @param handler The approval handler function, or null to clear
@@ -494,7 +574,7 @@ class ApprovalManager {
   ensureHandler() {
     if (!this.handler) {
       throw ApprovalError.invalidConfig(
-        'An approval handler is required but not configured.\nHandlers are required for:\n  \u2022 manual tool confirmation mode\n  \u2022 all elicitation requests (when elicitation is enabled)\nEither:\n  \u2022 set toolConfirmation.mode to "auto-approve" or "auto-deny", or\n  \u2022 disable elicitation (set elicitation.enabled: false), or\n  \u2022 call agent.setApprovalHandler(...) before processing requests.'
+        'An approval handler is required but not configured.\nHandlers are required for:\n  \u2022 manual tool approval mode\n  \u2022 all elicitation requests (when elicitation is enabled)\nEither:\n  \u2022 set permissions.mode to "auto-approve" or "auto-deny", or\n  \u2022 disable elicitation (set elicitation.enabled: false), or\n  \u2022 call agent.setApprovalHandler(...) before processing requests.'
       );
     }
     return this.handler;

package/dist/approval/schemas.cjs

@@ -42,10 +42,10 @@ __export(schemas_exports, {
   ElicitationRequestSchema: () => ElicitationRequestSchema,
   ElicitationResponseDataSchema: () => ElicitationResponseDataSchema,
   ElicitationResponseSchema: () => ElicitationResponseSchema,
-  ToolConfirmationMetadataSchema: () => ToolConfirmationMetadataSchema,
-  ToolConfirmationRequestSchema: () => ToolConfirmationRequestSchema,
-  ToolConfirmationResponseDataSchema: () => ToolConfirmationResponseDataSchema,
-  ToolConfirmationResponseSchema: () => ToolConfirmationResponseSchema
+  ToolApprovalMetadataSchema: () => ToolApprovalMetadataSchema,
+  ToolApprovalRequestSchema: () => ToolApprovalRequestSchema,
+  ToolApprovalResponseDataSchema: () => ToolApprovalResponseDataSchema,
+  ToolApprovalResponseSchema: () => ToolApprovalResponseSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
@@ -58,18 +58,36 @@ const DenialReasonSchema = import_zod.z.nativeEnum(import_types.DenialReason);
 const ToolDisplayDataSchema = import_zod.z.custom((val) => (0, import_display_types.isValidDisplayData)(val), {
   message: "Invalid ToolDisplayData"
 });
-const ToolConfirmationMetadataSchema = import_zod.z.object({
+const ToolPresentationSnapshotV1Schema = import_zod.z.custom(
+  (val) => typeof val === "object" && val !== null && val.version === 1,
+  {
+    message: "Invalid ToolPresentationSnapshotV1"
+  }
+);
+const DirectoryAccessMetadataSchema = import_zod.z.object({
+  path: import_zod.z.string().describe("Full path being accessed"),
+  parentDir: import_zod.z.string().describe("Parent directory (what gets approved for session)"),
+  operation: import_zod.z.enum(["read", "write", "edit"]).describe("Type of file operation"),
+  toolName: import_zod.z.string().describe("Name of the tool requesting access")
+}).strict().describe("Directory access metadata");
+const ToolApprovalMetadataSchema = import_zod.z.object({
   toolName: import_zod.z.string().describe("Name of the tool to confirm"),
+  presentationSnapshot: ToolPresentationSnapshotV1Schema.optional().describe(
+    "Optional UI-agnostic presentation snapshot for the tool call. Clients MUST ignore unknown fields."
+  ),
   toolCallId: import_zod.z.string().describe("Unique tool call ID for tracking parallel tool calls"),
   args: import_zod.z.record(import_zod.z.unknown()).describe("Arguments for the tool"),
   description: import_zod.z.string().optional().describe("Description of the tool"),
   displayPreview: ToolDisplayDataSchema.optional().describe(
     "Preview display data for approval UI (e.g., diff preview)"
   ),
+  directoryAccess: DirectoryAccessMetadataSchema.optional().describe(
+    "Optional directory access metadata when the tool targets a path outside config-allowed roots"
+  ),
   suggestedPatterns: import_zod.z.array(import_zod.z.string()).optional().describe(
-    'Suggested patterns for session approval (for bash commands). E.g., ["git push *", "git *"] for command "git push origin main"'
+    'Suggested patterns for session approval. Tools may provide patterns to allow approving a broader subset of future calls (e.g., ["git push *", "git *"]).'
   )
-}).strict().describe("Tool confirmation metadata");
+}).strict().describe("Tool approval metadata");
 const CommandConfirmationMetadataSchema = import_zod.z.object({
   toolName: import_zod.z.string().describe("Name of the tool executing the command"),
   command: import_zod.z.string().describe("The normalized command to execute"),
@@ -77,17 +95,11 @@ const CommandConfirmationMetadataSchema = import_zod.z.object({
 }).strict().describe("Command confirmation metadata");
 const ElicitationMetadataSchema = import_zod.z.object({
   schema: JsonSchema7Schema.describe("JSON Schema for the form"),
-  prompt: import_zod.z.string().describe("Prompt to show the user"),
+  prompt: import_zod.z.string().describe("High-level prompt/context for the form (clients may show it)"),
   serverName: import_zod.z.string().describe("MCP server requesting input"),
   context: import_zod.z.record(import_zod.z.unknown()).optional().describe("Additional context")
 }).strict().describe("Elicitation metadata");
 const CustomApprovalMetadataSchema = import_zod.z.record(import_zod.z.unknown()).describe("Custom metadata");
-const DirectoryAccessMetadataSchema = import_zod.z.object({
-  path: import_zod.z.string().describe("Full path being accessed"),
-  parentDir: import_zod.z.string().describe("Parent directory (what gets approved for session)"),
-  operation: import_zod.z.enum(["read", "write", "edit"]).describe("Type of file operation"),
-  toolName: import_zod.z.string().describe("Name of the tool requesting access")
-}).strict().describe("Directory access metadata");
 const BaseApprovalRequestSchema = import_zod.z.object({
   approvalId: import_zod.z.string().uuid().describe("Unique approval identifier"),
   type: ApprovalTypeSchema.describe("Type of approval"),
@@ -95,9 +107,9 @@ const BaseApprovalRequestSchema = import_zod.z.object({
   timeout: import_zod.z.number().int().positive().optional().describe("Timeout in milliseconds (optional - no timeout if not specified)"),
   timestamp: import_zod.z.date().describe("When the request was created")
 }).describe("Base approval request");
-const ToolConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
-  type: import_zod.z.literal(import_types.ApprovalType.TOOL_CONFIRMATION),
-  metadata: ToolConfirmationMetadataSchema
+const ToolApprovalRequestSchema = BaseApprovalRequestSchema.extend({
+  type: import_zod.z.literal(import_types.ApprovalType.TOOL_APPROVAL),
+  metadata: ToolApprovalMetadataSchema
 }).strict();
 const CommandConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
   type: import_zod.z.literal(import_types.ApprovalType.COMMAND_CONFIRMATION),
@@ -116,18 +128,21 @@ const DirectoryAccessRequestSchema = BaseApprovalRequestSchema.extend({
   metadata: DirectoryAccessMetadataSchema
 }).strict();
 const ApprovalRequestSchema = import_zod.z.discriminatedUnion("type", [
-  ToolConfirmationRequestSchema,
+  ToolApprovalRequestSchema,
   CommandConfirmationRequestSchema,
   ElicitationRequestSchema,
   CustomApprovalRequestSchema,
   DirectoryAccessRequestSchema
 ]);
-const ToolConfirmationResponseDataSchema = import_zod.z.object({
+const ToolApprovalResponseDataSchema = import_zod.z.object({
   rememberChoice: import_zod.z.boolean().optional().describe("Remember this tool for the session (approves ALL uses of this tool)"),
   rememberPattern: import_zod.z.string().optional().describe(
-    'Remember a command pattern for bash commands (e.g., "git *"). Only applicable for bash_exec tool approvals.'
+    'Remember an approval pattern (e.g., "git *"). Only applicable when the tool provides pattern-based approval support.'
+  ),
+  rememberDirectory: import_zod.z.boolean().optional().describe(
+    "Remember this directory for the session (allows future access without prompting again)"
   )
-}).strict().describe("Tool confirmation response data");
+}).strict().describe("Tool approval response data");
 const CommandConfirmationResponseDataSchema = import_zod.z.object({
   // Command confirmations don't have remember choice - they're per-command
   // Could add command pattern remembering in future (e.g., "remember git push *")
@@ -149,8 +164,8 @@ const BaseApprovalResponseSchema = import_zod.z.object({
   message: import_zod.z.string().optional().describe("Human-readable message explaining the denial/cancellation"),
   timeoutMs: import_zod.z.number().int().positive().optional().describe("Timeout duration in milliseconds (present for timeout events)")
 }).describe("Base approval response");
-const ToolConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
-  data: ToolConfirmationResponseDataSchema.optional()
+const ToolApprovalResponseSchema = BaseApprovalResponseSchema.extend({
+  data: ToolApprovalResponseDataSchema.optional()
 }).strict();
 const CommandConfirmationResponseSchema = BaseApprovalResponseSchema.extend({
   data: CommandConfirmationResponseDataSchema.optional()
@@ -165,7 +180,7 @@ const DirectoryAccessResponseSchema = BaseApprovalResponseSchema.extend({
   data: DirectoryAccessResponseDataSchema.optional()
 }).strict();
 const ApprovalResponseSchema = import_zod.z.union([
-  ToolConfirmationResponseSchema,
+  ToolApprovalResponseSchema,
   CommandConfirmationResponseSchema,
   ElicitationResponseSchema,
   CustomApprovalResponseSchema,
@@ -176,19 +191,19 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
   sessionId: import_zod.z.string().optional(),
   timeout: import_zod.z.number().int().positive().optional().describe("Timeout in milliseconds (optional - no timeout if not specified)"),
   metadata: import_zod.z.union([
-    ToolConfirmationMetadataSchema,
+    ToolApprovalMetadataSchema,
     CommandConfirmationMetadataSchema,
     ElicitationMetadataSchema,
     CustomApprovalMetadataSchema,
     DirectoryAccessMetadataSchema
   ])
 }).superRefine((data, ctx) => {
-  if (data.type === import_types.ApprovalType.TOOL_CONFIRMATION) {
-    const result = ToolConfirmationMetadataSchema.safeParse(data.metadata);
+  if (data.type === import_types.ApprovalType.TOOL_APPROVAL) {
+    const result = ToolApprovalMetadataSchema.safeParse(data.metadata);
     if (!result.success) {
       ctx.addIssue({
         code: import_zod.z.ZodIssueCode.custom,
-        message: "Metadata must match ToolConfirmationMetadataSchema for TOOL_CONFIRMATION type",
+        message: "Metadata must match ToolApprovalMetadataSchema for TOOL_APPROVAL type",
         path: ["metadata"]
       });
     }
@@ -256,8 +271,8 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
   ElicitationRequestSchema,
   ElicitationResponseDataSchema,
   ElicitationResponseSchema,
-  ToolConfirmationMetadataSchema,
-  ToolConfirmationRequestSchema,
-  ToolConfirmationResponseDataSchema,
-  ToolConfirmationResponseSchema
+  ToolApprovalMetadataSchema,
+  ToolApprovalRequestSchema,
+  ToolApprovalResponseDataSchema,
+  ToolApprovalResponseSchema
 });