@frontmcp/plugin-cache 0.0.1 → 0.7.1

package/cache.plugin.d.ts

@@ -0,0 +1,29 @@
+import { DynamicPlugin, FlowCtxOf, ProviderType } from '@frontmcp/sdk';
+import { CachePluginOptions } from './cache.types';
+export default class CachePlugin extends DynamicPlugin<CachePluginOptions> {
+    static dynamicProviders: (options: CachePluginOptions) => ProviderType[];
+    static defaultOptions: CachePluginOptions;
+    options: CachePluginOptions;
+    constructor(options?: CachePluginOptions);
+    /**
+     * Check if a tool should be cached based on metadata or tools list.
+     */
+    private shouldCacheTool;
+    /**
+     * Check if cache should be bypassed based on request headers.
+     * Accesses headers from FrontMcpContextStorage which extracts x-frontmcp-* custom headers.
+     */
+    private shouldBypassCache;
+    /**
+     * Get TTL for a tool, with metadata taking precedence over defaults.
+     */
+    private getTtl;
+    willReadCache(flowCtx: FlowCtxOf<'tools:call-tool'>): Promise<void>;
+    willWriteCache(flowCtx: FlowCtxOf<'tools:call-tool'>): Promise<void>;
+    /**
+     * Check if a tool is cacheable based on metadata or tools list.
+     * This can be used by other plugins or flows to determine cacheability.
+     */
+    isCacheable(toolName: string): boolean;
+}
+//# sourceMappingURL=cache.plugin.d.ts.map

package/cache.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.plugin.d.ts","sourceRoot":"","sources":["../src/cache.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,SAAS,EAET,YAAY,EAOb,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,kBAAkB,EAAiC,MAAM,eAAe,CAAC;AAyClF,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,aAAa,CAAC,kBAAkB,CAAC;IACxE,OAAgB,gBAAgB,GAAI,SAAS,kBAAkB,oBAqD7D;IAEF,MAAM,CAAC,cAAc,EAAE,kBAAkB,CAEvC;IACF,OAAO,EAAE,kBAAkB,CAAC;gBAEhB,OAAO,GAAE,kBAA+C;IAQpE;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,MAAM;IAQR,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC,iBAAiB,CAAC;IA0EnD,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,iBAAiB,CAAC;IAyB1D;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGvC"}

package/cache.symbol.d.ts

@@ -0,0 +1,4 @@
+import { CacheStoreInterface } from './cache.types';
+import { Token } from '@frontmcp/sdk';
+export declare const CacheStoreToken: Token<CacheStoreInterface>;
+//# sourceMappingURL=cache.symbol.d.ts.map

package/cache.symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.symbol.d.ts","sourceRoot":"","sources":["../src/cache.symbol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,mBAAmB,CAAgC,CAAC"}

package/cache.types.d.ts

@@ -0,0 +1,104 @@
+import { Redis as RedisClient } from 'ioredis';
+declare global {
+    interface ExtendFrontMcpToolMetadata {
+        cache?: CachePluginToolOptions | true;
+    }
+}
+export interface CachePluginToolOptions {
+    /**
+     * Time to live in seconds. Default is 1 day.
+     */
+    ttl?: number;
+    /**
+     * If true, the cache value will be updated with the new value after the TTL.
+     * Default is false.
+     */
+    slideWindow?: boolean;
+}
+export interface BaseCachePluginOptions {
+    /**
+     * Default time to live in seconds. Default is 1 day (86400 seconds).
+     */
+    defaultTTL?: number;
+    /**
+     * Tool names or glob patterns to cache.
+     * Supports exact names ('tool-name') and wildcards ('namespace:*').
+     * Tools matching these patterns use defaultTTL unless they have custom cache metadata.
+     *
+     * @example
+     * ```typescript
+     * toolPatterns: ['mintlify:*', 'local:ping', 'api:get-*']
+     * ```
+     */
+    toolPatterns?: string[];
+    /**
+     * HTTP header name that clients can send to bypass cache for a specific request.
+     * When this header is present with a truthy value ('true' or '1'), cache read/write is skipped.
+     *
+     * Note: Headers must use the `x-frontmcp-*` prefix to be captured by the context storage.
+     * Custom bypass headers should also follow this convention.
+     *
+     * @default 'x-frontmcp-disable-cache'
+     *
+     * @example
+     * ```typescript
+     * // Plugin config with custom bypass header
+     * CachePlugin.init({ type: 'memory', bypassHeader: 'x-frontmcp-no-cache' })
+     *
+     * // Client request with header
+     * fetch('/mcp', { headers: { 'x-frontmcp-disable-cache': 'true' } })
+     * // or
+     * fetch('/mcp', { headers: { 'x-frontmcp-disable-cache': '1' } })
+     * ```
+     */
+    bypassHeader?: string;
+}
+export interface RedisClientCachePluginOptions extends BaseCachePluginOptions {
+    type: 'redis-client';
+    client: RedisClient;
+}
+export interface RedisCachePluginOptions extends BaseCachePluginOptions {
+    type: 'redis';
+    config: {
+        host: string;
+        port: number;
+        password?: string;
+        db?: number;
+    };
+}
+export type MemoryCachePluginOptions = BaseCachePluginOptions & {
+    type: 'memory';
+};
+/**
+ * Use global store configuration from @FrontMcp decorator.
+ * Requires `redis` to be configured in the main FrontMcp options.
+ * Supports both Redis and Vercel KV global configurations.
+ *
+ * @example
+ * ```typescript
+ * // In main.ts - configure global store
+ * @FrontMcp({
+ *   redis: { host: 'localhost', port: 6379 },
+ *   apps: [MyApp]
+ * })
+ *
+ * // In app - use global store
+ * @App({
+ *   plugins: [CachePlugin.init({ type: 'global-store' })]
+ * })
+ * class MyApp {}
+ * ```
+ */
+export interface GlobalStoreCachePluginOptions extends BaseCachePluginOptions {
+    type: 'global-store';
+}
+export type RedisCacheOptions = RedisClientCachePluginOptions | RedisCachePluginOptions;
+export type CachePluginOptions = MemoryCachePluginOptions | RedisCacheOptions | GlobalStoreCachePluginOptions;
+export interface CacheStoreInterface {
+    setValue(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
+    getValue<T = unknown>(key: string, defaultValue?: T): Promise<T | undefined>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=cache.types.d.ts.map

package/cache.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.types.d.ts","sourceRoot":"","sources":["../src/cache.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,WAAW,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,0BAA0B;QAClC,KAAK,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;KACvC;CACF;AAED,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,6BAA8B,SAAQ,sBAAsB;IAC3E,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,uBAAwB,SAAQ,sBAAsB;IACrE,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAED,MAAM,MAAM,wBAAwB,GAAG,sBAAsB,GAAG;IAC9D,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,6BAA8B,SAAQ,sBAAsB;IAC3E,IAAI,EAAE,cAAc,CAAC;CACtB;AAED,MAAM,MAAM,iBAAiB,GAAG,6BAA6B,GAAG,uBAAuB,CAAC;AAExF,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,GAAG,iBAAiB,GAAG,6BAA6B,CAAC;AAE9G,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1E,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAE7E,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/esm/index.mjs

@@ -0,0 +1,474 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// plugins/plugin-cache/src/cache.plugin.ts
+import {
+  DynamicPlugin,
+  Plugin,
+  ToolHook,
+  FrontMcpConfig,
+  getGlobalStoreConfig,
+  isVercelKvProvider,
+  FrontMcpContextStorage
+} from "@frontmcp/sdk";
+
+// plugins/plugin-cache/src/providers/cache-redis.provider.ts
+import Redis from "ioredis";
+import { Provider, ProviderScope } from "@frontmcp/sdk";
+var CacheRedisProvider = class {
+  client;
+  constructor(options) {
+    if (options.type !== "redis" && options.type !== "redis-client") {
+      throw new Error("Invalid cache provider type");
+    }
+    if (options.type === "redis-client") {
+      this.client = options.client;
+      return;
+    }
+    this.client = new Redis({
+      lazyConnect: false,
+      maxRetriesPerRequest: 3,
+      ...options.config
+    });
+    this.client.on("connect", () => console.log("[Redis] Connected"));
+    this.client.on("error", (err) => console.error("[Redis] Error:", err));
+  }
+  /** Set a value (auto-stringifies objects) */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSeconds && ttlSeconds > 0) {
+      await this.client.set(key, strValue, "EX", ttlSeconds);
+    } else {
+      await this.client.set(key, strValue);
+    }
+  }
+  /** Get a value and automatically parse JSON if possible */
+  async getValue(key, defaultValue) {
+    const raw = await this.client.get(key);
+    if (raw === null) return defaultValue;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  /** Delete a key */
+  async delete(key) {
+    await this.client.del(key);
+  }
+  /** Check if a key exists */
+  async exists(key) {
+    return await this.client.exists(key) === 1;
+  }
+  /** Gracefully close the Redis connection */
+  async close() {
+    await this.client.quit();
+  }
+};
+CacheRedisProvider = __decorateClass([
+  Provider({
+    name: "provider:cache:redis",
+    description: "Redis-based cache provider",
+    scope: ProviderScope.GLOBAL
+  })
+], CacheRedisProvider);
+
+// plugins/plugin-cache/src/providers/cache-memory.provider.ts
+import { Provider as Provider2, ProviderScope as ProviderScope2 } from "@frontmcp/sdk";
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+var CacheMemoryProvider = class {
+  memory = /* @__PURE__ */ new Map();
+  sweeper;
+  constructor(sweepIntervalTTL = 60) {
+    this.sweeper = setInterval(() => this.sweep(), sweepIntervalTTL * 1e3);
+    this.sweeper.unref?.();
+  }
+  /** Set a value (auto-stringifies objects) */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const existing = this.memory.get(key);
+    if (existing?.timeout) clearTimeout(existing.timeout);
+    const entry = { value: strValue };
+    if (ttlSeconds && ttlSeconds > 0) {
+      const ttlMs = ttlSeconds * 1e3;
+      entry.expiresAt = Date.now() + ttlMs;
+      if (ttlMs <= MAX_TIMEOUT_MS) {
+        entry.timeout = setTimeout(() => {
+          const e = this.memory.get(key);
+          if (e && e.expiresAt && e.expiresAt <= Date.now()) {
+            this.memory.delete(key);
+          }
+        }, ttlMs);
+        entry.timeout.unref?.();
+      }
+    }
+    this.memory.set(key, entry);
+  }
+  /** Get a value and automatically parse JSON if possible */
+  async getValue(key, defaultValue) {
+    const entry = this.memory.get(key);
+    if (!entry) return defaultValue;
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return defaultValue;
+    }
+    const raw = entry.value;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  /** Delete a key */
+  async delete(key) {
+    const entry = this.memory.get(key);
+    if (entry?.timeout) clearTimeout(entry.timeout);
+    this.memory.delete(key);
+  }
+  /** Check if a key exists (and not expired) */
+  async exists(key) {
+    const entry = this.memory.get(key);
+    if (!entry) return false;
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /** Gracefully close the provider */
+  async close() {
+    if (this.sweeper) clearInterval(this.sweeper);
+    for (const [, entry] of this.memory) {
+      if (entry.timeout) clearTimeout(entry.timeout);
+    }
+    this.memory.clear();
+  }
+  // ---- internals ----
+  isExpired(entry) {
+    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+  }
+  /** Periodically remove expired keys to keep memory tidy */
+  sweep() {
+    const now = Date.now();
+    for (const [key, entry] of this.memory) {
+      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
+        if (entry.timeout) clearTimeout(entry.timeout);
+        this.memory.delete(key);
+      }
+    }
+  }
+};
+CacheMemoryProvider = __decorateClass([
+  Provider2({
+    name: "provider:cache:memory",
+    description: "Memory-based cache provider",
+    scope: ProviderScope2.GLOBAL
+  })
+], CacheMemoryProvider);
+
+// plugins/plugin-cache/src/providers/cache-vercel-kv.provider.ts
+import { Provider as Provider3, ProviderScope as ProviderScope3 } from "@frontmcp/sdk";
+var CacheVercelKvProvider = class {
+  kv;
+  keyPrefix;
+  defaultTTL;
+  constructor(options = {}) {
+    const vercelKv = __require("@vercel/kv");
+    const hasUrl = options.url !== void 0;
+    const hasToken = options.token !== void 0;
+    if (hasUrl !== hasToken) {
+      throw new Error(
+        `CacheVercelKvProvider: Both 'url' and 'token' must be provided together, or neither. Received: url=${hasUrl ? "provided" : "missing"}, token=${hasToken ? "provided" : "missing"}`
+      );
+    }
+    if (options.url && options.token) {
+      this.kv = vercelKv.createClient({
+        url: options.url,
+        token: options.token
+      });
+    } else {
+      this.kv = vercelKv.kv;
+    }
+    this.keyPrefix = options.keyPrefix ?? "cache:";
+    this.defaultTTL = options.defaultTTL ?? 60 * 60 * 24;
+  }
+  prefixKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  /** Set a value (auto-stringifies objects) */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const ttl = ttlSeconds ?? this.defaultTTL;
+    if (ttl > 0) {
+      await this.kv.set(this.prefixKey(key), strValue, { ex: ttl });
+    } else {
+      await this.kv.set(this.prefixKey(key), strValue);
+    }
+  }
+  /** Get a value and automatically parse JSON if possible */
+  async getValue(key, defaultValue) {
+    const raw = await this.kv.get(this.prefixKey(key));
+    if (raw === null || raw === void 0) return defaultValue;
+    if (typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
+  /** Delete a key */
+  async delete(key) {
+    await this.kv.del(this.prefixKey(key));
+  }
+  /** Check if a key exists */
+  async exists(key) {
+    return await this.kv.exists(this.prefixKey(key)) === 1;
+  }
+  /** Gracefully close the provider (no-op for Vercel KV - stateless REST API) */
+  async close() {
+  }
+};
+CacheVercelKvProvider = __decorateClass([
+  Provider3({
+    name: "provider:cache:vercel-kv",
+    description: "Vercel KV-based cache provider",
+    scope: ProviderScope3.GLOBAL
+  })
+], CacheVercelKvProvider);
+
+// plugins/plugin-cache/src/cache.symbol.ts
+var CacheStoreToken = /* @__PURE__ */ Symbol("plugin:cache:store");
+
+// plugins/plugin-cache/src/cache.plugin.ts
+var DEFAULT_BYPASS_HEADER = "x-frontmcp-disable-cache";
+function matchesToolPattern(toolName, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  return patterns.some((pattern) => {
+    if (pattern.includes("*")) {
+      const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp("^" + escaped.replace(/\*/g, ".*") + "$");
+      return regex.test(toolName);
+    }
+    return pattern === toolName;
+  });
+}
+var CachePlugin = class extends DynamicPlugin {
+  options;
+  constructor(options = CachePlugin.defaultOptions) {
+    super();
+    this.options = {
+      defaultTTL: 60 * 60 * 24,
+      ...options
+    };
+  }
+  /**
+   * Check if a tool should be cached based on metadata or tools list.
+   */
+  shouldCacheTool(toolName, cacheMetadata) {
+    if (cacheMetadata) return true;
+    const patterns = this.options.toolPatterns ?? [];
+    return matchesToolPattern(toolName, patterns);
+  }
+  /**
+   * Check if cache should be bypassed based on request headers.
+   * Accesses headers from FrontMcpContextStorage which extracts x-frontmcp-* custom headers.
+   */
+  shouldBypassCache(_flowCtx) {
+    const bypassHeader = this.options.bypassHeader ?? DEFAULT_BYPASS_HEADER;
+    try {
+      const contextStorage = this.get(FrontMcpContextStorage);
+      const context = contextStorage?.getStore();
+      const customHeaders = context?.metadata?.customHeaders;
+      if (!customHeaders) return false;
+      const headerKey = bypassHeader.toLowerCase();
+      const headerValue = customHeaders[headerKey];
+      return headerValue === "true" || headerValue === "1";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get TTL for a tool, with metadata taking precedence over defaults.
+   */
+  getTtl(cacheMetadata) {
+    if (typeof cacheMetadata === "object" && cacheMetadata.ttl !== void 0) {
+      return cacheMetadata.ttl;
+    }
+    return this.options.defaultTTL ?? 60 * 60 * 24;
+  }
+  async willReadCache(flowCtx) {
+    const { tool, toolContext } = flowCtx.state;
+    if (!tool || !toolContext) return;
+    if (this.shouldBypassCache(flowCtx)) {
+      return;
+    }
+    const { cache } = toolContext.metadata;
+    if (!this.shouldCacheTool(tool.fullName, cache) && !this.shouldCacheTool(tool.name, cache) || typeof toolContext.input === "undefined") {
+      return;
+    }
+    const cacheStore = this.get(CacheStoreToken);
+    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
+    const cached = await cacheStore.getValue(hash);
+    if (cached !== void 0 && cached !== null) {
+      const cacheConfig = typeof cache === "object" ? cache : void 0;
+      if (cache === true || cacheConfig?.ttl && cacheConfig?.slideWindow) {
+        const ttl = this.getTtl(cache);
+        await cacheStore.setValue(hash, cached, ttl);
+      }
+      if (!tool.safeParseOutput(cached).success) {
+        await cacheStore.delete(hash);
+        return;
+      }
+      const isPlainObject = typeof cached === "object" && cached !== null && !Array.isArray(cached);
+      let cachedWithMeta;
+      if (isPlainObject) {
+        const cachedRecord = cached;
+        const existingMeta = cachedRecord["_meta"] || {};
+        cachedWithMeta = {
+          ...cachedRecord,
+          _meta: {
+            ...existingMeta,
+            cache: "hit"
+          }
+        };
+      } else {
+        cachedWithMeta = cached;
+      }
+      flowCtx.state.rawOutput = cachedWithMeta;
+      toolContext.respond(cachedWithMeta);
+    }
+  }
+  async willWriteCache(flowCtx) {
+    const { tool, toolContext } = flowCtx.state;
+    if (!tool || !toolContext) return;
+    if (this.shouldBypassCache(flowCtx)) {
+      return;
+    }
+    const { cache } = toolContext.metadata;
+    const shouldCache = this.shouldCacheTool(tool.fullName, cache) || this.shouldCacheTool(tool.name, cache);
+    if (!shouldCache || typeof toolContext.input === "undefined") {
+      return;
+    }
+    const cacheStore = this.get(CacheStoreToken);
+    const ttl = this.getTtl(cache);
+    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
+    await cacheStore.setValue(hash, toolContext.output, ttl);
+  }
+  /**
+   * Check if a tool is cacheable based on metadata or tools list.
+   * This can be used by other plugins or flows to determine cacheability.
+   */
+  isCacheable(toolName) {
+    return matchesToolPattern(toolName, this.options.toolPatterns ?? []);
+  }
+};
+__publicField(CachePlugin, "dynamicProviders", (options) => {
+  const providers = [];
+  switch (options.type) {
+    case "global-store":
+      providers.push({
+        name: "cache:global-store",
+        provide: CacheStoreToken,
+        inject: () => [FrontMcpConfig],
+        useFactory: (config) => {
+          const storeConfig = getGlobalStoreConfig("CachePlugin", config);
+          const globalOptions = options;
+          if (isVercelKvProvider(storeConfig)) {
+            return new CacheVercelKvProvider({
+              url: storeConfig.url,
+              token: storeConfig.token,
+              keyPrefix: storeConfig.keyPrefix,
+              defaultTTL: globalOptions.defaultTTL
+            });
+          }
+          return new CacheRedisProvider({
+            type: "redis",
+            config: {
+              host: storeConfig.host ?? "localhost",
+              port: storeConfig.port ?? 6379,
+              password: storeConfig.password,
+              db: storeConfig.db
+            },
+            defaultTTL: globalOptions.defaultTTL
+          });
+        }
+      });
+      break;
+    case "redis":
+    case "redis-client":
+      providers.push({
+        name: "cache:redis",
+        provide: CacheStoreToken,
+        useValue: new CacheRedisProvider(options)
+      });
+      break;
+    case "memory":
+      providers.push({
+        name: "cache:memory",
+        provide: CacheStoreToken,
+        useValue: new CacheMemoryProvider(options.defaultTTL)
+      });
+      break;
+  }
+  return providers;
+});
+__publicField(CachePlugin, "defaultOptions", {
+  type: "memory"
+});
+__decorateClass([
+  ToolHook.Will("execute", { priority: 1e3 })
+], CachePlugin.prototype, "willReadCache", 1);
+__decorateClass([
+  ToolHook.Did("execute", { priority: 1e3 })
+], CachePlugin.prototype, "willWriteCache", 1);
+CachePlugin = __decorateClass([
+  Plugin({
+    name: "cache",
+    description: "Cache plugin for caching tool results",
+    providers: [
+      /* add providers that always loaded with the plugin or default providers */
+      {
+        // this is a default provider for cache, will be overridden if dynamicProviders based on config
+        name: "cache:memory",
+        provide: CacheStoreToken,
+        useValue: new CacheMemoryProvider(60 * 60 * 24)
+      }
+    ]
+  })
+], CachePlugin);
+function hashObject(obj) {
+  const keys = Object.keys(obj).sort();
+  return keys.reduce((acc, key) => {
+    acc += key + ":";
+    const val = obj[key];
+    if (typeof val === "object" && val !== null) {
+      acc += hashObject(val);
+    } else {
+      acc += String(val);
+    }
+    acc += ";";
+    return acc;
+  }, "");
+}
+export {
+  CachePlugin,
+  CachePlugin as default
+};

package/esm/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@frontmcp/plugin-cache",
+  "version": "0.7.1",
+  "description": "Cache plugin for FrontMCP - Redis, Vercel KV, and in-memory caching with automatic tool result caching",
+  "author": "AgentFront <info@agentfront.dev>",
+  "license": "Apache-2.0",
+  "keywords": [
+    "mcp",
+    "cache",
+    "redis",
+    "vercel-kv",
+    "plugin",
+    "frontmcp",
+    "agentfront"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentfront/frontmcp.git",
+    "directory": "plugins/plugin-cache"
+  },
+  "bugs": {
+    "url": "https://github.com/agentfront/frontmcp/issues"
+  },
+  "homepage": "https://github.com/agentfront/frontmcp/blob/main/plugins/plugin-cache/README.md",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "main": "../index.js",
+  "module": "./index.mjs",
+  "types": "../index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "../package.json",
+    ".": {
+      "require": {
+        "types": "../index.d.ts",
+        "default": "../index.js"
+      },
+      "import": {
+        "types": "../index.d.ts",
+        "default": "./index.mjs"
+      }
+    }
+  },
+  "dependencies": {
+    "ioredis": "^5.8.0",
+    "@frontmcp/sdk": "0.7.1",
+    "zod": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@vercel/kv": "^2.0.0 || ^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@vercel/kv": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "reflect-metadata": "^0.2.2"
+  }
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export { default, default as CachePlugin } from './cache.plugin';
+export * from './cache.types';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACjE,cAAc,eAAe,CAAC"}

package/index.js

@@ -0,0 +1,494 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// plugins/plugin-cache/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CachePlugin: () => CachePlugin,
+  default: () => CachePlugin
+});
+module.exports = __toCommonJS(index_exports);
+
+// plugins/plugin-cache/src/cache.plugin.ts
+var import_sdk4 = require("@frontmcp/sdk");
+
+// plugins/plugin-cache/src/providers/cache-redis.provider.ts
+var import_ioredis = __toESM(require("ioredis"));
+var import_sdk = require("@frontmcp/sdk");
+var CacheRedisProvider = class {
+  client;
+  constructor(options) {
+    if (options.type !== "redis" && options.type !== "redis-client") {
+      throw new Error("Invalid cache provider type");
+    }
+    if (options.type === "redis-client") {
+      this.client = options.client;
+      return;
+    }
+    this.client = new import_ioredis.default({
+      lazyConnect: false,
+      maxRetriesPerRequest: 3,
+      ...options.config
+    });
+    this.client.on("connect", () => console.log("[Redis] Connected"));
+    this.client.on("error", (err) => console.error("[Redis] Error:", err));
+  }
+  /** Set a value (auto-stringifies objects) */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSeconds && ttlSeconds > 0) {
+      await this.client.set(key, strValue, "EX", ttlSeconds);
+    } else {
+      await this.client.set(key, strValue);
+    }
+  }
+  /** Get a value and automatically parse JSON if possible */
+  async getValue(key, defaultValue) {
+    const raw = await this.client.get(key);
+    if (raw === null) return defaultValue;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  /** Delete a key */
+  async delete(key) {
+    await this.client.del(key);
+  }
+  /** Check if a key exists */
+  async exists(key) {
+    return await this.client.exists(key) === 1;
+  }
+  /** Gracefully close the Redis connection */
+  async close() {
+    await this.client.quit();
+  }
+};
+CacheRedisProvider = __decorateClass([
+  (0, import_sdk.Provider)({
+    name: "provider:cache:redis",
+    description: "Redis-based cache provider",
+    scope: import_sdk.ProviderScope.GLOBAL
+  })
+], CacheRedisProvider);
+
+// plugins/plugin-cache/src/providers/cache-memory.provider.ts
+var import_sdk2 = require("@frontmcp/sdk");
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+var CacheMemoryProvider = class {
+  memory = /* @__PURE__ */ new Map();
+  sweeper;
+  constructor(sweepIntervalTTL = 60) {
+    this.sweeper = setInterval(() => this.sweep(), sweepIntervalTTL * 1e3);
+    this.sweeper.unref?.();
+  }
+  /** Set a value (auto-stringifies objects) */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const existing = this.memory.get(key);
+    if (existing?.timeout) clearTimeout(existing.timeout);
+    const entry = { value: strValue };
+    if (ttlSeconds && ttlSeconds > 0) {
+      const ttlMs = ttlSeconds * 1e3;
+      entry.expiresAt = Date.now() + ttlMs;
+      if (ttlMs <= MAX_TIMEOUT_MS) {
+        entry.timeout = setTimeout(() => {
+          const e = this.memory.get(key);
+          if (e && e.expiresAt && e.expiresAt <= Date.now()) {
+            this.memory.delete(key);
+          }
+        }, ttlMs);
+        entry.timeout.unref?.();
+      }
+    }
+    this.memory.set(key, entry);
+  }
+  /** Get a value and automatically parse JSON if possible */
+  async getValue(key, defaultValue) {
+    const entry = this.memory.get(key);
+    if (!entry) return defaultValue;
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return defaultValue;
+    }
+    const raw = entry.value;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  /** Delete a key */
+  async delete(key) {
+    const entry = this.memory.get(key);
+    if (entry?.timeout) clearTimeout(entry.timeout);
+    this.memory.delete(key);
+  }
+  /** Check if a key exists (and not expired) */
+  async exists(key) {
+    const entry = this.memory.get(key);
+    if (!entry) return false;
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /** Gracefully close the provider */
+  async close() {
+    if (this.sweeper) clearInterval(this.sweeper);
+    for (const [, entry] of this.memory) {
+      if (entry.timeout) clearTimeout(entry.timeout);
+    }
+    this.memory.clear();
+  }
+  // ---- internals ----
+  isExpired(entry) {
+    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+  }
+  /** Periodically remove expired keys to keep memory tidy */
+  sweep() {
+    const now = Date.now();
+    for (const [key, entry] of this.memory) {
+      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
+        if (entry.timeout) clearTimeout(entry.timeout);
+        this.memory.delete(key);
+      }
+    }
+  }
+};
+CacheMemoryProvider = __decorateClass([
+  (0, import_sdk2.Provider)({
+    name: "provider:cache:memory",
+    description: "Memory-based cache provider",
+    scope: import_sdk2.ProviderScope.GLOBAL
+  })
+], CacheMemoryProvider);
+
+// plugins/plugin-cache/src/providers/cache-vercel-kv.provider.ts
+var import_sdk3 = require("@frontmcp/sdk");
+var CacheVercelKvProvider = class {
+  kv;
+  keyPrefix;
+  defaultTTL;
+  constructor(options = {}) {
+    const vercelKv = require("@vercel/kv");
+    const hasUrl = options.url !== void 0;
+    const hasToken = options.token !== void 0;
+    if (hasUrl !== hasToken) {
+      throw new Error(
+        `CacheVercelKvProvider: Both 'url' and 'token' must be provided together, or neither. Received: url=${hasUrl ? "provided" : "missing"}, token=${hasToken ? "provided" : "missing"}`
+      );
+    }
+    if (options.url && options.token) {
+      this.kv = vercelKv.createClient({
+        url: options.url,
+        token: options.token
+      });
+    } else {
+      this.kv = vercelKv.kv;
+    }
+    this.keyPrefix = options.keyPrefix ?? "cache:";
+    this.defaultTTL = options.defaultTTL ?? 60 * 60 * 24;
+  }
+  prefixKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  /** Set a value (auto-stringifies objects) */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const ttl = ttlSeconds ?? this.defaultTTL;
+    if (ttl > 0) {
+      await this.kv.set(this.prefixKey(key), strValue, { ex: ttl });
+    } else {
+      await this.kv.set(this.prefixKey(key), strValue);
+    }
+  }
+  /** Get a value and automatically parse JSON if possible */
+  async getValue(key, defaultValue) {
+    const raw = await this.kv.get(this.prefixKey(key));
+    if (raw === null || raw === void 0) return defaultValue;
+    if (typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
+  /** Delete a key */
+  async delete(key) {
+    await this.kv.del(this.prefixKey(key));
+  }
+  /** Check if a key exists */
+  async exists(key) {
+    return await this.kv.exists(this.prefixKey(key)) === 1;
+  }
+  /** Gracefully close the provider (no-op for Vercel KV - stateless REST API) */
+  async close() {
+  }
+};
+CacheVercelKvProvider = __decorateClass([
+  (0, import_sdk3.Provider)({
+    name: "provider:cache:vercel-kv",
+    description: "Vercel KV-based cache provider",
+    scope: import_sdk3.ProviderScope.GLOBAL
+  })
+], CacheVercelKvProvider);
+
+// plugins/plugin-cache/src/cache.symbol.ts
+var CacheStoreToken = /* @__PURE__ */ Symbol("plugin:cache:store");
+
+// plugins/plugin-cache/src/cache.plugin.ts
+var DEFAULT_BYPASS_HEADER = "x-frontmcp-disable-cache";
+function matchesToolPattern(toolName, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  return patterns.some((pattern) => {
+    if (pattern.includes("*")) {
+      const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp("^" + escaped.replace(/\*/g, ".*") + "$");
+      return regex.test(toolName);
+    }
+    return pattern === toolName;
+  });
+}
+var CachePlugin = class extends import_sdk4.DynamicPlugin {
+  options;
+  constructor(options = CachePlugin.defaultOptions) {
+    super();
+    this.options = {
+      defaultTTL: 60 * 60 * 24,
+      ...options
+    };
+  }
+  /**
+   * Check if a tool should be cached based on metadata or tools list.
+   */
+  shouldCacheTool(toolName, cacheMetadata) {
+    if (cacheMetadata) return true;
+    const patterns = this.options.toolPatterns ?? [];
+    return matchesToolPattern(toolName, patterns);
+  }
+  /**
+   * Check if cache should be bypassed based on request headers.
+   * Accesses headers from FrontMcpContextStorage which extracts x-frontmcp-* custom headers.
+   */
+  shouldBypassCache(_flowCtx) {
+    const bypassHeader = this.options.bypassHeader ?? DEFAULT_BYPASS_HEADER;
+    try {
+      const contextStorage = this.get(import_sdk4.FrontMcpContextStorage);
+      const context = contextStorage?.getStore();
+      const customHeaders = context?.metadata?.customHeaders;
+      if (!customHeaders) return false;
+      const headerKey = bypassHeader.toLowerCase();
+      const headerValue = customHeaders[headerKey];
+      return headerValue === "true" || headerValue === "1";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get TTL for a tool, with metadata taking precedence over defaults.
+   */
+  getTtl(cacheMetadata) {
+    if (typeof cacheMetadata === "object" && cacheMetadata.ttl !== void 0) {
+      return cacheMetadata.ttl;
+    }
+    return this.options.defaultTTL ?? 60 * 60 * 24;
+  }
+  async willReadCache(flowCtx) {
+    const { tool, toolContext } = flowCtx.state;
+    if (!tool || !toolContext) return;
+    if (this.shouldBypassCache(flowCtx)) {
+      return;
+    }
+    const { cache } = toolContext.metadata;
+    if (!this.shouldCacheTool(tool.fullName, cache) && !this.shouldCacheTool(tool.name, cache) || typeof toolContext.input === "undefined") {
+      return;
+    }
+    const cacheStore = this.get(CacheStoreToken);
+    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
+    const cached = await cacheStore.getValue(hash);
+    if (cached !== void 0 && cached !== null) {
+      const cacheConfig = typeof cache === "object" ? cache : void 0;
+      if (cache === true || cacheConfig?.ttl && cacheConfig?.slideWindow) {
+        const ttl = this.getTtl(cache);
+        await cacheStore.setValue(hash, cached, ttl);
+      }
+      if (!tool.safeParseOutput(cached).success) {
+        await cacheStore.delete(hash);
+        return;
+      }
+      const isPlainObject = typeof cached === "object" && cached !== null && !Array.isArray(cached);
+      let cachedWithMeta;
+      if (isPlainObject) {
+        const cachedRecord = cached;
+        const existingMeta = cachedRecord["_meta"] || {};
+        cachedWithMeta = {
+          ...cachedRecord,
+          _meta: {
+            ...existingMeta,
+            cache: "hit"
+          }
+        };
+      } else {
+        cachedWithMeta = cached;
+      }
+      flowCtx.state.rawOutput = cachedWithMeta;
+      toolContext.respond(cachedWithMeta);
+    }
+  }
+  async willWriteCache(flowCtx) {
+    const { tool, toolContext } = flowCtx.state;
+    if (!tool || !toolContext) return;
+    if (this.shouldBypassCache(flowCtx)) {
+      return;
+    }
+    const { cache } = toolContext.metadata;
+    const shouldCache = this.shouldCacheTool(tool.fullName, cache) || this.shouldCacheTool(tool.name, cache);
+    if (!shouldCache || typeof toolContext.input === "undefined") {
+      return;
+    }
+    const cacheStore = this.get(CacheStoreToken);
+    const ttl = this.getTtl(cache);
+    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
+    await cacheStore.setValue(hash, toolContext.output, ttl);
+  }
+  /**
+   * Check if a tool is cacheable based on metadata or tools list.
+   * This can be used by other plugins or flows to determine cacheability.
+   */
+  isCacheable(toolName) {
+    return matchesToolPattern(toolName, this.options.toolPatterns ?? []);
+  }
+};
+__publicField(CachePlugin, "dynamicProviders", (options) => {
+  const providers = [];
+  switch (options.type) {
+    case "global-store":
+      providers.push({
+        name: "cache:global-store",
+        provide: CacheStoreToken,
+        inject: () => [import_sdk4.FrontMcpConfig],
+        useFactory: (config) => {
+          const storeConfig = (0, import_sdk4.getGlobalStoreConfig)("CachePlugin", config);
+          const globalOptions = options;
+          if ((0, import_sdk4.isVercelKvProvider)(storeConfig)) {
+            return new CacheVercelKvProvider({
+              url: storeConfig.url,
+              token: storeConfig.token,
+              keyPrefix: storeConfig.keyPrefix,
+              defaultTTL: globalOptions.defaultTTL
+            });
+          }
+          return new CacheRedisProvider({
+            type: "redis",
+            config: {
+              host: storeConfig.host ?? "localhost",
+              port: storeConfig.port ?? 6379,
+              password: storeConfig.password,
+              db: storeConfig.db
+            },
+            defaultTTL: globalOptions.defaultTTL
+          });
+        }
+      });
+      break;
+    case "redis":
+    case "redis-client":
+      providers.push({
+        name: "cache:redis",
+        provide: CacheStoreToken,
+        useValue: new CacheRedisProvider(options)
+      });
+      break;
+    case "memory":
+      providers.push({
+        name: "cache:memory",
+        provide: CacheStoreToken,
+        useValue: new CacheMemoryProvider(options.defaultTTL)
+      });
+      break;
+  }
+  return providers;
+});
+__publicField(CachePlugin, "defaultOptions", {
+  type: "memory"
+});
+__decorateClass([
+  import_sdk4.ToolHook.Will("execute", { priority: 1e3 })
+], CachePlugin.prototype, "willReadCache", 1);
+__decorateClass([
+  import_sdk4.ToolHook.Did("execute", { priority: 1e3 })
+], CachePlugin.prototype, "willWriteCache", 1);
+CachePlugin = __decorateClass([
+  (0, import_sdk4.Plugin)({
+    name: "cache",
+    description: "Cache plugin for caching tool results",
+    providers: [
+      /* add providers that always loaded with the plugin or default providers */
+      {
+        // this is a default provider for cache, will be overridden if dynamicProviders based on config
+        name: "cache:memory",
+        provide: CacheStoreToken,
+        useValue: new CacheMemoryProvider(60 * 60 * 24)
+      }
+    ]
+  })
+], CachePlugin);
+function hashObject(obj) {
+  const keys = Object.keys(obj).sort();
+  return keys.reduce((acc, key) => {
+    acc += key + ":";
+    const val = obj[key];
+    if (typeof val === "object" && val !== null) {
+      acc += hashObject(val);
+    } else {
+      acc += String(val);
+    }
+    acc += ";";
+    return acc;
+  }, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CachePlugin
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/plugin-cache",
-  "version": "0.0.1",
+  "version": "0.7.1",
   "description": "Cache plugin for FrontMCP - Redis, Vercel KV, and in-memory caching with automatic tool result caching",
   "author": "AgentFront <info@agentfront.dev>",
   "license": "Apache-2.0",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "ioredis": "^5.8.0",
-    "@frontmcp/sdk": "0.7.0",
+    "@frontmcp/sdk": "0.7.1",
     "zod": "^4.0.0"
   },
   "peerDependencies": {

package/providers/cache-memory.provider.d.ts

@@ -0,0 +1,20 @@
+import { CacheStoreInterface } from '../cache.types';
+export default class CacheMemoryProvider implements CacheStoreInterface {
+    private readonly memory;
+    private sweeper?;
+    constructor(sweepIntervalTTL?: number);
+    /** Set a value (auto-stringifies objects) */
+    setValue(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
+    /** Get a value and automatically parse JSON if possible */
+    getValue<T = unknown>(key: string, defaultValue?: T): Promise<T | undefined>;
+    /** Delete a key */
+    delete(key: string): Promise<void>;
+    /** Check if a key exists (and not expired) */
+    exists(key: string): Promise<boolean>;
+    /** Gracefully close the provider */
+    close(): Promise<void>;
+    private isExpired;
+    /** Periodically remove expired keys to keep memory tidy */
+    private sweep;
+}
+//# sourceMappingURL=cache-memory.provider.d.ts.map

package/providers/cache-memory.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-memory.provider.d.ts","sourceRoot":"","sources":["../../src/providers/cache-memory.provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAiBrD,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,mBAAmB;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;IACnD,OAAO,CAAC,OAAO,CAAC,CAAiB;gBAErB,gBAAgB,SAAK;IAMjC,6CAA6C;IACvC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B/E,2DAA2D;IACrD,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAkBlF,mBAAmB;IACb,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxC,8CAA8C;IACxC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAU3C,oCAAoC;IAC9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAU5B,OAAO,CAAC,SAAS;IAIjB,2DAA2D;IAC3D,OAAO,CAAC,KAAK;CASd"}

package/providers/cache-redis.provider.d.ts

@@ -0,0 +1,16 @@
+import { CacheStoreInterface, RedisCacheOptions } from '../cache.types';
+export default class CacheRedisProvider implements CacheStoreInterface {
+    private readonly client;
+    constructor(options: RedisCacheOptions);
+    /** Set a value (auto-stringifies objects) */
+    setValue(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
+    /** Get a value and automatically parse JSON if possible */
+    getValue<T = unknown>(key: string, defaultValue?: T): Promise<T | undefined>;
+    /** Delete a key */
+    delete(key: string): Promise<void>;
+    /** Check if a key exists */
+    exists(key: string): Promise<boolean>;
+    /** Gracefully close the Redis connection */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=cache-redis.provider.d.ts.map

package/providers/cache-redis.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-redis.provider.d.ts","sourceRoot":"","sources":["../../src/providers/cache-redis.provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAOxE,MAAM,CAAC,OAAO,OAAO,kBAAmB,YAAW,mBAAmB;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,OAAO,EAAE,iBAAiB;IAmBtC,6CAA6C;IACvC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E,2DAA2D;IACrD,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAYlF,mBAAmB;IACb,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC,4BAA4B;IACtB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI3C,4CAA4C;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/providers/cache-vercel-kv.provider.d.ts

@@ -0,0 +1,25 @@
+import { CacheStoreInterface } from '../cache.types';
+export interface CacheVercelKvProviderOptions {
+    url?: string;
+    token?: string;
+    keyPrefix?: string;
+    defaultTTL?: number;
+}
+export default class CacheVercelKvProvider implements CacheStoreInterface {
+    private kv;
+    private readonly keyPrefix;
+    private readonly defaultTTL;
+    constructor(options?: CacheVercelKvProviderOptions);
+    private prefixKey;
+    /** Set a value (auto-stringifies objects) */
+    setValue(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
+    /** Get a value and automatically parse JSON if possible */
+    getValue<T = unknown>(key: string, defaultValue?: T): Promise<T | undefined>;
+    /** Delete a key */
+    delete(key: string): Promise<void>;
+    /** Check if a key exists */
+    exists(key: string): Promise<boolean>;
+    /** Gracefully close the provider (no-op for Vercel KV - stateless REST API) */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=cache-vercel-kv.provider.d.ts.map

package/providers/cache-vercel-kv.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-vercel-kv.provider.d.ts","sourceRoot":"","sources":["../../src/providers/cache-vercel-kv.provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,WAAW,4BAA4B;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAeD,MAAM,CAAC,OAAO,OAAO,qBAAsB,YAAW,mBAAmB;IACvE,OAAO,CAAC,EAAE,CAAiB;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,OAAO,GAAE,4BAAiC;IA6BtD,OAAO,CAAC,SAAS;IAIjB,6CAA6C;IACvC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/E,2DAA2D;IACrD,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAgBlF,mBAAmB;IACb,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxC,4BAA4B;IACtB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI3C,+EAA+E;IACzE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}