@dexto/core 1.5.7 → 1.6.0

package/dist/approval/manager.js

@@ -4,17 +4,18 @@ 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";
 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 +28,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.getApprovalPatternKey().
    */
-  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,21 +66,39 @@ 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).
+   */
+  getToolPatterns(toolName) {
+    return this.toolPatterns.get(toolName) ?? /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get all tool patterns (for debugging/display).
    */
-  getBashPatterns() {
-    return this.bashPatterns;
+  getAllToolPatterns() {
+    return this.toolPatterns;
   }
   // ==================== Directory Access Methods ====================
   /**
@@ -189,11 +209,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 +237,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 +258,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 +269,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 +305,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 +328,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 +350,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 +379,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 +396,7 @@ class ApprovalManager {
     } else {
       throw ApprovalError.cancelled(
         response.approvalId,
-        ApprovalType.TOOL_CONFIRMATION,
+        ApprovalType.TOOL_APPROVAL,
         response.message ?? response.reason
       );
     }
@@ -457,11 +477,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 +514,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,8 +58,9 @@ 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 ToolApprovalMetadataSchema = import_zod.z.object({
   toolName: import_zod.z.string().describe("Name of the tool to confirm"),
+  toolDisplayName: import_zod.z.string().optional().describe("Optional user-facing name for the tool (UI convenience)"),
   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"),
@@ -67,9 +68,9 @@ const ToolConfirmationMetadataSchema = import_zod.z.object({
     "Preview display data for approval UI (e.g., diff preview)"
   ),
   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"),
@@ -95,9 +96,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 +117,18 @@ 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.'
   )
-}).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 +150,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 +166,7 @@ const DirectoryAccessResponseSchema = BaseApprovalResponseSchema.extend({
   data: DirectoryAccessResponseDataSchema.optional()
 }).strict();
 const ApprovalResponseSchema = import_zod.z.union([
-  ToolConfirmationResponseSchema,
+  ToolApprovalResponseSchema,
   CommandConfirmationResponseSchema,
   ElicitationResponseSchema,
   CustomApprovalResponseSchema,
@@ -176,19 +177,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 +257,8 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
   ElicitationRequestSchema,
   ElicitationResponseDataSchema,
   ElicitationResponseSchema,
-  ToolConfirmationMetadataSchema,
-  ToolConfirmationRequestSchema,
-  ToolConfirmationResponseDataSchema,
-  ToolConfirmationResponseSchema
+  ToolApprovalMetadataSchema,
+  ToolApprovalRequestSchema,
+  ToolApprovalResponseDataSchema,
+  ToolApprovalResponseSchema
 });

package/dist/approval/schemas.d.ts

@@ -15,10 +15,11 @@ export declare const ApprovalStatusSchema: z.ZodNativeEnum<typeof ApprovalStatus
  */
 export declare const DenialReasonSchema: z.ZodNativeEnum<typeof DenialReason>;
 /**
- * Tool confirmation metadata schema
+ * Tool approval metadata schema
  */
-export declare const ToolConfirmationMetadataSchema: z.ZodObject<{
+export declare const ToolApprovalMetadataSchema: z.ZodObject<{
     toolName: z.ZodString;
+    toolDisplayName: z.ZodOptional<z.ZodString>;
     toolCallId: z.ZodString;
     args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     description: z.ZodOptional<z.ZodString>;
@@ -29,6 +30,7 @@ export declare const ToolConfirmationMetadataSchema: z.ZodObject<{
     args: Record<string, unknown>;
     toolName: string;
     description?: string | undefined;
+    toolDisplayName?: string | undefined;
     displayPreview?: ToolDisplayData | undefined;
     suggestedPatterns?: string[] | undefined;
 }, {
@@ -36,6 +38,7 @@ export declare const ToolConfirmationMetadataSchema: z.ZodObject<{
     args: Record<string, unknown>;
     toolName: string;
     description?: string | undefined;
+    toolDisplayName?: string | undefined;
     displayPreview?: ToolDisplayData | undefined;
     suggestedPatterns?: string[] | undefined;
 }>;
@@ -122,17 +125,18 @@ export declare const BaseApprovalRequestSchema: z.ZodObject<{
     sessionId?: string | undefined;
 }>;
 /**
- * Tool confirmation request schema
+ * Tool approval request schema
  */
-export declare const ToolConfirmationRequestSchema: z.ZodObject<{
+export declare const ToolApprovalRequestSchema: z.ZodObject<{
     approvalId: z.ZodString;
     sessionId: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodDate;
 } & {
-    type: z.ZodLiteral<ApprovalType.TOOL_CONFIRMATION>;
+    type: z.ZodLiteral<ApprovalType.TOOL_APPROVAL>;
     metadata: z.ZodObject<{
         toolName: z.ZodString;
+        toolDisplayName: z.ZodOptional<z.ZodString>;
         toolCallId: z.ZodString;
         args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         description: z.ZodOptional<z.ZodString>;
@@ -143,6 +147,7 @@ export declare const ToolConfirmationRequestSchema: z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     }, {
@@ -150,11 +155,12 @@ export declare const ToolConfirmationRequestSchema: z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
-    type: ApprovalType.TOOL_CONFIRMATION;
+    type: ApprovalType.TOOL_APPROVAL;
     approvalId: string;
     timestamp: Date;
     metadata: {
@@ -162,13 +168,14 @@ export declare const ToolConfirmationRequestSchema: z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     };
     timeout?: number | undefined;
     sessionId?: string | undefined;
 }, {
-    type: ApprovalType.TOOL_CONFIRMATION;
+    type: ApprovalType.TOOL_APPROVAL;
     approvalId: string;
     timestamp: Date;
     metadata: {
@@ -176,6 +183,7 @@ export declare const ToolConfirmationRequestSchema: z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     };
@@ -365,9 +373,10 @@ export declare const ApprovalRequestSchema: z.ZodDiscriminatedUnion<"type", [z.Z
     timeout: z.ZodOptional<z.ZodNumber>;
     timestamp: z.ZodDate;
 } & {
-    type: z.ZodLiteral<ApprovalType.TOOL_CONFIRMATION>;
+    type: z.ZodLiteral<ApprovalType.TOOL_APPROVAL>;
     metadata: z.ZodObject<{
         toolName: z.ZodString;
+        toolDisplayName: z.ZodOptional<z.ZodString>;
         toolCallId: z.ZodString;
         args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         description: z.ZodOptional<z.ZodString>;
@@ -378,6 +387,7 @@ export declare const ApprovalRequestSchema: z.ZodDiscriminatedUnion<"type", [z.Z
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     }, {
@@ -385,11 +395,12 @@ export declare const ApprovalRequestSchema: z.ZodDiscriminatedUnion<"type", [z.Z
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
-    type: ApprovalType.TOOL_CONFIRMATION;
+    type: ApprovalType.TOOL_APPROVAL;
     approvalId: string;
     timestamp: Date;
     metadata: {
@@ -397,13 +408,14 @@ export declare const ApprovalRequestSchema: z.ZodDiscriminatedUnion<"type", [z.Z
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     };
     timeout?: number | undefined;
     sessionId?: string | undefined;
 }, {
-    type: ApprovalType.TOOL_CONFIRMATION;
+    type: ApprovalType.TOOL_APPROVAL;
     approvalId: string;
     timestamp: Date;
     metadata: {
@@ -411,6 +423,7 @@ export declare const ApprovalRequestSchema: z.ZodDiscriminatedUnion<"type", [z.Z
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     };
@@ -576,9 +589,9 @@ export declare const ApprovalRequestSchema: z.ZodDiscriminatedUnion<"type", [z.Z
     sessionId?: string | undefined;
 }>]>;
 /**
- * Tool confirmation response data schema
+ * Tool approval response data schema
  */
-export declare const ToolConfirmationResponseDataSchema: z.ZodObject<{
+export declare const ToolApprovalResponseDataSchema: z.ZodObject<{
     rememberChoice: z.ZodOptional<z.ZodBoolean>;
     rememberPattern: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
@@ -642,9 +655,9 @@ export declare const BaseApprovalResponseSchema: z.ZodObject<{
     timeoutMs?: number | undefined;
 }>;
 /**
- * Tool confirmation response schema
+ * Tool approval response schema
  */
-export declare const ToolConfirmationResponseSchema: z.ZodObject<{
+export declare const ToolApprovalResponseSchema: z.ZodObject<{
     approvalId: z.ZodString;
     status: z.ZodNativeEnum<typeof ApprovalStatus>;
     sessionId: z.ZodOptional<z.ZodString>;
@@ -994,6 +1007,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
     timeout: z.ZodOptional<z.ZodNumber>;
     metadata: z.ZodUnion<[z.ZodObject<{
         toolName: z.ZodString;
+        toolDisplayName: z.ZodOptional<z.ZodString>;
         toolCallId: z.ZodString;
         args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         description: z.ZodOptional<z.ZodString>;
@@ -1004,6 +1018,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     }, {
@@ -1011,6 +1026,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     }>, z.ZodObject<{
@@ -1063,6 +1079,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     } | {
@@ -1089,6 +1106,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     } | {
@@ -1115,6 +1133,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     } | {
@@ -1141,6 +1160,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
         args: Record<string, unknown>;
         toolName: string;
         description?: string | undefined;
+        toolDisplayName?: string | undefined;
         displayPreview?: ToolDisplayData | undefined;
         suggestedPatterns?: string[] | undefined;
     } | {
@@ -1166,7 +1186,7 @@ export declare const ApprovalRequestDetailsSchema: z.ZodEffects<z.ZodObject<{
  */
 export type ValidatedApprovalRequest = z.output<typeof ApprovalRequestSchema>;
 export type ValidatedApprovalResponse = z.output<typeof ApprovalResponseSchema>;
-export type ValidatedToolConfirmationRequest = z.output<typeof ToolConfirmationRequestSchema>;
+export type ValidatedToolApprovalRequest = z.output<typeof ToolApprovalRequestSchema>;
 export type ValidatedElicitationRequest = z.output<typeof ElicitationRequestSchema>;
 export type ValidatedCustomApprovalRequest = z.output<typeof CustomApprovalRequestSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/approval/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/approval/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/approval/schemas.ts"],"names":[],"mappings":"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"}