@frontmcp/plugin-remember 1.8.6 → 1.9.0

package/index.js

@@ -50,6 +50,7 @@ __export(index_exports, {
   RememberMemoryProvider: () => RememberMemoryProvider,
   RememberPlugin: () => RememberPlugin,
   RememberRedisProvider: () => RememberRedisProvider,
+  RememberScopeNotAllowedError: () => RememberScopeNotAllowedError,
   RememberStoreToken: () => RememberStoreToken,
   RememberThisTool: () => RememberThisTool,
   RememberVercelKvProvider: () => RememberVercelKvProvider,
@@ -61,7 +62,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // plugins/plugin-remember/src/remember.plugin.ts
-var import_sdk6 = require("@frontmcp/sdk");
+var import_sdk11 = require("@frontmcp/sdk");
 
 // plugins/plugin-remember/src/providers/remember-accessor.provider.ts
 var import_sdk2 = require("@frontmcp/sdk");
@@ -310,6 +311,16 @@ var RememberIdentityError = class extends import_sdk.PublicMcpError {
     super(message, "REMEMBER_IDENTITY_REQUIRED", 403);
   }
 };
+var RememberScopeNotAllowedError = class extends import_sdk.PublicMcpError {
+  name = "RememberScopeNotAllowedError";
+  constructor(scope, allowedScopes) {
+    super(
+      `Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`,
+      "REMEMBER_SCOPE_NOT_ALLOWED",
+      400
+    );
+  }
+};
 
 // plugins/plugin-remember/src/remember.legacy-purge.ts
 var LEGACY_SCOPES = ["session", "tool", "user"];
@@ -416,6 +427,9 @@ var STORAGE_LAYOUT_VERSION = "v2";
 function encodeKeyPart(value) {
   return encodeURIComponent(value);
 }
+function remainingSeconds(expiresAt, now) {
+  return Math.max(1, Math.ceil((expiresAt - now) / 1e3));
+}
 var RememberAccessor = class {
   store;
   ctx;
@@ -465,16 +479,8 @@ var RememberAccessor = class {
    */
   async get(key, options = {}) {
     const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    const raw = await this.store.getValue(storageKey);
-    if (!raw) return options.defaultValue;
-    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
-    if (!entry) return options.defaultValue;
-    if (entry.expiresAt && Date.now() > entry.expiresAt) {
-      await this.forget(key, { scope });
-      return options.defaultValue;
-    }
-    return entry.value;
+    const entry = await this.readEntry(this.buildStorageKey(key, scope), scope);
+    return entry ? entry.value : options.defaultValue;
   }
   /**
    * Get the full entry including metadata.
@@ -485,16 +491,7 @@ var RememberAccessor = class {
    */
   async getEntry(key, options = {}) {
     const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    const raw = await this.store.getValue(storageKey);
-    if (!raw) return void 0;
-    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
-    if (!entry) return void 0;
-    if (entry.expiresAt && Date.now() > entry.expiresAt) {
-      await this.forget(key, { scope });
-      return void 0;
-    }
-    return entry;
+    return this.readEntry(this.buildStorageKey(key, scope), scope);
   }
   /**
    * Forget (delete) a value from memory.
@@ -508,19 +505,18 @@ var RememberAccessor = class {
     await this.store.delete(storageKey);
   }
   /**
-   * Check if a key is remembered (exists and not expired).
+   * Check if a key is remembered: true exactly when `get()` would return its value.
    *
    * @param key - The key to check
    * @param options - Options (scope)
-   * @returns true if the key exists
+   * @returns true if the key exists and has not expired
    */
   async knows(key, options = {}) {
     const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    return this.store.exists(storageKey);
+    return await this.readEntry(this.buildStorageKey(key, scope), scope) !== void 0;
   }
   /**
-   * List all remembered keys for a scope.
+   * List all remembered keys for a scope: the keys `get()` would return a value for.
    *
    * @param options - Options (scope, pattern)
    * @returns Array of keys (without the scope prefix)
@@ -528,13 +524,16 @@ var RememberAccessor = class {
   async list(options = {}) {
     const scope = options.scope ?? "session";
     const scopePrefix = this.buildScopePrefix(scope);
-    const fullPattern = scopePrefix + (options.pattern ?? "*");
-    const keys = await this.store.keys(fullPattern);
-    return keys.map((k) => k.slice(scopePrefix.length));
+    const storageKeys = await this.store.keys(scopePrefix + (options.pattern ?? "*"));
+    const entries = await Promise.all(storageKeys.map((storageKey) => this.readEntry(storageKey, scope)));
+    return storageKeys.filter((_storageKey, index) => entries[index] !== void 0).map((storageKey) => storageKey.slice(scopePrefix.length));
   }
   /**
    * Update an existing entry's value while preserving metadata.
    *
+   * With a `ttl` the entry expires that many seconds from now; without one it keeps its current
+   * expiry, in the store as well, so the store does not keep it past that (rounded up to a second).
+   *
    * @param key - The key to update
    * @param value - The new value
    * @param options - Options (scope, ttl)
@@ -543,15 +542,18 @@ var RememberAccessor = class {
     const scope = options.scope ?? "session";
     const existing = await this.getEntry(key, { scope });
     if (!existing) return false;
+    const now = Date.now();
+    const expiresAt = options.ttl ? now + options.ttl * 1e3 : existing.expiresAt;
     const entry = {
       ...existing,
       value,
-      updatedAt: Date.now(),
-      expiresAt: options.ttl ? Date.now() + options.ttl * 1e3 : existing.expiresAt
+      updatedAt: now,
+      expiresAt
     };
     const storageKey = this.buildStorageKey(key, scope);
     const serialized = this.encryptionEnabled ? await encryptAndSerialize(entry, this.getKeySource(scope)) : JSON.stringify(entry);
-    await this.store.setValue(storageKey, serialized, options.ttl);
+    const storageTtl = options.ttl ?? (expiresAt !== void 0 ? remainingSeconds(expiresAt, now) : void 0);
+    await this.store.setValue(storageKey, serialized, storageTtl);
     return true;
   }
   // ─────────────────────────────────────────────────────────────────────────────
@@ -669,6 +671,18 @@ var RememberAccessor = class {
       toolName: scope === "tool" ? this.toolName : void 0
     });
   }
+  /** The entry stored under `storageKey`, if readable and unexpired; an expired one is deleted. */
+  async readEntry(storageKey, scope) {
+    const raw = await this.store.getValue(storageKey);
+    if (!raw) return void 0;
+    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
+    if (!entry) return void 0;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      await this.store.delete(storageKey);
+      return void 0;
+    }
+    return entry;
+  }
   /**
    * Parse a JSON entry (when encryption is disabled).
    */
@@ -1150,8 +1164,267 @@ var RememberAccessorToken = /* @__PURE__ */ Symbol(
   "plugin:remember:accessor"
 );
 
+// plugins/plugin-remember/src/tools/remember-tools.factory.ts
+var import_sdk10 = require("@frontmcp/sdk");
+
+// plugins/plugin-remember/src/tools/forget.tool.ts
+var import_lazy_zod2 = require("@frontmcp/lazy-zod");
+var import_sdk6 = require("@frontmcp/sdk");
+
+// plugins/plugin-remember/src/tools/remember-scope.description.ts
+var REMEMBER_SCOPE_DESCRIPTION = "Whose memory to use (default: session). session: this session; without one (stateless HTTP, MCP 2026-07-28), the signed-in caller across its requests. user: the signed-in caller, across all of its sessions. tool: the tool running the call, for the same caller as session; each memory tool has its own, so the other memory tools do not see what one of them stores in tool scope. global: shared by every caller. An anonymous caller cannot use user scope, nor session or tool scope without a session.";
+
+// plugins/plugin-remember/src/tools/remember-tool-names.ts
+function rememberToolNames(prefix = "") {
+  return {
+    rememberThis: `${prefix}remember_this`,
+    recall: `${prefix}recall`,
+    forget: `${prefix}forget`,
+    listMemories: `${prefix}list_memories`
+  };
+}
+
+// plugins/plugin-remember/src/tools/forget.tool.ts
+var forgetInputSchema = {
+  key: import_lazy_zod2.z.string().min(1).describe("What memory to forget"),
+  scope: import_lazy_zod2.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
+};
+var forgetOutputSchema = import_lazy_zod2.z.object({
+  success: import_lazy_zod2.z.boolean(),
+  key: import_lazy_zod2.z.string(),
+  scope: import_lazy_zod2.z.string(),
+  existed: import_lazy_zod2.z.boolean()
+});
+function forgetDescription() {
+  return "Forget a previously remembered value. Use this when the user wants to delete stored preferences or information.";
+}
+function forgetToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.forget,
+    description: forgetDescription(),
+    inputSchema: forgetInputSchema,
+    outputSchema: forgetOutputSchema,
+    annotations: { readOnlyHint: false }
+  };
+}
+var ForgetTool = class extends import_sdk6.ToolContext {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    const existed = await remember.knows(input.key, { scope });
+    await remember.forget(input.key, { scope });
+    return {
+      success: true,
+      key: input.key,
+      scope,
+      existed
+    };
+  }
+};
+ForgetTool = __decorateClass([
+  (0, import_sdk6.Tool)(forgetToolMetadata())
+], ForgetTool);
+
+// plugins/plugin-remember/src/tools/list-memories.tool.ts
+var import_lazy_zod3 = require("@frontmcp/lazy-zod");
+var import_sdk7 = require("@frontmcp/sdk");
+var listMemoriesInputSchema = {
+  scope: import_lazy_zod3.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
+  pattern: import_lazy_zod3.z.string().optional().describe('Pattern to filter keys (e.g., "user_*")'),
+  limit: import_lazy_zod3.z.number().positive().max(100).optional().describe("Maximum number of keys to return (default: 50)")
+};
+var listMemoriesOutputSchema = import_lazy_zod3.z.object({
+  keys: import_lazy_zod3.z.array(import_lazy_zod3.z.string()),
+  scope: import_lazy_zod3.z.string(),
+  count: import_lazy_zod3.z.number(),
+  truncated: import_lazy_zod3.z.boolean()
+});
+function listMemoriesDescription(names = rememberToolNames()) {
+  return `List the remembered keys in one scope (default: session). Use this to see what memories are stored before you ${names.recall} or ${names.forget} one.`;
+}
+function listMemoriesToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.listMemories,
+    description: listMemoriesDescription(names),
+    inputSchema: listMemoriesInputSchema,
+    outputSchema: listMemoriesOutputSchema,
+    annotations: { readOnlyHint: true }
+  };
+}
+var ListMemoriesTool = class extends import_sdk7.ToolContext {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    const limit = input.limit ?? 50;
+    let keys = await remember.list({ scope, pattern: input.pattern });
+    const truncated = keys.length > limit;
+    if (truncated) {
+      keys = keys.slice(0, limit);
+    }
+    return {
+      keys,
+      scope,
+      count: keys.length,
+      truncated
+    };
+  }
+};
+ListMemoriesTool = __decorateClass([
+  (0, import_sdk7.Tool)(listMemoriesToolMetadata())
+], ListMemoriesTool);
+
+// plugins/plugin-remember/src/tools/recall.tool.ts
+var import_lazy_zod4 = require("@frontmcp/lazy-zod");
+var import_sdk8 = require("@frontmcp/sdk");
+var recallInputSchema = {
+  key: import_lazy_zod4.z.string().min(1).describe("What memory to recall"),
+  scope: import_lazy_zod4.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
+};
+var recallOutputSchema = import_lazy_zod4.z.object({
+  found: import_lazy_zod4.z.boolean(),
+  key: import_lazy_zod4.z.string(),
+  value: import_lazy_zod4.z.unknown().optional(),
+  scope: import_lazy_zod4.z.string(),
+  createdAt: import_lazy_zod4.z.number().optional(),
+  expiresAt: import_lazy_zod4.z.number().optional()
+});
+function recallDescription(names = rememberToolNames()) {
+  return `Recall something that was previously remembered. Use this to retrieve stored preferences, settings, or any information that was saved with ${names.rememberThis}.`;
+}
+function recallToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.recall,
+    description: recallDescription(names),
+    inputSchema: recallInputSchema,
+    outputSchema: recallOutputSchema,
+    annotations: { readOnlyHint: true }
+  };
+}
+var RecallTool = class extends import_sdk8.ToolContext {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    const entry = await remember.getEntry(input.key, { scope });
+    if (!entry) {
+      return {
+        found: false,
+        key: input.key,
+        scope
+      };
+    }
+    return {
+      found: true,
+      key: input.key,
+      value: entry.value,
+      scope,
+      createdAt: entry.createdAt,
+      expiresAt: entry.expiresAt
+    };
+  }
+};
+RecallTool = __decorateClass([
+  (0, import_sdk8.Tool)(recallToolMetadata())
+], RecallTool);
+
+// plugins/plugin-remember/src/tools/remember-this.tool.ts
+var import_lazy_zod5 = require("@frontmcp/lazy-zod");
+var import_sdk9 = require("@frontmcp/sdk");
+var rememberThisInputSchema = {
+  key: import_lazy_zod5.z.string().min(1).describe('What to call this memory (e.g., "user_preference", "last_action")'),
+  value: import_lazy_zod5.z.unknown().describe("The value to remember (any JSON-serializable data)"),
+  scope: import_lazy_zod5.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
+  ttl: import_lazy_zod5.z.number().positive().optional().describe("Forget after this many seconds"),
+  brand: import_lazy_zod5.z.enum(["preference", "cache", "state", "conversation", "custom"]).optional().describe("Type hint for the stored value")
+};
+var rememberThisOutputSchema = import_lazy_zod5.z.object({
+  success: import_lazy_zod5.z.boolean(),
+  key: import_lazy_zod5.z.string(),
+  scope: import_lazy_zod5.z.string(),
+  expiresAt: import_lazy_zod5.z.number().optional()
+});
+function rememberThisDescription(names = rememberToolNames()) {
+  return `Remember something for later: store a value under a key that ${names.recall} can read back, in the scope you choose (this session by default; user scope for the signed-in user across sessions). It lasts until it is forgotten or its ttl runs out. Use this when the user asks you to remember preferences, settings, or any information they want to persist.`;
+}
+function rememberThisToolMetadata(names = rememberToolNames()) {
+  return {
+    name: names.rememberThis,
+    description: rememberThisDescription(names),
+    inputSchema: rememberThisInputSchema,
+    outputSchema: rememberThisOutputSchema,
+    annotations: { readOnlyHint: false }
+  };
+}
+var RememberThisTool = class extends import_sdk9.ToolContext {
+  async execute(input) {
+    const remember = this.get(RememberAccessorToken);
+    const config = this.get(RememberConfigToken);
+    const scope = input.scope ?? "session";
+    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
+    if (!allowedScopes.includes(scope)) {
+      throw this.fail(new RememberScopeNotAllowedError(scope, allowedScopes));
+    }
+    await remember.set(input.key, input.value, {
+      scope,
+      ttl: input.ttl,
+      brand: input.brand
+    });
+    const expiresAt = input.ttl ? Date.now() + input.ttl * 1e3 : void 0;
+    return {
+      success: true,
+      key: input.key,
+      scope,
+      expiresAt
+    };
+  }
+};
+RememberThisTool = __decorateClass([
+  (0, import_sdk9.Tool)(rememberThisToolMetadata())
+], RememberThisTool);
+
+// plugins/plugin-remember/src/tools/remember-tools.factory.ts
+function createRememberTools(prefix = "") {
+  if (!prefix) return [RememberThisTool, RecallTool, ForgetTool, ListMemoriesTool];
+  const names = rememberToolNames(prefix);
+  let PrefixedRememberThisTool = class extends RememberThisTool {
+  };
+  PrefixedRememberThisTool = __decorateClass([
+    (0, import_sdk10.Tool)(rememberThisToolMetadata(names))
+  ], PrefixedRememberThisTool);
+  let PrefixedRecallTool = class extends RecallTool {
+  };
+  PrefixedRecallTool = __decorateClass([
+    (0, import_sdk10.Tool)(recallToolMetadata(names))
+  ], PrefixedRecallTool);
+  let PrefixedForgetTool = class extends ForgetTool {
+  };
+  PrefixedForgetTool = __decorateClass([
+    (0, import_sdk10.Tool)(forgetToolMetadata(names))
+  ], PrefixedForgetTool);
+  let PrefixedListMemoriesTool = class extends ListMemoriesTool {
+  };
+  PrefixedListMemoriesTool = __decorateClass([
+    (0, import_sdk10.Tool)(listMemoriesToolMetadata(names))
+  ], PrefixedListMemoriesTool);
+  return [PrefixedRememberThisTool, PrefixedRecallTool, PrefixedForgetTool, PrefixedListMemoriesTool];
+}
+
 // plugins/plugin-remember/src/remember.plugin.ts
-var RememberPlugin = class extends import_sdk6.DynamicPlugin {
+var RememberPlugin = class extends import_sdk11.DynamicPlugin {
   options;
   constructor(options = {}) {
     super();
@@ -1166,6 +1439,11 @@ __publicField(RememberPlugin, "defaultOptions", {
   keyPrefix: "remember:",
   encryption: { enabled: true }
 });
+/**
+ * The memory tools, when `tools.enabled` is set: `remember_this`, `recall`, `forget` and
+ * `list_memories`, under `tools.prefix`.
+ */
+__publicField(RememberPlugin, "dynamicTools", (options) => options.tools?.enabled ? createRememberTools(options.tools.prefix) : []);
 /**
  * Dynamic providers based on plugin options.
  */
@@ -1180,10 +1458,10 @@ __publicField(RememberPlugin, "dynamicProviders", (options) => {
       providers.push({
         name: "remember:store:global",
         provide: RememberStoreToken,
-        inject: () => [import_sdk6.FrontMcpConfig],
+        inject: () => [import_sdk11.FrontMcpConfig],
         useFactory: (frontmcpConfig) => {
-          const storeConfig = (0, import_sdk6.getGlobalStoreConfig)("RememberPlugin", frontmcpConfig);
-          if ((0, import_sdk6.isVercelKvProvider)(storeConfig)) {
+          const storeConfig = (0, import_sdk11.getGlobalStoreConfig)("RememberPlugin", frontmcpConfig);
+          if ((0, import_sdk11.isVercelKvProvider)(storeConfig)) {
             return new RememberVercelKvProvider({
               url: storeConfig.url,
               token: storeConfig.token,
@@ -1264,14 +1542,14 @@ __publicField(RememberPlugin, "dynamicProviders", (options) => {
   providers.push({
     name: "remember:accessor",
     provide: RememberAccessorToken,
-    scope: import_sdk6.ProviderScope.CONTEXT,
-    inject: () => [RememberStoreToken, import_sdk6.FRONTMCP_CONTEXT, RememberConfigToken, import_sdk6.FrontMcpLogger],
+    scope: import_sdk11.ProviderScope.CONTEXT,
+    inject: () => [RememberStoreToken, import_sdk11.FRONTMCP_CONTEXT, RememberConfigToken, import_sdk11.FrontMcpLogger],
     useFactory: (store, ctx, cfg, logger) => createRememberAccessor(store, ctx, cfg, logger)
   });
   return providers;
 });
 RememberPlugin = __decorateClass([
-  (0, import_sdk6.Plugin)({
+  (0, import_sdk11.Plugin)({
     name: "remember",
     description: "Help your LLM remember things across sessions",
     providers: [
@@ -1297,223 +1575,20 @@ RememberPlugin = __decorateClass([
 ], RememberPlugin);
 
 // plugins/plugin-remember/src/remember.types.ts
-var import_lazy_zod2 = require("@frontmcp/lazy-zod");
-var rememberScopeSchema = import_lazy_zod2.z.enum(["session", "user", "tool", "global"]);
+var import_lazy_zod6 = require("@frontmcp/lazy-zod");
+var rememberScopeSchema = import_lazy_zod6.z.enum(["session", "user", "tool", "global"]);
 function brand(data, _brand) {
   return data;
 }
-var rememberEntrySchema = import_lazy_zod2.z.object({
-  value: import_lazy_zod2.z.unknown(),
-  brand: import_lazy_zod2.z.enum(["approval", "preference", "cache", "state", "conversation", "custom"]).optional(),
-  createdAt: import_lazy_zod2.z.number(),
-  updatedAt: import_lazy_zod2.z.number(),
-  expiresAt: import_lazy_zod2.z.number().optional(),
-  metadata: import_lazy_zod2.z.record(import_lazy_zod2.z.string(), import_lazy_zod2.z.unknown()).optional()
+var rememberEntrySchema = import_lazy_zod6.z.object({
+  value: import_lazy_zod6.z.unknown(),
+  brand: import_lazy_zod6.z.enum(["approval", "preference", "cache", "state", "conversation", "custom"]).optional(),
+  createdAt: import_lazy_zod6.z.number(),
+  updatedAt: import_lazy_zod6.z.number(),
+  expiresAt: import_lazy_zod6.z.number().optional(),
+  metadata: import_lazy_zod6.z.record(import_lazy_zod6.z.string(), import_lazy_zod6.z.unknown()).optional()
 });
 
-// plugins/plugin-remember/src/tools/remember-this.tool.ts
-var import_lazy_zod3 = require("@frontmcp/lazy-zod");
-var import_sdk7 = require("@frontmcp/sdk");
-
-// plugins/plugin-remember/src/tools/remember-scope.description.ts
-var REMEMBER_SCOPE_DESCRIPTION = "Whose memory to use (default: session). session: this session; without one (stateless HTTP, MCP 2026-07-28), the signed-in caller across its requests. user: the signed-in caller, across all of its sessions. tool: the tool running the call, for the same caller as session; each memory tool has its own, so the other memory tools do not see what one of them stores in tool scope. global: shared by every caller. An anonymous caller cannot use user scope, nor session or tool scope without a session.";
-
-// plugins/plugin-remember/src/tools/remember-this.tool.ts
-var rememberThisInputSchema = {
-  key: import_lazy_zod3.z.string().min(1).describe('What to call this memory (e.g., "user_preference", "last_action")'),
-  value: import_lazy_zod3.z.unknown().describe("The value to remember (any JSON-serializable data)"),
-  scope: import_lazy_zod3.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
-  ttl: import_lazy_zod3.z.number().positive().optional().describe("Forget after this many seconds"),
-  brand: import_lazy_zod3.z.enum(["preference", "cache", "state", "conversation", "custom"]).optional().describe("Type hint for the stored value")
-};
-var rememberThisOutputSchema = import_lazy_zod3.z.object({
-  success: import_lazy_zod3.z.boolean(),
-  key: import_lazy_zod3.z.string(),
-  scope: import_lazy_zod3.z.string(),
-  expiresAt: import_lazy_zod3.z.number().optional()
-});
-var RememberThisTool = class extends import_sdk7.ToolContext {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      throw this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    await remember.set(input.key, input.value, {
-      scope,
-      ttl: input.ttl,
-      brand: input.brand
-    });
-    const expiresAt = input.ttl ? Date.now() + input.ttl * 1e3 : void 0;
-    return {
-      success: true,
-      key: input.key,
-      scope,
-      expiresAt
-    };
-  }
-};
-RememberThisTool = __decorateClass([
-  (0, import_sdk7.Tool)({
-    name: "remember_this",
-    description: "Remember something for later: store a value under a key that recall can read back, in the scope you choose (this session by default; user scope for the signed-in user across sessions). It lasts until it is forgotten or its ttl runs out. Use this when the user asks you to remember preferences, settings, or any information they want to persist.",
-    inputSchema: rememberThisInputSchema,
-    outputSchema: rememberThisOutputSchema,
-    annotations: {
-      readOnlyHint: false
-    }
-  })
-], RememberThisTool);
-
-// plugins/plugin-remember/src/tools/recall.tool.ts
-var import_lazy_zod4 = require("@frontmcp/lazy-zod");
-var import_sdk8 = require("@frontmcp/sdk");
-var recallInputSchema = {
-  key: import_lazy_zod4.z.string().min(1).describe("What memory to recall"),
-  scope: import_lazy_zod4.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
-};
-var recallOutputSchema = import_lazy_zod4.z.object({
-  found: import_lazy_zod4.z.boolean(),
-  key: import_lazy_zod4.z.string(),
-  value: import_lazy_zod4.z.unknown().optional(),
-  scope: import_lazy_zod4.z.string(),
-  createdAt: import_lazy_zod4.z.number().optional(),
-  expiresAt: import_lazy_zod4.z.number().optional()
-});
-var RecallTool = class extends import_sdk8.ToolContext {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    const entry = await remember.getEntry(input.key, { scope });
-    if (!entry) {
-      return {
-        found: false,
-        key: input.key,
-        scope
-      };
-    }
-    return {
-      found: true,
-      key: input.key,
-      value: entry.value,
-      scope,
-      createdAt: entry.createdAt,
-      expiresAt: entry.expiresAt
-    };
-  }
-};
-RecallTool = __decorateClass([
-  (0, import_sdk8.Tool)({
-    name: "recall",
-    description: "Recall something that was previously remembered. Use this to retrieve stored preferences, settings, or any information that was saved with remember_this.",
-    inputSchema: recallInputSchema,
-    outputSchema: recallOutputSchema,
-    annotations: {
-      readOnlyHint: true
-    }
-  })
-], RecallTool);
-
-// plugins/plugin-remember/src/tools/forget.tool.ts
-var import_lazy_zod5 = require("@frontmcp/lazy-zod");
-var import_sdk9 = require("@frontmcp/sdk");
-var forgetInputSchema = {
-  key: import_lazy_zod5.z.string().min(1).describe("What memory to forget"),
-  scope: import_lazy_zod5.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION)
-};
-var forgetOutputSchema = import_lazy_zod5.z.object({
-  success: import_lazy_zod5.z.boolean(),
-  key: import_lazy_zod5.z.string(),
-  scope: import_lazy_zod5.z.string(),
-  existed: import_lazy_zod5.z.boolean()
-});
-var ForgetTool = class extends import_sdk9.ToolContext {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      throw this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    const existed = await remember.knows(input.key, { scope });
-    await remember.forget(input.key, { scope });
-    return {
-      success: true,
-      key: input.key,
-      scope,
-      existed
-    };
-  }
-};
-ForgetTool = __decorateClass([
-  (0, import_sdk9.Tool)({
-    name: "forget",
-    description: "Forget a previously remembered value. Use this when the user wants to delete stored preferences or information.",
-    inputSchema: forgetInputSchema,
-    outputSchema: forgetOutputSchema,
-    annotations: {
-      readOnlyHint: false
-    }
-  })
-], ForgetTool);
-
-// plugins/plugin-remember/src/tools/list-memories.tool.ts
-var import_lazy_zod6 = require("@frontmcp/lazy-zod");
-var import_sdk10 = require("@frontmcp/sdk");
-var listMemoriesInputSchema = {
-  scope: import_lazy_zod6.z.enum(["session", "user", "tool", "global"]).optional().describe(REMEMBER_SCOPE_DESCRIPTION),
-  pattern: import_lazy_zod6.z.string().optional().describe('Pattern to filter keys (e.g., "user_*")'),
-  limit: import_lazy_zod6.z.number().positive().max(100).optional().describe("Maximum number of keys to return (default: 50)")
-};
-var listMemoriesOutputSchema = import_lazy_zod6.z.object({
-  keys: import_lazy_zod6.z.array(import_lazy_zod6.z.string()),
-  scope: import_lazy_zod6.z.string(),
-  count: import_lazy_zod6.z.number(),
-  truncated: import_lazy_zod6.z.boolean()
-});
-var ListMemoriesTool = class extends import_sdk10.ToolContext {
-  async execute(input) {
-    const remember = this.get(RememberAccessorToken);
-    const config = this.get(RememberConfigToken);
-    const scope = input.scope ?? "session";
-    const allowedScopes = config.tools?.allowedScopes ?? ["session", "user", "tool", "global"];
-    if (!allowedScopes.includes(scope)) {
-      throw this.fail(new Error(`Scope '${scope}' is not allowed. Allowed scopes: ${allowedScopes.join(", ")}`));
-    }
-    const limit = input.limit ?? 50;
-    let keys = await remember.list({ scope, pattern: input.pattern });
-    const truncated = keys.length > limit;
-    if (truncated) {
-      keys = keys.slice(0, limit);
-    }
-    return {
-      keys,
-      scope,
-      count: keys.length,
-      truncated
-    };
-  }
-};
-ListMemoriesTool = __decorateClass([
-  (0, import_sdk10.Tool)({
-    name: "list_memories",
-    description: "List the remembered keys in one scope (default: session). Use this to see what memories are stored before you recall or forget one.",
-    inputSchema: listMemoriesInputSchema,
-    outputSchema: listMemoriesOutputSchema,
-    annotations: {
-      readOnlyHint: true
-    }
-  })
-], ListMemoriesTool);
-
 // plugins/plugin-remember/src/remember.context-extension.ts
 function getRemember(ctx) {
   return ctx.get(RememberAccessorToken);
@@ -1536,6 +1611,7 @@ function tryGetRemember(ctx) {
   RememberMemoryProvider,
   RememberPlugin,
   RememberRedisProvider,
+  RememberScopeNotAllowedError,
   RememberStoreToken,
   RememberThisTool,
   RememberVercelKvProvider,