@frontmcp/plugin-approval 1.7.2 → 1.8.1

package/index.js

@@ -76,11 +76,37 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // plugins/plugin-approval/src/approval.plugin.ts
-var import_sdk5 = require("@frontmcp/sdk");
+var import_sdk6 = require("@frontmcp/sdk");
 
-// plugins/plugin-approval/src/stores/approval-storage.store.ts
+// plugins/plugin-approval/src/approval.identity.ts
 var import_sdk = require("@frontmcp/sdk");
 var import_utils = require("@frontmcp/utils");
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function resolveApprovalIdentity(ctx) {
+  const extra = ctx?.authInfo?.extra;
+  const userId = nonEmptyString(extra?.["userId"]) ?? nonEmptyString(extra?.["sub"]) ?? nonEmptyString(ctx?.authInfo?.clientId);
+  const sessionId = nonEmptyString(ctx?.sessionId);
+  if (sessionId && sessionId !== import_sdk.STATELESS_SESSION_ID) {
+    return { sessionId, userId };
+  }
+  return { sessionId: userId ? `stateless-user:${userId}` : `unidentified:${(0, import_utils.randomUUID)()}`, userId };
+}
+
+// plugins/plugin-approval/src/approval.symbols.ts
+var ApprovalStoreToken = /* @__PURE__ */ Symbol.for(
+  "plugin:approval:store"
+);
+var ApprovalServiceToken = /* @__PURE__ */ Symbol.for(
+  "plugin:approval:service"
+);
+var ChallengeServiceToken = /* @__PURE__ */ Symbol.for(
+  "plugin:approval:challenge-service"
+);
+
+// plugins/plugin-approval/src/hooks/approval-check.hook.ts
+var import_sdk2 = require("@frontmcp/sdk");
 
 // plugins/plugin-approval/src/approval/types.ts
 var ApprovalScope = /* @__PURE__ */ ((ApprovalScope2) => {
@@ -445,269 +471,125 @@ var ChallengeValidationError = class extends ApprovalError {
   }
 };
 
-// plugins/plugin-approval/src/stores/approval-storage.store.ts
-function escapePattern(str) {
-  return str.replace(/[*?[\]\\]/g, "\\$&");
-}
-var ApprovalStorageStore = class {
-  storage;
-  options;
-  cleanupInterval;
-  initialized = false;
-  ownedStorage = false;
-  constructor(options = {}) {
-    this.options = {
-      storage: options.storage ?? { type: "auto" },
-      storageInstance: options.storageInstance,
-      namespace: options.namespace ?? "approval",
-      cleanupIntervalSeconds: options.cleanupIntervalSeconds ?? 60
-    };
-  }
-  /**
-   * Initialize the storage connection.
-   */
-  async initialize() {
-    if (this.initialized) {
+// plugins/plugin-approval/src/hooks/approval-check.hook.ts
+var passedApprovalStores = /* @__PURE__ */ new WeakMap();
+var ApprovalCheckPlugin = class extends import_sdk2.DynamicPlugin {
+  async checkApproval(flowCtx) {
+    const { tool, toolContext } = flowCtx.state;
+    if (!tool || !toolContext) return;
+    const metadata = tool.metadata;
+    const approvalConfig = this.resolveApprovalConfig(
+      metadata["approval"]
+    );
+    if (!approvalConfig.required) {
       return;
     }
-    if (this.options.storageInstance) {
-      this.storage = this.options.storageInstance.namespace(this.options.namespace);
-      this.ownedStorage = false;
-    } else {
-      const rootStorage = await (0, import_utils.createStorage)(this.options.storage);
-      this.storage = rootStorage.namespace(this.options.namespace);
-      this.ownedStorage = true;
-    }
-    if (this.options.cleanupIntervalSeconds > 0) {
-      this.cleanupInterval = setInterval(() => {
-        void this.clearExpiredApprovals();
-      }, this.options.cleanupIntervalSeconds * 1e3);
-      this.cleanupInterval.unref?.();
+    if (approvalConfig.skipApproval) {
+      return;
     }
-    this.initialized = true;
+    const approvalStore = this.get(ApprovalStoreToken);
+    const passedStores = passedApprovalStores.get(toolContext) ?? /* @__PURE__ */ new WeakSet();
+    if (passedStores.has(approvalStore)) return;
+    await this.enforceApproval(flowCtx, tool, toolContext, approvalConfig, approvalStore);
+    passedStores.add(approvalStore);
+    passedApprovalStores.set(toolContext, passedStores);
   }
-  ensureInitialized() {
-    if (!this.initialized) {
-      throw new Error("ApprovalStorageStore not initialized. Call initialize() first.");
+  async enforceApproval(flowCtx, tool, toolContext, approvalConfig, approvalStore) {
+    const { sessionId, userId } = resolveApprovalIdentity(toolContext.tryGetContext?.());
+    const approval = await approvalStore.getApproval(tool.fullName, sessionId, userId);
+    if (approval?.state === "denied" /* DENIED */) {
+      throw new ApprovalRequiredError({
+        toolId: tool.fullName,
+        state: "denied",
+        message: `Tool "${tool.fullName}" execution denied.`
+      });
     }
-  }
-  buildKey(toolId, sessionId, userId, context) {
-    const parts = [toolId];
-    if (sessionId) parts.push(`session:${sessionId}`);
-    if (userId) parts.push(`user:${userId}`);
-    if (context) parts.push(`ctx:${context.type}:${context.identifier}`);
-    return parts.join(":");
-  }
-  parseRecord(value) {
-    if (!value) return void 0;
-    try {
-      const parsed = JSON.parse(value);
-      const result = approvalRecordSchema.safeParse(parsed);
-      if (!result.success) {
-        return void 0;
-      }
-      return result.data;
-    } catch {
-      return void 0;
+    if (this.isPreApprovedContext(approvalConfig, this.getCurrentContext(flowCtx))) {
+      return;
     }
-  }
-  isExpired(approval) {
-    return approval.expiresAt !== void 0 && Date.now() > approval.expiresAt;
-  }
-  async getApproval(toolId, sessionId, userId) {
-    this.ensureInitialized();
-    const sessionKey = this.buildKey(toolId, sessionId);
-    const sessionValue = await this.storage.get(sessionKey);
-    const sessionApproval = this.parseRecord(sessionValue);
-    if (sessionApproval && !this.isExpired(sessionApproval)) {
-      return sessionApproval;
+    if (approvalConfig.alwaysPrompt) {
+      await this.handleApprovalRequired(flowCtx, approvalConfig, approval);
+      return;
     }
-    if (userId) {
-      const userKey = this.buildKey(toolId, void 0, userId);
-      const userValue = await this.storage.get(userKey);
-      const userApproval = this.parseRecord(userValue);
-      if (userApproval && !this.isExpired(userApproval)) {
-        return userApproval;
+    if (approval?.state === "approved" /* APPROVED */) {
+      if (!this.isExpired(approval)) {
+        return;
       }
     }
-    return void 0;
+    await this.handleApprovalRequired(flowCtx, approvalConfig, approval);
   }
-  async queryApprovals(query) {
-    this.ensureInitialized();
-    const results = [];
-    const pattern = query.toolId ? `${query.toolId}:*` : "*";
-    const keys = await this.storage.keys(pattern);
-    const values = await this.storage.mget(keys);
-    for (const value of values) {
-      const approval = this.parseRecord(value);
-      if (!approval) continue;
-      if (!query.includeExpired && this.isExpired(approval)) {
-        continue;
-      }
-      if (query.toolId && approval.toolId !== query.toolId) continue;
-      if (query.toolIds && !query.toolIds.includes(approval.toolId)) continue;
-      if (query.scope && approval.scope !== query.scope) continue;
-      if (query.scopes && !query.scopes.includes(approval.scope)) continue;
-      if (query.state && approval.state !== query.state) continue;
-      if (query.states && !query.states.includes(approval.state)) continue;
-      if (query.sessionId && approval.sessionId !== query.sessionId) continue;
-      if (query.userId && approval.userId !== query.userId) continue;
-      if (query.context) {
-        if (!approval.context || approval.context.type !== query.context.type || approval.context.identifier !== query.context.identifier) {
-          continue;
-        }
-      }
-      results.push(approval);
+  resolveApprovalConfig(config) {
+    if (config === true) {
+      return { required: true, defaultScope: "session" /* SESSION */ };
     }
-    return results;
-  }
-  async grantApproval(options) {
-    this.ensureInitialized();
-    const now = Date.now();
-    const expiresAt = options.ttlMs ? now + options.ttlMs : void 0;
-    const grantedBy = normalizeGrantor(options.grantedBy);
-    const record = {
-      toolId: options.toolId,
-      state: "approved" /* APPROVED */,
-      scope: options.scope,
-      grantedAt: now,
-      expiresAt,
-      ttlMs: options.ttlMs,
-      sessionId: options.sessionId,
-      userId: options.userId,
-      context: options.context,
-      grantedBy,
-      reason: options.reason,
-      metadata: options.metadata
+    if (config === false || config === void 0) {
+      return { required: false };
+    }
+    return {
+      ...config,
+      required: config.required ?? true,
+      defaultScope: config.defaultScope ?? "session" /* SESSION */
     };
-    const key = this.buildKey(options.toolId, options.sessionId, options.userId, options.context);
-    const ttlSeconds = options.ttlMs ? Math.ceil(options.ttlMs / 1e3) : void 0;
-    await this.storage.set(key, JSON.stringify(record), { ttlSeconds });
-    return record;
   }
-  async revokeApproval(options) {
-    this.ensureInitialized();
-    const key = this.buildKey(options.toolId, options.sessionId, options.userId, options.context);
-    const exists = await this.storage.exists(key);
-    if (exists) {
-      await this.storage.delete(key);
-      return true;
-    }
-    return false;
+  isExpired(approval) {
+    if (!approval.expiresAt) return false;
+    return Date.now() > approval.expiresAt;
   }
-  async isApproved(toolId, sessionId, userId, context) {
-    this.ensureInitialized();
-    if (context) {
-      const contextKey = this.buildKey(toolId, sessionId, userId, context);
-      const contextValue = await this.storage.get(contextKey);
-      const contextApproval = this.parseRecord(contextValue);
-      if (contextApproval && contextApproval.state === "approved" /* APPROVED */ && !this.isExpired(contextApproval)) {
-        return true;
-      }
-    }
-    const sessionKey = this.buildKey(toolId, sessionId);
-    const sessionValue = await this.storage.get(sessionKey);
-    const sessionApproval = this.parseRecord(sessionValue);
-    if (sessionApproval && sessionApproval.state === "approved" /* APPROVED */ && !this.isExpired(sessionApproval)) {
-      return true;
-    }
-    if (userId) {
-      const userKey = this.buildKey(toolId, void 0, userId);
-      const userValue = await this.storage.get(userKey);
-      const userApproval = this.parseRecord(userValue);
-      if (userApproval && userApproval.state === "approved" /* APPROVED */ && !this.isExpired(userApproval)) {
-        return true;
-      }
-    }
-    return false;
+  /**
+   * The context this call is running in, as established by the SESSION (GHSA-r848-p7wf-96rc).
+   *
+   * Deliberately ignores `toolContext.input.context`. The only consumer of this value is
+   * `isPreApprovedContext`, which skips the approval prompt outright, so reading it from the
+   * arguments of the call being gated let a caller name its own pre-approved context and walk
+   * straight past the gate. Only `authInfo.extra.approvalContext`, which the server sets
+   * while authenticating, can say what context a call belongs to.
+   */
+  getCurrentContext(flowCtx) {
+    const ctx = flowCtx.state.toolContext?.tryGetContext?.();
+    const sessionContext = ctx?.authInfo?.extra?.["approvalContext"];
+    return this.isApprovalContext(sessionContext) ? sessionContext : void 0;
   }
-  async clearSessionApprovals(sessionId) {
-    this.ensureInitialized();
-    const escapedSessionId = escapePattern(sessionId);
-    const pattern = `*:session:${escapedSessionId}*`;
-    const keys = await this.storage.keys(pattern);
-    if (keys.length === 0) {
-      return 0;
-    }
-    return await this.storage.mdelete(keys);
+  isApprovalContext(value) {
+    return typeof value === "object" && value !== null && "type" in value && "identifier" in value && typeof value.type === "string" && typeof value.identifier === "string";
   }
-  async clearExpiredApprovals() {
-    this.ensureInitialized();
-    const now = Date.now();
-    const keys = await this.storage.keys("*");
-    const values = await this.storage.mget(keys);
-    const keysToDelete = [];
-    for (let i = 0; i < keys.length; i++) {
-      const approval = this.parseRecord(values[i]);
-      if (approval && approval.expiresAt && approval.expiresAt <= now) {
-        keysToDelete.push(keys[i]);
-      }
-    }
-    if (keysToDelete.length > 0) {
-      return await this.storage.mdelete(keysToDelete);
+  isPreApprovedContext(config, currentContext) {
+    if (!currentContext || !config.preApprovedContexts?.length) {
+      return false;
     }
-    return 0;
+    return config.preApprovedContexts.some(
+      (preApproved) => preApproved.type === currentContext.type && preApproved.identifier === currentContext.identifier
+    );
   }
-  async getStats() {
-    this.ensureInitialized();
-    const byScope = {
-      ["session" /* SESSION */]: 0,
-      ["user" /* USER */]: 0,
-      ["time_limited" /* TIME_LIMITED */]: 0,
-      ["tool_specific" /* TOOL_SPECIFIC */]: 0,
-      ["context_specific" /* CONTEXT_SPECIFIC */]: 0
-    };
-    const byState = {
-      ["pending" /* PENDING */]: 0,
-      ["approved" /* APPROVED */]: 0,
-      ["denied" /* DENIED */]: 0,
-      ["expired" /* EXPIRED */]: 0
-    };
-    const keys = await this.storage.keys("*");
-    const values = await this.storage.mget(keys);
-    let total = 0;
-    for (const value of values) {
-      const approval = this.parseRecord(value);
-      if (approval) {
-        total++;
-        byScope[approval.scope]++;
-        byState[approval.state]++;
+  async handleApprovalRequired(flowCtx, config, existingApproval) {
+    const { tool } = flowCtx.state;
+    const message = config.approvalMessage ?? `Tool "${tool?.fullName}" requires approval to execute. Allow?`;
+    const isExpiredApproval = existingApproval ? this.isExpired(existingApproval) : false;
+    throw new ApprovalRequiredError({
+      toolId: tool?.fullName ?? "unknown",
+      state: isExpiredApproval ? "expired" : "pending",
+      message,
+      approvalOptions: {
+        allowedScopes: config.allowedScopes,
+        defaultScope: config.defaultScope,
+        maxTtlMs: config.maxTtlMs,
+        category: config.category,
+        riskLevel: config.riskLevel
       }
-    }
-    return {
-      totalApprovals: total,
-      byScope,
-      byState
-    };
-  }
-  async close() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = void 0;
-    }
-    if (this.ownedStorage && this.storage) {
-      await this.storage.root.disconnect();
-    }
-    this.initialized = false;
+    });
   }
 };
-ApprovalStorageStore = __decorateClass([
-  (0, import_sdk.Provider)({
-    name: "provider:approval:store:storage",
-    description: "Storage-backed approval store (supports Memory, Redis, Vercel KV, Upstash)",
-    scope: import_sdk.ProviderScope.GLOBAL
+__decorateClass([
+  import_sdk2.ToolHook.Will("execute", { priority: 100 })
+], ApprovalCheckPlugin.prototype, "checkApproval", 1);
+ApprovalCheckPlugin = __decorateClass([
+  (0, import_sdk2.Plugin)({
+    name: "approval:check",
+    description: "Checks tool approval state before execution"
   })
-], ApprovalStorageStore);
-function createApprovalMemoryStore(options = {}) {
-  const memoryStorage = (0, import_utils.createMemoryStorage)();
-  return new ApprovalStorageStore({
-    ...options,
-    storageInstance: memoryStorage
-  });
-}
+], ApprovalCheckPlugin);
 
 // plugins/plugin-approval/src/services/approval.service.ts
-var import_sdk2 = require("@frontmcp/sdk");
+var import_sdk3 = require("@frontmcp/sdk");
 var ApprovalService = class {
   constructor(store, sessionId, userId) {
     this.store = store;
@@ -849,10 +731,10 @@ var ApprovalService = class {
   }
 };
 ApprovalService = __decorateClass([
-  (0, import_sdk2.Provider)({
+  (0, import_sdk3.Provider)({
     name: "provider:approval:service",
     description: "Service for managing tool approvals",
-    scope: import_sdk2.ProviderScope.CONTEXT
+    scope: import_sdk3.ProviderScope.CONTEXT
   })
 ], ApprovalService);
 function createApprovalService(store, sessionId, userId) {
@@ -860,7 +742,7 @@ function createApprovalService(store, sessionId, userId) {
 }
 
 // plugins/plugin-approval/src/services/challenge.service.ts
-var import_sdk3 = require("@frontmcp/sdk");
+var import_sdk4 = require("@frontmcp/sdk");
 var import_utils2 = require("@frontmcp/utils");
 var ChallengeService = class {
   storage;
@@ -994,10 +876,10 @@ var ChallengeService = class {
   }
 };
 ChallengeService = __decorateClass([
-  (0, import_sdk3.Provider)({
+  (0, import_sdk4.Provider)({
     name: "provider:approval:challenge-service",
     description: "PKCE challenge service for webhook approval flows",
-    scope: import_sdk3.ProviderScope.GLOBAL
+    scope: import_sdk4.ProviderScope.GLOBAL
   })
 ], ChallengeService);
 function generatePkcePairFromVerifier(codeVerifier) {
@@ -1014,132 +896,272 @@ function createMemoryChallengeService(options = {}) {
   });
 }
 
-// plugins/plugin-approval/src/approval.symbols.ts
-var ApprovalStoreToken = /* @__PURE__ */ Symbol.for(
-  "plugin:approval:store"
-);
-var ApprovalServiceToken = /* @__PURE__ */ Symbol.for(
-  "plugin:approval:service"
-);
-var ChallengeServiceToken = /* @__PURE__ */ Symbol.for(
-  "plugin:approval:challenge-service"
-);
-
-// plugins/plugin-approval/src/hooks/approval-check.hook.ts
-var import_sdk4 = require("@frontmcp/sdk");
-var ApprovalCheckPlugin = class extends import_sdk4.DynamicPlugin {
-  async checkApproval(flowCtx) {
-    const { tool, toolContext } = flowCtx.state;
-    if (!tool || !toolContext) return;
-    const metadata = tool.metadata;
-    const approvalConfig = this.resolveApprovalConfig(
-      metadata["approval"]
-    );
-    if (!approvalConfig.required) {
+// plugins/plugin-approval/src/stores/approval-storage.store.ts
+var import_sdk5 = require("@frontmcp/sdk");
+var import_utils3 = require("@frontmcp/utils");
+function escapePattern(str) {
+  return str.replace(/[*?[\]\\]/g, "\\$&");
+}
+var ApprovalStorageStore = class {
+  storage;
+  options;
+  cleanupInterval;
+  initialized = false;
+  ownedStorage = false;
+  constructor(options = {}) {
+    this.options = {
+      storage: options.storage ?? { type: "auto" },
+      storageInstance: options.storageInstance,
+      namespace: options.namespace ?? "approval",
+      cleanupIntervalSeconds: options.cleanupIntervalSeconds ?? 60
+    };
+  }
+  /**
+   * Initialize the storage connection.
+   */
+  async initialize() {
+    if (this.initialized) {
       return;
     }
-    if (approvalConfig.skipApproval) {
-      return;
+    if (this.options.storageInstance) {
+      this.storage = this.options.storageInstance.namespace(this.options.namespace);
+      this.ownedStorage = false;
+    } else {
+      const rootStorage = await (0, import_utils3.createStorage)(this.options.storage);
+      this.storage = rootStorage.namespace(this.options.namespace);
+      this.ownedStorage = true;
     }
-    const ctx = toolContext.tryGetContext?.();
-    const sessionId = ctx?.sessionId ?? "unknown";
-    const userId = this.getStringExtra(ctx?.authInfo?.extra, "userId") ?? this.getStringExtra(ctx?.authInfo?.extra, "sub") ?? ctx?.authInfo?.clientId;
-    const currentContext = this.getCurrentContext(flowCtx);
-    if (this.isPreApprovedContext(approvalConfig, currentContext)) {
-      return;
+    if (this.options.cleanupIntervalSeconds > 0) {
+      this.cleanupInterval = setInterval(() => {
+        void this.clearExpiredApprovals();
+      }, this.options.cleanupIntervalSeconds * 1e3);
+      this.cleanupInterval.unref?.();
     }
-    const approvalStore = this.get(ApprovalStoreToken);
-    const approval = await approvalStore.getApproval(tool.fullName, sessionId, userId);
-    if (approvalConfig.alwaysPrompt) {
-      await this.handleApprovalRequired(flowCtx, approvalConfig, approval);
-      return;
+    this.initialized = true;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("ApprovalStorageStore not initialized. Call initialize() first.");
     }
-    if (approval?.state === "approved" /* APPROVED */) {
-      if (!this.isExpired(approval)) {
-        return;
+  }
+  buildKey(toolId, sessionId, userId, context) {
+    const parts = [toolId];
+    if (sessionId) parts.push(`session:${sessionId}`);
+    if (userId) parts.push(`user:${userId}`);
+    if (context) parts.push(`ctx:${context.type}:${context.identifier}`);
+    return parts.join(":");
+  }
+  parseRecord(value) {
+    if (!value) return void 0;
+    try {
+      const parsed = JSON.parse(value);
+      const result = approvalRecordSchema.safeParse(parsed);
+      if (!result.success) {
+        return void 0;
       }
+      return result.data;
+    } catch {
+      return void 0;
     }
-    if (approval?.state === "denied" /* DENIED */) {
-      throw new ApprovalRequiredError({
-        toolId: tool.fullName,
-        state: "denied",
-        message: `Tool "${tool.fullName}" execution denied.`
-      });
-    }
-    await this.handleApprovalRequired(flowCtx, approvalConfig, approval);
   }
-  resolveApprovalConfig(config) {
-    if (config === true) {
-      return { required: true, defaultScope: "session" /* SESSION */ };
+  isExpired(approval) {
+    return approval.expiresAt !== void 0 && Date.now() > approval.expiresAt;
+  }
+  /**
+   * The session record, else the user record, except that a denial in either scope wins,
+   * so a session approval cannot mask a user-level denial.
+   */
+  async getApproval(toolId, sessionId, userId) {
+    this.ensureInitialized();
+    const keys = [this.buildKey(toolId, sessionId)];
+    if (userId) {
+      keys.push(this.buildKey(toolId, void 0, userId));
     }
-    if (config === false || config === void 0) {
-      return { required: false };
+    const activeRecords = [];
+    for (const key of keys) {
+      const record = this.parseRecord(await this.storage.get(key));
+      if (record && !this.isExpired(record)) {
+        activeRecords.push(record);
+      }
     }
-    return {
-      ...config,
-      required: config.required ?? true,
-      defaultScope: config.defaultScope ?? "session" /* SESSION */
-    };
+    return activeRecords.find((record) => record.state === "denied" /* DENIED */) ?? activeRecords[0];
   }
-  isExpired(approval) {
-    if (!approval.expiresAt) return false;
-    return Date.now() > approval.expiresAt;
+  async queryApprovals(query) {
+    this.ensureInitialized();
+    const results = [];
+    const pattern = query.toolId ? `${query.toolId}:*` : "*";
+    const keys = await this.storage.keys(pattern);
+    const values = await this.storage.mget(keys);
+    for (const value of values) {
+      const approval = this.parseRecord(value);
+      if (!approval) continue;
+      if (!query.includeExpired && this.isExpired(approval)) {
+        continue;
+      }
+      if (query.toolId && approval.toolId !== query.toolId) continue;
+      if (query.toolIds && !query.toolIds.includes(approval.toolId)) continue;
+      if (query.scope && approval.scope !== query.scope) continue;
+      if (query.scopes && !query.scopes.includes(approval.scope)) continue;
+      if (query.state && approval.state !== query.state) continue;
+      if (query.states && !query.states.includes(approval.state)) continue;
+      if (query.sessionId && approval.sessionId !== query.sessionId) continue;
+      if (query.userId && approval.userId !== query.userId) continue;
+      if (query.context) {
+        if (!approval.context || approval.context.type !== query.context.type || approval.context.identifier !== query.context.identifier) {
+          continue;
+        }
+      }
+      results.push(approval);
+    }
+    return results;
   }
-  getCurrentContext(flowCtx) {
-    const { toolContext } = flowCtx.state;
-    const ctx = toolContext?.tryGetContext?.();
-    const inputContext = toolContext?.input?.["context"];
-    const contextFromInput = this.isApprovalContext(inputContext) ? inputContext : void 0;
-    const sessionContext = ctx?.authInfo?.extra?.["approvalContext"];
-    const contextFromSession = this.isApprovalContext(sessionContext) ? sessionContext : void 0;
-    return contextFromInput ?? contextFromSession;
+  async grantApproval(options) {
+    this.ensureInitialized();
+    const now = Date.now();
+    const expiresAt = options.ttlMs ? now + options.ttlMs : void 0;
+    const grantedBy = normalizeGrantor(options.grantedBy);
+    const record = {
+      toolId: options.toolId,
+      state: "approved" /* APPROVED */,
+      scope: options.scope,
+      grantedAt: now,
+      expiresAt,
+      ttlMs: options.ttlMs,
+      sessionId: options.sessionId,
+      userId: options.userId,
+      context: options.context,
+      grantedBy,
+      reason: options.reason,
+      metadata: options.metadata
+    };
+    const key = this.buildKey(options.toolId, options.sessionId, options.userId, options.context);
+    const ttlSeconds = options.ttlMs ? Math.ceil(options.ttlMs / 1e3) : void 0;
+    await this.storage.set(key, JSON.stringify(record), { ttlSeconds });
+    return record;
   }
-  isApprovalContext(value) {
-    return typeof value === "object" && value !== null && "type" in value && "identifier" in value && typeof value.type === "string" && typeof value.identifier === "string";
+  async revokeApproval(options) {
+    this.ensureInitialized();
+    const key = this.buildKey(options.toolId, options.sessionId, options.userId, options.context);
+    const exists = await this.storage.exists(key);
+    if (exists) {
+      await this.storage.delete(key);
+      return true;
+    }
+    return false;
   }
-  getStringExtra(extra, key) {
-    if (!extra) return void 0;
-    const value = extra[key];
-    return typeof value === "string" ? value : void 0;
+  async isApproved(toolId, sessionId, userId, context) {
+    this.ensureInitialized();
+    if (context) {
+      const contextKey = this.buildKey(toolId, sessionId, userId, context);
+      const contextValue = await this.storage.get(contextKey);
+      const contextApproval = this.parseRecord(contextValue);
+      if (contextApproval && contextApproval.state === "approved" /* APPROVED */ && !this.isExpired(contextApproval)) {
+        return true;
+      }
+    }
+    const sessionKey = this.buildKey(toolId, sessionId);
+    const sessionValue = await this.storage.get(sessionKey);
+    const sessionApproval = this.parseRecord(sessionValue);
+    if (sessionApproval && sessionApproval.state === "approved" /* APPROVED */ && !this.isExpired(sessionApproval)) {
+      return true;
+    }
+    if (userId) {
+      const userKey = this.buildKey(toolId, void 0, userId);
+      const userValue = await this.storage.get(userKey);
+      const userApproval = this.parseRecord(userValue);
+      if (userApproval && userApproval.state === "approved" /* APPROVED */ && !this.isExpired(userApproval)) {
+        return true;
+      }
+    }
+    return false;
   }
-  isPreApprovedContext(config, currentContext) {
-    if (!currentContext || !config.preApprovedContexts?.length) {
-      return false;
+  async clearSessionApprovals(sessionId) {
+    this.ensureInitialized();
+    const escapedSessionId = escapePattern(sessionId);
+    const pattern = `*:session:${escapedSessionId}*`;
+    const keys = await this.storage.keys(pattern);
+    if (keys.length === 0) {
+      return 0;
     }
-    return config.preApprovedContexts.some(
-      (preApproved) => preApproved.type === currentContext.type && preApproved.identifier === currentContext.identifier
-    );
+    return await this.storage.mdelete(keys);
   }
-  async handleApprovalRequired(flowCtx, config, existingApproval) {
-    const { tool } = flowCtx.state;
-    const message = config.approvalMessage ?? `Tool "${tool?.fullName}" requires approval to execute. Allow?`;
-    const isExpiredApproval = existingApproval ? this.isExpired(existingApproval) : false;
-    throw new ApprovalRequiredError({
-      toolId: tool?.fullName ?? "unknown",
-      state: isExpiredApproval ? "expired" : "pending",
-      message,
-      approvalOptions: {
-        allowedScopes: config.allowedScopes,
-        defaultScope: config.defaultScope,
-        maxTtlMs: config.maxTtlMs,
-        category: config.category,
-        riskLevel: config.riskLevel
+  async clearExpiredApprovals() {
+    this.ensureInitialized();
+    const now = Date.now();
+    const keys = await this.storage.keys("*");
+    const values = await this.storage.mget(keys);
+    const keysToDelete = [];
+    for (let i = 0; i < keys.length; i++) {
+      const approval = this.parseRecord(values[i]);
+      if (approval && approval.expiresAt && approval.expiresAt <= now) {
+        keysToDelete.push(keys[i]);
       }
-    });
+    }
+    if (keysToDelete.length > 0) {
+      return await this.storage.mdelete(keysToDelete);
+    }
+    return 0;
+  }
+  async getStats() {
+    this.ensureInitialized();
+    const byScope = {
+      ["session" /* SESSION */]: 0,
+      ["user" /* USER */]: 0,
+      ["time_limited" /* TIME_LIMITED */]: 0,
+      ["tool_specific" /* TOOL_SPECIFIC */]: 0,
+      ["context_specific" /* CONTEXT_SPECIFIC */]: 0
+    };
+    const byState = {
+      ["pending" /* PENDING */]: 0,
+      ["approved" /* APPROVED */]: 0,
+      ["denied" /* DENIED */]: 0,
+      ["expired" /* EXPIRED */]: 0
+    };
+    const keys = await this.storage.keys("*");
+    const values = await this.storage.mget(keys);
+    let total = 0;
+    for (const value of values) {
+      const approval = this.parseRecord(value);
+      if (approval) {
+        total++;
+        byScope[approval.scope]++;
+        byState[approval.state]++;
+      }
+    }
+    return {
+      totalApprovals: total,
+      byScope,
+      byState
+    };
+  }
+  async close() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = void 0;
+    }
+    if (this.ownedStorage && this.storage) {
+      await this.storage.root.disconnect();
+    }
+    this.initialized = false;
   }
 };
-__decorateClass([
-  import_sdk4.ToolHook.Will("execute", { priority: 100 })
-], ApprovalCheckPlugin.prototype, "checkApproval", 1);
-ApprovalCheckPlugin = __decorateClass([
-  (0, import_sdk4.Plugin)({
-    name: "approval:check",
-    description: "Checks tool approval state before execution"
+ApprovalStorageStore = __decorateClass([
+  (0, import_sdk5.Provider)({
+    name: "provider:approval:store:storage",
+    description: "Storage-backed approval store (supports Memory, Redis, Vercel KV, Upstash)",
+    scope: import_sdk5.ProviderScope.GLOBAL
   })
-], ApprovalCheckPlugin);
+], ApprovalStorageStore);
+function createApprovalMemoryStore(options = {}) {
+  const memoryStorage = (0, import_utils3.createMemoryStorage)();
+  return new ApprovalStorageStore({
+    ...options,
+    storageInstance: memoryStorage
+  });
+}
 
 // plugins/plugin-approval/src/approval.plugin.ts
-var ApprovalPlugin = class extends import_sdk5.DynamicPlugin {
+var ApprovalPlugin = class extends import_sdk6.DynamicPlugin {
   options;
   constructor(options = {}) {
     super();
@@ -1148,12 +1170,6 @@ var ApprovalPlugin = class extends import_sdk5.DynamicPlugin {
       ...options
     };
   }
-  /**
-   * Get plugin metadata including nested plugins.
-   */
-  static getPluginMetadata(_options) {
-    return { plugins: [ApprovalCheckPlugin] };
-  }
 };
 __publicField(ApprovalPlugin, "defaultOptions", {
   namespace: "approval",
@@ -1206,19 +1222,20 @@ __publicField(ApprovalPlugin, "dynamicProviders", (options) => {
   providers.push({
     name: "approval:service",
     provide: ApprovalServiceToken,
-    scope: import_sdk5.ProviderScope.CONTEXT,
-    inject: () => [ApprovalStoreToken, import_sdk5.FRONTMCP_CONTEXT],
+    scope: import_sdk6.ProviderScope.CONTEXT,
+    inject: () => [ApprovalStoreToken, import_sdk6.FRONTMCP_CONTEXT],
     useFactory: (store, ctx) => {
-      const userId = ctx.authInfo?.extra?.["userId"] ?? ctx.authInfo?.extra?.["sub"] ?? ctx.authInfo?.clientId;
-      return createApprovalService(store, ctx.sessionId, userId);
+      const { sessionId, userId } = resolveApprovalIdentity(ctx);
+      return createApprovalService(store, sessionId, userId);
     }
   });
   return providers;
 });
 ApprovalPlugin = __decorateClass([
-  (0, import_sdk5.Plugin)({
+  (0, import_sdk6.Plugin)({
     name: "approval",
     description: "Tool authorization workflow with PKCE webhook security",
+    plugins: [ApprovalCheckPlugin],
     contextExtensions: [
       {
         property: "approval",