@frontmcp/sdk 1.8.5 → 1.8.7

package/esm/index.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -1861,7 +1862,7 @@ var init_session = __esm({
 
 // libs/sdk/src/common/types/options/http/schema.ts
 import { z as z8 } from "@frontmcp/lazy-zod";
-var HTTP_METHODS, httpRouteSchema, bodyParserLimitSchema, corsOptionsSchema, httpOptionsSchema;
+var HTTP_METHODS, httpRouteSchema, bodyParserLimitSchema, corsOptionsSchema, securityHeaderValueSchema, securityHeadersSchema, httpOptionsSchema;
 var init_schema3 = __esm({
   "libs/sdk/src/common/types/options/http/schema.ts"() {
     "use strict";
@@ -1898,6 +1899,19 @@ var init_schema3 = __esm({
       credentials: z8.boolean().optional(),
       maxAge: z8.number().optional()
     });
+    securityHeaderValueSchema = z8.union([z8.string(), z8.literal(false)]);
+    securityHeadersSchema = z8.object({
+      hsts: securityHeaderValueSchema.optional(),
+      contentTypeOptions: securityHeaderValueSchema.optional(),
+      frameOptions: securityHeaderValueSchema.optional(),
+      custom: z8.record(z8.string(), z8.string()).optional(),
+      csp: z8.object({
+        enabled: z8.boolean().optional(),
+        directives: z8.record(z8.string(), z8.union([z8.string(), z8.array(z8.string())])).optional(),
+        reportUri: z8.string().optional(),
+        reportOnly: z8.boolean().optional()
+      }).optional()
+    });
     httpOptionsSchema = z8.object({
       port: z8.number().optional().default(Number(process.env["PORT"]) || 3e3),
       // `FRONTMCP_HTTP_ENTRY_PATH` lets `frontmcp dev` propagate the configured
@@ -1956,7 +1970,9 @@ var init_schema3 = __esm({
        * app as the MCP endpoint; public by default, `auth: true` opts into the MCP
        * `session:verify` flow. Reserved-path collisions are rejected at startup.
        */
-      routes: z8.array(httpRouteSchema).optional()
+      routes: z8.array(httpRouteSchema).optional(),
+      /** Response security headers; see `SecurityHeadersOptions`. */
+      securityHeaders: securityHeadersSchema.optional()
     });
   }
 });
@@ -2394,7 +2410,7 @@ var init_schema7 = __esm({
     persistenceConfigSchema = z12.object({
       redis: redisOptionsSchema.optional(),
       sqlite: sqliteOptionsSchema.optional(),
-      defaultTtlMs: z12.number().int().positive().default(36e5)
+      defaultTtlMs: z12.number().int().positive().optional()
     }).refine((cfg) => !(cfg.redis && cfg.sqlite), {
       message: "Invalid persistence config: choose either redis or sqlite, not both",
       path: ["sqlite"]
@@ -6035,6 +6051,33 @@ var init_errors = __esm({
   }
 });
 
+// libs/sdk/src/common/utils/list-all-pages.utils.ts
+async function listAllPages(method, fetchPage, fail = (message) => new InternalMcpError(message, "LIST_PAGINATION_STALLED")) {
+  const items = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  for (let page = 0; page < MAX_LIST_PAGES; page++) {
+    const result = await fetchPage(cursor);
+    items.push(...result.items ?? []);
+    const next = result.nextCursor;
+    if (!next) return items;
+    if (seenCursors.has(next)) {
+      throw fail(`${method} returned the cursor "${next}" twice`);
+    }
+    seenCursors.add(next);
+    cursor = next;
+  }
+  throw fail(`${method} did not finish within ${MAX_LIST_PAGES} pages`);
+}
+var MAX_LIST_PAGES;
+var init_list_all_pages_utils = __esm({
+  "libs/sdk/src/common/utils/list-all-pages.utils.ts"() {
+    "use strict";
+    init_mcp_error();
+    MAX_LIST_PAGES = 1e3;
+  }
+});
+
 // libs/sdk/src/transport/mcp-handlers/skills-mcp.types.ts
 import { z as z40 } from "@frontmcp/lazy-zod";
 var SkillsSearchRequestSchema, SkillsSearchResultSchema, SkillsLoadRequestSchema, SkillsLoadResultSchema, SkillsListRequestSchema, SkillsListResultSchema;
@@ -6483,6 +6526,7 @@ var require_dist = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var index_exports = {};
     __export2(index_exports, {
+      SqliteDecryptionError: () => SqliteDecryptionError,
       SqliteElicitationStore: () => SqliteElicitationStore,
       SqliteEventStore: () => SqliteEventStore,
       SqliteKvStore: () => SqliteKvStore,
@@ -6494,34 +6538,47 @@ var require_dist = __commonJS({
       encryptValue: () => encryptValue,
       loadBetterSqlite3: () => loadBetterSqlite3,
       openDatabase: () => openDatabase,
-      sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema
+      sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema,
+      withBusyRetry: () => withBusyRetry
     });
     module.exports = __toCommonJS2(index_exports);
-    var import_utils114 = __require("@frontmcp/utils");
+    var import_utils119 = __require("@frontmcp/utils");
+    var SqliteDecryptionError = class extends Error {
+      code = "SQLITE_DECRYPTION_FAILED";
+      constructor() {
+        super(
+          "SqliteKvStore: failed to decrypt a stored value. The encryption secret differs from the one the database was written with (or the value is corrupted). Restore the original secret, or delete the database file to start empty."
+        );
+        this.name = "SqliteDecryptionError";
+      }
+    };
     var HKDF_SALT = new TextEncoder().encode("frontmcp-sqlite-storage-v1");
     var HKDF_INFO = new TextEncoder().encode("aes-256-gcm-value-encryption");
     var KEY_LENGTH = 32;
     function deriveEncryptionKey(secret) {
       const ikm = new TextEncoder().encode(secret);
-      return (0, import_utils114.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
+      return (0, import_utils119.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
     }
     var SEPARATOR = ":";
     function encryptValue(key, plaintext) {
-      const iv = (0, import_utils114.randomBytes)(12);
+      const iv = (0, import_utils119.randomBytes)(12);
       const plaintextBytes = new TextEncoder().encode(plaintext);
-      const { ciphertext, tag } = (0, import_utils114.encryptAesGcm)(key, plaintextBytes, iv);
-      return [(0, import_utils114.base64urlEncode)(iv), (0, import_utils114.base64urlEncode)(tag), (0, import_utils114.base64urlEncode)(ciphertext)].join(SEPARATOR);
+      const { ciphertext, tag } = (0, import_utils119.encryptAesGcm)(key, plaintextBytes, iv);
+      return [(0, import_utils119.base64urlEncode)(iv), (0, import_utils119.base64urlEncode)(tag), (0, import_utils119.base64urlEncode)(ciphertext)].join(SEPARATOR);
     }
     function decryptValue(key, encrypted) {
       const parts = encrypted.split(SEPARATOR);
       if (parts.length !== 3) {
         throw new Error("Invalid encrypted value format");
       }
-      const iv = (0, import_utils114.base64urlDecode)(parts[0]);
-      const tag = (0, import_utils114.base64urlDecode)(parts[1]);
-      const ciphertext = (0, import_utils114.base64urlDecode)(parts[2]);
-      const plaintext = (0, import_utils114.decryptAesGcm)(key, ciphertext, iv, tag);
-      return new TextDecoder().decode(plaintext);
+      const iv = (0, import_utils119.base64urlDecode)(parts[0]);
+      const tag = (0, import_utils119.base64urlDecode)(parts[1]);
+      const ciphertext = (0, import_utils119.base64urlDecode)(parts[2]);
+      try {
+        return new TextDecoder().decode((0, import_utils119.decryptAesGcm)(key, ciphertext, iv, tag));
+      } catch {
+        throw new SqliteDecryptionError();
+      }
     }
     var import_utils210 = __require("@frontmcp/utils");
     var cached = null;
@@ -6534,7 +6591,27 @@ var require_dist = __commonJS({
       return mod;
     }
     var MEMORY_PATH = ":memory:";
-    function openDatabase(path3, storeName) {
+    var DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+    function isBusyError(err) {
+      const code = err?.code;
+      return code === "SQLITE_BUSY" || code === "SQLITE_BUSY_RECOVERY" || code === "SQLITE_BUSY_SNAPSHOT";
+    }
+    function sleepSync(ms) {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    function withBusyRetry(operation, options = {}) {
+      const attempts = options.attempts ?? 5;
+      const delayMs = options.delayMs ?? 50;
+      for (let attempt = 1; ; attempt++) {
+        try {
+          return operation();
+        } catch (err) {
+          if (!isBusyError(err) || attempt >= attempts) throw err;
+          sleepSync(delayMs * attempt);
+        }
+      }
+    }
+    function openDatabase(path3, storeName, options = {}) {
       const BetterSqlite3 = loadBetterSqlite3();
       if (path3 !== MEMORY_PATH && path3 !== "") {
         const dir = (0, import_utils210.dirname)(path3);
@@ -6543,16 +6620,28 @@ var require_dist = __commonJS({
             (0, import_utils210.ensureDirSync)(dir);
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            throw new Error(`${storeName}: failed to create directory "${dir}" for database "${path3}": ${message}`);
+            throw new Error(`${storeName}: failed to create directory "${dir}" for database "${path3}": ${message}`, {
+              cause: err
+            });
           }
         }
       }
+      let db;
+      try {
+        db = new BetterSqlite3(path3);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`${storeName}: failed to open database at "${path3}": ${message}`, { cause: err });
+      }
       try {
-        return new BetterSqlite3(path3);
+        db.pragma(`busy_timeout = ${Math.max(0, Math.floor(options.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS))}`);
+        if (options.walMode) withBusyRetry(() => db.pragma("journal_mode = WAL"));
       } catch (err) {
+        db.close();
         const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`${storeName}: failed to open database at "${path3}": ${message}`);
+        throw new Error(`${storeName}: failed to configure database at "${path3}": ${message}`, { cause: err });
       }
+      return db;
     }
     var SqliteKvStore = class {
       db;
@@ -6560,14 +6649,14 @@ var require_dist = __commonJS({
       cleanupTimer = null;
       stmts = null;
       constructor(options) {
-        this.db = openDatabase(options.path, "SqliteKvStore");
-        if (options.walMode !== false) {
-          this.db.pragma("journal_mode = WAL");
-        }
+        this.db = openDatabase(options.path, "SqliteKvStore", {
+          busyTimeoutMs: options.busyTimeoutMs,
+          walMode: options.walMode !== false
+        });
         if (options.encryption?.secret) {
           this.encryptionKey = deriveEncryptionKey(options.encryption.secret);
         }
-        this.initSchema();
+        withBusyRetry(() => this.initSchema());
         this.prepareStatements();
         const cleanupInterval = options.ttlCleanupIntervalMs ?? 6e4;
         if (cleanupInterval > 0) {
@@ -7026,17 +7115,17 @@ var require_dist = __commonJS({
       encryptionKey = null;
       stmts = null;
       constructor(options) {
-        this.db = openDatabase(options.path, "SqliteTaskStore");
-        if (options.walMode !== false) {
-          this.db.pragma("journal_mode = WAL");
-        }
+        this.db = openDatabase(options.path, "SqliteTaskStore", {
+          busyTimeoutMs: options.busyTimeoutMs,
+          walMode: options.walMode !== false
+        });
         this.logger = options.logger;
         this.liveness = options.livenessProbe ?? defaultLivenessProbe;
         if (options.encryption?.secret) {
           this.encryptionKey = deriveEncryptionKey(options.encryption.secret);
         }
         this.emitter.setMaxListeners(200);
-        this.initSchema();
+        withBusyRetry(() => this.initSchema());
         this.prepareStatements();
         const cleanupInterval = options.ttlCleanupIntervalMs ?? 6e4;
         if (cleanupInterval > 0) {
@@ -7273,13 +7362,13 @@ var require_dist = __commonJS({
       cleanupTimer = null;
       stmts = null;
       constructor(options) {
-        this.db = openDatabase(options.path, "SqliteEventStore");
-        if (options.walMode !== false) {
-          this.db.pragma("journal_mode = WAL");
-        }
+        this.db = openDatabase(options.path, "SqliteEventStore", {
+          busyTimeoutMs: options.busyTimeoutMs,
+          walMode: options.walMode !== false
+        });
         this.maxEvents = options.maxEvents ?? 1e4;
         this.ttlMs = options.ttlMs ?? 3e5;
-        this.initSchema();
+        withBusyRetry(() => this.initSchema());
         this.prepareStatements();
         const cleanupInterval = options.ttlCleanupIntervalMs ?? 6e4;
         if (cleanupInterval > 0) {
@@ -7414,7 +7503,8 @@ var require_dist = __commonJS({
         secret: import_lazy_zod113.z.string().min(1)
       }).optional(),
       ttlCleanupIntervalMs: import_lazy_zod113.z.number().int().nonnegative().optional().default(6e4),
-      walMode: import_lazy_zod113.z.boolean().optional().default(true)
+      walMode: import_lazy_zod113.z.boolean().optional().default(true),
+      busyTimeoutMs: import_lazy_zod113.z.number().int().nonnegative().optional().default(5e3)
     });
   }
 });
@@ -7433,6 +7523,14 @@ function detectStorageType(storage, configuredType) {
   if (getEnv("REDIS_URL") || getEnv("REDIS_HOST")) return "redis";
   return "memory";
 }
+function isExplicitStorage(storage) {
+  return Boolean(storage?.type && storage.type !== "auto");
+}
+function resolvesToVercelKvTaskBackend(redis, storage) {
+  if (isExplicitStorage(storage)) return storage.type === "vercel-kv";
+  if (redis) return "provider" in redis && redis.provider === "vercel-kv";
+  return Boolean(getEnv("KV_REST_API_URL"));
+}
 async function createTaskStore(options = {}) {
   const { storage: storageConfig, redis, keyPrefix = "mcp:task:", logger, isEdgeRuntime: isEdgeRuntime3 = false, sqlite } = options;
   if (isEdgeRuntime3 && sqlite) {
@@ -7457,7 +7555,7 @@ async function createTaskStore(options = {}) {
     return { store: store2, type: "sqlite" };
   }
   let finalStorageConfig = storageConfig;
-  if (redis && !storageConfig) {
+  if (redis && !isExplicitStorage(storageConfig)) {
     if ("provider" in redis && redis.provider === "vercel-kv") {
       throw new TaskStoreNotSupportedError(
         "Vercel KV is not supported for task stores. Task result blocking and cancel signalling require pub/sub. Use Redis or Upstash instead."
@@ -7485,7 +7583,8 @@ async function createTaskStore(options = {}) {
       };
     }
   }
-  if (finalStorageConfig?.type === "vercel-kv" || getEnv("KV_REST_API_URL")) {
+  const explicitBackend = isExplicitStorage(storageConfig) || Boolean(redis);
+  if (finalStorageConfig?.type === "vercel-kv" || !explicitBackend && getEnv("KV_REST_API_URL")) {
     throw new TaskStoreNotSupportedError(
       "Vercel KV is not supported for task stores (pub/sub required). Use Redis or Upstash."
     );
@@ -8726,11 +8825,8 @@ import {
 } from "@frontmcp/protocol";
 import { awaitOutsideRequest } from "@frontmcp/utils";
 function hasMcpAppsExtension(capabilities) {
-  if (!capabilities?.experimental) {
-    return false;
-  }
-  const uiExtension = capabilities.experimental[MCP_APPS_EXTENSION_KEY];
-  return uiExtension !== void 0 && uiExtension !== null;
+  const declared = capabilities?.experimental?.[MCP_APPS_EXTENSION_KEY] ?? capabilities?.extensions?.[MCP_APPS_EXTENSION_KEY];
+  return declared !== void 0 && declared !== null;
 }
 function detectPlatformFromCapabilities(capabilities) {
   if (hasMcpAppsExtension(capabilities)) {
@@ -11337,6 +11433,8 @@ var init_ui_shared = __esm({
       widgets = /* @__PURE__ */ new Map();
       manifests = /* @__PURE__ */ new Map();
       resourceMeta = /* @__PURE__ */ new Map();
+      uiTools = /* @__PURE__ */ new Set();
+      customUris = /* @__PURE__ */ new Map();
       resolver;
       options;
       constructor(resolver, options = {}) {
@@ -11351,6 +11449,28 @@ var init_ui_shared = __esm({
           logger: this.options.logger
         };
       }
+      /**
+       * Record that `toolName` has a UI, and the custom `ui.resourceUri` it advertises (if any).
+       * `tools/list` advertises that URI verbatim, so `resources/read` must resolve it back to the
+       * tool; and only registered tools may be served a placeholder widget.
+       */
+      registerTool(toolName, resourceUri) {
+        this.uiTools.add(toolName);
+        if (resourceUri) this.customUris.set(resourceUri, toolName);
+      }
+      /** The tool that advertised `uri` as its custom `ui.resourceUri`. */
+      resolveCustomUri(uri) {
+        return this.customUris.get(uri);
+      }
+      /**
+       * Whether `name` (or its app-qualified form `app:name`) is a tool with a UI.
+       */
+      hasTool(name44) {
+        const known = (n) => this.uiTools.has(n) || this.widgets.has(n) || this.resourceMeta.has(n);
+        if (known(name44)) return true;
+        const sep = name44.indexOf(":");
+        return sep > 0 && known(name44.slice(sep + 1));
+      }
       getStaticWidget(name44) {
         return this.widgets.get(name44);
       }
@@ -11379,8 +11499,9 @@ var init_ui_shared = __esm({
         const output = options["output"] ?? {};
         const uiConfig = options["uiConfig"];
         const resourceMode = uiConfig?.["resourceMode"] ?? options["resourceMode"];
-        if (!toolName || !template) return;
+        if (!toolName) return;
         this.updateResourceMetaFromConfig(toolName, uiConfig);
+        if (!template) return;
         const result = renderToolTemplate({
           toolName,
           input,
@@ -11389,6 +11510,7 @@ var init_ui_shared = __esm({
           resolver: this.resolver,
           resourceMode,
           sizing: extractSizing(uiConfig),
+          csp: uiConfig?.["csp"],
           ...this.stringResultOptions(uiConfig)
         });
         this.widgets.set(toolName, result.html);
@@ -11467,6 +11589,7 @@ var init_ui_shared = __esm({
           resolver: this.resolver,
           resourceMode,
           sizing: extractSizing(uiConfig),
+          csp: uiConfig?.["csp"],
           ...this.stringResultOptions(uiConfig)
         });
         return { meta: result.meta };
@@ -11519,26 +11642,14 @@ function handleUIResourceRead(uri, registry, platformType) {
     return { handled: false };
   }
   const mimeType = getUIResourceMimeType(platformType);
-  const widgetParsed = parseWidgetUri(uri);
+  const customTool = registry.resolveCustomUri(uri);
+  const widgetParsed = customTool ? { toolName: customTool } : parseWidgetUri(uri);
   if (widgetParsed) {
-    const resourceMeta = buildResourceMetaForWidget(registry, widgetParsed.toolName);
-    const cachedWidget = registry.getStaticWidget(widgetParsed.toolName);
-    if (cachedWidget) {
-      return {
-        handled: true,
-        result: {
-          contents: [
-            {
-              uri,
-              mimeType,
-              text: cachedWidget,
-              ...resourceMeta ? { _meta: resourceMeta } : {}
-            }
-          ]
-        }
-      };
+    if (!registry.hasTool(widgetParsed.toolName)) {
+      return { handled: true, error: `No UI widget is registered for ${uri}` };
     }
-    const html = generatePlaceholderWidget(widgetParsed.toolName);
+    const resourceMeta = buildResourceMetaForWidget(registry, widgetParsed.toolName);
+    const html = registry.getStaticWidget(widgetParsed.toolName) ?? generatePlaceholderWidget(widgetParsed.toolName);
     return {
       handled: true,
       result: {
@@ -12108,6 +12219,7 @@ var DirectClientImpl;
 var init_direct_client = __esm({
   "libs/sdk/src/direct/direct-client.ts"() {
     "use strict";
+    init_list_all_pages_utils();
     init_errors();
     init_skills_mcp_types();
     init_llm_platform();
@@ -12254,8 +12366,11 @@ var init_direct_client = __esm({
       // Tool Operations (platform-formatted)
       // ─────────────────────────────────────────────────────────────────────────────
       async listTools() {
-        const result = await this.mcpClient.listTools();
-        return formatToolsForPlatform(result.tools, this.platform);
+        const tools = await listAllPages("tools/list", async (cursor) => {
+          const result = await this.mcpClient.listTools(cursor ? { cursor } : void 0);
+          return { items: result.tools, nextCursor: result.nextCursor };
+        });
+        return formatToolsForPlatform(tools, this.platform);
       }
       async callTool(name44, args) {
         const result = await this.mcpClient.callTool({
@@ -12268,19 +12383,34 @@ var init_direct_client = __esm({
       // Resource Operations (raw format)
       // ─────────────────────────────────────────────────────────────────────────────
       async listResources() {
-        return this.mcpClient.listResources();
+        const resources = await listAllPages("resources/list", async (cursor) => {
+          const result = await this.mcpClient.listResources(cursor ? { cursor } : void 0);
+          return { items: result.resources, nextCursor: result.nextCursor };
+        });
+        return { resources };
       }
       async readResource(uri) {
         return this.mcpClient.readResource({ uri });
       }
       async listResourceTemplates() {
-        return this.mcpClient.listResourceTemplates();
+        const resourceTemplates = await listAllPages(
+          "resources/templates/list",
+          async (cursor) => {
+            const result = await this.mcpClient.listResourceTemplates(cursor ? { cursor } : void 0);
+            return { items: result.resourceTemplates, nextCursor: result.nextCursor };
+          }
+        );
+        return { resourceTemplates };
       }
       // ─────────────────────────────────────────────────────────────────────────────
       // Prompt Operations (raw format)
       // ─────────────────────────────────────────────────────────────────────────────
       async listPrompts() {
-        return this.mcpClient.listPrompts();
+        const prompts = await listAllPages("prompts/list", async (cursor) => {
+          const result = await this.mcpClient.listPrompts(cursor ? { cursor } : void 0);
+          return { items: result.prompts, nextCursor: result.nextCursor };
+        });
+        return { prompts };
       }
       async getPrompt(name44, args) {
         return this.mcpClient.getPrompt({
@@ -13008,8 +13138,8 @@ function createRemoteAppProbe(appId, provider) {
     name: `remote:${appId}`,
     async check() {
       const result = provider.getHealthStatus(appId);
-      if (!result) {
-        return { status: "unhealthy", error: "No health check result available" };
+      if (!result || result.status === "unknown" && result.consecutiveFailures === 0) {
+        return { status: "degraded", details: { state: "unknown" } };
       }
       return {
         status: result.status === "healthy" ? "healthy" : result.status === "degraded" ? "degraded" : "unhealthy",
@@ -14122,6 +14252,12 @@ var init_frontmcp_context = __esm({
       // =====================
       /** Request metadata (headers, user-agent, etc.) */
       metadata;
+      /**
+       * The hosting platform's bindings object for this request: a Cloudflare Worker's `env`
+       * (KV namespaces, D1 databases, R2 buckets, Durable Objects, `[vars]`, secrets).
+       * `undefined` on Node, where bindings do not exist.
+       */
+      platformEnv;
       // =====================
       // Auth (mutable, progressively populated)
       // =====================
@@ -14157,6 +14293,7 @@ var init_frontmcp_context = __esm({
         this.traceContext = args.traceContext ?? generateTraceContext();
         this.timestamp = args.timestamp ?? Date.now();
         this._authInfo = args.authInfo ?? {};
+        this.platformEnv = args.platformEnv;
         this.config = {
           forwardCallerTokenTo: toOrigins(args.config?.forwardCallerTokenTo),
           forwardCustomHeadersTo: toOrigins(args.config?.forwardCustomHeadersTo),
@@ -14858,6 +14995,7 @@ var init_frontmcp_context_storage = __esm({
     "use strict";
     init_decorators();
     init_metadata();
+    init_tokens();
     init_mcp_error();
     init_frontmcp_context();
     init_metadata_utils();
@@ -14925,7 +15063,12 @@ var init_frontmcp_context_storage = __esm({
         const headers = request.headers ?? {};
         const headerSessionId = typeof headers["mcp-session-id"] === "string" ? headers["mcp-session-id"].trim() : "";
         const sessionId = headerSessionId.length > 0 ? headerSessionId : `anon:${randomUUID9()}`;
-        return this.runFromHeaders(headers, { sessionId, scopeId, peerAddress: request.socket?.remoteAddress }, fn);
+        const platformEnv = request[ServerRequestTokens.webEnv];
+        return this.runFromHeaders(
+          headers,
+          { sessionId, scopeId, peerAddress: request.socket?.remoteAddress, platformEnv },
+          fn
+        );
       }
       withServerConfig(args) {
         return { ...args, config: { ...this.contextConfig, ...args.config } };
@@ -21987,6 +22130,14 @@ import {
   isDevelopment as isDevelopment2,
   randomUUID as randomUUID11
 } from "@frontmcp/utils";
+function declaredOutput(tool, output) {
+  if (!tool?.outputSchema || typeof output !== "object" || output === null || Array.isArray(output)) return output;
+  if (Array.isArray(output["content"])) return output;
+  const parsed = tool.safeParseOutput(output);
+  if (!parsed.success) return output;
+  const structured = parsed.data.structuredContent;
+  return typeof structured === "object" && structured !== null && !Array.isArray(structured) ? structured : output;
+}
 function toolNameCandidates(name44) {
   if (!/[-_]/.test(name44)) return [name44];
   return [name44, name44.includes("_") ? name44.replace(/_/g, "-") : name44.replace(/-/g, "_")];
@@ -22056,6 +22207,9 @@ var init_call_tool_flow = __esm({
       uiResult: z57.any().optional(),
       // UI metadata from rendering (merged into _meta)
       uiMeta: z57.record(z57.string(), z57.unknown()).optional(),
+      // Metadata hooks add to the result (e.g. the cache plugin's `cache: 'hit'`), merged into the
+      // result's _meta; never merged into rawOutput, which is the tool's data
+      resultMeta: z57.record(z57.string(), z57.unknown()).optional(),
       // Progress token from request's _meta (for progress notifications)
       progressToken: z57.union([z57.string(), z57.number()]).optional(),
       // JSON-RPC request ID (for elicitation routing)
@@ -22711,7 +22865,7 @@ ${JSON.stringify(error.schema, null, 2)}
             this.logger.verbose("execute:done (elicitation fire-and-forget fallback)");
             return;
           }
-          if (isClientFacingError(error)) throw error;
+          if (isClientFacingError(error) || error instanceof InvalidOutputError) throw error;
           throw new ToolExecutionError(
             this.state.tool?.metadata.name || "unknown",
             error instanceof Error ? error : void 0
@@ -22754,7 +22908,8 @@ ${JSON.stringify(error.schema, null, 2)}
       }
       async applyUI() {
         this.logger.verbose("applyUI:start");
-        const { tool, rawOutput, input } = this.state;
+        const { tool, rawOutput: executeOutput, input } = this.state;
+        const rawOutput = declaredOutput(tool, executeOutput);
         const ctx = this.input.ctx;
         if (ctx?._skipUI) {
           this.logger.verbose("applyUI:skip (agent context - structured data only)");
@@ -22883,7 +23038,7 @@ ${JSON.stringify(error.schema, null, 2)}
       }
       async finalize() {
         this.logger.verbose("finalize:start");
-        const { tool, rawOutput, uiResult, uiMeta } = this.state;
+        const { tool, rawOutput, uiResult, uiMeta, resultMeta } = this.state;
         if (!tool) {
           this.logger.verbose("finalize: skipping (no tool in state)");
           return;
@@ -22926,6 +23081,9 @@ ${JSON.stringify(error.schema, null, 2)}
         if (rawMeta) {
           result._meta = { ...result._meta, ...rawMeta };
         }
+        if (resultMeta) {
+          result._meta = { ...result._meta, ...resultMeta };
+        }
         if (uiResult) {
           result.content = uiResult.content;
           if (uiResult.structuredContent !== void 0 && uiResult.structuredContent !== null) {
@@ -24376,6 +24534,38 @@ var init_context = __esm({
   }
 });
 
+// libs/sdk/src/errors/misconfiguration.ts
+function findMisconfiguration(error) {
+  let current = error;
+  for (let depth = 0; current instanceof Error && depth < 5; depth++) {
+    const code = current.code;
+    if (typeof code === "string" && Object.prototype.hasOwnProperty.call(MISCONFIGURATION_REMEDIES, code)) {
+      return { code, remedy: MISCONFIGURATION_REMEDIES[code] };
+    }
+    if (current.name === "ZodError") return { code: "CONFIG_INVALID", remedy: CONFIG_INVALID_REMEDY };
+    current = current.cause;
+  }
+  return void 0;
+}
+function misconfigurationBody(m) {
+  return { error: "server_misconfigured", code: m.code, message: m.remedy };
+}
+var MISCONFIGURATION_REMEDIES, CONFIG_INVALID_REMEDY;
+var init_misconfiguration = __esm({
+  "libs/sdk/src/errors/misconfiguration.ts"() {
+    "use strict";
+    MISCONFIGURATION_REMEDIES = {
+      SESSION_SECRET_REQUIRED: "Set MCP_SESSION_SECRET in the deployment environment (e.g. `wrangler secret put MCP_SESSION_SECRET` on Cloudflare, or the platform environment settings on Node, Vercel and Lambda). Session IDs are encrypted with it, and production refuses the development machine-id fallback.",
+      JWT_SECRET_INVALID: "JWT_SECRET is present but too weak: HS256 requires at least 32 bytes (RFC 7518). Replace it with `openssl rand -hex 32`.",
+      JWT_SECRET_REQUIRED: "Set JWT_SECRET in the deployment environment (e.g. `wrangler secret put JWT_SECRET`). Tokens are signed with it; production refuses the random per-process fallback because tokens would not survive a restart or verify across instances.",
+      // The startup checks: a server whose entries ask for protection nothing gives them does not start.
+      UNENFORCED_METADATA: "An entry declares a field only a plugin enforces (approval, featureFlag, ...) and no installed plugin that enforces it reaches the entry, so the server refuses to start. Install the plugin or remove the field; the server log names the entries.",
+      AUTH_CONFIGURATION_ERROR: "The auth or authorities configuration is invalid (for example, entries declare authorities and the server has no authorities option, or a rule checks nothing), so the server refuses to start. The server log names the entries."
+    };
+    CONFIG_INVALID_REMEDY = "The FrontMCP configuration failed validation, so the server refuses to start. The server log names the invalid fields.";
+  }
+});
+
 // libs/sdk/src/server/server.validation.ts
 import { base64Decode } from "@frontmcp/utils";
 function applyHeaders(res, headers) {
@@ -24687,6 +24877,7 @@ var init_flow_instance = __esm({
     init_common();
     init_context();
     init_errors();
+    init_misconfiguration();
     init_server_validation();
     init_flow_http_path();
     init_flow_stages();
@@ -24746,6 +24937,15 @@ var init_flow_instance = __esm({
                     return writeHttpResponse(response, e.output);
                 }
               }
+              const misconfiguration = findMisconfiguration(e);
+              if (misconfiguration) {
+                this.logger.error("Server misconfigured", { flow: this.name, code: misconfiguration.code });
+                return writeHttpResponse(response, {
+                  kind: "json",
+                  status: 500,
+                  body: misconfigurationBody(misconfiguration)
+                });
+              }
               if (e instanceof PublicMcpError) {
                 const challenge = e.wwwAuthenticate;
                 this.logger.warn("Public error in flow", {
@@ -25457,14 +25657,90 @@ function collectDynamicProviders(klass, options) {
   }
   return out;
 }
+function collectDynamicTools(klass, options) {
+  const chain = [];
+  for (let k = klass; k && k !== Function.prototype; k = Object.getPrototypeOf(k)) {
+    chain.push(k);
+  }
+  const out = [];
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const k = chain[i];
+    if (Object.prototype.hasOwnProperty.call(k, "dynamicTools") && typeof k.dynamicTools === "function") {
+      out.push(...k.dynamicTools(options) ?? []);
+    }
+  }
+  return out;
+}
+function pluginMetadataFromOptions(options, dynamicTools) {
+  const out = { ...options };
+  for (const key of LIST_METADATA_KEYS) {
+    if (key in out && !Array.isArray(out[key])) delete out[key];
+  }
+  const tools = [...out["tools"] ?? [], ...dynamicTools];
+  if (tools.length > 0) out["tools"] = tools;
+  return out;
+}
 function dedupePluginProviders(providers) {
   const map = /* @__PURE__ */ new Map();
   for (const p of providers) map.set(p["provide"] ?? p, p);
   return [...map.values()];
 }
+var LIST_METADATA_KEYS;
 var init_dynamic_utils = __esm({
   "libs/sdk/src/common/dynamic/dynamic.utils.ts"() {
     "use strict";
+    LIST_METADATA_KEYS = ["exports", "plugins", "adapters", "tools", "resources", "prompts", "skills"];
+  }
+});
+
+// libs/sdk/src/common/dynamic/dynamic.plugin.ts
+function isDynamicPluginClass(value) {
+  return typeof value === "function" && value.prototype instanceof DynamicPlugin;
+}
+function initOptionsOf(instance) {
+  return initOptionsByInstance.has(instance) ? { options: initOptionsByInstance.get(instance) } : void 0;
+}
+var initOptionsByInstance, DynamicPlugin;
+var init_dynamic_plugin = __esm({
+  "libs/sdk/src/common/dynamic/dynamic.plugin.ts"() {
+    "use strict";
+    init_transport_errors();
+    init_dynamic_utils();
+    initOptionsByInstance = /* @__PURE__ */ new WeakMap();
+    DynamicPlugin = class {
+      get(token) {
+        throw new MethodNotImplementedError("DynamicPlugin", "get");
+      }
+      /**
+       * Static init() method to create a plugin provider.
+       * @param options - Input options (with optional fields for defaults). Omitted, the plugin is
+       *   built with `{}`, as `ApprovalPlugin.init()` is documented.
+       */
+      static init(options = {}) {
+        const extraProviders = options.providers;
+        const typedOptions = options;
+        if ("useFactory" in options) {
+          return {
+            ...pluginMetadataFromOptions(typedOptions, []),
+            provide: this,
+            inject: options.inject,
+            useFactory: options.useFactory,
+            providers: dedupePluginProviders(extraProviders ?? [])
+          };
+        }
+        const dyn = collectDynamicProviders(this, typedOptions);
+        const mergedProviders = dedupePluginProviders([...dyn ?? [], ...extraProviders ?? []]);
+        const dynamicTools = collectDynamicTools(this, typedOptions);
+        const instance = new this(options);
+        initOptionsByInstance.set(instance, options);
+        return {
+          ...pluginMetadataFromOptions(typedOptions, dynamicTools),
+          provide: this,
+          useValue: instance,
+          providers: mergedProviders
+        };
+      }
+    };
   }
 });
 
@@ -25720,9 +25996,18 @@ var init_execution_context_interface = __esm({
         if (this._authContext) return this._authContext;
         const rawAuth = __require("@frontmcp/auth");
         const auth = rawAuth.default ?? rawAuth;
-        this._authContext = auth.buildAuthContext(this._authInfo, this.scope.metadata.authorities?.claimsMapping);
+        this._authContext = auth.buildAuthContext(this.resolveAuthSource(), this.scope.metadata.authorities?.claimsMapping);
         return this._authContext;
       }
+      resolveAuthSource() {
+        const fromContext = this.tryGetContext()?.authInfo;
+        if (!fromContext) return this._authInfo;
+        const merged = { ...this._authInfo };
+        for (const [key, value] of Object.entries(fromContext)) {
+          if (value !== void 0) merged[key] = value;
+        }
+        return merged;
+      }
       /**
        * Try to get the context, returning undefined if not available.
        *
@@ -25908,6 +26193,23 @@ var init_execution_context_interface = __esm({
       get config() {
         return this.providers.get(ConfigService);
       }
+      // ---- Platform bindings ----
+      /**
+       * The hosting platform's bindings for the current request — on a Cloudflare Worker, the `env`
+       * object holding KV namespaces, D1 databases, R2 buckets, Durable Object namespaces, `[vars]`
+       * and secrets. `undefined` on Node/Express, where no such object exists.
+       *
+       * Only string bindings are mirrored into `process.env`; use this for the rest.
+       *
+       * @example
+       * ```typescript
+       * const kv = this.workerEnv?.['MY_KV'] as KVNamespace | undefined;
+       * ```
+       */
+      get workerEnv() {
+        const env = this.tryGetContext()?.platformEnv;
+        return env !== null && typeof env === "object" ? env : void 0;
+      }
       // ---- Runtime context helpers ----
       /**
        * Get the current runtime context (platform, runtime, deployment, env).
@@ -28955,12 +29257,13 @@ var init_plugin_utils = __esm({
 // libs/sdk/src/plugin/plugin.registry.ts
 import "reflect-metadata";
 import { tokenName as tokenName11 } from "@frontmcp/di";
-var PluginRegistry;
+var installedPluginValues, PluginRegistry;
 var init_plugin_registry = __esm({
   "libs/sdk/src/plugin/plugin.registry.ts"() {
     "use strict";
     init_adapter_registry();
     init_common();
+    init_dynamic_plugin();
     init_dynamic_utils();
     init_context_extension();
     init_errors();
@@ -28973,6 +29276,7 @@ var init_plugin_registry = __esm({
     init_skill_registry();
     init_tool_registry();
     init_plugin_utils();
+    installedPluginValues = /* @__PURE__ */ new WeakSet();
     PluginRegistry = class _PluginRegistry extends RegistryAbstract {
       /** providers by token */
       pProviders = /* @__PURE__ */ new Map();
@@ -29161,8 +29465,15 @@ var init_plugin_registry = __esm({
               pluginInstance: new rec.provide(...depsInstances),
               dynamicProviders: rec.providers
             };
-          case "VALUE" /* VALUE */:
-            return { pluginInstance: rec.useValue, dynamicProviders: rec.providers };
+          case "VALUE" /* VALUE */: {
+            const value = rec.useValue;
+            const init = installedPluginValues.has(value) ? initOptionsOf(value) : void 0;
+            installedPluginValues.add(value);
+            if (init && isDynamicPluginClass(rec.provide)) {
+              return { pluginInstance: new rec.provide(init.options), dynamicProviders: rec.providers };
+            }
+            return { pluginInstance: value, dynamicProviders: rec.providers };
+          }
           case "FACTORY" /* FACTORY */: {
             const args = [];
             for (const d of rec.inject()) args.push(await this.providers.resolveBootstrapDep(d));
@@ -30705,6 +31016,9 @@ import { AuthorityDeniedError as AuthorityDeniedError7, resolveRequiredScopes as
 import { ExecutionTimeoutError as ExecutionTimeoutError2, withTimeout as withTimeout2 } from "@frontmcp/guard";
 import { z as z60 } from "@frontmcp/lazy-zod";
 import { CallToolRequestSchema as CallToolRequestSchema3, CallToolResultSchema as CallToolResultSchema3 } from "@frontmcp/protocol";
+function invalidOutputFrom(outputError) {
+  return outputError instanceof InvalidOutputError ? outputError : new InvalidOutputError();
+}
 var inputSchema15, outputSchema14, stateSchema14, plan14, name14, Stage14, CallAgentFlow;
 var init_call_agent_flow = __esm({
   "libs/sdk/src/agent/flows/call-agent.flow.ts"() {
@@ -31087,7 +31401,7 @@ var init_call_agent_flow = __esm({
         const { agent, agentContext, executionStartedAt, executionError, outputError, authInfo } = this.state;
         if (!agent || executionStartedAt === void 0) return;
         if (executionError instanceof ElicitationFallbackRequired || executionError instanceof FlowControl) return;
-        const failure = executionError ?? (outputError !== void 0 ? new InvalidOutputError() : void 0);
+        const failure = executionError ?? (outputError !== void 0 ? invalidOutputFrom(outputError) : void 0);
         const failed = failure !== void 0;
         const requestId = this.tryGetContext()?.requestId;
         const sessionId = typeof authInfo?.sessionId === "string" && authInfo.sessionId ? authInfo.sessionId : void 0;
@@ -31117,7 +31431,7 @@ var init_call_agent_flow = __esm({
             agent: agent.metadata.name,
             errors: outputError
           });
-          throw new InvalidOutputError();
+          throw invalidOutputFrom(outputError);
         }
         const result = parsedOutput;
         if (executionMeta) {
@@ -31697,13 +32011,46 @@ var init_request_validation = __esm({
 });
 
 // libs/sdk/src/transport/mcp-20260728/request-state.ts
-import { base64urlDecode as base64urlDecode2, base64urlEncode as base64urlEncode2, hmacSha256, randomBytes as randomBytes3, sha256Hex as sha256Hex5, timingSafeEqual } from "@frontmcp/utils";
-function getRequestStateKey() {
+import {
+  base64urlDecode as base64urlDecode2,
+  base64urlEncode as base64urlEncode2,
+  getEnv as getEnv4,
+  hmacSha256,
+  isProduction as isProduction4,
+  randomBytes as randomBytes3,
+  sha256Hex as sha256Hex5,
+  timingSafeEqual
+} from "@frontmcp/utils";
+function configuredSecret(name44) {
+  const value = getEnv4(name44);
+  return value && value.trim().length > 0 ? value : void 0;
+}
+function resolveKey() {
   if (cachedKey) return cachedKey;
-  const secret = process.env["VAULT_SECRET"] ?? process.env["JWT_SECRET"];
-  cachedKey = secret ? encoder.encode(secret) : randomBytes3(32);
+  const vault = configuredSecret("VAULT_SECRET");
+  const jwt = vault ? void 0 : configuredSecret("JWT_SECRET");
+  if (vault) cachedKey = { key: encoder.encode(vault), source: "VAULT_SECRET" };
+  else if (jwt) cachedKey = { key: encoder.encode(jwt), source: "JWT_SECRET" };
+  else cachedKey = { key: randomBytes3(32), source: "per-process" };
   return cachedKey;
 }
+function getRequestStateKey() {
+  return resolveKey().key;
+}
+function getRequestStateKeySource() {
+  return resolveKey().source;
+}
+function warnIfRequestStateKeyNotShared(options) {
+  if (warnedKeyNotShared || !isProduction4()) return;
+  const { metadata } = options;
+  const persistence = metadata.transport?.persistence;
+  const sharesState = Boolean(metadata.redis) || typeof persistence === "object" && persistence !== null;
+  if (!sharesState || getRequestStateKeySource() !== "per-process") return;
+  warnedKeyNotShared = true;
+  options.logger.warn(
+    "requestState is signed with a per-process key (neither VAULT_SECRET nor JWT_SECRET is set). Multi-round tools (elicit/sample) restart when a round lands on another instance; set VAULT_SECRET (or JWT_SECRET) to the same value on every instance."
+  );
+}
 function computeRequestBinding(method, params) {
   const salient = {};
   for (const key of ["name", "uri", "arguments"]) {
@@ -31753,12 +32100,13 @@ function decodeRequestState(state, expected) {
   if (payload.b !== expected.binding) return { ok: false, reason: "request-mismatch" };
   return { ok: true, responses: payload.r };
 }
-var DEFAULT_REQUEST_STATE_TTL_MS, MAX_REQUEST_STATE_BYTES, cachedKey, encoder, decoder;
+var DEFAULT_REQUEST_STATE_TTL_MS, MAX_REQUEST_STATE_BYTES, cachedKey, warnedKeyNotShared, encoder, decoder;
 var init_request_state = __esm({
   "libs/sdk/src/transport/mcp-20260728/request-state.ts"() {
     "use strict";
     DEFAULT_REQUEST_STATE_TTL_MS = 10 * 60 * 1e3;
     MAX_REQUEST_STATE_BYTES = 256 * 1024;
+    warnedKeyNotShared = false;
     encoder = new TextEncoder();
     decoder = new TextDecoder();
   }
@@ -32486,7 +32834,8 @@ async function dispatch20260728(options) {
   };
   const carried = decodeRequestState(params["requestState"], binding);
   if (!carried.ok && carried.reason !== "absent") {
-    scope.logger.warn("mcp-20260728: rejected requestState", { method, reason: carried.reason });
+    const hint = carried.reason === "bad-signature" && getRequestStateKeySource() === "per-process" ? "requestState is signed with a per-process key; set VAULT_SECRET (or JWT_SECRET) to the same value on every instance so a round can land on any of them" : void 0;
+    scope.logger.warn("mcp-20260728: rejected requestState", { method, reason: carried.reason, ...hint && { hint } });
   }
   const exchange = new MrtrExchange({
     inputResponses: params["inputResponses"],
@@ -32640,6 +32989,7 @@ var McpStatelessError, DEFAULT_CLIENT_INFO, McpStatelessClient, TASKS_CLIENT_CAP
 var init_mcp_stateless_client = __esm({
   "libs/sdk/src/transport/mcp-20260728/client/mcp-stateless.client.ts"() {
     "use strict";
+    init_list_all_pages_utils();
     init_header_codec();
     init_protocol_20260728_constants();
     init_tasks_extension();
@@ -32680,10 +33030,22 @@ var init_mcp_stateless_client = __esm({
        * The spec requires this: one malformed tool definition must not prevent the
        * other tools from being used, so the offender is excluded and logged rather
        * than failing the call.
+       *
+       * Every page is fetched (`nextCursor` is followed to the end), since the
+       * schemas cached here are what later `tools/call` headers are derived from.
        */
       async listTools() {
-        const result = await this.request("tools/list");
-        const tools = Array.isArray(result["tools"]) ? result["tools"] : [];
+        const tools = await listAllPages(
+          "tools/list",
+          async (cursor) => {
+            const result = await this.request("tools/list", cursor ? { cursor } : {});
+            return {
+              items: Array.isArray(result["tools"]) ? result["tools"] : [],
+              nextCursor: typeof result["nextCursor"] === "string" ? result["nextCursor"] : void 0
+            };
+          },
+          (message) => new McpStatelessError(-32603, message)
+        );
         const usable = [];
         for (const tool of tools) {
           const validation = validateHeaderParams(tool["inputSchema"]);
@@ -32702,11 +33064,17 @@ var init_mcp_stateless_client = __esm({
       async readResource(uri) {
         return this.request("resources/read", { uri });
       }
-      async listResources() {
-        return this.request("resources/list");
+      /** One page of `resources/list`; pass the previous page's `nextCursor` for the next. */
+      async listResources(cursor) {
+        return this.request("resources/list", cursor ? { cursor } : {});
       }
-      async listPrompts() {
-        return this.request("prompts/list");
+      /** One page of `resources/templates/list`; pass the previous page's `nextCursor` for the next. */
+      async listResourceTemplates(cursor) {
+        return this.request("resources/templates/list", cursor ? { cursor } : {});
+      }
+      /** One page of `prompts/list`; pass the previous page's `nextCursor` for the next. */
+      async listPrompts(cursor) {
+        return this.request("prompts/list", cursor ? { cursor } : {});
       }
       async getPrompt(name44, args = {}) {
         return this.request("prompts/get", { name: name44, arguments: args });
@@ -32992,6 +33360,10 @@ var init_mcp_20260728 = __esm({
 });
 
 // libs/sdk/src/remote-mcp/mcp-stateless-client.adapter.ts
+function nextCursorOf(result) {
+  const next = result["nextCursor"];
+  return typeof next === "string" && next.length > 0 ? { nextCursor: next } : {};
+}
 async function negotiateRemoteProtocol(url, configured, headers, fetchImpl = fetch) {
   if (configured === "2026-07-28") return "2026-07-28";
   if (configured !== "auto") return "legacy";
@@ -33034,16 +33406,29 @@ var init_mcp_stateless_client_adapter = __esm({
       async callTool(params) {
         return this.client.callTool(params.name, params.arguments ?? {});
       }
-      async listResources() {
-        const result = await this.client.listResources();
-        return { resources: Array.isArray(result["resources"]) ? result["resources"] : [] };
+      async listResources(params) {
+        const result = await this.client.listResources(params?.cursor);
+        return {
+          resources: Array.isArray(result["resources"]) ? result["resources"] : [],
+          ...nextCursorOf(result)
+        };
+      }
+      async listResourceTemplates(params) {
+        const result = await this.client.listResourceTemplates(params?.cursor);
+        return {
+          resourceTemplates: Array.isArray(result["resourceTemplates"]) ? result["resourceTemplates"] : [],
+          ...nextCursorOf(result)
+        };
       }
       async readResource(params) {
         return this.client.readResource(params.uri);
       }
-      async listPrompts() {
-        const result = await this.client.listPrompts();
-        return { prompts: Array.isArray(result["prompts"]) ? result["prompts"] : [] };
+      async listPrompts(params) {
+        const result = await this.client.listPrompts(params?.cursor);
+        return {
+          prompts: Array.isArray(result["prompts"]) ? result["prompts"] : [],
+          ...nextCursorOf(result)
+        };
       }
       async getPrompt(params) {
         return this.client.getPrompt(params.name, params.arguments ?? {});
@@ -33402,7 +33787,7 @@ var init_health_check = __esm({
           this.consecutiveSuccesses++;
           this.consecutiveFailures = 0;
           const previousStatus = this.status;
-          if (this.consecutiveSuccesses >= this.options.healthyThreshold) {
+          if (previousStatus === "unknown" || this.consecutiveSuccesses >= this.options.healthyThreshold) {
             this.status = latencyMs > this.options.degradedLatencyMs ? "degraded" : "healthy";
           }
           this.lastResult = {
@@ -33570,6 +33955,7 @@ var DEFAULT_RETRY_OPTIONS2, DEFAULT_CIRCUIT_BREAKER_OPTIONS, DEFAULT_HEALTH_CHEC
 var init_mcp_client_service = __esm({
   "libs/sdk/src/remote-mcp/mcp-client.service.ts"() {
     "use strict";
+    init_list_all_pages_utils();
     init_mcp_error();
     init_remote_errors();
     init_transport_errors();
@@ -34173,10 +34559,15 @@ var init_mcp_client_service = __esm({
         const httpOptions = request.transportOptions;
         return httpOptions?.fallbackToSSE ?? true;
       }
+      // Each list follows `nextCursor` to the end: a FrontMCP remote pages its lists
+      // (40 per page by default), and proxying only the first page silently dropped
+      // everything after it.
       async listToolsInternal(connection) {
         try {
-          const result = await connection.client.listTools();
-          return result.tools || [];
+          return await listAllPages("tools/list", async (cursor) => {
+            const result = await connection.client.listTools(cursor ? { cursor } : void 0);
+            return { items: result.tools, nextCursor: result.nextCursor };
+          });
         } catch (error) {
           this.logger.warn(`Failed to list tools: ${error.message}`);
           return [];
@@ -34184,8 +34575,10 @@ var init_mcp_client_service = __esm({
       }
       async listResourcesInternal(connection) {
         try {
-          const result = await connection.client.listResources();
-          return result.resources || [];
+          return await listAllPages("resources/list", async (cursor) => {
+            const result = await connection.client.listResources(cursor ? { cursor } : void 0);
+            return { items: result.resources, nextCursor: result.nextCursor };
+          });
         } catch (error) {
           this.logger.warn(`Failed to list resources: ${error.message}`);
           return [];
@@ -34193,8 +34586,10 @@ var init_mcp_client_service = __esm({
       }
       async listResourceTemplatesInternal(connection) {
         try {
-          const result = await connection.client.listResourceTemplates();
-          return result.resourceTemplates || [];
+          return await listAllPages("resources/templates/list", async (cursor) => {
+            const result = await connection.client.listResourceTemplates(cursor ? { cursor } : void 0);
+            return { items: result.resourceTemplates, nextCursor: result.nextCursor };
+          });
         } catch (error) {
           this.logger.warn(`Failed to list resource templates: ${error.message}`);
           return [];
@@ -34202,8 +34597,10 @@ var init_mcp_client_service = __esm({
       }
       async listPromptsInternal(connection) {
         try {
-          const result = await connection.client.listPrompts();
-          return result.prompts || [];
+          return await listAllPages("prompts/list", async (cursor) => {
+            const result = await connection.client.listPrompts(cursor ? { cursor } : void 0);
+            return { items: result.prompts, nextCursor: result.nextCursor };
+          });
         } catch (error) {
           this.logger.warn(`Failed to list prompts: ${error.message}`);
           return [];
@@ -41748,8 +42145,11 @@ var init_session_verify_flow = __esm({
         const machineId = getMachineId2();
         const authSignature = subject ? `${authMode}:${subject}` : authMode;
         if (sessionIdHeader) {
-          const existingPayload = decryptPublicSession(sessionIdHeader, authSignature);
-          if (existingPayload && existingPayload.nodeId === machineId) {
+          const body = this.rawInput.request.body;
+          const isInitialize2 = typeof body === "object" && body !== null && "method" in body && body.method === "initialize";
+          const decrypted = decryptPublicSession(sessionIdHeader, authSignature);
+          const existingPayload = decrypted && isInitialize2 && decrypted.nodeId !== machineId ? void 0 : decrypted;
+          if (existingPayload) {
             const anonId = existingPayload.uuid ?? `${existingPayload.iat * 1e3}`;
             const user2 = anonymousCallerClaims(options, anonId);
             this.respond({
@@ -42209,7 +42609,7 @@ var init_well_known_jwks_flow = __esm({
 import "reflect-metadata";
 import { advertisedScopes } from "@frontmcp/auth";
 import { z as z74 } from "@frontmcp/lazy-zod";
-import { isProduction as isProduction4 } from "@frontmcp/utils";
+import { isProduction as isProduction5 } from "@frontmcp/utils";
 function resolveDcrEnabled(auth) {
   if (auth && isLocalMode(auth)) {
     const dcr = auth.dcr;
@@ -42217,7 +42617,7 @@ function resolveDcrEnabled(auth) {
       return dcr.enabled;
     }
   }
-  return !isProduction4();
+  return !isProduction5();
 }
 var inputSchema25, AuthServerMetadataSchema, outputSchema23, wellKnownAsStateSchema, wellKnownAsPlan, name24, Stage24, WellKnownAsFlow;
 var init_well_known_oauth_authorization_server_flow = __esm({
@@ -42619,8 +43019,8 @@ import {
   verifyPkce
 } from "@frontmcp/auth";
 import {
-  getEnv as getEnv4,
-  isProduction as isProduction5,
+  getEnv as getEnv5,
+  isProduction as isProduction6,
   MemoryStorageAdapter,
   randomBytes as randomBytes8,
   randomUUID as randomUUID21,
@@ -42716,26 +43116,28 @@ var init_instance_local_primary_auth = __esm({
         this.providers = providers;
         this.logger = this.providers.getActiveScope().logger.child("LocalPrimaryAuth");
         this.port = this.providers.getActiveScope().metadata.http?.port ?? 3001;
-        this.host = getEnv4("FRONTMCP_PUBLIC_HOST")?.trim() || "localhost";
+        this.host = getEnv5("FRONTMCP_PUBLIC_HOST")?.trim() || "localhost";
         this.issuer = this.deriveIssuer(options);
-        this.publicHostPinned = !!getEnv4("FRONTMCP_PUBLIC_HOST")?.trim();
-        const jwtSecret = getEnv4("JWT_SECRET");
+        this.publicHostPinned = !!getEnv5("FRONTMCP_PUBLIC_HOST")?.trim();
+        const jwtSecret = getEnv5("JWT_SECRET");
         const hasJwtSecret = !!jwtSecret?.trim();
         if (hasJwtSecret && jwtSecret) {
           const encoded = new TextEncoder().encode(jwtSecret);
           if (encoded.length < MIN_HS256_SECRET_BYTES) {
-            if (isProduction5()) throw new JwtSecretWeakError(encoded.length);
+            if (isProduction6()) throw new JwtSecretWeakError(encoded.length);
             this.logger.warn(
               `JWT_SECRET is ${encoded.length} bytes; HS256 wants at least ${MIN_HS256_SECRET_BYTES} (RFC 7518). This is refused in production \u2014 generate one with \`openssl rand -hex 32\`.`
             );
           }
           this.secret = encoded;
-        } else if (isProduction5() && isOrchestratedMode(options)) {
+        } else if (isProduction6() && isOrchestratedMode(options)) {
           throw new JwtSecretRequiredError(options.mode);
         } else {
-          this.logger.warn(
-            "JWT_SECRET is not set; signing with a random per-process secret. Tokens will not survive a restart and will not verify across instances. Set JWT_SECRET for any deployment that mints tokens."
-          );
+          if (!isPublicMode(options)) {
+            this.logger.warn(
+              "JWT_SECRET is not set; signing with a random per-process secret. Tokens will not survive a restart and will not verify across instances. Set JWT_SECRET for any deployment that mints tokens."
+            );
+          }
           this.secret = getDefaultNoAuthSecret();
         }
         this.tokenStorage = this.readTokenStorage(options);
@@ -42874,7 +43276,7 @@ var init_instance_local_primary_auth = __esm({
         if (dcr && typeof dcr.enabled === "boolean") {
           return dcr.enabled;
         }
-        return !isProduction5();
+        return !isProduction6();
       }
       /** Provider configurations (indexed by provider ID) */
       providerConfigs = /* @__PURE__ */ new Map();
@@ -43103,7 +43505,7 @@ var init_instance_local_primary_auth = __esm({
           await memory.connect();
           storage = memory;
         }
-        const pepper = getEnv4("VAULT_SECRET") ?? getEnv4("JWT_SECRET") ?? void 0;
+        const pepper = getEnv5("VAULT_SECRET") ?? getEnv5("JWT_SECRET") ?? void 0;
         this.credentialVaultImpl = new SessionCredentialVault({
           storage,
           pepper,
@@ -43154,7 +43556,7 @@ var init_instance_local_primary_auth = __esm({
         }
         const config = this.readSecureStoreConfig();
         const reuseAdapter = this.storageAdapter && this.secureStoreSharesTokenStorage(config) ? this.storageAdapter : void 0;
-        const pepper = getEnv4("VAULT_SECRET") ?? getEnv4("JWT_SECRET") ?? new TextDecoder().decode(this.secret);
+        const pepper = getEnv5("VAULT_SECRET") ?? getEnv5("JWT_SECRET") ?? new TextDecoder().decode(this.secret);
         const resolved = await createSecureStore({
           config,
           pepper,
@@ -46231,10 +46633,10 @@ import {
   randomBytes as randomBytes9,
   base64urlEncode as base64urlEncode6,
   base64urlDecode as base64urlDecode3,
-  getEnv as getEnv5
+  getEnv as getEnv6
 } from "@frontmcp/utils";
 function getElicitationSecret() {
-  return getEnv5("MCP_ELICITATION_SECRET") || getEnv5("MCP_SESSION_SECRET") || getEnv5("MCP_SERVER_SECRET") || null;
+  return getEnv6("MCP_ELICITATION_SECRET") || getEnv6("MCP_SESSION_SECRET") || getEnv6("MCP_SERVER_SECRET") || null;
 }
 function isElicitationEncryptionAvailable() {
   return getElicitationSecret() !== null;
@@ -46711,12 +47113,19 @@ var init_encrypted_elicitation_store = __esm({
 });
 
 // libs/sdk/src/elicitation/store/elicitation-store.factory.ts
-import { createMemoryStorage as createMemoryStorage2, createStorage as createStorage2, getEnv as getEnv6 } from "@frontmcp/utils";
-function detectStorageType2(storage) {
-  if (getEnv6("UPSTASH_REDIS_REST_URL")) {
+import { createMemoryStorage as createMemoryStorage2, createStorage as createStorage2, getEnv as getEnv7 } from "@frontmcp/utils";
+function detectStorageType2(storage, configuredType) {
+  if (configuredType === "redis" || configuredType === "upstash" || configuredType === "memory") {
+    return configuredType;
+  }
+  const backend = storage.type ?? storage.backendName;
+  if (backend === "redis" || backend === "upstash" || backend === "memory") {
+    return backend;
+  }
+  if (getEnv7("UPSTASH_REDIS_REST_URL")) {
     return "upstash";
   }
-  if (getEnv6("REDIS_URL") || getEnv6("REDIS_HOST")) {
+  if (getEnv7("REDIS_URL") || getEnv7("REDIS_HOST")) {
     return "redis";
   }
   return "memory";
@@ -46802,7 +47211,8 @@ async function createElicitationStore(options = {}) {
       });
     }
   }
-  if (finalStorageConfig?.type === "vercel-kv" || getEnv6("KV_REST_API_URL")) {
+  const explicitBackend = Boolean(storageConfig || redis);
+  if (finalStorageConfig?.type === "vercel-kv" || !explicitBackend && getEnv7("KV_REST_API_URL")) {
     throw new ElicitationNotSupportedError(
       "Vercel KV is not supported for elicitation stores. Elicitation requires pub/sub for cross-node result routing, which Vercel KV does not support. Use Redis or Upstash instead."
     );
@@ -46823,7 +47233,7 @@ async function createElicitationStore(options = {}) {
     );
   }
   let store = new StorageElicitationStore(storage, logger);
-  const type = detectStorageType2(storage);
+  const type = detectStorageType2(storage, finalStorageConfig?.type);
   const encryptionEnabled = encryption?.enabled ?? "auto";
   const encryptionSecret = encryption?.secret;
   const hasSecret = encryptionSecret || isElicitationEncryptionAvailable();
@@ -49635,6 +50045,7 @@ var init_redis_job_definition_store = __esm({
 });
 
 // libs/sdk/src/job/store/job-definition-store.factory.ts
+import { attachRedisErrorListener } from "@frontmcp/utils";
 function createJobDefinitionStore(options, logger) {
   const keyPrefix = options?.keyPrefix ?? "mcp:jobs:def:";
   const effectiveLogger = logger ?? noopLogger2;
@@ -49646,6 +50057,7 @@ function createJobDefinitionStore(options, logger) {
         host: options.redis.host ?? "localhost",
         port: options.redis.port ?? 6379
       });
+      attachRedisErrorListener(client, { label: "JobDefinitionStore", logger: effectiveLogger });
       return {
         // Factory-created client lifetime is bound to the store, so the store
         // must close it on dispose() — pass ownsClient: true.
@@ -49846,6 +50258,7 @@ var init_redis_job_state_store = __esm({
 });
 
 // libs/sdk/src/job/store/job-state-store.factory.ts
+import { attachRedisErrorListener as attachRedisErrorListener2 } from "@frontmcp/utils";
 function createJobStateStore(options, logger) {
   const keyPrefix = options?.keyPrefix ?? "mcp:jobs:";
   const ttlSeconds = options?.ttlSeconds ?? 86400;
@@ -49857,6 +50270,7 @@ function createJobStateStore(options, logger) {
         host: options.redis.host ?? "localhost",
         port: options.redis.port ?? 6379
       });
+      attachRedisErrorListener2(client, { label: "JobStateStore", logger });
       return {
         store: new RedisJobStateStore2(client, logger, keyPrefix, ttlSeconds),
         type: "redis"
@@ -52272,6 +52686,7 @@ var init_skill_http_cache = __esm({
 });
 
 // libs/sdk/src/skill/cache/skill-http-cache.factory.ts
+import { attachRedisErrorListener as attachRedisErrorListener3 } from "@frontmcp/utils";
 function hasRedisProvider(redis) {
   if (!redis?.provider) return false;
   const provider = redis.provider;
@@ -52316,6 +52731,7 @@ async function createRedisCache(redis, keyPrefix, ttlMs, logger) {
     enableReadyCheck: false,
     maxRetriesPerRequest: 3
   });
+  attachRedisErrorListener3(client, { label: "SkillHttpCache" });
   await client.connect();
   return new RedisSkillHttpCache({
     getClient: async () => client,
@@ -56131,6 +56547,51 @@ var init_skill_scope_helper = __esm({
   }
 });
 
+// libs/sdk/src/tool/ui/ui-option-warnings.ts
+function describeIgnoredUiOptions(toolName, ui) {
+  if (!ui) return [];
+  const messages = [];
+  const ignored = IGNORED_UI_OPTIONS.filter((key) => ui[key] !== void 0);
+  if (ignored.length > 0) {
+    messages.push(
+      `Tool "${toolName}": \`ui.${ignored.join("`, `ui.")}\` ${ignored.length === 1 ? "is" : "are"} accepted but not used yet, so ${ignored.length === 1 ? "it has" : "they have"} no effect.`
+    );
+  }
+  const mode = ui["servingMode"];
+  if (UNSUPPORTED_SERVING_MODES.includes(mode)) {
+    messages.push(
+      `Tool "${toolName}": \`ui.servingMode: '${String(mode)}'\` is not implemented; the widget is served inline, as with \`servingMode: 'inline'\`.`
+    );
+  }
+  if (mode === "hybrid") {
+    messages.push(
+      `Tool "${toolName}": \`ui.servingMode: 'hybrid'\` sends only a reference in \`_meta['ui/component']\` ({ type, hash, toolName }), not the component code; the widget is rendered from its \`ui://\` resource.`
+    );
+  }
+  return messages;
+}
+var IGNORED_UI_OPTIONS, UNSUPPORTED_SERVING_MODES;
+var init_ui_option_warnings = __esm({
+  "libs/sdk/src/tool/ui/ui-option-warnings.ts"() {
+    "use strict";
+    IGNORED_UI_OPTIONS = [
+      "widgetDescription",
+      "widgetAccessible",
+      "displayMode",
+      "prefersBorder",
+      "sandboxDomain",
+      "contentSecurity",
+      "hydrate",
+      "runtimeOptions",
+      "mdxComponents",
+      "bundlingMode",
+      "uiType",
+      "htmlResponsePrefix"
+    ];
+    UNSUPPORTED_SERVING_MODES = ["direct-url", "custom-url"];
+  }
+});
+
 // libs/sdk/src/transport/bus/redis-transport-bus.ts
 var DEFAULT_BUS_PREFIX, DEFAULT_BUS_TTL_SECONDS, REVOKE_LUA, RedisTransportBus;
 var init_redis_transport_bus = __esm({
@@ -56260,6 +56721,7 @@ var redis_event_store_exports = {};
 __export(redis_event_store_exports, {
   RedisEventStore: () => RedisEventStore
 });
+import { attachRedisErrorListener as attachRedisErrorListener4 } from "@frontmcp/utils";
 var RedisEventStore;
 var init_redis_event_store = __esm({
   "libs/sdk/src/transport/event-stores/redis.event-store.ts"() {
@@ -56307,6 +56769,9 @@ var init_redis_event_store = __esm({
             enableReadyCheck: false,
             maxRetriesPerRequest: 3
           });
+          attachRedisErrorListener4(this.client, {
+            label: "RedisEventStore"
+          });
           await this.client.connect();
         }
         return this.client;
@@ -56959,7 +57424,7 @@ var init_handle_mcp_20260728_flow = __esm({
         const sink = new RequestNotificationSink(logLevel, progressToken);
         const clientInfo = toClientInfo(meta[MCP_20260728_META5.clientInfo]);
         if (clientInfo) {
-          const platformType = detectAIPlatform(clientInfo, this.scope.metadata.transport?.platformDetection);
+          const platformType = detectPlatformFromCapabilities(clientCapabilities) ?? detectAIPlatform(clientInfo, this.scope.metadata.transport?.platformDetection);
           this.tryGetContext()?.setClientInfo(clientInfo, platformType);
         }
         const dispatchOptions = {
@@ -57057,6 +57522,28 @@ var init_handle_mcp_20260728_flow = __esm({
   }
 });
 
+// libs/sdk/src/ha/ha-headers.ts
+import { buildSetCookie, getMachineId as getMachineId3, getRuntimeContext as getRuntimeContext13 } from "@frontmcp/utils";
+function applyMachineIdHeader(response) {
+  if (getRuntimeContext13().deployment !== "distributed") return false;
+  response.setHeader(DEFAULT_FRONTMCP_MACHINE_ID_HEADER, getMachineId3());
+  return true;
+}
+function applyNodeAffinity(response, request) {
+  if (!applyMachineIdHeader(response)) return;
+  const cookie = buildSetCookie({ name: DEFAULT_FRONTMCP_NODE_COOKIE, value: getMachineId3() }, request);
+  if (!cookie) return;
+  const existing = response.getHeader("Set-Cookie");
+  const existingArr = Array.isArray(existing) ? existing : existing ? [String(existing)] : [];
+  response.setHeader("Set-Cookie", [...existingArr, cookie]);
+}
+var init_ha_headers = __esm({
+  "libs/sdk/src/ha/ha-headers.ts"() {
+    "use strict";
+    init_ha_constants();
+  }
+});
+
 // libs/sdk/src/skill/skill-mode.utils.ts
 function detectSkillsOnlyMode(query) {
   if (!query) return false;
@@ -57077,7 +57564,7 @@ var init_skill_mode_utils = __esm({
 
 // libs/sdk/src/transport/flows/handle.sse.flow.ts
 import { z as z103 } from "@frontmcp/lazy-zod";
-import { buildSetCookie, getMachineId as getMachineId3, getRuntimeContext as getRuntimeContext13 } from "@frontmcp/utils";
+import { getMachineId as getMachineId4, getRuntimeContext as getRuntimeContext14 } from "@frontmcp/utils";
 function getQuerySessionId2(urlPath) {
   if (!urlPath) return void 0;
   try {
@@ -57087,6 +57574,30 @@ function getQuerySessionId2(urlPath) {
     return void 0;
   }
 }
+function resolveLegacySseSession(params) {
+  const { rawHeader, requestUrl, authorizationSession, createSession } = params;
+  const rawMcpSessionHeader = typeof rawHeader === "string" ? rawHeader : void 0;
+  const mcpSessionHeader = validateMcpSessionHeader(rawMcpSessionHeader);
+  const querySessionId = getQuerySessionId2(requestUrl);
+  const validatedQuerySessionId = querySessionId ? validateMcpSessionHeader(querySessionId) : void 0;
+  if (rawHeader !== void 0 && !mcpSessionHeader) {
+    return { responded404: true, createdNew: false };
+  }
+  if (querySessionId !== void 0 && !validatedQuerySessionId) {
+    return { responded404: true, createdNew: false };
+  }
+  const effectiveSessionId = mcpSessionHeader ?? validatedQuerySessionId;
+  if (effectiveSessionId) {
+    if (authorizationSession?.id === effectiveSessionId) {
+      return { session: authorizationSession, createdNew: false, responded404: false };
+    }
+    return { responded404: true, createdNew: false };
+  }
+  if (authorizationSession) {
+    return { session: authorizationSession, createdNew: false, responded404: false };
+  }
+  return { session: createSession(), createdNew: true, responded404: false };
+}
 var plan38, stateSessionSchema, stateSchema38, name39, Stage39, HandleSseFlow;
 var init_handle_sse_flow = __esm({
   "libs/sdk/src/transport/flows/handle.sse.flow.ts"() {
@@ -57094,7 +57605,7 @@ var init_handle_sse_flow = __esm({
     init_session_id_utils();
     init_common();
     init_errors();
-    init_ha_constants();
+    init_ha_headers();
     init_skill_mode_utils();
     plan38 = {
       pre: ["parseInput", "router"],
@@ -57126,39 +57637,26 @@ var init_handle_sse_flow = __esm({
         const { request } = this.rawInput;
         const authorization = request[ServerRequestTokens.auth];
         const { token } = authorization;
-        const raw = request.headers?.["mcp-session-id"];
-        const rawMcpSessionHeader = typeof raw === "string" ? raw : void 0;
-        const mcpSessionHeader = validateMcpSessionHeader(rawMcpSessionHeader);
         const anyReq = request;
-        const querySessionId = getQuerySessionId2(anyReq.url ?? anyReq.path);
-        const validatedQuerySessionId = querySessionId ? validateMcpSessionHeader(querySessionId) : void 0;
-        if (raw !== void 0 && !mcpSessionHeader) {
-          this.respond(httpRespond.sessionNotFound("invalid session id"));
-          return;
-        }
-        if (querySessionId !== void 0 && !validatedQuerySessionId) {
+        const resolution = resolveLegacySseSession({
+          rawHeader: request.headers?.["mcp-session-id"],
+          requestUrl: anyReq.url ?? anyReq.path,
+          authorizationSession: authorization.session,
+          createSession: () => {
+            const query = request.query;
+            const skillsOnlyMode = detectSkillsOnlyMode(query);
+            return createSessionId("legacy-sse", token, {
+              userAgent: request.headers?.["user-agent"],
+              platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
+              skillsOnlyMode
+            });
+          }
+        });
+        if (resolution.responded404 || !resolution.session) {
           this.respond(httpRespond.sessionNotFound("invalid session id"));
           return;
         }
-        const effectiveSessionId = mcpSessionHeader ?? validatedQuerySessionId;
-        let session;
-        if (effectiveSessionId) {
-          if (authorization.session?.id === effectiveSessionId) {
-            session = authorization.session;
-          } else {
-            session = { id: effectiveSessionId };
-          }
-        } else if (authorization.session) {
-          session = authorization.session;
-        } else {
-          const query = request.query;
-          const skillsOnlyMode = detectSkillsOnlyMode(query);
-          session = createSessionId("legacy-sse", token, {
-            userAgent: request.headers?.["user-agent"],
-            platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
-            skillsOnlyMode
-          });
-        }
+        const session = resolution.session;
         this.state.set(stateSchema38.parse({ token, session }));
       }
       async router() {
@@ -57181,16 +57679,7 @@ var init_handle_sse_flow = __esm({
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
         const transport = await transportService.createTransporter("sse", token, session.id, response);
-        if (getRuntimeContext13().deployment === "distributed") {
-          const nodeId = getMachineId3();
-          response.setHeader(DEFAULT_FRONTMCP_MACHINE_ID_HEADER, nodeId);
-          const cookie = buildSetCookie({ name: DEFAULT_FRONTMCP_NODE_COOKIE, value: nodeId }, request);
-          if (cookie) {
-            const existing = response.getHeader("Set-Cookie");
-            const existingArr = Array.isArray(existing) ? existing : existing ? [String(existing)] : [];
-            response.setHeader("Set-Cookie", [...existingArr, cookie]);
-          }
-        }
+        applyNodeAffinity(response, request);
         await transport.initialize(request, response);
         this.handled();
       }
@@ -57206,12 +57695,12 @@ var init_handle_sse_flow = __esm({
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
         const transport = await transportService.getTransporter("sse", token, session.id);
-        if (!transport && getRuntimeContext13().deployment === "distributed") {
+        if (!transport && getRuntimeContext14().deployment === "distributed") {
           const storedSession = await transportService.getStoredSession("sse", token, session.id);
           if (storedSession) {
             const haManager = this.scope.haManager;
             const relay = haManager?.getRelay();
-            if (relay && storedSession.session.nodeId && storedSession.session.nodeId !== getMachineId3()) {
+            if (relay && storedSession.session.nodeId && storedSession.session.nodeId !== getMachineId4()) {
               const isAlive2 = await haManager.isNodeAlive(storedSession.session.nodeId);
               if (isAlive2) {
                 try {
@@ -57306,9 +57795,10 @@ var init_handle_stateless_http_flow = __esm({
     "use strict";
     init_common();
     init_errors();
+    init_ha_headers();
     init_transport_types();
     plan39 = {
-      pre: ["parseInput", "router"],
+      pre: ["applyNodeHeaders", "parseInput", "router"],
       execute: ["handleRequest"],
       post: [],
       finalize: ["cleanup"]
@@ -57322,6 +57812,9 @@ var init_handle_stateless_http_flow = __esm({
     ({ Stage: Stage40 } = FlowHooksOf(name40));
     HandleStatelessHttpFlow = class extends FlowBase {
       name = name40;
+      async applyNodeHeaders() {
+        applyMachineIdHeader(this.rawInput.response);
+      }
       async parseInput() {
         const { request } = this.rawInput;
         const logger = this.scope.logger.child("HandleStatelessHttpFlow");
@@ -57383,6 +57876,9 @@ var init_handle_stateless_http_flow = __esm({
         this.handled();
       }
     };
+    __decorateClass([
+      Stage40("applyNodeHeaders")
+    ], HandleStatelessHttpFlow.prototype, "applyNodeHeaders", 1);
     __decorateClass([
       Stage40("parseInput")
     ], HandleStatelessHttpFlow.prototype, "parseInput", 1);
@@ -57762,7 +58258,6 @@ var init_ext_apps2 = __esm({
 // libs/sdk/src/transport/flows/handle.streamable-http.flow.ts
 import { z as z105 } from "@frontmcp/lazy-zod";
 import { CallToolResultSchema as CallToolResultSchema4, ElicitResultSchema, RequestSchema as RequestSchema2 } from "@frontmcp/protocol";
-import { buildSetCookie as buildSetCookie2, getMachineId as getMachineId4, getRuntimeContext as getRuntimeContext14 } from "@frontmcp/utils";
 function resolveStreamableHttpSession(params) {
   const { rawHeader, authorizationSession, createSession } = params;
   const rawMcpSessionHeader = typeof rawHeader === "string" ? rawHeader : void 0;
@@ -57774,7 +58269,7 @@ function resolveStreamableHttpSession(params) {
     if (authorizationSession?.id === mcpSessionHeader) {
       return { session: authorizationSession, createdNew: false, responded404: false };
     }
-    return { session: { id: mcpSessionHeader }, createdNew: false, responded404: false };
+    return { responded404: true, createdNew: false };
   }
   if (authorizationSession) {
     return { session: authorizationSession, createdNew: false, responded404: false };
@@ -57858,11 +58353,11 @@ var init_handle_streamable_http_flow = __esm({
     init_common();
     init_errors();
     init_ext_apps2();
-    init_ha_constants();
+    init_ha_headers();
     init_skill_mode_utils();
     init_mcp_surface();
     plan40 = {
-      pre: ["parseInput", "router"],
+      pre: ["applyNodeHeaders", "parseInput", "router"],
       execute: ["onInitialize", "onMessage", "onElicitResult", "onSseListener", "onExtApps"],
       post: [],
       finalize: ["cleanup"]
@@ -57888,6 +58383,9 @@ var init_handle_streamable_http_flow = __esm({
     ({ Stage: Stage41 } = FlowHooksOf(name41));
     HandleStreamableHttpFlow = class extends FlowBase {
       name = name41;
+      async applyNodeHeaders() {
+        applyMachineIdHeader(this.rawInput.response);
+      }
       async parseInput() {
         const { request } = this.rawInput;
         const authorization = request[ServerRequestTokens.auth];
@@ -57919,7 +58417,7 @@ var init_handle_streamable_http_flow = __esm({
           });
         }
         if (sessionResolution.responded404 || !sessionResolution.session) {
-          logger.warn("parseInput: invalid mcp-session-id header");
+          logger.warn("parseInput: mcp-session-id is not a session this server verified");
           this.respond(httpRespond.sessionNotFound("invalid session id"));
           return;
         }
@@ -57986,16 +58484,7 @@ var init_handle_streamable_http_flow = __esm({
               return;
             }
           }
-          if (getRuntimeContext14().deployment === "distributed") {
-            const nodeId = getMachineId4();
-            response.setHeader(DEFAULT_FRONTMCP_MACHINE_ID_HEADER, nodeId);
-            const cookie = buildSetCookie2({ name: DEFAULT_FRONTMCP_NODE_COOKIE, value: nodeId }, request);
-            if (cookie) {
-              const existing = response.getHeader("Set-Cookie");
-              const existingArr = Array.isArray(existing) ? existing : existing ? [String(existing)] : [];
-              response.setHeader("Set-Cookie", [...existingArr, cookie]);
-            }
-          }
+          applyNodeAffinity(response, request);
           logger.info("onInitialize: transport created, calling initialize");
           await transport.initialize(request, response);
           logger.info("onInitialize: completed successfully");
@@ -58178,6 +58667,17 @@ var init_handle_streamable_http_flow = __esm({
         const logger = this.scopeLogger.child("handle:streamable-http:onExtApps");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
+        if (this.scope.metadata.extApps?.enabled === false) {
+          const rpc = request.body;
+          logger.verbose("onExtApps: ext-apps disabled by config", { method: rpc?.method });
+          response.status(200).json({
+            jsonrpc: "2.0",
+            id: rpc?.id ?? null,
+            error: { code: -32601, message: `Method not found: ${rpc?.method}` }
+          });
+          this.handled();
+          return;
+        }
         logger.info("onExtApps: starting", {
           sessionId: session.id?.slice(0, 20),
           method: request.body?.method
@@ -58229,8 +58729,20 @@ var init_handle_streamable_http_flow = __esm({
         const hostCapabilities = {
           serverToolProxy: configuredCapabilities?.serverToolProxy ?? true,
           logging: configuredCapabilities?.logging ?? true,
-          ...configuredCapabilities
+          ...configuredCapabilities,
+          // Only advertise what this host can serve: the context below provides callTool and nothing else
+          openLink: false,
+          modelContextUpdate: false,
+          widgetTools: false
         };
+        const unsupported = ["openLink", "modelContextUpdate", "widgetTools"].filter(
+          (key) => configuredCapabilities?.[key] === true
+        );
+        if (unsupported.length > 0) {
+          logger.warn(
+            `onExtApps: extApps.hostCapabilities ${unsupported.join(", ")} are not supported yet and are not advertised`
+          );
+        }
         const handler = createExtAppsMessageHandler({
           context: {
             sessionId: session.id,
@@ -58264,6 +58776,9 @@ var init_handle_streamable_http_flow = __esm({
         this.handled();
       }
     };
+    __decorateClass([
+      Stage41("applyNodeHeaders")
+    ], HandleStreamableHttpFlow.prototype, "applyNodeHeaders", 1);
     __decorateClass([
       Stage41("parseInput")
     ], HandleStreamableHttpFlow.prototype, "parseInput", 1);
@@ -59856,7 +60371,7 @@ var init_transport_remote = __esm({
 
 // libs/sdk/src/transport/transport.registry.ts
 import { getMachineId as getMachineId5, sha256Hex as sha256Hex12 } from "@frontmcp/utils";
-var TransportService;
+var SESSION_STORE_RETRY_BASE_MS, SESSION_STORE_RETRY_MAX_MS, TransportService;
 var init_transport_registry = __esm({
   "libs/sdk/src/transport/transport.registry.ts"() {
     "use strict";
@@ -59869,6 +60384,8 @@ var init_transport_registry = __esm({
     init_transport_local();
     init_transport_remote();
     init_transport_types();
+    SESSION_STORE_RETRY_BASE_MS = 1e3;
+    SESSION_STORE_RETRY_MAX_MS = 3e4;
     TransportService = class {
       ready;
       byType = /* @__PURE__ */ new Map();
@@ -59925,8 +60442,28 @@ var init_transport_registry = __esm({
        * Returns undefined if persistence is disabled or not configured.
        */
       getDefaultTtlMs() {
+        if (this.resolvedTtlMs !== void 0) return this.resolvedTtlMs;
         return typeof this.persistenceConfig === "object" ? this.persistenceConfig?.defaultTtlMs : void 0;
       }
+      /**
+       * TTL resolved from `persistence.defaultTtlMs`, then `persistence.redis.defaultTtlMs`, then 1 hour.
+       * Set only when a persistence backend is configured.
+       */
+      resolvedTtlMs;
+      /** Store config kept after a successful create so a failed ping can be retried. */
+      storeRetryConfig;
+      storeRetryTimer;
+      storeRetryAttempt = 0;
+      destroyed = false;
+      /** Last time a request refreshed the stored session's TTL, by session id. */
+      lastTtlRefreshAt = /* @__PURE__ */ new Map();
+      /**
+       * Redis key prefix under which session records are stored.
+       * The session store appends `session:` to the transport key prefix.
+       */
+      getSessionKeyPrefix() {
+        return `${this.transportKeyPrefix}session:`;
+      }
       constructor(scope, persistenceConfig, bus) {
         this.scope = scope;
         this.persistenceConfig = persistenceConfig;
@@ -59937,10 +60474,11 @@ var init_transport_registry = __esm({
           this.backendKind = "sqlite";
           const sqliteConfig = persistenceConfig.sqlite;
           this.transportKeyPrefix = "mcp:transport:";
+          this.resolvedTtlMs = persistenceConfig.defaultTtlMs ?? 36e5;
           this.pendingStoreConfig = {
             sqlite: sqliteConfig,
             keyPrefix: this.transportKeyPrefix,
-            defaultTtlMs: persistenceConfig.defaultTtlMs ?? 36e5
+            defaultTtlMs: this.resolvedTtlMs
           };
           this.scope.logger.info("[TransportService] sqlite session store will be initialized for transport persistence");
         } else if (persistenceConfig !== false && persistenceConfig?.redis) {
@@ -59949,43 +60487,23 @@ var init_transport_registry = __esm({
           const providerType = "provider" in redisConfig ? redisConfig.provider : "redis";
           this.backendKind = providerType === "vercel-kv" ? "vercel-kv" : "redis";
           this.transportKeyPrefix = redisConfig.keyPrefix ?? "mcp:transport:";
+          this.resolvedTtlMs = persistenceConfig.defaultTtlMs ?? redisConfig.defaultTtlMs ?? 36e5;
           this.pendingStoreConfig = {
             ...redisConfig,
             keyPrefix: this.transportKeyPrefix,
-            defaultTtlMs: persistenceConfig.defaultTtlMs ?? 36e5
-            // 1 hour default
+            defaultTtlMs: this.resolvedTtlMs
           };
           this.scope.logger.info(
             `[TransportService] ${providerType} session store will be initialized for transport persistence`
           );
         }
+        this.storeRetryConfig = this.pendingStoreConfig;
         this.ready = this.initialize();
       }
       async initialize() {
         if (this.pendingStoreConfig) {
-          try {
-            const store = await createSessionStore(this.pendingStoreConfig, this.scope.logger.child("SessionStore"));
-            this.sessionStore = store;
-            this.pendingStoreConfig = void 0;
-          } catch (error) {
-            const err = error;
-            this.scope.logger.error("[TransportService] Failed to create session store - session persistence disabled", {
-              error: err.message,
-              cause: err.cause?.message
-            });
-          }
-        }
-        if (this.sessionStore) {
-          const isConnected = this.sessionStore.ping ? await this.sessionStore.ping() : true;
-          if (!isConnected) {
-            const providerType = this.backendKind ?? "redis";
-            this.scope.logger.error(
-              `[TransportService] Failed to connect to ${providerType} - session persistence disabled`
-            );
-            await this.teardownSessionStore().catch(() => void 0);
-          } else {
-            this.scope.logger.info("[TransportService] Session store connection validated successfully");
-          }
+          const connected = await this.connectSessionStore();
+          if (!connected && this.backendKind !== "sqlite") this.scheduleSessionStoreRetry();
         }
         await this.scope.registryFlows(
           HandleStreamableHttpFlow,
@@ -59994,7 +60512,70 @@ var init_transport_registry = __esm({
           HandleMcp20260728Flow
         );
       }
+      /**
+       * Create the session store and validate the connection.
+       * Returns true when the store is usable; on failure the store is left undefined.
+       */
+      async connectSessionStore() {
+        const storeConfig = this.pendingStoreConfig ?? this.storeRetryConfig;
+        if (!storeConfig) return false;
+        try {
+          const store = await createSessionStore(storeConfig, this.scope.logger.child("SessionStore"));
+          this.sessionStore = store;
+          this.pendingStoreConfig = void 0;
+        } catch (error) {
+          const err = error;
+          this.scope.logger.error("[TransportService] Failed to create session store - session persistence disabled", {
+            error: err.message,
+            cause: err.cause?.message
+          });
+          return false;
+        }
+        const isConnected = this.sessionStore?.ping ? await this.sessionStore.ping() : true;
+        if (!isConnected) {
+          const providerType = this.backendKind ?? "redis";
+          this.scope.logger.error(`[TransportService] Failed to connect to ${providerType} - session persistence disabled`);
+          await this.teardownSessionStore().catch(() => void 0);
+          return false;
+        }
+        this.scope.logger.info("[TransportService] Session store connection validated successfully");
+        return true;
+      }
+      /**
+       * Retry the session store with exponential backoff (1s doubling to 30s) so a Redis that
+       * was down at startup is picked up when it comes back, and `/readyz` turns healthy.
+       */
+      scheduleSessionStoreRetry() {
+        if (this.destroyed || this.storeRetryTimer) return;
+        const delay = Math.min(SESSION_STORE_RETRY_MAX_MS, SESSION_STORE_RETRY_BASE_MS * 2 ** this.storeRetryAttempt);
+        this.storeRetryAttempt++;
+        this.storeRetryTimer = setTimeout(() => {
+          this.storeRetryTimer = void 0;
+          void this.retrySessionStore();
+        }, delay);
+        this.storeRetryTimer.unref?.();
+      }
+      async retrySessionStore() {
+        if (this.destroyed || this.sessionStore) return;
+        const connected = await this.connectSessionStore().catch(() => false);
+        if (this.destroyed) {
+          await this.teardownSessionStore().catch(() => void 0);
+          return;
+        }
+        if (connected) {
+          this.storeRetryAttempt = 0;
+          this.scope.logger.info("[TransportService] Session store recovered after startup failure");
+          return;
+        }
+        this.scheduleSessionStoreRetry();
+      }
       async destroy() {
+        this.destroyed = true;
+        if (this.storeRetryTimer) {
+          clearTimeout(this.storeRetryTimer);
+          this.storeRetryTimer = void 0;
+        }
+        this.lastTtlRefreshAt.clear();
         await this.teardownSessionStore();
       }
       /**
@@ -60055,10 +60636,33 @@ var init_transport_registry = __esm({
       getBackendKind() {
         return this.backendKind;
       }
+      /**
+       * Slide the stored session's TTL while this instance is serving it. Redis and Vercel KV
+       * session stores extend the TTL on read, so a plain `get` is enough. Throttled per session
+       * to a quarter of the TTL, fire-and-forget.
+       */
+      refreshStoredSessionTtl(sessionId) {
+        const store = this.sessionStore;
+        const ttlMs = this.getDefaultTtlMs();
+        if (!store || !ttlMs || this.backendKind !== "redis" && this.backendKind !== "vercel-kv") return;
+        const now = Date.now();
+        const last = this.lastTtlRefreshAt.get(sessionId);
+        if (last !== void 0 && now - last < Math.max(1e3, Math.floor(ttlMs / 4))) return;
+        this.lastTtlRefreshAt.set(sessionId, now);
+        store.get(sessionId).catch((err) => {
+          this.scope.logger.warn("[TransportService] Failed to refresh session TTL", {
+            sessionId: sessionId.slice(0, 20),
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
       async getTransporter(type, token, sessionId) {
         const key = this.keyOf(type, token, sessionId);
         const local = this.lookupLocal(key);
-        if (local) return local;
+        if (local) {
+          this.refreshStoredSessionTtl(sessionId);
+          return local;
+        }
         if (this.distributed && this.bus) {
           const location = await this.bus.lookup(key);
           if (location) {
@@ -60153,7 +60757,7 @@ var init_transport_registry = __esm({
         });
         const currentNodeId = getMachineId5();
         if (this.scope.haManager && storedSession.session.nodeId && storedSession.session.nodeId !== currentNodeId) {
-          const sessionKey = `${this.transportKeyPrefix}${sessionId}`;
+          const sessionKey = `${this.getSessionKeyPrefix()}${sessionId}`;
           const result = await this.scope.haManager.attemptTakeover(sessionKey, storedSession.session.nodeId);
           if (!result.claimed) {
             this.scope.logger.debug("[HA] Session already claimed by another pod", { sessionId: sessionId.slice(0, 20) });
@@ -60486,6 +61090,7 @@ var init_transport_registry = __esm({
         }
       }
       evictLocal(key) {
+        this.lastTtlRefreshAt.delete(key.sessionId);
         const typeBucket = this.byType.get(key.type);
         if (!typeBucket) return;
         const tokenBucket = typeBucket.get(key.tokenHash);
@@ -61442,7 +62047,7 @@ var init_http_request_flow = __esm({
 // libs/sdk/src/scope/scope.instance.ts
 import "reflect-metadata";
 import { createGuardManager } from "@frontmcp/guard";
-import { getEnvFlag, getMachineId as getMachineId6, getRuntimeContext as getRuntimeContext15, isEdgeRuntime } from "@frontmcp/utils";
+import { createRedisClient, getEnvFlag, getMachineId as getMachineId6, getRuntimeContext as getRuntimeContext15, isEdgeRuntime } from "@frontmcp/utils";
 var SCOPE_NON_DISPATCHABLE_FLOWS, Scope;
 var init_scope_instance = __esm({
   "libs/sdk/src/scope/scope.instance.ts"() {
@@ -61487,8 +62092,10 @@ var init_scope_instance = __esm({
     init_tool_registry();
     init_tool_utils();
     init_ui();
+    init_ui_option_warnings();
     init_bus();
     init_event_stores();
+    init_request_state();
     init_transport_registry();
     init_http_ip_filter_flow();
     init_http_request_flow();
@@ -61512,6 +62119,8 @@ var init_scope_instance = __esm({
       transportService;
       // TODO: migrate transport service to transport.registry
       notificationService;
+      /** ioredis client owned by the HA manager and transport bus; closed in shutdown(). */
+      haRedisClient;
       toolUIRegistry;
       authUiRegistry;
       entryPath;
@@ -61592,7 +62201,7 @@ var init_scope_instance = __esm({
         const isDistributed = getRuntimeContext15().deployment === "distributed";
         if (isDistributed && this.metadata.redis && !this.cliMode) {
           try {
-            const haRedis = this.metadata.redis;
+            const haRedis = this.createHaRedisClient();
             this.haManager = HaManager.create({
               redis: haRedis,
               nodeId: getMachineId6(),
@@ -61602,11 +62211,13 @@ var init_scope_instance = __esm({
             this.logger.info("[HA] Manager started for distributed deployment");
           } catch (err) {
             this.logger.warn("[HA] Failed to start HA manager \u2014 running without HA", { error: err });
+            this.haManager = void 0;
+            await this.closeHaRedisClient();
           }
         }
         let transportBus;
-        if (this.haManager && isDistributed && this.metadata.redis) {
-          transportBus = new RedisTransportBus(this.metadata.redis, getMachineId6(), {
+        if (this.haManager && this.haRedisClient && isDistributed) {
+          transportBus = new RedisTransportBus(this.haRedisClient, getMachineId6(), {
             logger: this.logger
           });
           this.logger.info("[HA] Transport bus created for distributed session routing");
@@ -61617,11 +62228,10 @@ var init_scope_instance = __esm({
           effectivePersistence = { sqlite: resolvedTopLevelSqlite };
         }
         this.transportService = new TransportService(this, effectivePersistence, transportBus);
-        if (this.haManager && isDistributed) {
-          const persistCfg = transportConfig?.persistence;
-          const resolvedPrefix = persistCfg && typeof persistCfg === "object" && persistCfg.redis?.keyPrefix ? persistCfg.redis.keyPrefix : "mcp:transport:";
+        warnIfRequestStateKeyNotShared({ logger: this.logger, metadata: this.metadata });
+        if (this.haManager && isDistributed && this.transportService.getBackendKind() === "redis") {
           this.haManager.startOrphanScanner({
-            sessionKeyPrefix: resolvedPrefix,
+            sessionKeyPrefix: this.transportService.getSessionKeyPrefix(),
             onOrphan: (sessionId, previousNodeId) => {
               this.logger.info(
                 `[HA] Orphaned session ${sessionId.slice(0, 20)} from ${previousNodeId} \u2014 available for recreation`
@@ -61677,7 +62287,15 @@ var init_scope_instance = __esm({
             "[tasks] Background tasks are unavailable on this edge/serverless runtime: the in-process runner cannot continue past the HTTP response, and an in-memory store is not shared between isolates. Serving without tasks. Configure `tasks.redis` (Upstash Redis over HTTP works on Workers) to enable them."
           );
         }
-        const shouldInitTasks = !tasksExplicitlyDisabled && !tasksUnavailableOnEdge && (!this.cliMode || tasksEnabledForCli || isTaskWorker);
+        const gateTasksRedis = tasksConfig?.redis ?? this.metadata.redis;
+        const tasksUseSqlite = Boolean(tasksConfig?.sqlite ?? (gateTasksRedis ? void 0 : resolvedTopLevelSqlite));
+        const tasksUnavailableOnVercelKv = !tasksExplicitlyEnabled && !tasksUseSqlite && resolvesToVercelKvTaskBackend(gateTasksRedis);
+        if (tasksUnavailableOnVercelKv && !tasksExplicitlyDisabled) {
+          this.logger.warn(
+            "[tasks] Background tasks are disabled: Vercel KV has no pub/sub, which task results and cancellation require. Serving without tasks. Configure `tasks.redis` with Redis or Upstash to enable them."
+          );
+        }
+        const shouldInitTasks = !tasksExplicitlyDisabled && !tasksUnavailableOnEdge && !tasksUnavailableOnVercelKv && (!this.cliMode || tasksEnabledForCli || isTaskWorker);
         const tasksPromise = shouldInitTasks ? (async () => {
           const tasksRedis = tasksConfig?.redis ?? this.metadata.redis;
           const tasksSqlite = tasksConfig?.sqlite ?? (tasksRedis ? void 0 : resolvedTopLevelSqlite);
@@ -62176,6 +62794,16 @@ var init_scope_instance = __esm({
       async compileUIWidgets() {
         const toolsWithUI = this.scopeTools.getTools(true).filter((t) => hasUIConfig(t.metadata));
         if (toolsWithUI.length === 0) return;
+        for (const tool of toolsWithUI) {
+          const resourceUri = tool.metadata.ui?.resourceUri;
+          this.toolUIRegistry.registerTool(tool.metadata.name, typeof resourceUri === "string" ? resourceUri : void 0);
+          for (const message of describeIgnoredUiOptions(
+            tool.metadata.name,
+            tool.metadata.ui
+          )) {
+            this.logger.warn(message);
+          }
+        }
         this.scopeResources.registerDynamicResource(StaticWidgetResourceTemplate);
         this.logger.verbose(`Registered UI resource template for ${toolsWithUI.length} tool(s) with UI configs`);
         const staticModeTools = toolsWithUI.filter(
@@ -62754,6 +63382,29 @@ var init_scope_instance = __esm({
         }
         throw new FlowExitedWithoutOutputError();
       }
+      /**
+       * Build the ioredis client shared by the HA manager and the transport bus from `metadata.redis`.
+       * The client reconnects on its own and has a permanent, rate-limited 'error' listener.
+       */
+      createHaRedisClient() {
+        const redis = this.metadata.redis;
+        if (!redis || redis.provider === "vercel-kv") {
+          throw new Error("Distributed HA requires a TCP Redis (ioredis); Vercel KV over REST has no Lua/pub-sub support");
+        }
+        const client = createRedisClient({ ...redis, label: "ha", logger: this.logger });
+        this.haRedisClient = client;
+        return client;
+      }
+      async closeHaRedisClient() {
+        const client = this.haRedisClient;
+        if (!client) return;
+        this.haRedisClient = void 0;
+        try {
+          await client.quit();
+        } catch {
+          client.disconnect();
+        }
+      }
       /**
        * Shut down the scope and release resources.
        * Disconnects channel service connectors, unsubscribes event handlers,
@@ -62767,6 +63418,7 @@ var init_scope_instance = __esm({
             this.logger.error("[HA] Manager shutdown failed", { error: err });
           }
         }
+        await this.closeHaRedisClient();
         if (this._channelTeardown) {
           try {
             await this._channelTeardown();
@@ -63895,6 +64547,177 @@ var init_scope_registry = __esm({
   }
 });
 
+// libs/sdk/src/transport/ipc-server.transport.ts
+function isIpcStdioRequested() {
+  return !!process.env["FRONTMCP_DEV_STDIO_FD"] && typeof process.send === "function";
+}
+var IPC_READY_MESSAGE, IpcServerTransport;
+var init_ipc_server_transport = __esm({
+  "libs/sdk/src/transport/ipc-server.transport.ts"() {
+    "use strict";
+    IPC_READY_MESSAGE = { __frontmcp: "ready" };
+    IpcServerTransport = class {
+      onclose;
+      onerror;
+      onmessage;
+      started = false;
+      handleMessage = (raw) => {
+        if (!raw || typeof raw !== "object" || raw.__frontmcp !== void 0) return;
+        this.onmessage?.(raw);
+      };
+      handleDisconnect = () => {
+        this.onclose?.();
+      };
+      async start() {
+        if (this.started) throw new Error("IpcServerTransport already started");
+        if (typeof process.send !== "function") {
+          throw new Error("IpcServerTransport requires a process forked with an IPC channel");
+        }
+        this.started = true;
+        process.on("message", this.handleMessage);
+        process.once("disconnect", this.handleDisconnect);
+        process.send(IPC_READY_MESSAGE);
+      }
+      async send(message) {
+        const send = process.send;
+        if (!process.connected || typeof send !== "function") {
+          throw new Error("IPC channel is closed");
+        }
+        await new Promise((resolve, reject) => {
+          send.call(process, message, (err) => err ? reject(err) : resolve());
+        });
+      }
+      async close() {
+        process.off("message", this.handleMessage);
+        process.off("disconnect", this.handleDisconnect);
+        this.started = false;
+        this.onclose?.();
+      }
+    };
+  }
+});
+
+// libs/sdk/src/server/middleware/csp.middleware.ts
+import { getEnv as getEnv8, getEnvFlag as getEnvFlag2 } from "@frontmcp/utils";
+function readCspFromEnv() {
+  if (!getEnvFlag2("FRONTMCP_CSP_ENABLED")) return void 0;
+  const rawDirectives = getEnv8("FRONTMCP_CSP_DIRECTIVES") ?? "";
+  const directives = {};
+  for (const part of rawDirectives.split(";")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const spaceIdx = trimmed.indexOf(" ");
+    if (spaceIdx > 0) {
+      directives[trimmed.slice(0, spaceIdx)] = trimmed.slice(spaceIdx + 1);
+    } else {
+      directives[trimmed] = "";
+    }
+  }
+  return {
+    enabled: true,
+    directives,
+    reportUri: getEnv8("FRONTMCP_CSP_REPORT_URI"),
+    reportOnly: getEnvFlag2("FRONTMCP_CSP_REPORT_ONLY")
+  };
+}
+function buildCspHeaderValue(options) {
+  const parts = [];
+  for (const [directive, value] of Object.entries(options.directives)) {
+    parts.push(value ? `${directive} ${value}` : directive);
+  }
+  if (options.reportUri) {
+    parts.push(`report-uri ${options.reportUri}`);
+  }
+  return parts.join("; ");
+}
+function getCspHeaderName(reportOnly) {
+  return reportOnly ? "Content-Security-Policy-Report-Only" : "Content-Security-Policy";
+}
+function readSecurityHeadersFromEnv() {
+  return {
+    hsts: readHeaderEnv("FRONTMCP_HSTS"),
+    contentTypeOptions: readHeaderEnv("FRONTMCP_CONTENT_TYPE_OPTIONS", "nosniff"),
+    frameOptions: readHeaderEnv("FRONTMCP_FRAME_OPTIONS", "DENY"),
+    custom: readCustomHeadersFromEnv()
+  };
+}
+function readHeaderEnv(name44, fallback) {
+  const value = getEnv8(name44);
+  if (value === void 0 || value === "") return fallback;
+  return ["off", "false", "none"].includes(value.trim().toLowerCase()) ? void 0 : value;
+}
+function readCustomHeadersFromEnv() {
+  const raw = getEnv8("FRONTMCP_HEADERS_CUSTOM");
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+    return Object.fromEntries(
+      Object.entries(parsed).filter((entry) => typeof entry[1] === "string")
+    );
+  } catch {
+    return void 0;
+  }
+}
+function applySecurityHeaders(res, headers, csp) {
+  if (headers.hsts) {
+    res.setHeader("Strict-Transport-Security", headers.hsts);
+  }
+  if (headers.contentTypeOptions) {
+    res.setHeader("X-Content-Type-Options", headers.contentTypeOptions);
+  }
+  if (headers.frameOptions) {
+    res.setHeader("X-Frame-Options", headers.frameOptions);
+  }
+  if (headers.custom) {
+    for (const [name44, value] of Object.entries(headers.custom)) {
+      res.setHeader(name44, value);
+    }
+  }
+  if (csp?.enabled) {
+    const headerName = getCspHeaderName(csp.reportOnly);
+    const headerValue = buildCspHeaderValue(csp);
+    if (headerValue) {
+      res.setHeader(headerName, headerValue);
+    }
+  }
+}
+function resolveSecurityHeaders(options = {}) {
+  const env = readSecurityHeadersFromEnv();
+  const pick = (explicit, fromEnv) => explicit === false ? void 0 : explicit ?? fromEnv;
+  const resolved = {
+    hsts: pick(options.hsts, env.hsts),
+    contentTypeOptions: pick(options.contentTypeOptions, env.contentTypeOptions),
+    frameOptions: pick(options.frameOptions, env.frameOptions),
+    custom: { ...env.custom, ...options.custom }
+  };
+  let csp;
+  if (options.csp?.enabled === false) {
+    csp = void 0;
+  } else if (options.csp?.enabled === true) {
+    const directives = {};
+    for (const [name44, value] of Object.entries(options.csp.directives ?? {})) {
+      directives[name44] = Array.isArray(value) ? value.join(" ") : value;
+    }
+    csp = {
+      enabled: true,
+      directives,
+      reportUri: options.csp.reportUri,
+      reportOnly: options.csp.reportOnly ?? false
+    };
+  } else {
+    csp = readCspFromEnv();
+  }
+  const headers = {};
+  applySecurityHeaders({ setHeader: (name44, value) => void (headers[name44] = value) }, resolved, csp);
+  return headers;
+}
+var init_csp_middleware = __esm({
+  "libs/sdk/src/server/middleware/csp.middleware.ts"() {
+    "use strict";
+  }
+});
+
 // libs/sdk/src/transport/web-response.renderer.ts
 function toByteStream(streamLike) {
   const iter = streamLike[Symbol.asyncIterator];
@@ -64000,6 +64823,7 @@ function isCloudflareWorkersRuntime(request) {
   return typeof cloudflareProperties === "object" && cloudflareProperties !== null;
 }
 function resolvePeerAddress(request, ctx) {
+  if (carriedPeerAddresses.has(request)) return carriedPeerAddresses.get(request);
   if (typeof ctx?.requestIP === "function") return ctx.requestIP(request)?.address;
   if (typeof ctx?.remoteAddr?.hostname === "string") return ctx.remoteAddr.hostname;
   if (isCloudflareWorkersRuntime(request)) return request.headers.get("cf-connecting-ip") ?? void 0;
@@ -64018,7 +64842,13 @@ function mapHttpCors(httpCors, scope) {
 }
 function createWebFetchHandler(scope, options = {}) {
   const httpConfig = scope.metadata.http;
-  const healthPaths = new Set(options.healthPaths ?? ["/healthz", "/readyz"]);
+  const healthConfig = scope.metadata.health ?? {};
+  const healthEnabled = healthConfig.enabled !== false;
+  const healthzPath = healthConfig.healthzPath ?? "/healthz";
+  const readyzPath = healthConfig.readyzPath ?? "/readyz";
+  const readyzEnabled = isReadyzEnabled(healthConfig);
+  const bodyLimit = parseByteLimit(httpConfig?.bodyLimit);
+  const securityHeaders = resolveSecurityHeaders(httpConfig?.securityHeaders);
   const normalizePath = (p) => {
     const withSlash = p.startsWith("/") ? p : `/${p}`;
     let end = withSlash.length;
@@ -64062,7 +64892,13 @@ function createWebFetchHandler(scope, options = {}) {
     for (const [k, v] of Object.entries(corsHeadersFor(request))) headers.set(k, v);
     return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
   };
-  return async function handle(request, ctx, env) {
+  const withSecurityHeaders = (response) => {
+    const headers = new Headers(response.headers);
+    for (const [k, v] of Object.entries(securityHeaders)) if (!headers.has(k)) headers.set(k, v);
+    headers.delete("x-powered-by");
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+  };
+  const handleRequest = async (request, ctx, env) => {
     const url = new URL(request.url);
     if (hostValidation) {
       const rejection = validateHostHeaders(
@@ -64077,17 +64913,34 @@ function createWebFetchHandler(scope, options = {}) {
         return Response.json({ error: rejection.error, message: rejection.message }, { status: rejection.status });
       }
     }
+    const limited = await enforceBodyLimit(request, bodyLimit, ctx);
+    if (limited instanceof Response) return withCors(limited, request);
+    request = limited;
     if (corsEnabled && request.method === "OPTIONS") {
       return new Response(null, { status: 204, headers: corsHeadersFor(request) });
     }
-    if (healthPaths.has(url.pathname)) {
-      return withCors(
-        Response.json(
-          { status: "ok", server: scope.metadata.info, transport: "web-fetch" },
-          { headers: { "Cache-Control": "no-store" } }
-        ),
-        request
-      );
+    if (options.healthPaths ? options.healthPaths.includes(url.pathname) : healthEnabled) {
+      const isReadyz = !options.healthPaths && url.pathname === readyzPath && readyzEnabled;
+      const isHealthz = options.healthPaths ? url.pathname !== "/readyz" : url.pathname === healthzPath || url.pathname === "/health";
+      if (isReadyz && scope.healthService) {
+        const readiness = await scope.healthService.getReadyz();
+        return withCors(
+          Response.json(
+            { ...readiness, transport: "web-fetch" },
+            { status: readiness.status === "ready" ? 200 : 503, headers: { "Cache-Control": "no-store" } }
+          ),
+          request
+        );
+      }
+      if (isHealthz || isReadyz || options.healthPaths) {
+        return withCors(
+          Response.json(
+            { status: "ok", server: scope.metadata.info, transport: "web-fetch" },
+            { headers: { "Cache-Control": "no-store" } }
+          ),
+          request
+        );
+      }
     }
     if (!entryPaths.has(normalizePath(url.pathname))) {
       const authResponse = await runMatchingHttpFlowWeb(scope, request, { ctx, env });
@@ -64101,6 +64954,53 @@ function createWebFetchHandler(scope, options = {}) {
     const rendered = await runHttpRequestFlowWeb(scope, request, { ctx, env });
     return withCors(rendered ?? Response.json({ error: "Not Found" }, { status: 404 }), request);
   };
+  return async function handle(request, ctx, env) {
+    return withSecurityHeaders(await handleRequest(request, ctx, env));
+  };
+}
+function parseByteLimit(limit) {
+  if (typeof limit === "number" && Number.isFinite(limit) && limit >= 0) return limit;
+  if (typeof limit === "string") {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(limit.trim());
+    if (match) return Math.floor(Number(match[1]) * BYTE_UNITS[(match[2] ?? "b").toLowerCase()]);
+  }
+  return DEFAULT_BODY_LIMIT_BYTES;
+}
+function payloadTooLarge(limit, length) {
+  const error = new PayloadTooLargeError(limit, length);
+  return Response.json({ jsonrpc: "2.0", error: error.toJsonRpcError(), id: null }, { status: 413 });
+}
+async function enforceBodyLimit(request, limit, ctx) {
+  const method = request.method.toUpperCase();
+  if (method === "GET" || method === "HEAD" || method === "OPTIONS" || !request.body) return request;
+  const declared = request.headers.get("content-length");
+  if (declared !== null) {
+    const length = Number(declared);
+    if (Number.isFinite(length) && length > limit) return payloadTooLarge(limit, length);
+  }
+  const peerAddress = resolvePeerAddress(request, ctx);
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > limit) {
+      await reader.cancel().catch(() => void 0);
+      return payloadTooLarge(limit, total);
+    }
+    chunks.push(value);
+  }
+  const buffered = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffered.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const rebuilt = new Request(request.url, { method: request.method, headers: request.headers, body: buffered });
+  carriedPeerAddresses.set(rebuilt, peerAddress);
+  return rebuilt;
 }
 async function runHttpRequestFlowWeb(scope, request, opts = {}) {
   const url = new URL(request.url);
@@ -64191,22 +65091,7 @@ async function toServerRequest(request, url, ctx, persistent, env) {
 function misconfigurationResponse(error) {
   const misconfiguration = findMisconfiguration(error);
   if (!misconfiguration) return void 0;
-  return Response.json(
-    { error: "server_misconfigured", code: misconfiguration.code, message: misconfiguration.remedy },
-    { status: 500 }
-  );
-}
-function findMisconfiguration(error) {
-  let current = error;
-  for (let depth = 0; current instanceof Error && depth < 5; depth++) {
-    const code = current.code;
-    if (typeof code === "string" && MISCONFIGURATION_REMEDIES[code]) {
-      return { code, remedy: MISCONFIGURATION_REMEDIES[code] };
-    }
-    if (current.name === "ZodError") return { code: "CONFIG_INVALID", remedy: CONFIG_INVALID_REMEDY };
-    current = current.cause;
-  }
-  return void 0;
+  return Response.json(misconfigurationBody(misconfiguration), { status: 500 });
 }
 function createDeferredServerBuild(build, options = {}) {
   const now = options.now ?? Date.now;
@@ -64261,7 +65146,7 @@ function flowErrorToHttpOutput(error) {
       kind: "json",
       status: 500,
       contentType: "application/json; charset=utf-8",
-      body: { error: "server_misconfigured", code: misconfiguration.code, message: misconfiguration.remedy }
+      body: misconfigurationBody(misconfiguration)
     };
   }
   if (error instanceof FlowControl) {
@@ -64287,7 +65172,7 @@ function flowErrorToHttpOutput(error) {
   }
   return { kind: "text", status: 500, body: "Internal Server Error", contentType: "text/plain; charset=utf-8" };
 }
-var CLOUDFLARE_WORKERS_USER_AGENT, MISCONFIGURATION_REMEDIES, CONFIG_INVALID_REMEDY, STARTUP_RETRY_MIN_MS, STARTUP_RETRY_MAX_MS;
+var CLOUDFLARE_WORKERS_USER_AGENT, carriedPeerAddresses, DEFAULT_BODY_LIMIT_BYTES, BYTE_UNITS, STARTUP_RETRY_MIN_MS, STARTUP_RETRY_MAX_MS;
 var init_web_fetch_handler = __esm({
   "libs/sdk/src/transport/web-fetch-handler.ts"() {
     "use strict";
@@ -64295,18 +65180,15 @@ var init_web_fetch_handler = __esm({
     init_server_tokens();
     init_path_utils();
     init_errors();
+    init_misconfiguration();
+    init_health_routes();
+    init_csp_middleware();
     init_host_validation();
     init_web_response_renderer();
     CLOUDFLARE_WORKERS_USER_AGENT = "Cloudflare-Workers";
-    MISCONFIGURATION_REMEDIES = {
-      SESSION_SECRET_REQUIRED: "Set MCP_SESSION_SECRET in the deployment environment (e.g. `wrangler secret put MCP_SESSION_SECRET`). Session IDs are encrypted with it, and production refuses the development machine-id fallback.",
-      JWT_SECRET_INVALID: "JWT_SECRET is present but too weak: HS256 requires at least 32 bytes (RFC 7518). Replace it with `openssl rand -hex 32`.",
-      JWT_SECRET_REQUIRED: "Set JWT_SECRET in the deployment environment (e.g. `wrangler secret put JWT_SECRET`). Tokens are signed with it; production refuses the random per-process fallback because tokens would not survive a restart or verify across instances.",
-      // The startup checks: a server whose entries ask for protection nothing gives them does not start.
-      UNENFORCED_METADATA: "An entry declares a field only a plugin enforces (approval, featureFlag, ...) and no installed plugin that enforces it reaches the entry, so the server refuses to start. Install the plugin or remove the field; the server log names the entries.",
-      AUTH_CONFIGURATION_ERROR: "The auth or authorities configuration is invalid (for example, entries declare authorities and the server has no authorities option, or a rule checks nothing), so the server refuses to start. The server log names the entries."
-    };
-    CONFIG_INVALID_REMEDY = "The FrontMCP configuration failed validation, so the server refuses to start. The server log names the invalid fields.";
+    carriedPeerAddresses = /* @__PURE__ */ new WeakMap();
+    DEFAULT_BODY_LIMIT_BYTES = 4 * 1024 * 1024;
+    BYTE_UNITS = { b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3 };
     STARTUP_RETRY_MIN_MS = 1e3;
     STARTUP_RETRY_MAX_MS = 6e4;
   }
@@ -64338,9 +65220,9 @@ var init_noop_server = __esm({
 });
 
 // libs/sdk/src/server/security/security-audit.ts
-function auditSecurityDefaults(config, isProduction6) {
+function auditSecurityDefaults(config, isProduction7) {
   const findings = [];
-  if (!isProduction6 && config.deploymentMode !== "distributed") {
+  if (!isProduction7 && config.deploymentMode !== "distributed") {
     return findings;
   }
   const strict = config.security?.strict === true;
@@ -64388,13 +65270,13 @@ function auditSecurityDefaults(config, isProduction6) {
       message: `Server bound to ${bindAddress}.`
     });
   }
-  const dnsProtectionEnabled = config.security?.dnsRebindingProtection?.enabled ?? strict;
+  const dnsProtectionEnabled = config.security?.dnsRebindingProtection?.enabled !== false;
   if (!dnsProtectionEnabled) {
     findings.push({
       level: "warn",
       code: "DNS_REBINDING_UNPROTECTED",
-      message: "DNS rebinding protection is disabled.",
-      recommendation: "Enable security.dnsRebindingProtection with allowedHosts to prevent DNS rebinding attacks."
+      message: "DNS rebinding protection is disabled (security.dnsRebindingProtection.enabled is false).",
+      recommendation: "Remove `enabled: false`, or set security.dnsRebindingProtection.allowedHosts, to prevent DNS rebinding attacks."
     });
   } else {
     findings.push({
@@ -64583,6 +65465,7 @@ var init_express_host_adapter = __esm({
   "libs/sdk/src/server/adapters/express.host.adapter.ts"() {
     "use strict";
     init_mcp_error();
+    init_csp_middleware();
     init_host_validation_middleware();
     init_resolve_allowed_hosts();
     init_base_host_adapter();
@@ -64597,6 +65480,12 @@ var init_express_host_adapter = __esm({
       deriveHostValidation;
       constructor(options) {
         super();
+        this.app.disable("x-powered-by");
+        const securityHeaders = resolveSecurityHeaders(options?.securityHeaders);
+        this.app.use((_req, res, next) => {
+          for (const [name44, value] of Object.entries(securityHeaders)) res.setHeader(name44, value);
+          next();
+        });
         const corsOptions = options?.cors;
         const corsEnabled = corsOptions?.origin !== void 0 && corsOptions.origin !== false;
         if (corsEnabled) {
@@ -64824,6 +65713,7 @@ var init_server_instance = __esm({
           this.host = new ExpressHostAdapter2({
             ...corsConfig ? { cors: corsConfig } : {},
             ...this.config.security ? { security: this.config.security } : {},
+            ...this.config.securityHeaders ? { securityHeaders: this.config.securityHeaders } : {},
             ...this.config.bodyLimit !== void 0 ? { bodyLimit: this.config.bodyLimit } : {},
             ...this.config.urlencodedLimit !== void 0 ? { urlencodedLimit: this.config.urlencodedLimit } : {}
           });
@@ -64896,7 +65786,7 @@ var init_server_instance = __esm({
         this.prepare();
         const deploymentMode = getRuntimeContext16().deployment;
         const bindAddress = resolveBindAddress(this.config.security, deploymentMode);
-        const isProduction6 = process.env["NODE_ENV"] === "production";
+        const isProduction7 = process.env["NODE_ENV"] === "production";
         const findings = auditSecurityDefaults(
           {
             cors: this.config.cors,
@@ -64904,7 +65794,7 @@ var init_server_instance = __esm({
             resolvedBindAddress: bindAddress,
             deploymentMode
           },
-          isProduction6
+          isProduction7
         );
         logSecurityFindings(findings, console);
         await this.host.start(this.config.socketPath ?? this.config.port, bindAddress);
@@ -65148,6 +66038,7 @@ var init_front_mcp = __esm({
     init_scope_registry();
     init_skill_instructions_helper();
     init_task();
+    init_ipc_server_transport();
     init_web_fetch_handler();
     init_front_mcp_providers();
     init_static_startup_check();
@@ -65267,7 +66158,13 @@ var init_front_mcp = __esm({
         }
       }
       static async bootstrap(options) {
-        const parsedConfig = frontMcpMetadataSchema.parse(options);
+        const sqlitePath = process.env["FRONTMCP_SQLITE_PATH"];
+        const parsedConfig = frontMcpMetadataSchema.parse(
+          sqlitePath ? {
+            ...options,
+            sqlite: { ...options.sqlite ?? {}, path: sqlitePath }
+          } : options
+        );
         const daemonSocket = process.env["FRONTMCP_DAEMON_SOCKET"];
         if (daemonSocket) {
           await _FrontMcpInstance2.runUnixSocket({ ...parsedConfig, socketPath: daemonSocket });
@@ -65644,7 +66541,7 @@ var init_front_mcp = __esm({
             };
             mcpServer.setRequestHandler(handler.requestSchema, wrappedHandler);
           }
-          const transport = new StdioServerTransport();
+          const transport = isIpcStdioRequested() ? new IpcServerTransport() : new StdioServerTransport();
           startupCleanups.push(() => transport.close());
           await mcpServer.connect(transport);
           startupSucceeded = true;
@@ -65897,7 +66794,7 @@ var init_execute_task = __esm({
 
 // libs/sdk/src/common/decorators/front-mcp.decorator.ts
 import "reflect-metadata";
-import { getEnvFlag as getEnvFlag2 } from "@frontmcp/utils";
+import { getEnvFlag as getEnvFlag3 } from "@frontmcp/utils";
 function getDecoratorConfig(target) {
   if (typeof target !== "function") return void 0;
   if (typeof Reflect === "undefined") return void 0;
@@ -65952,9 +66849,9 @@ function FrontMcp(providedMetadata) {
       Reflect.defineMetadata(FrontMcpTokens[property] ?? property, metadata[property], target);
     }
     Reflect.defineMetadata(FRONTMCP_CONFIG_METADATA_KEY, metadata, target);
-    const isServerless2 = getEnvFlag2("FRONTMCP_SERVERLESS");
-    const isSchemaExtract = getEnvFlag2("FRONTMCP_SCHEMA_EXTRACT");
-    const isStdio = getEnvFlag2("FRONTMCP_STDIO");
+    const isServerless2 = getEnvFlag3("FRONTMCP_SERVERLESS");
+    const isSchemaExtract = getEnvFlag3("FRONTMCP_SCHEMA_EXTRACT");
+    const isStdio = getEnvFlag3("FRONTMCP_STDIO");
     const taskWorkerId = typeof process !== "undefined" ? process.env?.["FRONTMCP_RUN_TASK_ID"] : void 0;
     if (taskWorkerId && metadata.serve !== false) {
       void (async () => {
@@ -65980,7 +66877,7 @@ function FrontMcp(providedMetadata) {
     } else if (isServerless2) {
       const ServerlessInstance = getFrontMcpInstance();
       const { setServerlessHandler: setServerlessHandler2, setServerlessHandlerPromise: setServerlessHandlerPromise2, setServerlessHandlerError: setServerlessHandlerError2 } = getServerlessHandlerFns();
-      const isWorker = getEnvFlag2("FRONTMCP_WORKER");
+      const isWorker = getEnvFlag3("FRONTMCP_WORKER");
       const handlerPromise = isWorker ? ServerlessInstance.createFetchHandler(metadata) : ServerlessInstance.createHandler(metadata);
       setServerlessHandlerPromise2(handlerPromise);
       handlerPromise.then(setServerlessHandler2).catch((err) => {
@@ -66704,7 +67601,7 @@ var init_dynamic_adapter = __esm({
        * @param options - Adapter options including required `name` field
        * @throws Error if `name` is missing/empty or if a duplicate name is detected
        */
-      static init(options) {
+      static init(options = {}) {
         const typedOptions = options;
         const adapterName = typedOptions.name;
         if (!adapterName || typeof adapterName !== "string" || adapterName.trim() === "") {
@@ -66743,49 +67640,6 @@ var init_dynamic_adapter = __esm({
   }
 });
 
-// libs/sdk/src/common/dynamic/dynamic.plugin.ts
-function isDynamicPluginClass(value) {
-  return typeof value === "function" && value.prototype instanceof DynamicPlugin;
-}
-var DynamicPlugin;
-var init_dynamic_plugin = __esm({
-  "libs/sdk/src/common/dynamic/dynamic.plugin.ts"() {
-    "use strict";
-    init_transport_errors();
-    init_dynamic_utils();
-    DynamicPlugin = class {
-      get(token) {
-        throw new MethodNotImplementedError("DynamicPlugin", "get");
-      }
-      /**
-       * Static init() method to create a plugin provider.
-       * @param options - Input options (with optional fields for defaults)
-       */
-      static init(options) {
-        const extraProviders = options.providers;
-        const typedOptions = options;
-        if ("useFactory" in options) {
-          return {
-            ...typedOptions,
-            provide: this,
-            inject: options.inject,
-            useFactory: options.useFactory,
-            providers: dedupePluginProviders(extraProviders ?? [])
-          };
-        }
-        const dyn = collectDynamicProviders(this, typedOptions);
-        const mergedProviders = dedupePluginProviders([...dyn ?? [], ...extraProviders ?? []]);
-        return {
-          ...typedOptions,
-          provide: this,
-          useValue: new this(options),
-          providers: mergedProviders
-        };
-      }
-    };
-  }
-});
-
 // libs/sdk/src/common/dynamic/index.ts
 var init_dynamic = __esm({
   "libs/sdk/src/common/dynamic/index.ts"() {
@@ -68801,6 +69655,7 @@ export {
   httpRequestInputSchema,
   httpRespond,
   incrementalAuthConfigSchema,
+  initOptionsOf,
   intentSchema,
   isAlive,
   isAnonymousSubject7 as isAnonymousSubject,
@@ -68923,6 +69778,7 @@ export {
   resolveSchemaDescriptionFormat,
   resolveToolVisibility,
   resolveWithFallbacks,
+  resolvesToVercelKvTaskBackend,
   frontMcpResource as resource,
   frontMcpResourceTemplate as resourceTemplate,
   resourceUriMatches,