@dexto/core 1.8.12 → 1.9.1

package/dist/approval/manager.js

@@ -1,44 +1,16 @@
 import "../chunk-C6A6W6XS.js";
-import path from "node:path";
-import { realpathSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
 import { ApprovalType, ApprovalStatus } from "./types.js";
 import {
   CommandApprovalResponseSchema,
   CustomApprovalResponseSchema,
-  DirectoryAccessResponseSchema,
   ElicitationResponseSchema,
   ToolApprovalResponseSchema
 } from "./schemas.js";
 import { createApprovalRequest, createDeterministicApprovalId } from "./factory.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { ApprovalError } from "./errors.js";
-import { patternCovers } from "../tools/pattern-utils.js";
 const GLOBAL_APPROVAL_SCOPE = "__global__";
-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 {
   constructor(config, logger, approvalStore) {
     this.approvalStore = approvalStore;
@@ -72,8 +44,7 @@ class ApprovalManager {
   }
   createEmptyScopeState() {
     return {
-      toolPatterns: /* @__PURE__ */ new Map(),
-      approvedDirectories: /* @__PURE__ */ new Map()
+      approvedKeys: /* @__PURE__ */ new Map()
     };
   }
   getOrCreateScope(scopeKey) {
@@ -120,26 +91,13 @@ class ApprovalManager {
       }
     }
   }
-  snapshotToolPatterns(scopeKey) {
-    const snapshot = {};
-    for (const [toolName, patterns] of this.getScope(scopeKey).toolPatterns) {
-      snapshot[toolName] = Array.from(patterns);
-    }
-    return snapshot;
-  }
-  snapshotApprovedDirectories(scopeKey) {
-    return Array.from(this.getScope(scopeKey).approvedDirectories.entries()).map(
-      ([path2, type]) => ({
-        path: path2,
-        type
-      })
-    );
+  snapshotApprovedKeys(scopeKey) {
+    return Object.fromEntries(this.getScope(scopeKey).approvedKeys.entries());
   }
   async persistScope(sessionId) {
     const scopeKey = this.getScopeKey(sessionId);
     const state = {
-      toolPatterns: this.snapshotToolPatterns(scopeKey),
-      approvedDirectories: this.snapshotApprovedDirectories(scopeKey)
+      approvedKeys: this.snapshotApprovedKeys(scopeKey)
     };
     await this.approvalStore.saveSessionState({
       ...this.sessionScope(sessionId),
@@ -148,17 +106,12 @@ class ApprovalManager {
   }
   hydrateScope(sessionId, state) {
     const scopeKey = this.getScopeKey(sessionId);
-    const toolPatterns = /* @__PURE__ */ new Map();
-    for (const [toolName, patterns] of Object.entries(state.toolPatterns)) {
-      toolPatterns.set(toolName, new Set(patterns));
-    }
-    const approvedDirectories = /* @__PURE__ */ new Map();
-    for (const entry of state.approvedDirectories) {
-      approvedDirectories.set(entry.path, entry.type);
+    const approvedKeys = /* @__PURE__ */ new Map();
+    for (const [key, type] of Object.entries(state.approvedKeys ?? {})) {
+      approvedKeys.set(key, type);
     }
     this.scopes.set(scopeKey, {
-      toolPatterns,
-      approvedDirectories
+      approvedKeys
     });
   }
   async restoreSessionState(sessionId) {
@@ -175,8 +128,7 @@ class ApprovalManager {
       this.loadedScopes.add(scopeKey);
       this.logger.debug("Restored persisted approval state", {
         sessionId: this.getScopeLabel(sessionId),
-        toolCount: Object.keys(state.toolPatterns).length,
-        directoryCount: state.approvedDirectories.length
+        keyCount: Object.keys(state.approvedKeys ?? {}).length
       });
     });
   }
@@ -192,94 +144,37 @@ class ApprovalManager {
       await this.approvalStore.deleteSessionState(this.sessionScope(sessionId));
     });
   }
-  // ==================== Pattern Methods ====================
-  getOrCreateToolPatternSet(toolName, scopeKey) {
-    const scope = this.getOrCreateScope(scopeKey).toolPatterns;
-    const existing = scope.get(toolName);
-    if (existing) return existing;
-    const created = /* @__PURE__ */ new Set();
-    scope.set(toolName, created);
-    return created;
-  }
-  /**
-   * Add an approval pattern for a tool.
-   */
-  async addPattern(toolName, pattern, sessionId) {
+  // ==================== Generic Approval Key Methods ====================
+  async addApprovedKey(key, type = "session", sessionId) {
     await this.restoreSessionState(sessionId);
     const scopeKey = this.getScopeKey(sessionId);
     await this.runWithScopeLock(scopeKey, async () => {
-      this.getOrCreateToolPatternSet(toolName, scopeKey).add(pattern);
+      const approvedKeys = this.getOrCreateScope(scopeKey).approvedKeys;
+      const existing = approvedKeys.get(key);
+      const effectiveType = type === "session" || existing === "session" ? "session" : "once";
+      approvedKeys.set(key, effectiveType);
       await this.persistScope(sessionId);
     });
-    this.logger.debug(
-      `Added pattern for '${toolName}' in '${this.getScopeLabel(sessionId)}': "${pattern}"`
-    );
   }
-  /**
-   * Check if a pattern key is covered by any approved pattern for a tool.
-   *
-   * Note: This expects a pattern key (e.g. "git push *"), not raw arguments.
-   * Tools are responsible for generating the key via `tool.approval.patternKey()`.
-   */
-  matchesPattern(toolName, patternKey, sessionId) {
-    const scopeKey = this.getScopeKey(sessionId);
-    const patterns = this.getScope(scopeKey).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}" (tool: ${toolName})`
-        );
-        return true;
-      }
-    }
-    return false;
+  isApprovalKeySessionApproved(key, sessionId) {
+    return this.getScope(this.getScopeKey(sessionId)).approvedKeys.get(key) === "session";
   }
-  /**
-   * Clear all patterns for a tool (or all tools when omitted).
-   */
-  async clearPatterns(toolName, sessionId) {
+  isApprovalKeyApproved(key, sessionId) {
+    return this.getScope(this.getScopeKey(sessionId)).approvedKeys.has(key);
+  }
+  getApprovedKeys(sessionId) {
+    return this.getScope(this.getScopeKey(sessionId)).approvedKeys;
+  }
+  async clearApprovedKeys(sessionId) {
     await this.restoreSessionState(sessionId);
     const scopeKey = this.getScopeKey(sessionId);
     await this.runWithScopeLock(scopeKey, async () => {
-      const scope = this.getOrCreateScope(scopeKey).toolPatterns;
-      if (toolName) {
-        const patterns = scope.get(toolName);
-        if (!patterns) return;
-        const count2 = patterns.size;
-        scope.delete(toolName);
-        await this.persistScope(sessionId);
-        if (count2 > 0) {
-          this.logger.debug(
-            `Cleared ${count2} pattern(s) for '${toolName}' in '${this.getScopeLabel(sessionId)}'`
-          );
-        }
-        return;
-      }
-      const count = Array.from(scope.values()).reduce((sum, set) => sum + set.size, 0);
-      scope.clear();
+      const approvedKeys = this.getOrCreateScope(scopeKey).approvedKeys;
+      if (approvedKeys.size === 0) return;
+      approvedKeys.clear();
       await this.persistScope(sessionId);
-      if (count > 0) {
-        this.logger.debug(
-          `Cleared ${count} total tool pattern(s) in '${this.getScopeLabel(sessionId)}'`
-        );
-      }
     });
   }
-  /**
-   * Get patterns for a tool (for debugging/display).
-   */
-  getToolPatterns(toolName, sessionId) {
-    const scopeKey = this.getScopeKey(sessionId);
-    return this.getScope(scopeKey).toolPatterns.get(toolName) ?? /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get all tool patterns (for debugging/display).
-   */
-  getAllToolPatterns(sessionId) {
-    const scopeKey = this.getScopeKey(sessionId);
-    return this.getScope(scopeKey).toolPatterns;
-  }
   // ==================== Directory Access Methods ====================
   /**
    * Resolve a directory path for use as an approval key.
@@ -288,150 +183,8 @@ class ApprovalManager {
    * continue to work even when other subsystems canonicalize paths via realpath
    * (e.g. macOS /tmp -> /private/tmp or custom symlinked directories).
    */
-  getPathApprovalKeys(targetPath) {
-    const resolved = path.resolve(targetPath);
-    const real = tryRealpathSyncWithExistingParent(resolved);
-    if (real && real !== resolved) {
-      return [resolved, real];
-    }
-    return [resolved];
-  }
-  isPathWithinApprovedDirectory(targetPath, sessionId, approvedTypes) {
-    const scopeKey = this.getScopeKey(sessionId);
-    const directoryScope = this.getScope(scopeKey).approvedDirectories;
-    for (const normalized of this.getPathApprovalKeys(targetPath)) {
-      for (const [approvedDir, type] of directoryScope) {
-        if (!approvedTypes.has(type)) {
-          continue;
-        }
-        const relative = path.relative(approvedDir, normalized);
-        if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
-          this.logger.debug(
-            `Path "${normalized}" is within approved directory "${approvedDir}" (type: ${type})`
-          );
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Initialize the working directory as a session-approved directory.
-   * This should be called once during setup to ensure the working directory
-   * never triggers directory access prompts.
-   *
-   * @param workingDir The working directory path
-   */
-  async initializeWorkingDirectory(workingDir, sessionId) {
-    await this.addApprovedDirectory(workingDir, "session", sessionId);
-  }
-  /**
-   * Add a directory to the approved list for this session.
-   * Files within this directory (including subdirectories) will be allowed.
-   *
-   * @param directory Absolute path to the directory to approve
-   * @param type The approval type:
-   *   - 'session': No directory prompt on future accesses, follows tool config
-   *   - 'once': Will prompt again on future accesses, but tool can execute this time
-   * @example
-   * ```typescript
-   * manager.addApprovedDirectory("/external/project", 'session');
-   * // Now /external/project/src/file.ts is accessible without directory prompt
-   *
-   * manager.addApprovedDirectory("/tmp/files", 'once');
-   * // Tool can access, but will prompt again next time
-   * ```
-   */
-  async addApprovedDirectory(directory, type = "session", sessionId) {
-    await this.restoreSessionState(sessionId);
-    const scopeKey = this.getScopeKey(sessionId);
-    await this.runWithScopeLock(scopeKey, async () => {
-      const keys = this.getPathApprovalKeys(directory);
-      const directoryScope = this.getOrCreateScope(scopeKey).approvedDirectories;
-      const existingTypes = keys.map((key) => directoryScope.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 = directoryScope.get(key);
-        if (existing === "session") {
-          continue;
-        }
-        directoryScope.set(key, effectiveType);
-      }
-      await this.persistScope(sessionId);
-      const resolvedKey = keys[0];
-      if (effectiveType === "session" && type === "once" && hasSessionApproval) {
-        this.logger.debug(
-          `Directory "${resolvedKey}" already approved as 'session', not downgrading to 'once'`
-        );
-        return;
-      }
-      const realKey = keys.length > 1 ? keys[1] : null;
-      this.logger.debug(
-        `Added approved directory in '${this.getScopeLabel(sessionId)}': "${resolvedKey}" (type: ${effectiveType})${realKey ? `, realpath: "${realKey}"` : ""}`
-      );
-    });
-  }
   /**
-   * Check if a file path is within any session-approved directory.
-   * This is used for PROMPTING decisions - only 'session' type directories count.
-   * Working directory and user session-approved directories return true.
-   *
-   * @param filePath The file path to check (can be relative or absolute)
-   * @returns true if the path is within a session-approved directory
-   */
-  isDirectorySessionApproved(filePath, sessionId) {
-    return this.isPathWithinApprovedDirectory(filePath, sessionId, /* @__PURE__ */ new Set(["session"]));
-  }
-  /**
-   * Check if a file path is within any approved directory (session OR once).
-   * This is used for EXECUTION decisions - both 'session' and 'once' types count.
-   * PathValidator uses this to determine if a tool can access the path.
-   *
-   * @param filePath The file path to check (can be relative or absolute)
-   * @returns true if the path is within any approved directory
-   */
-  isDirectoryApproved(filePath, sessionId) {
-    return this.isPathWithinApprovedDirectory(
-      filePath,
-      sessionId,
-      /* @__PURE__ */ new Set(["session", "once"])
-    );
-  }
-  /**
-   * Clear all approved directories.
-   * Should be called when session ends.
-   */
-  async clearApprovedDirectories(sessionId) {
-    await this.restoreSessionState(sessionId);
-    const scopeKey = this.getScopeKey(sessionId);
-    await this.runWithScopeLock(scopeKey, async () => {
-      const scope = this.getOrCreateScope(scopeKey).approvedDirectories;
-      const count = scope.size;
-      scope.clear();
-      await this.persistScope(sessionId);
-      if (count > 0) {
-        this.logger.debug(
-          `Cleared ${count} approved directories in '${this.getScopeLabel(sessionId)}'`
-        );
-      }
-    });
-  }
-  /**
-   * Get the current map of approved directories with their types (for debugging/display).
-   */
-  getApprovedDirectories(sessionId) {
-    const scopeKey = this.getScopeKey(sessionId);
-    return this.getScope(scopeKey).approvedDirectories;
-  }
-  /**
-   * Get just the directory paths that are approved (for debugging/display).
-   */
-  getApprovedDirectoryPaths(sessionId) {
-    return Array.from(this.getApprovedDirectories(sessionId).keys());
-  }
-  /**
-   * Clear all session-scoped approvals (tool patterns and directories).
+   * Clear all session-scoped approvals.
    * Convenience method for clearing all session state at once.
    */
   async clearSessionApprovals(sessionId) {
@@ -439,17 +192,12 @@ class ApprovalManager {
     const scopeKey = this.getScopeKey(sessionId);
     await this.runWithScopeLock(scopeKey, async () => {
       const scope = this.getOrCreateScope(scopeKey);
-      const patternCount = Array.from(scope.toolPatterns.values()).reduce(
-        (sum, set) => sum + set.size,
-        0
-      );
-      const directoryCount = scope.approvedDirectories.size;
-      scope.toolPatterns.clear();
-      scope.approvedDirectories.clear();
+      const keyCount = scope.approvedKeys.size;
+      scope.approvedKeys.clear();
       await this.persistScope(sessionId);
-      if (patternCount > 0 || directoryCount > 0) {
+      if (keyCount > 0) {
         this.logger.debug(
-          `Cleared ${patternCount} tool pattern(s) and ${directoryCount} approved director${directoryCount === 1 ? "y" : "ies"} in '${this.getScopeLabel(sessionId)}'`
+          `Cleared ${keyCount} approval key(s) in '${this.getScopeLabel(sessionId)}'`
         );
       }
     });
@@ -529,8 +277,6 @@ class ApprovalManager {
         return ElicitationResponseSchema.parse(response);
       case ApprovalType.CUSTOM:
         return CustomApprovalResponseSchema.parse(response);
-      case ApprovalType.DIRECTORY_ACCESS:
-        return DirectoryAccessResponseSchema.parse(response);
     }
   }
   getElicitationFormData(response) {
@@ -546,33 +292,6 @@ class ApprovalManager {
       field: "formData"
     });
   }
-  /**
-   * Request directory access approval.
-   * Convenience method for directory access requests.
-   *
-   * @example
-   * ```typescript
-   * const response = await manager.requestDirectoryAccess({
-   *   path: '/external/project/src/file.ts',
-   *   parentDir: '/external/project',
-   *   operation: 'write',
-   *   toolName: 'write_file',
-   *   sessionId: 'session-123'
-   * });
-   * ```
-   */
-  async requestDirectoryAccess(metadata) {
-    const { sessionId, hostRuntime, timeout, ...directoryMetadata } = metadata;
-    return this.requestApproval(
-      this.createApprovalDetails(
-        ApprovalType.DIRECTORY_ACCESS,
-        directoryMetadata,
-        sessionId,
-        hostRuntime,
-        timeout
-      )
-    );
-  }
   /**
    * Request a generic approval
    */
@@ -824,8 +543,8 @@ class ApprovalManager {
   }
   /**
    * Auto-approve pending requests that match a predicate.
-   * Used when a pattern is remembered to auto-approve other parallel requests
-   * that would now match the same pattern.
+   * Used when a remembered approval should auto-approve other parallel requests
+   * selected by the caller.
    *
    * @param predicate Function that returns true for requests that should be auto-approved
    * @param responseData Optional data to include in the auto-approval response
@@ -834,7 +553,9 @@ class ApprovalManager {
   autoApprovePendingRequests(predicate, responseData) {
     const count = this.handler?.autoApprovePending?.(predicate, responseData) ?? 0;
     if (count > 0) {
-      this.logger.info(`Auto-approved ${count} pending request(s) due to matching pattern`);
+      this.logger.info(
+        `Auto-approved ${count} pending request(s) due to remembered approval`
+      );
     }
     return count;
   }

package/dist/approval/schemas.cjs

@@ -34,10 +34,6 @@ __export(schemas_exports, {
   CustomApprovalResponseDataSchema: () => CustomApprovalResponseDataSchema,
   CustomApprovalResponseSchema: () => CustomApprovalResponseSchema,
   DenialReasonSchema: () => DenialReasonSchema,
-  DirectoryAccessMetadataSchema: () => DirectoryAccessMetadataSchema,
-  DirectoryAccessRequestSchema: () => DirectoryAccessRequestSchema,
-  DirectoryAccessResponseDataSchema: () => DirectoryAccessResponseDataSchema,
-  DirectoryAccessResponseSchema: () => DirectoryAccessResponseSchema,
   ElicitationMetadataSchema: () => ElicitationMetadataSchema,
   ElicitationRequestSchema: () => ElicitationRequestSchema,
   ElicitationResponseDataSchema: () => ElicitationResponseDataSchema,
@@ -65,14 +61,11 @@ const ToolPresentationSnapshotV1Schema = import_zod.z.custom(
     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 approve"),
+  approvalKey: import_zod.z.string().min(1).optional().describe(
+    "Optional opaque key identifying the approval scope. Core stores keys exactly and does not interpret them."
+  ),
   presentationSnapshot: ToolPresentationSnapshotV1Schema.optional().describe(
     "Optional UI-agnostic presentation snapshot for the tool call. Clients MUST ignore unknown fields."
   ),
@@ -81,12 +74,6 @@ const ToolApprovalMetadataSchema = import_zod.z.object({
   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. Tools may provide patterns to allow approving a broader subset of future calls (e.g., ["git push *", "git *"]).'
   )
 }).strict().describe("Tool approval metadata");
 const CommandApprovalMetadataSchema = import_zod.z.object({
@@ -127,24 +114,15 @@ const CustomApprovalRequestSchema = BaseApprovalRequestSchema.extend({
   type: import_zod.z.literal(import_types.ApprovalType.CUSTOM),
   metadata: CustomApprovalMetadataSchema
 }).strict();
-const DirectoryAccessRequestSchema = BaseApprovalRequestSchema.extend({
-  type: import_zod.z.literal(import_types.ApprovalType.DIRECTORY_ACCESS),
-  metadata: DirectoryAccessMetadataSchema
-}).strict();
 const ApprovalRequestSchema = import_zod.z.discriminatedUnion("type", [
   ToolApprovalRequestSchema,
   CommandApprovalRequestSchema,
   ElicitationRequestSchema,
-  CustomApprovalRequestSchema,
-  DirectoryAccessRequestSchema
+  CustomApprovalRequestSchema
 ]);
 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 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)"
+  rememberChoice: import_zod.z.boolean().optional().describe(
+    "Remember this approval scope for the session. If an approval key is present, only matching keys are remembered; otherwise all uses of this tool are approved."
   )
 }).strict().describe("Tool approval response data");
 const CommandApprovalResponseDataSchema = import_zod.z.object({
@@ -155,9 +133,6 @@ const ElicitationResponseDataSchema = import_zod.z.object({
   formData: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).describe("Form data matching schema")
 }).strict().describe("Elicitation response data");
 const CustomApprovalResponseDataSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).describe("Custom response data");
-const DirectoryAccessResponseDataSchema = import_zod.z.object({
-  rememberDirectory: import_zod.z.boolean().optional().describe("Remember this directory for the session (allows all file access within it)")
-}).strict().describe("Directory access response data");
 const BaseApprovalResponseSchema = import_zod.z.object({
   approvalId: import_zod.z.string().uuid().describe("Must match request approvalId"),
   status: ApprovalStatusSchema.describe("Approval status"),
@@ -183,15 +158,11 @@ const ElicitationResponseSchema = BaseApprovalResponseSchema.extend({
 const CustomApprovalResponseSchema = BaseApprovalResponseSchema.extend({
   data: CustomApprovalResponseDataSchema.optional()
 }).strict();
-const DirectoryAccessResponseSchema = BaseApprovalResponseSchema.extend({
-  data: DirectoryAccessResponseDataSchema.optional()
-}).strict();
 const ApprovalResponseSchema = import_zod.z.union([
   ToolApprovalResponseSchema,
   CommandApprovalResponseSchema,
   ElicitationResponseSchema,
-  CustomApprovalResponseSchema,
-  DirectoryAccessResponseSchema
+  CustomApprovalResponseSchema
 ]);
 const ApprovalRequestDetailsSchema = import_zod.z.object({
   type: ApprovalTypeSchema,
@@ -204,8 +175,7 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
     ToolApprovalMetadataSchema,
     CommandApprovalMetadataSchema,
     ElicitationMetadataSchema,
-    CustomApprovalMetadataSchema,
-    DirectoryAccessMetadataSchema
+    CustomApprovalMetadataSchema
   ])
 }).superRefine((data, ctx) => {
   if (data.type === import_types.ApprovalType.TOOL_APPROVAL) {
@@ -235,15 +205,6 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
         path: ["metadata"]
       });
     }
-  } else if (data.type === import_types.ApprovalType.DIRECTORY_ACCESS) {
-    const result = DirectoryAccessMetadataSchema.safeParse(data.metadata);
-    if (!result.success) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: "Metadata must match DirectoryAccessMetadataSchema for DIRECTORY_ACCESS type",
-        path: ["metadata"]
-      });
-    }
   } else if (data.type === import_types.ApprovalType.CUSTOM) {
     const result = CustomApprovalMetadataSchema.safeParse(data.metadata);
     if (!result.success) {
@@ -273,10 +234,6 @@ const ApprovalRequestDetailsSchema = import_zod.z.object({
   CustomApprovalResponseDataSchema,
   CustomApprovalResponseSchema,
   DenialReasonSchema,
-  DirectoryAccessMetadataSchema,
-  DirectoryAccessRequestSchema,
-  DirectoryAccessResponseDataSchema,
-  DirectoryAccessResponseSchema,
   ElicitationMetadataSchema,
   ElicitationRequestSchema,
   ElicitationResponseDataSchema,