@frontmcp/sdk 1.8.4 → 1.8.6

package/index.js

@@ -5972,6 +5972,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
 var import_lazy_zod40, SkillsSearchRequestSchema, SkillsSearchResultSchema, SkillsLoadRequestSchema, SkillsLoadResultSchema, SkillsListRequestSchema, SkillsListResultSchema;
 var init_skills_mcp_types = __esm({
@@ -6429,30 +6456,30 @@ var require_dist = __commonJS({
       sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_utils113 = require("@frontmcp/utils");
+    var import_utils114 = require("@frontmcp/utils");
     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_utils113.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
+      return (0, import_utils114.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
     }
     var SEPARATOR = ":";
     function encryptValue(key, plaintext) {
-      const iv = (0, import_utils113.randomBytes)(12);
+      const iv = (0, import_utils114.randomBytes)(12);
       const plaintextBytes = new TextEncoder().encode(plaintext);
-      const { ciphertext, tag } = (0, import_utils113.encryptAesGcm)(key, plaintextBytes, iv);
-      return [(0, import_utils113.base64urlEncode)(iv), (0, import_utils113.base64urlEncode)(tag), (0, import_utils113.base64urlEncode)(ciphertext)].join(SEPARATOR);
+      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);
     }
     function decryptValue(key, encrypted) {
       const parts = encrypted.split(SEPARATOR);
       if (parts.length !== 3) {
         throw new Error("Invalid encrypted value format");
       }
-      const iv = (0, import_utils113.base64urlDecode)(parts[0]);
-      const tag = (0, import_utils113.base64urlDecode)(parts[1]);
-      const ciphertext = (0, import_utils113.base64urlDecode)(parts[2]);
-      const plaintext = (0, import_utils113.decryptAesGcm)(key, ciphertext, iv, tag);
+      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);
     }
     var import_utils210 = require("@frontmcp/utils");
@@ -10203,7 +10230,33 @@ async function filterDiscoverableSkillResults(scope, registry, results, caller =
     return entry === void 0 || servable.has(entry);
   });
 }
-var SKILLS_HTTP_SURFACE;
+function skillToolsForCaller(loaded, tools, ctx, surface) {
+  const caller = callerSurface(ctx, surface);
+  if (!tools || caller === void 0 || loaded.availableTools.length === 0) return loaded;
+  const availability = new Map(tools.getTools(true).map((tool) => [tool.name, tool.metadata?.availableWhen]));
+  const notOffered = loaded.availableTools.filter((name44) => !isOfferedOnSurface(availability.get(name44), caller));
+  if (notOffered.length === 0) return loaded;
+  return {
+    ...loaded,
+    availableTools: loaded.availableTools.filter((name44) => !notOffered.includes(name44)),
+    missingTools: [...loaded.missingTools, ...notOffered],
+    isComplete: false,
+    warning: warningWithMissingTools(loaded.warning, loaded.skill?.name, notOffered)
+  };
+}
+function warningWithMissingTools(warning, skillName, names) {
+  const prefix = warning?.match(WARNING_PREFIX);
+  if (warning && prefix && warning.endsWith(WARNING_SUFFIX)) {
+    const parts = warning.slice(prefix[0].length, -WARNING_SUFFIX.length).split("; ");
+    const missing = parts.findIndex((part) => part.startsWith(MISSING_PART));
+    if (missing === -1) parts.unshift(`${MISSING_PART}${names.join(", ")}`);
+    else parts[missing] = `${parts[missing]}, ${names.join(", ")}`;
+    return `${prefix[0]}${parts.join("; ")}${WARNING_SUFFIX}`;
+  }
+  const sentence = `Skill "${skillName ?? "skill"}" references ${MISSING_PART}${names.join(", ")}${WARNING_SUFFIX}`;
+  return warning ? `${warning} ${sentence}` : sentence;
+}
+var SKILLS_HTTP_SURFACE, WARNING_PREFIX, WARNING_SUFFIX, MISSING_PART;
 var init_skill_filter_helper = __esm({
   "libs/sdk/src/skill/skill-filter.helper.ts"() {
     "use strict";
@@ -10212,6 +10265,9 @@ var init_skill_filter_helper = __esm({
     init_skill_authorities_helper();
     init_skill_entry_resolver();
     SKILLS_HTTP_SURFACE = "mcp";
+    WARNING_PREFIX = /^Skill "(.*)" references /;
+    WARNING_SUFFIX = ". Some functionality may be limited.";
+    MISSING_PART = "missing tools: ";
   }
 });
 
@@ -10312,7 +10368,13 @@ async function formatSkillsForLlmFull(registry, toolRegistry, visibility = "both
     }
     const loaded = await registry.loadSkill(skill.name);
     if (loaded) {
-      parts.push(formatSkillForLLMWithSchemas(loaded.skill, loaded.availableTools, loaded.missingTools, toolRegistry));
+      const { availableTools, missingTools } = skillToolsForCaller(
+        loaded,
+        toolRegistry,
+        void 0,
+        SKILLS_HTTP_SURFACE
+      );
+      parts.push(formatSkillForLLMWithSchemas(loaded.skill, availableTools, missingTools, toolRegistry));
     }
   }
   return parts.join("\n\n---\n\n");
@@ -10432,6 +10494,7 @@ function skillToApiResponse(skill, loadResult) {
 var init_skill_http_utils = __esm({
   "libs/sdk/src/skill/skill-http.utils.ts"() {
     "use strict";
+    init_skill_filter_helper();
   }
 });
 
@@ -10995,7 +11058,11 @@ function skillsLoadRequestHandler({
             throw toSdkMcpError(err);
           }
         }
-        const { skill, availableTools, missingTools, isComplete, warning } = loadResult;
+        const { skill, availableTools, missingTools, isComplete, warning } = skillToolsForCaller(
+          loadResult,
+          toolRegistry,
+          withMcpSurface(scope, ctx)
+        );
         if (warning) {
           warnings.push(warning);
         }
@@ -12003,6 +12070,7 @@ var init_direct_client = __esm({
     "use strict";
     import_protocol30 = require("@frontmcp/protocol");
     import_utils29 = require("@frontmcp/utils");
+    init_list_all_pages_utils();
     init_errors();
     init_skills_mcp_types();
     init_llm_platform();
@@ -12149,8 +12217,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({
@@ -14550,6 +14621,9 @@ function readPublicUrlPin() {
 function isPublicUrlPinned() {
   return readPublicUrlPin() !== void 0;
 }
+function getPinnedPublicUrl() {
+  return readPublicUrlPin();
+}
 function isProxyTrusted() {
   try {
     if (typeof process !== "undefined" && process.env) {
@@ -15999,6 +16073,11 @@ async function performElicit(deps, message, requestedSchema, options) {
   }
   const ctx = tryGetContext();
   const mrtr = ctx?.getMrtrExchange?.();
+  if (mrtr && mrtr.clientDeclaredRevision === false && mrtr.supportsElicitation?.(options?.mode ?? "form") !== true) {
+    throw new ElicitationNotSupportedError(
+      "This client does not support elicitation: it declared no elicitation capability, and without a session the elicitation fallback has no one to answer it"
+    );
+  }
   if (mrtr) {
     const zodSchema = requestedSchema instanceof import_lazy_zod45.z.ZodType ? requestedSchema : import_lazy_zod45.z.object(requestedSchema);
     const answer = mrtr.resolveElicitation({
@@ -21944,6 +22023,9 @@ var init_call_tool_flow = __esm({
       uiResult: import_lazy_zod57.z.any().optional(),
       // UI metadata from rendering (merged into _meta)
       uiMeta: import_lazy_zod57.z.record(import_lazy_zod57.z.string(), import_lazy_zod57.z.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: import_lazy_zod57.z.record(import_lazy_zod57.z.string(), import_lazy_zod57.z.unknown()).optional(),
       // Progress token from request's _meta (for progress notifications)
       progressToken: import_lazy_zod57.z.union([import_lazy_zod57.z.string(), import_lazy_zod57.z.number()]).optional(),
       // JSON-RPC request ID (for elicitation routing)
@@ -22364,6 +22446,7 @@ var init_call_tool_flow = __esm({
           context.mark("createToolCallContext");
           context._toolNameInternal = tool.metadata.id ?? tool.metadata.name;
           context._toolInputInternal = input.arguments;
+          context._jsonRpcRequestIdInternal = this.state.jsonRpcRequestId;
           const frontmcpContext = context.tryGetContext();
           const authInfoWithTransport = authInfo;
           if (frontmcpContext && authInfoWithTransport?.transport?.sendElicitRequest) {
@@ -22770,7 +22853,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;
@@ -22813,6 +22896,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) {
@@ -25358,6 +25444,56 @@ var init_dynamic_utils = __esm({
   }
 });
 
+// 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 {
+            ...typedOptions,
+            provide: this,
+            inject: options.inject,
+            useFactory: options.useFactory,
+            providers: dedupePluginProviders(extraProviders ?? [])
+          };
+        }
+        const dyn = collectDynamicProviders(this, typedOptions);
+        const mergedProviders = dedupePluginProviders([...dyn ?? [], ...extraProviders ?? []]);
+        const instance = new this(options);
+        initOptionsByInstance.set(instance, options);
+        return {
+          ...typedOptions,
+          provide: this,
+          useValue: instance,
+          providers: mergedProviders
+        };
+      }
+    };
+  }
+});
+
 // libs/sdk/src/common/interfaces/internal/flow.utils.ts
 var FlowState;
 var init_flow_utils2 = __esm({
@@ -27238,7 +27374,11 @@ var init_skill_events = __esm({
        */
       emit(event) {
         for (const listener of [...this.listeners]) {
-          listener(event);
+          try {
+            listener(event);
+          } catch (err) {
+            console.error("SkillEmitter listener error:", err instanceof Error ? err.message : "Unknown error");
+          }
         }
       }
       /**
@@ -27517,6 +27657,24 @@ var init_skill_instance = __esm({
 });
 
 // libs/sdk/src/skill/skill.registry.ts
+function findIdPathCollision(skills) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const path3 = skill.getSkillPath();
+    if (!byPath.has(path3)) byPath.set(path3, skill);
+  }
+  for (const idOwner of skills) {
+    const id = idOwner.metadata.id;
+    if (!id || id === idOwner.getSkillPath()) continue;
+    const pathOwner = byPath.get(id);
+    if (pathOwner) return { idOwner, pathOwner };
+  }
+  return void 0;
+}
+function describeIdPathCollision({ idOwner, pathOwner }) {
+  const id = idOwner.metadata.id;
+  return `id "${id}" of skill "${idOwner.metadata.name}" is the skill:// path of skill "${pathOwner.metadata.name}", so skill://${id}/SKILL.md would serve one for the other. Give one of them another id or name.`;
+}
 var import_di22, import_utils61, DEFAULT_LIST_LIMIT, SkillRegistry;
 var init_skill_registry = __esm({
   "libs/sdk/src/skill/skill.registry.ts"() {
@@ -27550,16 +27708,30 @@ var init_skill_registry = __esm({
       dynamicContents = /* @__PURE__ */ new Map();
       /**
        * Per-id generation counter for dynamic registrations. Bumped on every
-       * registerSkillContent call so a stale unregister handle held by an earlier
-       * caller cannot remove a replacement registration.
+       * registerSkillContent call, and on every removal, so a stale unregister
+       * handle held by an earlier caller cannot remove a later registration. Never
+       * reset: a counter restarted at 1 would match an old handle's generation.
        */
       dynamicGenerations = /* @__PURE__ */ new Map();
+      /**
+       * Ids of skills that left the registry (its own dynamic skills, or an adopted child's) whose copy
+       * in the storage provider is not removed yet: the removal is pending, or the provider failed it.
+       * Provider-backed reads skip them until the removal succeeds or the id is served again. Each maps
+       * to the number of its withdrawal.
+       */
+      withdrawn = /* @__PURE__ */ new Map();
+      /** Numbers each withdrawal, so a removal that completes late clears only its own. */
+      withdrawals = 0;
+      /** The last storage-provider write queued per skill id ({@link syncProvider}). */
+      providerWrites = /* @__PURE__ */ new Map();
       /** Whether a plugin registers skills at runtime ({@link expectDynamicSkills}). */
       dynamicSkillsExpected = false;
       /** Adopted skills from child registries */
       adopted = /* @__PURE__ */ new Map();
       /** Children registries */
       children = /* @__PURE__ */ new Set();
+      /** The registries that adopted this one: a skill registered here is served through them too. */
+      adopters = /* @__PURE__ */ new Set();
       /** O(1) indexes */
       byQualifiedId = /* @__PURE__ */ new Map();
       /** Owner lineage per skill instance, rebuilt with the index so `lineageOf` is O(1). */
@@ -27644,8 +27816,10 @@ var init_skill_registry = __esm({
           const row = this.makeRow(token, instance, lineage, this);
           this.localRows.push(row);
           try {
-            const content = await instance.load();
-            await this.storageProvider.add(content);
+            await this.syncProvider(instance.metadata.id ?? instance.metadata.name, async () => {
+              const content = await instance.load();
+              await this.storageProvider.add(content);
+            });
           } catch (error) {
             this.scope.logger.warn(`Failed to load skill ${instance.name}: ${error.message}`);
           }
@@ -27668,6 +27842,10 @@ var init_skill_registry = __esm({
             await this.adoptFromChild(child, child.owner);
           }
         }
+        const collision = findIdPathCollision(this.listAllInstances());
+        if (collision) {
+          throw new InvalidSkillError(collision.idOwner.metadata.name, describeIdPathCollision(collision));
+        }
         this.reindex();
         logAvailabilityFiltering(
           "SkillRegistry",
@@ -27687,24 +27865,31 @@ var init_skill_registry = __esm({
         const adoptedRows = childRows.map((r) => this.relineage(r, prepend));
         this.adopted.set(child, adoptedRows);
         this.children.add(child);
+        child.adopters.add(this);
         child.subscribe({ immediate: false }, () => {
+          const previous = this.adopted.get(child) ?? [];
           const latest = child.listAllIndexed().map((r) => this.relineage(r, prepend));
           this.adopted.set(child, latest);
           this.reindex();
-          this.bump("reset");
+          this.withdrawGoneAdoptedSkills(previous);
           for (const row of latest) {
-            row.instance.load().then((content) => {
-              this.storageProvider.add(content);
+            const skillId = row.instance.metadata.id ?? row.instance.metadata.name;
+            this.syncProvider(skillId, async () => {
+              const content = await row.instance.load();
+              await this.storageProvider.add(content);
             }).catch((error) => {
               this.scope.logger.warn(`Failed to reload adopted skill ${row.baseName}: ${error.message}`);
             });
           }
+          this.bump("reset");
         });
         await Promise.all(
           adoptedRows.map(async (row) => {
             try {
-              const content = await row.instance.load();
-              await this.storageProvider.add(content);
+              await this.syncProvider(row.instance.metadata.id ?? row.instance.metadata.name, async () => {
+                const content = await row.instance.load();
+                await this.storageProvider.add(content);
+              });
             } catch (error) {
               this.scope.logger.warn(`Failed to load adopted skill ${row.baseName}: ${error.message}`);
             }
@@ -27713,6 +27898,37 @@ var init_skill_registry = __esm({
         this.reindex();
         this.bump("reset");
       }
+      /**
+       * The `skill://` namespaces this registry's skills are served in: its own, and that of every
+       * registry that adopts it, directly or through another, sibling registries included.
+       */
+      namespacesServingThis() {
+        const registries = /* @__PURE__ */ new Set();
+        const climb = (registry) => {
+          if (registries.has(registry)) return;
+          registries.add(registry);
+          for (const adopter of registry.adopters) climb(adopter);
+        };
+        climb(this);
+        return [...registries].map((registry) => registry.liveSkills());
+      }
+      /**
+       * This registry's skills and those of every registry it adopted, read from each registry's own rows.
+       * An adopter's copy of a child's rows is refreshed only on the child's change event, which a
+       * registration emits after it has committed its row and awaited the storage provider.
+       */
+      liveSkills() {
+        const registries = /* @__PURE__ */ new Set();
+        const skills = /* @__PURE__ */ new Set();
+        const descend = (registry) => {
+          if (registries.has(registry)) return;
+          registries.add(registry);
+          for (const row of [...registry.localRows, ...registry.dynamicRows]) skills.add(row.instance);
+          for (const child of registry.children) descend(child);
+        };
+        descend(this);
+        return [...skills];
+      }
       /* -------------------- Public API -------------------- */
       /**
        * Get all skills in the registry.
@@ -27830,7 +28046,14 @@ var init_skill_registry = __esm({
         }
       }
       async search(query, options) {
-        const baseResults = await this.storageProvider.search(query, options);
+        const topK = options?.topK;
+        const hidden = this.hiddenFromProviderRead();
+        const providerOptions = hidden.size > 0 && typeof topK === "number" && topK >= 0 ? { ...options, topK: topK + hidden.size } : options;
+        let baseResults = await this.storageProvider.search(query, providerOptions);
+        if (hidden.size > 0 || this.withdrawn.size > 0) {
+          baseResults = baseResults.filter((r) => !hidden.has(r.metadata));
+          if (typeof topK === "number" && topK >= 0) baseResults = baseResults.slice(0, topK);
+        }
         if (this.dynamicContents.size === 0) return baseResults;
         const baseSeen = /* @__PURE__ */ new Set();
         let rewrites = 0;
@@ -27854,7 +28077,6 @@ var init_skill_registry = __esm({
         const overlayOnly = this.searchDynamicOverlay(query, options, baseSeen);
         if (overlayOnly.length === 0 && rewrites === 0) return baseResults;
         const merged = [...rewrittenBase, ...overlayOnly].sort((a, b) => b.score - a.score);
-        const topK = options?.topK;
         return typeof topK === "number" && topK >= 0 ? merged.slice(0, topK) : merged;
       }
       /**
@@ -27909,7 +28131,10 @@ var init_skill_registry = __esm({
             warning
           };
         }
+        const hidden = this.hiddenFromProviderRead();
+        if (hidden.has({ name: skillId })) return void 0;
         const result = await this.storageProvider.load(skillId);
+        if (result && hidden.has(result.skill)) return void 0;
         return result ?? void 0;
       }
       /**
@@ -27945,8 +28170,12 @@ var init_skill_registry = __esm({
        * and `hasMore` stay correct.
        */
       async listSkills(options) {
-        if (this.dynamicContents.size === 0) return this.storageProvider.list(options);
-        const base = await this.listAllFromProvider(options);
+        const hidden = this.hiddenFromProviderRead();
+        if (this.dynamicContents.size === 0 && hidden.size === 0) {
+          const page = await this.storageProvider.list(options);
+          if (this.withdrawn.size === 0) return page;
+        }
+        const base = (await this.listAllFromProvider(options)).filter((meta) => !hidden.has(meta));
         const baseIds = /* @__PURE__ */ new Set();
         const merged = base.map((meta) => {
           const id = meta.id ?? meta.name;
@@ -28006,21 +28235,20 @@ var init_skill_registry = __esm({
       /**
        * Get total skill count.
        *
-       * Sums the provider count with overlay rows the provider does not know
+       * Counts the provider's rows with overlay rows the provider does not know
        * about so callers see the same surface as `search` / `listSkills`.
        */
       async count(options) {
-        const baseCount = await this.storageProvider.count(options);
-        if (this.dynamicContents.size === 0) return baseCount;
-        const baseList = await this.storageProvider.list({
-          tags: options?.tags,
-          includeHidden: options?.includeHidden,
-          limit: Number.MAX_SAFE_INTEGER
-        });
+        const hidden = this.hiddenFromProviderRead();
+        if (this.dynamicContents.size === 0 && hidden.size === 0) {
+          const counted = await this.storageProvider.count(options);
+          if (this.withdrawn.size === 0) return counted;
+        }
+        const baseList = (await this.listAllFromProvider({ tags: options?.tags, includeHidden: options?.includeHidden })).filter((m) => !hidden.has(m));
         const baseIds = /* @__PURE__ */ new Set();
-        for (const m of baseList.skills) baseIds.add(m.id ?? m.name);
+        for (const m of baseList) baseIds.add(m.id ?? m.name);
         const overlay = this.collectDynamicMetadata(options).filter((m) => !baseIds.has(m.id ?? m.name));
-        return baseCount + overlay.length;
+        return baseList.length + overlay.length;
       }
       /**
        * Project a SkillContent into the SkillMetadata shape callers expect from
@@ -28310,10 +28538,6 @@ var init_skill_registry = __esm({
           throw new PublicMcpError("registerSkillContent: SkillContent.name is required", "INVALID_PARAMS");
         }
         const id = content.id;
-        const existingIdx = this.dynamicRows.findIndex((r) => r.instance.name === id);
-        if (existingIdx !== -1) {
-          this.dynamicRows.splice(existingIdx, 1);
-        }
         const metadata = {
           id,
           name: content.name,
@@ -28349,28 +28573,49 @@ var init_skill_registry = __esm({
             `[SkillRegistry] Failed to pre-load dynamic skill ${id} from source ${opts?.source ?? "unknown"}: ${error.message}`
           );
         }
+        const existingIdx = this.dynamicRows.findIndex((r) => r.instance.name === id);
+        const superseded = new Set(opts?.supersedes);
+        const leaving = new Set(
+          this.dynamicRows.filter((r) => r.instance.name === id || superseded.has(r.instance.name)).map((r) => r.instance)
+        );
+        for (const skills of this.namespacesServingThis()) {
+          const collision = findIdPathCollision([...skills.filter((other) => !leaving.has(other)), instance]);
+          if (collision) {
+            throw new PublicMcpError(`registerSkillContent: ${describeIdPathCollision(collision)}`, "INVALID_PARAMS");
+          }
+        }
+        if (existingIdx !== -1) {
+          this.dynamicRows.splice(existingIdx, 1);
+        }
+        const mutable = this.asMutableProvider(this.storageProvider);
+        const removed = this.dynamicRows.filter((r) => superseded.has(r.instance.name) && findIdPathCollision([r.instance, instance])).map((r) => r.instance.name);
+        for (const removedId of removed) {
+          this.withdrawDynamicSkill(removedId, mutable);
+        }
         const lineage = this.owner ? [this.owner] : [];
         const row = this.makeRow(provideToken, instance, lineage, this);
         this.dynamicRows.push(row);
         this.dynamicContents.set(id, structuredClone(content));
+        this.withdrawn.delete(id);
         const generation = (this.dynamicGenerations.get(id) ?? 0) + 1;
         this.dynamicGenerations.set(id, generation);
-        const mutable = this.asMutableProvider(this.storageProvider);
-        if (mutable) {
-          try {
+        this.reindex();
+        const providerWrites = mutable ? [
+          ...removed.map((removedId) => this.removeFromProvider(mutable, removedId)),
+          this.syncProvider(id, async () => {
             if (await mutable.exists(id)) {
               await mutable.update(id, content);
             } else {
               await mutable.add(content);
             }
-          } catch (error) {
+          }).catch((error) => {
             this.scope.logger.warn(
               `[SkillRegistry] Failed to index dynamic skill ${id} in storage provider: ${error.message}`
             );
-          }
-        }
-        this.reindex();
+          })
+        ] : [];
         this.bump("reset");
+        await Promise.all(providerWrites);
         let unregistered = false;
         const unregister = async () => {
           if (unregistered) return;
@@ -28383,32 +28628,99 @@ var init_skill_registry = __esm({
         this.scope.logger.debug(
           `[SkillRegistry] Registered dynamic skill ${id}${opts?.source ? ` (source: ${opts.source})` : ""}`
         );
-        return { id, unregister };
+        return { id, unregister, removed };
       }
       /**
        * Remove a previously-registered dynamic skill by id.
        */
       async unregisterSkill(id) {
-        const idx = this.dynamicRows.findIndex((r) => r.instance.name === id);
-        if (idx === -1) return false;
-        this.dynamicRows.splice(idx, 1);
-        this.dynamicContents.delete(id);
-        this.dynamicGenerations.delete(id);
+        if (!this.dynamicRows.some((r) => r.instance.name === id)) return false;
         const mutable = this.asMutableProvider(this.storageProvider);
-        if (mutable) {
-          try {
-            await mutable.remove(id);
-          } catch (error) {
-            this.scope.logger.warn(
-              `[SkillRegistry] Failed to remove dynamic skill ${id} from storage provider: ${error.message}`
-            );
-          }
-        }
+        this.withdrawDynamicSkill(id, mutable);
         this.reindex();
+        const removal = mutable ? this.removeFromProvider(mutable, id) : void 0;
         this.bump("reset");
+        await removal;
         this.scope.logger.debug(`[SkillRegistry] Unregistered dynamic skill ${id}`);
         return true;
       }
+      /**
+       * Take a dynamic skill out of the registry, synchronously. Its generation advances so a handle
+       * from an earlier registration stays a no-op, and while a mutable provider still holds its copy it
+       * is withdrawn from provider-backed reads.
+       */
+      withdrawDynamicSkill(id, mutable) {
+        this.dynamicRows.splice(
+          this.dynamicRows.findIndex((r) => r.instance.name === id),
+          1
+        );
+        this.dynamicContents.delete(id);
+        this.dynamicGenerations.set(id, (this.dynamicGenerations.get(id) ?? 0) + 1);
+        if (mutable) this.withdrawn.set(id, ++this.withdrawals);
+      }
+      /** Remove a withdrawn skill's copy from the provider. If that fails it stays withdrawn from reads. */
+      async removeFromProvider(mutable, id) {
+        const withdrawal = this.withdrawn.get(id);
+        try {
+          await this.syncProvider(id, () => mutable.remove(id));
+          if (this.withdrawn.get(id) === withdrawal) this.withdrawn.delete(id);
+        } catch (error) {
+          this.scope.logger.warn(
+            `[SkillRegistry] Failed to remove skill ${id} from storage provider; it stays hidden from provider-backed reads: ${error.message}`
+          );
+        }
+      }
+      /**
+       * Run a storage-provider write for one skill id after the ones queued before it for that id, so a
+       * removal that completes late cannot delete the copy a later registration added. The returned
+       * promise settles with the write; a failure does not hold back the next one.
+       */
+      syncProvider(id, write) {
+        const run = (this.providerWrites.get(id) ?? Promise.resolve()).then(write);
+        const settled = run.then(
+          () => void 0,
+          () => void 0
+        );
+        this.providerWrites.set(id, settled);
+        void settled.then(() => {
+          if (this.providerWrites.get(id) === settled) this.providerWrites.delete(id);
+        });
+        return run;
+      }
+      /**
+       * After a child's change, take the skills that left it (and are not served here some other way)
+       * out of this registry's storage provider too. The re-add on change only adds, so without this an
+       * adopter's provider kept serving a skill the child had removed. Until the removal completes, and
+       * if it fails, provider-backed reads skip it.
+       */
+      withdrawGoneAdoptedSkills(previous) {
+        const mutable = this.asMutableProvider(this.storageProvider);
+        if (!mutable) return;
+        const skillIdOf = (entry) => entry.metadata.id ?? entry.metadata.name;
+        const live = new Set(this.listAllIndexed().map((r) => skillIdOf(r.instance)));
+        for (const id of live) this.withdrawn.delete(id);
+        for (const row of previous) {
+          const id = skillIdOf(row.instance);
+          if (live.has(id) || this.withdrawn.has(id)) continue;
+          this.withdrawn.set(id, ++this.withdrawals);
+          void this.removeFromProvider(mutable, id);
+        }
+      }
+      /**
+       * Which provider-backed rows a read that starts now must skip: a skill withdrawn when the read
+       * starts (its removal may complete while the provider answers, clearing the withdrawal, yet the
+       * answer can still hold it), or withdrawn by the time the answer arrives.
+       */
+      hiddenFromProviderRead() {
+        const atStart = new Set(this.withdrawn.keys());
+        return {
+          size: atStart.size,
+          has: (meta) => {
+            const id = meta.id ?? meta.name;
+            return atStart.has(id) || this.withdrawn.has(id);
+          }
+        };
+      }
       /* -------------------- Internal helpers -------------------- */
       asMutableProvider(provider) {
         const candidate = provider;
@@ -28670,7 +28982,7 @@ var init_plugin_utils = __esm({
 });
 
 // libs/sdk/src/plugin/plugin.registry.ts
-var import_reflect_metadata12, import_di24, PluginRegistry;
+var import_reflect_metadata12, import_di24, installedPluginValues, PluginRegistry;
 var init_plugin_registry = __esm({
   "libs/sdk/src/plugin/plugin.registry.ts"() {
     "use strict";
@@ -28678,6 +28990,7 @@ var init_plugin_registry = __esm({
     import_di24 = require("@frontmcp/di");
     init_adapter_registry();
     init_common();
+    init_dynamic_plugin();
     init_dynamic_utils();
     init_context_extension();
     init_errors();
@@ -28690,6 +29003,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();
@@ -28878,8 +29192,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));
@@ -29393,7 +29714,7 @@ var init_agent_instance = __esm({
       "hideFromDiscovery"
     ]);
     AgentInstance = class extends AgentEntry {
-      providers;
+      providerRegistry;
       scope;
       hooks;
       /** The LLM adapter for this agent */
@@ -29411,11 +29732,11 @@ var init_agent_instance = __esm({
       constructor(record, providers, owner) {
         super(record);
         this.owner = owner;
-        this.providers = providers;
+        this.providerRegistry = providers;
         this.name = record.metadata.id ?? record.metadata.name;
         this.id = record.metadata.id ?? record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
-        this.scope = this.providers.getActiveScope();
+        this.scope = this.providerRegistry.getActiveScope();
         this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         this.outputSchema = record.metadata.outputSchema;
@@ -29474,11 +29795,11 @@ var init_agent_instance = __esm({
         const adapterOptions = {
           providerResolver: {
             get: (token) => {
-              return this.providers.get(token);
+              return this.providerRegistry.get(token);
             },
             tryGet: (token) => {
               try {
-                return this.providers.get(token);
+                return this.providerRegistry.get(token);
               } catch {
                 return void 0;
               }
@@ -29491,7 +29812,7 @@ var init_agent_instance = __esm({
           }
         };
         try {
-          const configService = this.providers.get(ConfigService);
+          const configService = this.providerRegistry.get(ConfigService);
           if (configService) {
             adapterOptions.configResolver = this.createConfigResolver(configService);
           }
@@ -29599,7 +29920,7 @@ var init_agent_instance = __esm({
           const toolMetadata = this.buildAgentToolMetadata();
           const agentToolFunction = frontMcpTool(toolMetadata)(this.createAgentToolExecuteHandler());
           const toolRecord = normalizeTool(agentToolFunction);
-          this.agentToolInstance = new ToolInstance(toolRecord, this.providers, this.owner);
+          this.agentToolInstance = new ToolInstance(toolRecord, this.providerRegistry, this.owner);
           await this.agentToolInstance.ready;
           this.scope.logger.debug(`Created agent tool instance: ${this.agentToolInstance.name} for agent ${this.name}`);
         } catch (error) {
@@ -29641,16 +29962,34 @@ var init_agent_instance = __esm({
       /**
        * Create the execute handler for the agent tool.
        *
-       * This handler is called when the tool is invoked through the standard
-       * tools:call-tool flow. It creates an AgentContext and runs the LLM loop.
+       * The tool's `tools:call-tool` flow has already applied everything the agent declares
+       * (authorities, rate limit, concurrency, timeout and plugin gates, copied onto the tool). The
+       * handler then runs the agent through the `agents:call-agent` flow, so the hooks registered for
+       * agent invocation (`AgentCallHook`, and the agent class's own hooks on that flow) run and the
+       * agent's context gets the request's context providers. The flow's own gates are left to the
+       * tool flow (`gatedBy`), so nothing is counted twice.
        */
       createAgentToolExecuteHandler() {
         return async (input, toolCtx) => {
           const authInfo = toolCtx.authInfo;
-          const agentCallExtra = { authInfo };
-          const agentContext = this.create(input, agentCallExtra);
-          const result = await agentContext.execute(input);
-          return result;
+          const progressToken = toolCtx._progressTokenInternal;
+          const requestId = toolCtx._jsonRpcRequestIdInternal;
+          return this.scope.runFlowForOutput("agents:call-agent", {
+            request: {
+              method: "tools/call",
+              params: {
+                name: this.id,
+                arguments: input,
+                ...progressToken !== void 0 ? { _meta: { progressToken } } : {}
+              }
+            },
+            ctx: {
+              authInfo,
+              ...requestId !== void 0 ? { requestId } : {},
+              ...toolCtx.signal ? { signal: toolCtx.signal } : {}
+            },
+            gatedBy: "tools:call-tool"
+          });
         };
       }
       /**
@@ -29664,6 +30003,10 @@ var init_agent_instance = __esm({
       getToolInstance() {
         return this.agentToolInstance;
       }
+      /** The provider registry this agent was registered with (its app's). */
+      get providers() {
+        return this.providerRegistry;
+      }
       /**
        * The tools this agent can call: those it declares and those its plugins contribute, as its private
        * scope holds them. Empty until the agent is initialized.
@@ -29713,7 +30056,7 @@ var init_agent_instance = __esm({
           case "VALUE" /* VALUE */:
             return this.record.useValue;
           case "FACTORY" /* FACTORY */:
-            return this.record.useFactory(this.providers);
+            return this.record.useFactory(this.providerRegistry);
           case "ESM" /* ESM */:
             throw new AgentNotConfiguredError(`ESM agent "${this.name}" cannot be created via AgentInstance.create()`);
           case "REMOTE" /* REMOTE */:
@@ -29732,11 +30075,13 @@ var init_agent_instance = __esm({
        * @param llmAdapter - The LLM adapter (passed explicitly to avoid non-null assertion)
        */
       buildAgentCtorArgs(input, ctx, llmAdapter) {
-        const scope = this.providers.getActiveScope();
+        const scope = this.providerRegistry.getActiveScope();
         return {
           metadata: this.metadata,
           input,
-          providers: this.providers,
+          // The request's context-aware providers when the agents:call-agent flow built them, so
+          // `this.context` and CONTEXT-scoped providers resolve inside the agent.
+          providers: ctx.contextProviders ?? this.providerRegistry,
           logger: scope.logger,
           authInfo: ctx.authInfo,
           llmAdapter,
@@ -29807,7 +30152,8 @@ var init_agent_instance = __esm({
           await this.assertToolAuthorized(tool, ctx.authInfo, args);
           const runningTool = { name: tool.name, fullName: tool.fullName };
           return runOnSurface(AGENT_SURFACE, () => {
-            const toolContext = runAsTool(runningTool, () => tool.create(args, ctx));
+            const { contextProviders: _agentProviders, ...toolCtx } = ctx;
+            const toolContext = runAsTool(runningTool, () => tool.create(args, toolCtx));
             return runAsTool(runningTool, () => Promise.resolve(toolContext.execute(args)));
           });
         };
@@ -30346,6 +30692,53 @@ var init_agent_registry = __esm({
   }
 });
 
+// libs/sdk/src/channel/sources/completion-events.ts
+function completionEventsOf(scope) {
+  let events = byScope.get(scope);
+  if (!events) {
+    events = new ScopeCompletionEvents();
+    byScope.set(scope, events);
+  }
+  return events;
+}
+function completionOutputText(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var CompletionStream, ScopeCompletionEvents, byScope;
+var init_completion_events = __esm({
+  "libs/sdk/src/channel/sources/completion-events.ts"() {
+    "use strict";
+    CompletionStream = class {
+      listeners = /* @__PURE__ */ new Set();
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+          this.listeners.delete(listener);
+        };
+      }
+      emit(event) {
+        for (const listener of [...this.listeners]) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+      }
+    };
+    ScopeCompletionEvents = class {
+      agents = new CompletionStream();
+      jobs = new CompletionStream();
+    };
+    byScope = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // libs/sdk/src/agent/flows/call-agent.flow.ts
 var import_auth26, import_guard6, import_lazy_zod60, import_protocol41, inputSchema15, outputSchema14, stateSchema14, plan14, name14, Stage14, CallAgentFlow;
 var init_call_agent_flow = __esm({
@@ -30355,13 +30748,22 @@ var init_call_agent_flow = __esm({
     import_guard6 = require("@frontmcp/guard");
     import_lazy_zod60 = require("@frontmcp/lazy-zod");
     import_protocol41 = require("@frontmcp/protocol");
+    init_completion_events();
     init_common();
     init_errors();
     init_hooks_utils();
+    init_flow_context_providers();
     inputSchema15 = import_lazy_zod60.z.object({
       request: import_protocol41.CallToolRequestSchema,
       // z.any() used because ctx is the MCP SDK's ToolCallExtra type which varies by SDK version
-      ctx: import_lazy_zod60.z.any()
+      ctx: import_lazy_zod60.z.any(),
+      /**
+       * Set when the agent's `invoke_<agent>` tool runs this flow. That tool's `tools:call-tool` flow
+       * has already applied the agent's authorities, rate limit, concurrency and timeout (they are
+       * copied onto the tool), so this flow's stages for them leave the checks to it instead of
+       * counting the call twice. Their hooks still run.
+       */
+      gatedBy: import_lazy_zod60.z.literal("tools:call-tool").optional()
     });
     outputSchema14 = import_protocol41.CallToolResultSchema;
     stateSchema14 = import_lazy_zod60.z.object({
@@ -30394,7 +30796,13 @@ var init_call_agent_flow = __esm({
       // Semaphore ticket for concurrency control (set by acquireSemaphore, used by releaseSemaphore)
       semaphoreTicket: import_lazy_zod60.z.any().optional(),
       // A timed-out execute() that is still running; its concurrency slot is released when it settles
-      abandonedExecution: import_lazy_zod60.z.instanceof(Promise).optional()
+      abandonedExecution: import_lazy_zod60.z.instanceof(Promise).optional(),
+      // When execute() started, and the error it ended with (for the completion event)
+      executionStartedAt: import_lazy_zod60.z.number().optional(),
+      executionError: import_lazy_zod60.z.any().optional(),
+      // The MCP result built from rawOutput (parseOutput), or why it could not be built
+      parsedOutput: import_lazy_zod60.z.any().optional(),
+      outputError: import_lazy_zod60.z.any().optional()
     });
     plan14 = {
       pre: [
@@ -30407,12 +30815,16 @@ var init_call_agent_flow = __esm({
         "acquireSemaphore"
       ],
       execute: ["validateInput", "execute", "validateOutput"],
-      finalize: ["releaseSemaphore", "releaseQuota", "finalize"]
+      finalize: ["releaseSemaphore", "releaseQuota", "parseOutput", "emitCompletion", "finalize"]
     };
     name14 = "agents:call-agent";
     ({ Stage: Stage14 } = FlowHooksOf(name14));
     CallAgentFlow = class extends FlowBase {
       logger = this.scopeLogger.child("CallAgentFlow");
+      /** Whether the `invoke_<agent>` tool's flow already applied the agent's gates. */
+      get gatedByToolFlow() {
+        return this.input.gatedBy === "tools:call-tool";
+      }
       async parseInput() {
         this.logger.verbose("parseInput:start");
         let method;
@@ -30479,6 +30891,10 @@ var init_call_agent_flow = __esm({
       }
       async checkEntryAuthorities() {
         this.logger.verbose("checkEntryAuthorities:start");
+        if (this.gatedByToolFlow) {
+          this.logger.verbose("checkEntryAuthorities:skip (checked by the invoke tool flow)");
+          return;
+        }
         const engine = this.scope.authoritiesEngine;
         const ctxBuilder = this.scope.authoritiesContextBuilder;
         if (!engine || !ctxBuilder) {
@@ -30544,14 +30960,17 @@ var init_call_agent_flow = __esm({
         const progressToken = this.state.progressToken;
         const authInfo = this.state.authInfo;
         try {
-          const context = agent.create(input.arguments, { ...ctx, progressToken });
+          const sessionKey = authInfo?.sessionId ?? "anonymous";
+          const agentViews = await agent.providers.buildViews(sessionKey, new Map(this.deps), this.scope.providers);
+          const contextProviders = new FlowContextProviders(agent.providers, agentViews.context);
+          const context = agent.create(input.arguments, { ...ctx, progressToken, contextProviders });
           this.appendContextHooks(hooksBoundTo(this.scope.hooks.getClsHooks(agent.record.provide), context));
           context.mark("createAgentContext");
           const frontmcpContext = context.tryGetContext();
           const sdkAuthInfo = authInfo;
-          if (frontmcpContext && sdkAuthInfo?.transport?.sendElicitRequest) {
+          const jsonRpcRequestId = this.state.jsonRpcRequestId;
+          if (frontmcpContext && sdkAuthInfo?.transport?.sendElicitRequest && jsonRpcRequestId !== void 0) {
             const transport = sdkAuthInfo.transport;
-            const jsonRpcRequestId = this.state.jsonRpcRequestId;
             frontmcpContext.setTransport({
               sendElicitRequest: transport.sendElicitRequest.bind(transport),
               type: transport.type ?? "unknown",
@@ -30568,7 +30987,7 @@ var init_call_agent_flow = __esm({
       async acquireQuota() {
         this.logger.verbose("acquireQuota:start");
         const manager = this.scope.rateLimitManager;
-        if (!manager) {
+        if (!manager || this.gatedByToolFlow) {
           this.state.agentContext?.mark("acquireQuota");
           this.logger.verbose("acquireQuota:done (no rate limit manager)");
           return;
@@ -30592,7 +31011,7 @@ var init_call_agent_flow = __esm({
       async acquireSemaphore() {
         this.logger.verbose("acquireSemaphore:start");
         const manager = this.scope.rateLimitManager;
-        if (!manager) {
+        if (!manager || this.gatedByToolFlow) {
           this.state.agentContext?.mark("acquireSemaphore");
           this.logger.verbose("acquireSemaphore:done (no rate limit manager)");
           return;
@@ -30637,7 +31056,8 @@ var init_call_agent_flow = __esm({
         }
         agentContext.mark("execute");
         const startTime = Date.now();
-        const timeoutMs = agent.metadata.timeout?.executeMs ?? agent.metadata.execution?.timeout ?? this.scope.rateLimitManager?.config?.defaultTimeout?.executeMs;
+        this.state.set("executionStartedAt", startTime);
+        const timeoutMs = this.gatedByToolFlow ? agent.metadata.timeout?.executeMs === void 0 ? agent.metadata.execution?.timeout : void 0 : agent.metadata.timeout?.executeMs ?? agent.metadata.execution?.timeout ?? this.scope.rateLimitManager?.config?.defaultTimeout?.executeMs;
         const running = (async () => {
           agentContext.output = await agentContext.execute(agentContext.input);
         })();
@@ -30648,6 +31068,7 @@ var init_call_agent_flow = __esm({
           });
           this.logger.verbose("execute:done");
         } catch (error) {
+          this.state.set("executionError", error);
           if (error instanceof import_guard6.ExecutionTimeoutError) {
             this.logger.warn("execute: agent execution timed out", {
               agent: agent.metadata.name,
@@ -30656,6 +31077,7 @@ var init_call_agent_flow = __esm({
             this.state.set("abandonedExecution", running);
             throw error;
           }
+          if (this.gatedByToolFlow) throw error;
           throw new AgentExecutionError(agent.metadata.name, error instanceof Error ? error : void 0);
         }
       }
@@ -30693,9 +31115,34 @@ var init_call_agent_flow = __esm({
         this.state.agentContext?.mark("releaseQuota");
         this.logger.verbose("releaseQuota:done");
       }
+      async parseOutput() {
+        const { agent, rawOutput } = this.state;
+        if (!agent || rawOutput === void 0) return;
+        const parseResult = agent.safeParseOutput(rawOutput);
+        if (parseResult.success) this.state.set("parsedOutput", parseResult.data);
+        else this.state.set("outputError", parseResult.error);
+      }
+      async emitCompletion() {
+        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 failed = failure !== void 0;
+        const requestId = this.tryGetContext()?.requestId;
+        const sessionId = typeof authInfo?.sessionId === "string" && authInfo.sessionId ? authInfo.sessionId : void 0;
+        completionEventsOf(this.scope).agents.emit({
+          agentId: agent.id,
+          agentName: agent.name,
+          status: failed ? "error" : "success",
+          durationMs: Date.now() - executionStartedAt,
+          ...failed ? { error: failure instanceof Error ? failure.message : String(failure) } : { output: completionOutputText(agentContext?.output) },
+          ...requestId ? { runId: requestId } : {},
+          ...sessionId ? { sessionId } : {}
+        });
+      }
       async finalize() {
         this.logger.verbose("finalize:start");
-        const { agent, rawOutput, executionMeta } = this.state;
+        const { agent, rawOutput, parsedOutput, outputError, executionMeta } = this.state;
         if (!agent) {
           this.logger.verbose("finalize: skipping (no agent in state)");
           return;
@@ -30704,15 +31151,14 @@ var init_call_agent_flow = __esm({
           this.logger.verbose("finalize: skipping (no output - execute stage likely failed)");
           return;
         }
-        const parseResult = agent.safeParseOutput(rawOutput);
-        if (!parseResult.success) {
+        if (outputError !== void 0 || parsedOutput === void 0) {
           this.logger.error("finalize: output validation failed", {
             agent: agent.metadata.name,
-            errors: parseResult.error
+            errors: outputError
           });
           throw new InvalidOutputError();
         }
-        const result = parseResult.data;
+        const result = parsedOutput;
         if (executionMeta) {
           result._meta = {
             ...result._meta,
@@ -30778,6 +31224,12 @@ var init_call_agent_flow = __esm({
     __decorateClass([
       Stage14("releaseQuota")
     ], CallAgentFlow.prototype, "releaseQuota", 1);
+    __decorateClass([
+      Stage14("parseOutput")
+    ], CallAgentFlow.prototype, "parseOutput", 1);
+    __decorateClass([
+      Stage14("emitCompletion")
+    ], CallAgentFlow.prototype, "emitCompletion", 1);
     __decorateClass([
       Stage14("finalize")
     ], CallAgentFlow.prototype, "finalize", 1);
@@ -31285,12 +31737,36 @@ var init_request_validation = __esm({
 });
 
 // libs/sdk/src/transport/mcp-20260728/request-state.ts
-function getRequestStateKey() {
+function configuredSecret(name44) {
+  const value = (0, import_utils65.getEnv)(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) : (0, import_utils65.randomBytes)(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: (0, import_utils65.randomBytes)(32), source: "per-process" };
   return cachedKey;
 }
+function getRequestStateKey() {
+  return resolveKey().key;
+}
+function getRequestStateKeySource() {
+  return resolveKey().source;
+}
+function warnIfRequestStateKeyNotShared(options) {
+  if (warnedKeyNotShared || !(0, import_utils65.isProduction)()) 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"]) {
@@ -31340,13 +31816,14 @@ function decodeRequestState(state, expected) {
   if (payload.b !== expected.binding) return { ok: false, reason: "request-mismatch" };
   return { ok: true, responses: payload.r };
 }
-var import_utils65, DEFAULT_REQUEST_STATE_TTL_MS, MAX_REQUEST_STATE_BYTES, cachedKey, encoder, decoder;
+var import_utils65, 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";
     import_utils65 = require("@frontmcp/utils");
     DEFAULT_REQUEST_STATE_TTL_MS = 10 * 60 * 1e3;
     MAX_REQUEST_STATE_BYTES = 256 * 1024;
+    warnedKeyNotShared = false;
     encoder = new TextEncoder();
     decoder = new TextDecoder();
   }
@@ -31580,10 +32057,17 @@ var init_mrtr = __esm({
       /** Per-kind call counters, used to derive stable keys across a replay. */
       counters = { elicitation: 0, sampling: 0, roots: 0 };
       clientCapabilities;
+      /**
+       * Whether the client itself declared this revision. `false` when the SERVER served an
+       * unversioned call as 2026-07-28 (`transport.defaultProtocolVersion`, the Worker default): such a
+       * client, typically a 2025-03-26 one, never agreed to the revision's input-request contract.
+       */
+      clientDeclaredRevision;
       binding;
       constructor(params) {
         this.responses = { ...params.carriedResponses ?? {}, ...params.inputResponses ?? {} };
         this.clientCapabilities = params.clientCapabilities;
+        this.clientDeclaredRevision = params.clientDeclaredRevision ?? true;
         this.binding = params.binding;
       }
       /** True when the client declared the capability a given request kind needs. */
@@ -31929,7 +32413,7 @@ function shouldCreateTask(params) {
   return { kind: "create", owner: ownership.owner };
 }
 async function resumeTask(params) {
-  const { scope, record, authInfo, clientCapabilities, frontmcpContext } = params;
+  const { scope, record, authInfo, clientCapabilities, frontmcpContext, clientDeclaredRevision } = params;
   const registry = scope.tasks;
   const runner = registry?.runner;
   if (!runner) {
@@ -31940,6 +32424,8 @@ async function resumeTask(params) {
     new MrtrExchange({
       carriedResponses: record.inputResponses ?? {},
       clientCapabilities,
+      // A caller that never declared the revision is refused an elicitation as a legacy caller is.
+      clientDeclaredRevision,
       binding: {
         principal: resolveTaskPrincipal(authInfo),
         binding: computeRequestBinding("tasks/resume", { name: record.taskId })
@@ -31986,6 +32472,7 @@ async function dispatch20260728(options) {
     scope,
     body,
     clientCapabilities,
+    clientDeclaredRevision,
     frontmcpContext,
     authInfo,
     isAnonymous,
@@ -32032,7 +32519,8 @@ async function dispatch20260728(options) {
         record,
         authInfo: { ...authInfo ?? {}, sessionId: ownership.owner },
         clientCapabilities,
-        frontmcpContext
+        frontmcpContext,
+        clientDeclaredRevision
       })
     });
     return outcome.kind === "result" ? { kind: "result", result: decorate(outcome.result) } : outcome;
@@ -32056,13 +32544,15 @@ 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"],
     carriedResponses: carried.ok ? carried.responses : {},
     clientCapabilities,
-    binding
+    binding,
+    clientDeclaredRevision
   });
   frontmcpContext?.setMrtrExchange(exchange);
   if (notificationSink) frontmcpContext?.setRequestNotificationSink(notificationSink);
@@ -32212,6 +32702,7 @@ var init_mcp_stateless_client = __esm({
   "libs/sdk/src/transport/mcp-20260728/client/mcp-stateless.client.ts"() {
     "use strict";
     import_protocol47 = require("@frontmcp/protocol");
+    init_list_all_pages_utils();
     init_header_codec();
     init_protocol_20260728_constants();
     init_tasks_extension();
@@ -32252,10 +32743,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"]);
@@ -32274,11 +32777,13 @@ 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 `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 });
@@ -32564,6 +33069,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";
@@ -32606,16 +33115,22 @@ 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 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 ?? {});
@@ -33138,6 +33653,7 @@ var init_mcp_client_service = __esm({
   "libs/sdk/src/remote-mcp/mcp-client.service.ts"() {
     "use strict";
     import_protocol48 = require("@frontmcp/protocol");
+    init_list_all_pages_utils();
     init_mcp_error();
     init_remote_errors();
     init_transport_errors();
@@ -33741,10 +34257,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 [];
@@ -33752,8 +34273,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 [];
@@ -33761,8 +34284,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 [];
@@ -33770,8 +34295,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 [];
@@ -38029,6 +38556,8 @@ var init_oauth_authorize_flow = __esm({
             if (state) {
               url.searchParams.set("state", state);
             }
+            const issuer = this.resolveIssuer(this.rawInput.request);
+            if (issuer) url.searchParams.set("iss", issuer);
             this.respond(httpRespond.redirect(url.toString()));
             return;
           }
@@ -40148,7 +40677,7 @@ var init_oauth_provider_callback_flow = __esm({
         if (session.state) {
           url.searchParams.set("state", session.state);
         }
-        url.searchParams.set("iss", this.getLocalAuth().issuer);
+        url.searchParams.set("iss", this.getLocalAuth().issuerFor(this.rawInput.request));
         this.logger.info(
           `Federated auth complete: ${selectedProviderIds.length} providers authenticated, redirecting to client`
         );
@@ -41061,7 +41590,7 @@ var init_oauth_userinfo_flow = __esm({
           return;
         }
         const localAuth = this.scope.auth;
-        const issuer = localAuth.issuerFor?.(this.rawInput.request);
+        const issuer = localAuth.acceptedIssuersFor?.(this.rawInput.request);
         const result = await localAuth.verifyGatewayToken(token, baseUrl, void 0, issuer);
         if (!result.ok) {
           this.logger.warn("userinfo: token verification failed", { error: result.error });
@@ -41145,7 +41674,14 @@ var init_session_verify_flow = __esm({
     import_utils78 = require("@frontmcp/utils");
     init_notification_service();
     init_session_id_utils();
-    inputSchema23 = httpRequestInputSchema;
+    inputSchema23 = httpRequestInputSchema.extend({
+      /**
+       * The request is served without a session (MCP 2026-07-28): an anonymous or static-key caller is
+       * identified for this request only, and no session is minted for it (#629). Minting one needs
+       * `MCP_SESSION_SECRET`, for a session id the client would never present.
+       */
+      sessionless: import_lazy_zod72.z.boolean().optional()
+    });
     stateSchema22 = import_lazy_zod72.z.object({
       baseUrl: import_lazy_zod72.z.string().min(1),
       authorizationHeader: import_lazy_zod72.z.string().optional(),
@@ -41203,20 +41739,25 @@ var init_session_verify_flow = __esm({
        * Encapsulates the shared logic for session creation, payload encryption, and user derivation.
        */
       createAnonymousSession(options) {
-        const { authMode, issuer, scopes = ["anonymous"], subject, sessionIdHeader } = options;
+        const { authMode, subject, sessionIdHeader } = options;
         this.logger.verbose("createAnonymousSession", { authMode, hasExistingSession: !!sessionIdHeader });
+        if (this.rawInput.sessionless) {
+          this.respond({
+            kind: "authorized",
+            authorization: { token: "", user: (0, import_auth39.anonymousCallerClaims)(options, (0, import_utils78.randomUUID)()) }
+          });
+          return;
+        }
         const machineId = (0, import_utils78.getMachineId)();
         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 = {
-              sub: subject ?? `anon:${anonId}`,
-              iss: issuer,
-              name: subject ? "Static token" : "Anonymous",
-              scope: scopes.join(" ")
-            };
+            const user2 = (0, import_auth39.anonymousCallerClaims)(options, anonId);
             this.respond({
               kind: "authorized",
               authorization: {
@@ -41230,13 +41771,8 @@ var init_session_verify_flow = __esm({
           this.logger.verbose("createAnonymousSession: ignoring unrecognized client session id; minting a fresh one");
         }
         const now = Date.now();
-        const user = {
-          sub: subject ?? `anon:${(0, import_utils78.randomUUID)()}`,
-          iss: issuer,
-          name: subject ? "Static token" : "Anonymous",
-          scope: scopes.join(" ")
-        };
         const uuid = (0, import_utils78.randomUUID)();
+        const user = (0, import_auth39.anonymousCallerClaims)(options, uuid);
         const platformDetectionConfig = this.scope.metadata.transport?.platformDetection;
         const platformType = detectPlatformFromUserAgent(this.state.userAgent, platformDetectionConfig);
         const payload = {
@@ -41429,7 +41965,7 @@ var init_session_verify_flow = __esm({
         } else {
           const configuredAudience = (0, import_auth12.isOrchestratedMode)(authOptions) ? authOptions.expectedAudience : void 0;
           const resource = computeResource(this.rawInput.request, this.scope.entryPath, this.scope.routeBase);
-          const issuer = auth.issuerFor?.(this.rawInput.request);
+          const issuer = auth.acceptedIssuersFor?.(this.rawInput.request);
           verify = auth.verifyGatewayToken(token, this.state.required.baseUrl, configuredAudience ?? resource, issuer);
         }
         const result = await verify;
@@ -41722,6 +42258,9 @@ var init_well_known_oauth_authorization_server_flow = __esm({
     wellKnownAsStateSchema = import_lazy_zod74.z.object({
       baseUrl: import_lazy_zod74.z.string().min(1),
       // baseUrl + entryPrefix (unsuffixed)
+      // The issuer this server names in answer to the request (`LocalPrimaryAuth.issuerFor`, #629): the
+      // one on its authorization responses and tokens. Without it, `baseUrl`.
+      issuer: import_lazy_zod74.z.string().min(1).optional(),
       // Root origin (proto://host WITHOUT the entryPath prefix). The OAuth
       // endpoints (/oauth/authorize, /oauth/token, /oauth/register, …) are
       // registered at literal root paths by their flows, NOT under entryPath, so
@@ -41753,6 +42292,9 @@ var init_well_known_oauth_authorization_server_flow = __esm({
         if (!request) throw new FlowInputMissingError("request", "well-known:oauth-authorization-server");
         const { metadata } = this.scope;
         const baseUrl = getRequestBaseUrl(request, this.scope.entryPath);
+        const issuer = this.scope.auth?.issuerFor?.(
+          request
+        );
         const oauthBaseUrl = getRequestBaseUrl(request);
         let cimdEnabled = true;
         if (metadata.auth && (0, import_auth12.isOrchestratedMode)(metadata.auth)) {
@@ -41761,6 +42303,7 @@ var init_well_known_oauth_authorization_server_flow = __esm({
         this.state.set(
           wellKnownAsStateSchema.parse({
             baseUrl,
+            issuer,
             oauthBaseUrl,
             // The scopes this server grants (`allowedScopes`, #262): the literal
             // entries; a `*` glob names no scope a client could ask for.
@@ -41775,6 +42318,7 @@ var init_well_known_oauth_authorization_server_flow = __esm({
         );
       }
       async collectData() {
+        const { issuer } = this.state;
         const {
           baseUrl,
           oauthBaseUrl,
@@ -41785,7 +42329,7 @@ var init_well_known_oauth_authorization_server_flow = __esm({
           cimdEnabled
         } = this.state.required;
         if (isOrchestrated) {
-          const baseIssuer = `${baseUrl}`;
+          const baseIssuer = issuer ?? baseUrl;
           this.respond({
             kind: "json",
             contentType: "application/json; charset=utf-8",
@@ -41812,6 +42356,8 @@ var init_well_known_oauth_authorization_server_flow = __esm({
               grant_types_supported: ["authorization_code", "refresh_token"],
               scopes_supported: scopesSupported,
               code_challenge_methods_supported: ["S256"],
+              // Every authorization response, error responses included, carries `iss` (RFC 9207 §2, §3).
+              authorization_response_iss_parameter_supported: true,
               // CIMD support advertisement per draft-ietf-oauth-client-id-metadata-document-00
               client_id_metadata_document_supported: cimdEnabled
             }
@@ -41860,14 +42406,16 @@ var init_well_known_prm_flow = __esm({
     stateSchema24 = import_lazy_zod75.z.object({
       resource: import_lazy_zod75.z.string().min(1),
       baseUrl: import_lazy_zod75.z.string().min(1),
-      scopesSupported: import_lazy_zod75.z.array(import_lazy_zod75.z.string()).default(["openid", "profile", "email"]),
+      // The authorization server to name: the issuer this server names for the request (#629).
+      authorizationServer: import_lazy_zod75.z.string().min(1).optional(),
+      scopesSupported: import_lazy_zod75.z.array(import_lazy_zod75.z.string()),
       isOrchestrated: import_lazy_zod75.z.boolean()
     });
     outputSchema24 = HttpJsonSchema.extend({
       body: import_lazy_zod75.z.object({
         resource: import_lazy_zod75.z.string().min(1),
         authorization_servers: import_lazy_zod75.z.array(import_lazy_zod75.z.string().min(1)).min(1),
-        scopes_supported: import_lazy_zod75.z.array(import_lazy_zod75.z.string()).default(["openid", "profile", "email"]),
+        scopes_supported: import_lazy_zod75.z.array(import_lazy_zod75.z.string()).optional(),
         bearer_methods_supported: import_lazy_zod75.z.array(import_lazy_zod75.z.string()).default(["header"])
       }).passthrough()
     });
@@ -41891,12 +42439,17 @@ var init_well_known_prm_flow = __esm({
         if (!request) throw new FlowInputMissingError("request", "well-known:prm");
         const resource = computeResource(request, scope.entryPath, scope.routeBase);
         const baseUrl = getRequestBaseUrl(request, scope.entryPath);
-        const auth = scope.metadata.auth;
+        const authorizationServer = scope.auth?.issuerFor?.(request);
+        const authOptions = scope.auth?.options ?? scope.metadata.auth;
+        const granted = (0, import_auth42.resourceScopesFor)(authOptions);
+        const orchestrated = authOptions?.mode === "local" || authOptions?.mode === "remote";
+        const scopesSupported = orchestrated ? granted : [.../* @__PURE__ */ new Set([...granted, ...scope.getAllSupportedScopes()])];
         this.state.set(
           stateSchema24.parse({
             resource,
             baseUrl,
-            scopesSupported: auth && (0, import_auth12.isOrchestratedMode)(auth) ? (0, import_auth42.advertisedScopes)(auth.allowedScopes) : scope.getAllSupportedScopes(),
+            authorizationServer,
+            scopesSupported,
             isOrchestrated: false
             //scope.orchestrated,// TODO: fix
           })
@@ -41904,6 +42457,8 @@ var init_well_known_prm_flow = __esm({
       }
       async collectData() {
         const { resource, baseUrl, scopesSupported, isOrchestrated } = this.state.required;
+        const { authorizationServer } = this.state;
+        const scopes = scopesSupported.length > 0 ? { scopes_supported: scopesSupported } : {};
         if (isOrchestrated) {
           this.respond({
             kind: "json",
@@ -41915,8 +42470,8 @@ var init_well_known_prm_flow = __esm({
             headers: { "cache-control": "no-store" },
             body: {
               resource,
-              authorization_servers: [baseUrl],
-              scopes_supported: scopesSupported,
+              authorization_servers: [authorizationServer ?? baseUrl],
+              ...scopes,
               bearer_methods_supported: ["header"]
             }
           });
@@ -41929,8 +42484,8 @@ var init_well_known_prm_flow = __esm({
           headers: { "cache-control": "no-store" },
           body: {
             resource,
-            authorization_servers: [baseUrl],
-            scopes_supported: scopesSupported,
+            authorization_servers: [authorizationServer ?? baseUrl],
+            ...scopes,
             bearer_methods_supported: ["header"]
           }
         });
@@ -42078,6 +42633,14 @@ function audienceMatchesResource(aud, expected) {
 function isUnsupportedOperation(error) {
   return error instanceof import_utils80.StorageNotSupportedError;
 }
+function originOf2(value) {
+  try {
+    const origin = new URL(value).origin;
+    return origin === "null" ? void 0 : origin;
+  } catch {
+    return void 0;
+  }
+}
 var import_jose, import_auth46, import_utils80, MIN_HS256_SECRET_BYTES, defaultNoAuthSecret, RESERVED_JWT_CLAIMS, LocalPrimaryAuth;
 var init_instance_local_primary_auth = __esm({
   "libs/sdk/src/auth/instances/instance.local-primary-auth.ts"() {
@@ -42133,7 +42696,7 @@ var init_instance_local_primary_auth = __esm({
         this.port = this.providers.getActiveScope().metadata.http?.port ?? 3001;
         this.host = (0, import_utils80.getEnv)("FRONTMCP_PUBLIC_HOST")?.trim() || "localhost";
         this.issuer = this.deriveIssuer(options);
-        this.issuerIsConfigured = this.configuredIssuer(options) !== void 0 || !!(0, import_utils80.getEnv)("FRONTMCP_PUBLIC_HOST")?.trim();
+        this.publicHostPinned = !!(0, import_utils80.getEnv)("FRONTMCP_PUBLIC_HOST")?.trim();
         const jwtSecret = (0, import_utils80.getEnv)("JWT_SECRET");
         const hasJwtSecret = !!jwtSecret?.trim();
         if (hasJwtSecret && jwtSecret) {
@@ -42174,8 +42737,8 @@ var init_instance_local_primary_auth = __esm({
       port;
       /** The boot-time issuer: the configured one, else this server's listener address (see {@link issuerFor}). */
       issuer;
-      /** Whether the operator named the issuer (`issuer` / `local.issuer`, or its host with `FRONTMCP_PUBLIC_HOST`). */
-      issuerIsConfigured;
+      /** Whether `FRONTMCP_PUBLIC_HOST` names the boot-time issuer's host, pinning it for every request. */
+      publicHostPinned;
       keys = [];
       secret;
       logger;
@@ -42333,27 +42896,52 @@ var init_instance_local_primary_auth = __esm({
         return void 0;
       }
       /**
-       * The issuer (`iss`) this server names on the tokens it issues in answer to
-       * `request`, and requires on the tokens it accepts there (#269). Issuing and
-       * verifying both ask this, so they can't disagree:
+       * The issuer this server names in answer to `request`: in its discovery
+       * documents (`/.well-known/oauth-authorization-server`'s `issuer`, the
+       * protected resource metadata's `authorization_servers`), on its
+       * authorization responses (the RFC 9207 `iss`, errors included), and as the
+       * `iss` of the tokens it issues; the tokens it accepts there must name it
+       * (#269, and see {@link acceptedIssuersFor}). Every entry point asks this, so
+       * none of them can disagree, on the Node server and under a Web fetch
+       * handler alike (#629). In order:
        *
-       * - a configured issuer (`issuer` / `local.issuer`) is the issuer;
-       * - with `FRONTMCP_PUBLIC_URL` pinned, the issuer is that URL plus this
-       *   scope's path, the address discovery advertises;
-       * - with `FRONTMCP_PUBLIC_HOST` or `expectedAudience` set, the boot-time
-       *   issuer, so a token serves at every address the server answers to;
-       * - a request that came through a Web fetch handler (a Worker, Deno, Bun, a
-       *   Durable Object) has no listener the boot-time issuer could describe, so
-       *   the issuer is the request's own origin plus this scope's path;
-       * - otherwise (the Node server) the boot-time issuer.
+       * 1. a configured issuer (`issuer` / `local.issuer`);
+       * 2. with `FRONTMCP_PUBLIC_URL` pinned, that URL plus this scope's path;
+       * 3. with `FRONTMCP_PUBLIC_HOST` set, the boot-time issuer it names the host
+       *    of (`http://<host>:<http.port><path>`);
+       * 4. the request's own origin plus this scope's path;
+       * 5. without a request, the boot-time issuer.
        */
       issuerFor(request) {
-        if (!request || this.issuerIsConfigured) return this.issuer;
-        if (isPublicUrlPinned()) return computeIssuer(request, this.scope.entryPath, this.scope.routeBase);
+        const configured = this.configuredIssuer(this.options);
+        if (configured !== void 0) return configured;
+        const pinned = getPinnedPublicUrl();
+        if (pinned !== void 0) {
+          return request ? computeIssuer(request, this.scope.entryPath, this.scope.routeBase) : `${pinned}${this.scope.fullPath}`;
+        }
+        if (this.publicHostPinned || !request) return this.issuer;
+        return computeIssuer(request, this.scope.entryPath, this.scope.routeBase);
+      }
+      /**
+       * The issuers a token presented with `request` may name: {@link issuerFor}
+       * the request. When the issuer follows the request (nothing pins it) and
+       * local or remote mode lists `expectedAudience`, a token for any listed
+       * address was issued under that address's issuer, so each listed address's
+       * issuer is accepted too, and so is the boot-time issuer that 1.8.4 named on
+       * those tokens. The token's `aud` must still name a listed resource.
+       */
+      acceptedIssuersFor(request) {
+        const issuer = this.issuerFor(request);
         const options = this.options;
-        if ((0, import_auth12.isOrchestratedMode)(options) && options.expectedAudience !== void 0) return this.issuer;
-        const webRequest = request[ServerRequestTokens.webRequest];
-        return webRequest === void 0 ? this.issuer : computeIssuer(request, this.scope.entryPath, this.scope.routeBase);
+        const followsRequest = !!request && this.configuredIssuer(options) === void 0 && getPinnedPublicUrl() === void 0 && !this.publicHostPinned;
+        if (!followsRequest || !(0, import_auth12.isOrchestratedMode)(options) || options.expectedAudience === void 0) return issuer;
+        const listed = Array.isArray(options.expectedAudience) ? options.expectedAudience : [options.expectedAudience];
+        const accepted = /* @__PURE__ */ new Set([issuer, this.issuer]);
+        for (const audience of listed) {
+          const origin = originOf2(audience);
+          if (origin) accepted.add(`${origin}${this.scope.fullPath}`);
+        }
+        return [...accepted];
       }
       /**
        * Read the `tokenStorage` selection off the auth options. Only
@@ -42604,10 +43192,10 @@ var init_instance_local_primary_auth = __esm({
        *
        * The secret alone doesn't make a token this server's: every server started
        * with the same JWT_SECRET holds it. So a token must also (#269):
-       * - name THIS instance as its issuer (`iss`): `expectedIssuer`, which callers
-       *   take from {@link issuerFor} the request, as the token endpoint does when
-       *   it signs; the boot-time issuer when not given. Never the token's own
-       *   claim; and
+       * - name THIS instance as its issuer (`iss`): `expectedIssuer` (one issuer or
+       *   several), which callers take from {@link acceptedIssuersFor} the request,
+       *   matching what the token endpoint names when it signs ({@link issuerFor});
+       *   the boot-time issuer when not given. Never the token's own claim; and
        * - when `expectedAudience` is given, be issued for that protected resource,
        *   or one of those resources (`aud`, compared as RFC 8707 resource URIs).
        *   `session:verify` passes the request's resource URL, or the configured
@@ -42620,7 +43208,7 @@ var init_instance_local_primary_auth = __esm({
         try {
           const { payload, protectedHeader } = await (0, import_jose.jwtVerify)(token, this.secret, {
             algorithms: ["HS256"],
-            issuer: expectedIssuer ?? this.issuer,
+            issuer: typeof expectedIssuer === "string" ? expectedIssuer : expectedIssuer ? [...expectedIssuer] : this.issuer,
             requiredClaims: ["exp"]
           });
           if (expectedAudience !== void 0 && !audienceMatchesResource(payload.aud, expectedAudience)) {
@@ -43576,6 +44164,111 @@ var init_auth_registry = __esm({
   }
 });
 
+// libs/sdk/src/server/custom-routes.helper.ts
+function computeReservedPaths(entryPath, routeBase) {
+  const prefix = normalizeEntryPrefix(entryPath);
+  const base = normalizeScopeBase(routeBase);
+  const mcpBase = `${prefix}${base}`;
+  const exact = /* @__PURE__ */ new Set([
+    mcpBase === "" ? "/" : mcpBase,
+    `${mcpBase}/sse`,
+    `${mcpBase}/message`,
+    "/health",
+    "/metrics"
+  ]);
+  return { exact, prefixes: ["/oauth", "/.well-known"] };
+}
+function normalizeForCompare(path3) {
+  if (path3.length > 1 && path3.endsWith("/")) return path3.slice(0, -1);
+  return path3;
+}
+function assertNotReserved(method, path3, reserved) {
+  const normalized = normalizeForCompare(path3);
+  if (reserved.exact.has(normalized)) {
+    throw new ReservedRouteCollisionError(method, path3, normalized);
+  }
+  for (const prefix of reserved.prefixes) {
+    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+      throw new ReservedRouteCollisionError(method, path3, prefix);
+    }
+  }
+}
+function wrapWithAuth(handler, verifySession, logger) {
+  return async (req, res, next) => {
+    let result;
+    try {
+      result = await verifySession(req);
+    } catch (error) {
+      if (error instanceof FlowControl && error.type === "respond") {
+        result = error.output;
+      } else {
+        throw error;
+      }
+    }
+    if (!result || result.kind === "unauthorized") {
+      logger.verbose("custom-route auth: unauthorized");
+      return writeHttpResponse(
+        res,
+        httpRespond.unauthorized({
+          headers: result?.kind === "unauthorized" ? { "WWW-Authenticate": result.prmMetadataHeader } : void 0
+        })
+      );
+    }
+    if (result.kind === "forbidden") {
+      logger.verbose("custom-route auth: forbidden (insufficient scope)");
+      return writeHttpResponse(
+        res,
+        httpRespond.forbidden({
+          headers: { "WWW-Authenticate": result.prmMetadataHeader }
+        })
+      );
+    }
+    req.authSession = result.authorization;
+    req[ServerRequestTokens.auth] = result.authorization;
+    return handler(req, res, next);
+  };
+}
+function wrapWithIpFilter(handler, checkClientIp) {
+  return async (req, res, next) => {
+    const rejection = await checkClientIp(req, res);
+    if (rejection) return writeHttpResponse(res, rejection);
+    return handler(req, res, next);
+  };
+}
+function registerCustomHttpRoutes(args) {
+  const { routes, server, verifySession, checkClientIp, entryPath, routeBase, logger } = args;
+  if (!routes || routes.length === 0) return;
+  const reserved = computeReservedPaths(entryPath, routeBase);
+  for (const route of routes) {
+    assertNotReserved(route.method, route.path, reserved);
+    const handler = route.auth === true ? wrapWithAuth(route.handler, verifySession, logger) : route.handler;
+    server.registerRoute(route.method, route.path, wrapWithIpFilter(handler, checkClientIp));
+    logger.info(`Registered custom http route: ${route.method} ${route.path}${route.auth ? " (auth)" : ""}`);
+  }
+}
+var ReservedRouteCollisionError;
+var init_custom_routes_helper = __esm({
+  "libs/sdk/src/server/custom-routes.helper.ts"() {
+    "use strict";
+    init_common();
+    init_server_validation();
+    ReservedRouteCollisionError = class extends Error {
+      constructor(method, path3, reserved) {
+        super(
+          `Custom http.route "${method} ${path3}" collides with the reserved FrontMCP path "${reserved}". Reserved prefixes are the MCP entry path (and its /sse + /message siblings), /oauth/*, /.well-known/*, /health, and /metrics. Choose a different path.`
+        );
+        this.method = method;
+        this.path = path3;
+        this.reserved = reserved;
+        this.name = "ReservedRouteCollisionError";
+      }
+      method;
+      path;
+      reserved;
+    };
+  }
+});
+
 // libs/sdk/src/channel/channel-notification.service.ts
 var CHANNEL_NOTIFICATION_METHOD, ChannelNotificationService;
 var init_channel_notification_service = __esm({
@@ -44546,6 +45239,12 @@ function wireJobCompletionSource(channel2, sourceConfig, jobEmitterSubscribe, lo
         return;
       }
     }
+    if (!event.sessionId) {
+      logger.verbose(
+        `Skipping job completion for channel "${channel2.name}": no sessionId (prevents cross-session leak)`
+      );
+      return;
+    }
     logger.verbose(`Job completion event for channel "${channel2.name}": job=${event.jobName}, status=${event.status}`);
     channel2.handleEvent(event, event.sessionId).catch((err) => {
       logger.error(`Failed to handle job completion event in channel "${channel2.name}"`, { error: err });
@@ -44558,6 +45257,41 @@ var init_job_completion_source = __esm({
   }
 });
 
+// libs/sdk/src/channel/sources/webhook.source.ts
+function createWebhookMiddleware(channel2, sourceConfig, logger) {
+  return async (req, res) => {
+    const rawHeaders = req.headers ?? {};
+    const normalizedHeaders = {};
+    for (const [key, value] of Object.entries(rawHeaders)) {
+      normalizedHeaders[key.toLowerCase()] = value;
+    }
+    const payload = {
+      body: req.body,
+      headers: normalizedHeaders,
+      method: req.method ?? "POST",
+      query: req.query
+    };
+    logger.verbose(`Webhook received for channel "${channel2.name}" at ${sourceConfig.path}`);
+    try {
+      const notification = await runOnSurface("http-trigger", () => channel2.handleEvent(payload));
+      if (notification) {
+        res.status(200).json({ ok: true, channel: channel2.name });
+      } else {
+        res.status(200).json({ ok: true, channel: channel2.name, skipped: true });
+      }
+    } catch (err) {
+      logger.error(`Webhook handler failed for channel "${channel2.name}"`, { error: err });
+      res.status(500).json({ ok: false, error: "Internal channel error" });
+    }
+  };
+}
+var init_webhook_source = __esm({
+  "libs/sdk/src/channel/sources/webhook.source.ts"() {
+    "use strict";
+    init_call_surface();
+  }
+});
+
 // libs/sdk/src/channel/channel-scope.helper.ts
 async function registerChannelCapabilities(args) {
   const {
@@ -44568,11 +45302,15 @@ async function registerChannelCapabilities(args) {
     notificationService,
     flowRegistry,
     toolRegistry,
-    agentEmitterSubscribe,
-    jobEmitterSubscribe,
+    http: http2,
     logger
   } = args;
+  const completions = completionEventsOf(providers.getActiveScope());
+  const agentEmitterSubscribe = args.agentEmitterSubscribe ?? ((cb) => completions.agents.subscribe(cb));
+  const jobEmitterSubscribe = args.jobEmitterSubscribe ?? ((cb) => completions.jobs.subscribe(cb));
   const unsubscribers = [];
+  const reservedPaths = http2 ? computeReservedPaths(http2.entryPath, http2.routeBase) : void 0;
+  const webhookPaths = /* @__PURE__ */ new Map();
   const channelRegistry = new ChannelRegistry(providers, channelsList, owner);
   await channelRegistry.ready;
   const channelNotificationService = new ChannelNotificationService(
@@ -44588,31 +45326,23 @@ async function registerChannelCapabilities(args) {
     const sourceType = instance.source.type;
     switch (sourceType) {
       case "agent-completion": {
-        if (agentEmitterSubscribe) {
-          const unsub = wireAgentCompletionSource(
-            instance,
-            instance.metadata.source,
-            agentEmitterSubscribe,
-            logger
-          );
-          unsubscribers.push(unsub);
-        } else {
-          logger.warn(`Channel "${instance.name}" has agent-completion source but no agent emitter available`);
-        }
+        const unsub = wireAgentCompletionSource(
+          instance,
+          instance.metadata.source,
+          agentEmitterSubscribe,
+          logger
+        );
+        unsubscribers.push(unsub);
         break;
       }
       case "job-completion": {
-        if (jobEmitterSubscribe) {
-          const unsub = wireJobCompletionSource(
-            instance,
-            instance.metadata.source,
-            jobEmitterSubscribe,
-            logger
-          );
-          unsubscribers.push(unsub);
-        } else {
-          logger.warn(`Channel "${instance.name}" has job-completion source but no job emitter available`);
-        }
+        const unsub = wireJobCompletionSource(
+          instance,
+          instance.metadata.source,
+          jobEmitterSubscribe,
+          logger
+        );
+        unsubscribers.push(unsub);
         break;
       }
       case "app-event": {
@@ -44621,7 +45351,25 @@ async function registerChannelCapabilities(args) {
         unsubscribers.push(unsub);
         break;
       }
-      case "webhook":
+      case "webhook": {
+        const source = instance.metadata.source;
+        if (!http2 || !reservedPaths) {
+          logger.warn(`Channel "${instance.name}" has a webhook source but no HTTP server to serve ${source.path}`);
+          break;
+        }
+        assertNotReserved("POST", source.path, reservedPaths);
+        const claimedBy = webhookPaths.get(source.path);
+        if (claimedBy) {
+          throw new Error(
+            `Channels "${claimedBy}" and "${instance.name}" both declare the webhook path ${source.path}. Give each webhook channel its own path.`
+          );
+        }
+        webhookPaths.set(source.path, instance.name);
+        const handler = createWebhookMiddleware(instance, source, logger);
+        await http2.server.registerRoute("POST", source.path, wrapWithIpFilter(handler, http2.checkClientIp));
+        logger.info(`Registered webhook route for channel "${instance.name}": POST ${source.path}`);
+        break;
+      }
       case "manual":
         break;
       case "service":
@@ -44704,6 +45452,7 @@ async function registerChannelCapabilities(args) {
 var init_channel_scope_helper = __esm({
   "libs/sdk/src/channel/channel-scope.helper.ts"() {
     "use strict";
+    init_custom_routes_helper();
     init_tool_instance();
     init_tool_utils();
     init_channel_notification_service();
@@ -44713,7 +45462,9 @@ var init_channel_scope_helper = __esm({
     init_channel_reply_tool();
     init_agent_completion_source();
     init_app_event_source();
+    init_completion_events();
     init_job_completion_source();
+    init_webhook_source();
   }
 });
 
@@ -47780,10 +48531,11 @@ var init_workflow_step_executor = __esm({
 });
 
 // libs/sdk/src/workflow/engine/workflow.engine.ts
-var WorkflowEngine;
+var import_utils86, WorkflowEngine;
 var init_workflow_engine = __esm({
   "libs/sdk/src/workflow/engine/workflow.engine.ts"() {
     "use strict";
+    import_utils86 = require("@frontmcp/utils");
     init_workflow_errors();
     init_workflow_step_executor();
     WorkflowEngine = class {
@@ -47849,7 +48601,7 @@ var init_workflow_engine = __esm({
             }
             continue;
           }
-          const batch = ready.slice(0, this.maxConcurrency);
+          const batch = ready.slice(0, (0, import_utils86.getAsyncContextMode)() === "serialized" ? 1 : this.maxConcurrency);
           await Promise.allSettled(
             batch.map(async (step) => {
               if (step.condition) {
@@ -47956,11 +48708,11 @@ var init_workflow_engine = __esm({
 });
 
 // libs/sdk/src/job/execution/job-execution.manager.ts
-var import_utils86, JobExecutionManager;
+var import_utils87, JobExecutionManager;
 var init_job_execution_manager = __esm({
   "libs/sdk/src/job/execution/job-execution.manager.ts"() {
     "use strict";
-    import_utils86 = require("@frontmcp/utils");
+    import_utils87 = require("@frontmcp/utils");
     init_principal_utils();
     init_call_surface();
     init_errors();
@@ -47980,7 +48732,7 @@ var init_job_execution_manager = __esm({
        */
       async executeJob(job, input, opts = {}) {
         await this.assertMayExecute(job.metadata.permissions, job.name, opts);
-        const runId = (0, import_utils86.randomUUID)();
+        const runId = (0, import_utils87.randomUUID)();
         const retryConfig = job.metadata.retry ?? {};
         const maxAttempts = retryConfig.maxAttempts ?? 1;
         const runRecord = {
@@ -47999,7 +48751,7 @@ var init_job_execution_manager = __esm({
         };
         await this.stateStore.createRun(runRecord);
         if (opts.background) {
-          (0, import_utils86.runRequestExclusive)(() => this.executeJobBackground(job, input, runId, opts)).catch(async (err) => {
+          (0, import_utils87.runRequestExclusive)(() => this.executeJobBackground(job, input, runId, opts)).catch(async (err) => {
             this.logger.error(`Background job execution failed: ${err}`);
             try {
               await this.updateState(runId, {
@@ -48020,7 +48772,7 @@ var init_job_execution_manager = __esm({
        */
       async executeWorkflow(workflow, jobRegistry, opts = {}) {
         await this.assertMayExecute(workflow.metadata.permissions, workflow.name, opts);
-        const runId = (0, import_utils86.randomUUID)();
+        const runId = (0, import_utils87.randomUUID)();
         const runRecord = {
           runId,
           jobId: workflow.metadata.id ?? workflow.name,
@@ -48039,7 +48791,7 @@ var init_job_execution_manager = __esm({
         };
         await this.stateStore.createRun(runRecord);
         if (opts.background) {
-          (0, import_utils86.runRequestExclusive)(() => this.executeWorkflowBackground(workflow, jobRegistry, runId, opts)).catch(
+          (0, import_utils87.runRequestExclusive)(() => this.executeWorkflowBackground(workflow, jobRegistry, runId, opts)).catch(
             async (err) => {
               this.logger.error(`Background workflow execution failed: ${err}`);
               try {
@@ -49447,7 +50199,11 @@ async function registerJobCapabilities(args) {
   for (const dynWf of dynamicWorkflows) {
     workflowRegistry.registerDynamic(dynWf);
   }
-  const executionManager = new JobExecutionManager(stateStore, logger, notifyFn);
+  const completions = completionEventsOf(providers.getActiveScope());
+  const executionManager = new JobExecutionManager(stateStore, logger, async (data) => {
+    await notifyFn?.(data);
+    await publishJobCompletion(data, stateStore, completions);
+  });
   const managementTools = [
     ListJobsTool,
     ExecuteJobTool,
@@ -49476,9 +50232,27 @@ async function registerJobCapabilities(args) {
     managementTools
   };
 }
+async function publishJobCompletion(data, stateStore, completions) {
+  const { type, state, runId } = data;
+  if (type !== "job:status" && type !== "workflow:status") return;
+  if (state !== "completed" && state !== "failed" || typeof runId !== "string") return;
+  const run = await stateStore.getRun(runId);
+  if (!run) return;
+  const workflowName = type === "workflow:status" ? run.workflowName : void 0;
+  completions.jobs.emit({
+    jobName: workflowName ?? run.jobName,
+    jobId: run.jobId,
+    status: state === "completed" ? "success" : "error",
+    ...run.completedAt !== void 0 ? { durationMs: run.completedAt - run.startedAt } : {},
+    ...state === "completed" ? { output: completionOutputText(run.result) } : { error: run.error?.message },
+    attempt: run.attempt,
+    ...run.sessionId ? { sessionId: run.sessionId } : {}
+  });
+}
 var init_job_scope_helper = __esm({
   "libs/sdk/src/job/job-scope.helper.ts"() {
     "use strict";
+    init_completion_events();
     init_execute_workflow_tool();
     init_get_workflow_status_tool();
     init_list_workflows_tool();
@@ -49704,111 +50478,6 @@ var init_enforced_metadata_check = __esm({
   }
 });
 
-// libs/sdk/src/server/custom-routes.helper.ts
-function computeReservedPaths(entryPath, routeBase) {
-  const prefix = normalizeEntryPrefix(entryPath);
-  const base = normalizeScopeBase(routeBase);
-  const mcpBase = `${prefix}${base}`;
-  const exact = /* @__PURE__ */ new Set([
-    mcpBase === "" ? "/" : mcpBase,
-    `${mcpBase}/sse`,
-    `${mcpBase}/message`,
-    "/health",
-    "/metrics"
-  ]);
-  return { exact, prefixes: ["/oauth", "/.well-known"] };
-}
-function normalizeForCompare(path3) {
-  if (path3.length > 1 && path3.endsWith("/")) return path3.slice(0, -1);
-  return path3;
-}
-function assertNotReserved(method, path3, reserved) {
-  const normalized = normalizeForCompare(path3);
-  if (reserved.exact.has(normalized)) {
-    throw new ReservedRouteCollisionError(method, path3, normalized);
-  }
-  for (const prefix of reserved.prefixes) {
-    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
-      throw new ReservedRouteCollisionError(method, path3, prefix);
-    }
-  }
-}
-function wrapWithAuth(handler, verifySession, logger) {
-  return async (req, res, next) => {
-    let result;
-    try {
-      result = await verifySession(req);
-    } catch (error) {
-      if (error instanceof FlowControl && error.type === "respond") {
-        result = error.output;
-      } else {
-        throw error;
-      }
-    }
-    if (!result || result.kind === "unauthorized") {
-      logger.verbose("custom-route auth: unauthorized");
-      return writeHttpResponse(
-        res,
-        httpRespond.unauthorized({
-          headers: result?.kind === "unauthorized" ? { "WWW-Authenticate": result.prmMetadataHeader } : void 0
-        })
-      );
-    }
-    if (result.kind === "forbidden") {
-      logger.verbose("custom-route auth: forbidden (insufficient scope)");
-      return writeHttpResponse(
-        res,
-        httpRespond.forbidden({
-          headers: { "WWW-Authenticate": result.prmMetadataHeader }
-        })
-      );
-    }
-    req.authSession = result.authorization;
-    req[ServerRequestTokens.auth] = result.authorization;
-    return handler(req, res, next);
-  };
-}
-function wrapWithIpFilter(handler, checkClientIp) {
-  return async (req, res, next) => {
-    const rejection = await checkClientIp(req, res);
-    if (rejection) return writeHttpResponse(res, rejection);
-    return handler(req, res, next);
-  };
-}
-function registerCustomHttpRoutes(args) {
-  const { routes, server, verifySession, checkClientIp, entryPath, routeBase, logger } = args;
-  if (!routes || routes.length === 0) return;
-  const reserved = computeReservedPaths(entryPath, routeBase);
-  for (const route of routes) {
-    assertNotReserved(route.method, route.path, reserved);
-    const handler = route.auth === true ? wrapWithAuth(route.handler, verifySession, logger) : route.handler;
-    server.registerRoute(route.method, route.path, wrapWithIpFilter(handler, checkClientIp));
-    logger.info(`Registered custom http route: ${route.method} ${route.path}${route.auth ? " (auth)" : ""}`);
-  }
-}
-var ReservedRouteCollisionError;
-var init_custom_routes_helper = __esm({
-  "libs/sdk/src/server/custom-routes.helper.ts"() {
-    "use strict";
-    init_common();
-    init_server_validation();
-    ReservedRouteCollisionError = class extends Error {
-      constructor(method, path3, reserved) {
-        super(
-          `Custom http.route "${method} ${path3}" collides with the reserved FrontMCP path "${reserved}". Reserved prefixes are the MCP entry path (and its /sse + /message siblings), /oauth/*, /.well-known/*, /health, and /metrics. Choose a different path.`
-        );
-        this.method = method;
-        this.path = path3;
-        this.reserved = reserved;
-        this.name = "ReservedRouteCollisionError";
-      }
-      method;
-      path;
-      reserved;
-    };
-  }
-});
-
 // libs/sdk/src/skill/errors/tool-not-allowed.error.ts
 var ToolNotAllowedError, ToolApprovalRequiredError;
 var init_tool_not_allowed_error = __esm({
@@ -50048,15 +50717,15 @@ var init_skill_session_types = __esm({
 });
 
 // libs/sdk/src/skill/session/skill-session.manager.ts
-var import_utils87, SkillSessionManager;
+var import_utils88, SkillSessionManager;
 var init_skill_session_manager = __esm({
   "libs/sdk/src/skill/session/skill-session.manager.ts"() {
     "use strict";
-    import_utils87 = require("@frontmcp/utils");
+    import_utils88 = require("@frontmcp/utils");
     init_errors();
     init_skill_session_types();
-    SkillSessionManager = class extends import_utils87.EventEmitter {
-      storage = new import_utils87.AsyncLocalStorage();
+    SkillSessionManager = class extends import_utils88.EventEmitter {
+      storage = new import_utils88.AsyncLocalStorage();
       options;
       logger;
       store;
@@ -50983,7 +51652,7 @@ var init_load_skill_flow = __esm({
             }
             await assertSkillAuthorized(this.scope, entry, authInfo);
           }
-          loadResults.push({ loadResult: result });
+          loadResults.push({ loadResult: skillToolsForCaller(result, this.scope.tools, ctx) });
         }
         this.state.set({ loadResults, warnings });
         this.logger.verbose("loadSkills:done", { loaded: loadResults.length, notFound: warnings.length });
@@ -51228,7 +51897,10 @@ async function authorizeSkillHttpRequest(scope, skillsConfig, request, logger) {
   if (mode === "inherit") {
     const authOptions = scope.auth?.options;
     if (!authOptions || (0, import_auth12.isPublicMode)(authOptions)) return { allowed: true, authInfo: {} };
-    const verified = await scope.runFlow("session:verify", { request });
+    const verified = await scope.runFlow("session:verify", {
+      request,
+      sessionless: true
+    });
     if (verified?.kind === "authorized") {
       return { allowed: true, authInfo: { ...authInfoFromAuthorization(verified.authorization) } };
     }
@@ -51252,11 +51924,11 @@ function createSkillHttpAuthValidator(skillsConfig, logger) {
     logger
   });
 }
-var import_utils88, SkillHttpAuthValidator;
+var import_utils89, SkillHttpAuthValidator;
 var init_skill_http_auth = __esm({
   "libs/sdk/src/skill/auth/skill-http-auth.ts"() {
     "use strict";
-    import_utils88 = require("@frontmcp/utils");
+    import_utils89 = require("@frontmcp/utils");
     init_common();
     SkillHttpAuthValidator = class {
       skillsConfig;
@@ -51338,7 +52010,7 @@ var init_skill_http_auth = __esm({
           const keyBytes = encoder5.encode(key);
           if (keyBytes.length === candidateBytes.length) {
             try {
-              if ((0, import_utils88.timingSafeEqual)(keyBytes, candidateBytes)) {
+              if ((0, import_utils89.timingSafeEqual)(keyBytes, candidateBytes)) {
                 found = true;
               }
             } catch {
@@ -52198,7 +52870,12 @@ var init_skills_api_flow = __esm({
           respondNotFound();
           return;
         }
-        const { skill, availableTools, missingTools, isComplete, warning } = loadResult;
+        const { skill, availableTools, missingTools, isComplete, warning } = skillToolsForCaller(
+          loadResult,
+          toolRegistry,
+          void 0,
+          SKILLS_HTTP_SURFACE
+        );
         const skillEntry = createSkillEntryResolver(skillRegistry)(skillId, skill.id);
         if (skillEntry) {
           if (!await isSkillServable(this.scope, skillEntry, void 0, SKILLS_HTTP_SURFACE)) {
@@ -52559,6 +53236,8 @@ var init_tool_interface = __esm({
       _toolNameInternal;
       /** @internal Tool input for fallback elicitation - set by CallToolFlow */
       _toolInputInternal;
+      /** @internal JSON-RPC id of the tools/call request - set by CallToolFlow, for flows the call is handed on to */
+      _jsonRpcRequestIdInternal;
       // ---- INPUT storages (backing fields)
       _rawInput;
       _input;
@@ -52591,6 +53270,10 @@ var init_tool_interface = __esm({
         this._progressToken = progressToken;
         this.signal = signal;
       }
+      /** @internal The request's progress token, for flows the call is handed on to (the agent tool). */
+      get _progressTokenInternal() {
+        return this._progressToken;
+      }
       /**
        * Like {@link ExecutionContextBase.fetch}, and also aborted with {@link signal}, so a
        * cancelled or timed-out call stops its outbound requests.
@@ -54636,10 +55319,10 @@ var init_primary_auth_provider_interface = __esm({
        * @param _expectedAudience  The protected resource(s) the token must be for
        *                           (`aud` names at least one), when the caller is a
        *                           resource endpoint.
-       * @param _expectedIssuer    The issuer the token must name: the one this
-       *                           instance issues tokens under for the request
-       *                           (`LocalPrimaryAuth.issuerFor`). Default: its
-       *                           boot-time issuer.
+       * @param _expectedIssuer    The issuer the token must name (or one of them):
+       *                           the ones this instance accepts for the request
+       *                           (`LocalPrimaryAuth.acceptedIssuersFor`). Default:
+       *                           its boot-time issuer.
        */
       verifyGatewayToken(_token, _requestBaseUrl, _expectedAudience, _expectedIssuer) {
         return Promise.resolve({
@@ -54713,7 +55396,10 @@ function findSkillByPath(scope, skillPath) {
   const segments = skillPath.split("/").filter((s) => s.length > 0);
   if (segments.length === 0) return void 0;
   const lastSegment = segments[segments.length - 1];
-  return visible.find((s) => s.name === lastSegment && s.getSkillPath() === lastSegment);
+  const byName = visible.find((s) => s.name === lastSegment && s.getSkillPath() === lastSegment);
+  if (byName) return byName;
+  if (segments.length !== 1) return void 0;
+  return visible.find((s) => s.metadata.id === lastSegment && s.getSkillPath() === s.metadata.name);
 }
 async function findAndLoadSkillByPath(scope, skillPath) {
   const registry = scope.skills;
@@ -54785,15 +55471,15 @@ async function readSkillFileByPath(instance, filePath) {
   let candidatePath;
   for (const [subdir, configured] of candidateDirs) {
     if (segments[0] !== subdir) continue;
-    const dir = configured ? (0, import_utils90.isAbsolute)(configured) ? configured : (0, import_utils90.pathResolve)(baseDir, configured) : (0, import_utils90.joinPath)(baseDir, subdir);
-    candidatePath = (0, import_utils90.pathResolve)(dir, ...segments.slice(1));
+    const dir = configured ? (0, import_utils91.isAbsolute)(configured) ? configured : (0, import_utils91.pathResolve)(baseDir, configured) : (0, import_utils91.joinPath)(baseDir, subdir);
+    candidatePath = (0, import_utils91.pathResolve)(dir, ...segments.slice(1));
     if (!isInside(candidatePath, dir)) {
       throw new PublicMcpError(`Invalid file path "${filePath}".`, "INVALID_PARAMS", 400);
     }
     break;
   }
   if (!candidatePath) {
-    candidatePath = (0, import_utils90.pathResolve)(baseDir, ...segments);
+    candidatePath = (0, import_utils91.pathResolve)(baseDir, ...segments);
     if (!isInside(candidatePath, baseDir)) {
       throw new PublicMcpError(`Invalid file path "${filePath}".`, "INVALID_PARAMS", 400);
     }
@@ -54801,7 +55487,7 @@ async function readSkillFileByPath(instance, filePath) {
   const mimeType = guessMimeType(filePath);
   let buffer;
   try {
-    buffer = await (0, import_utils90.readFileBuffer)(candidatePath);
+    buffer = await (0, import_utils91.readFileBuffer)(candidatePath);
   } catch (err) {
     if (isFileMissingError(err)) {
       throw new ResourceNotFoundError(`skill://${instance.getSkillPath()}/${filePath}`);
@@ -54844,7 +55530,7 @@ async function tryResolvedSubFile(instance, kind, tail) {
     const resolvedPath = resolveEntryPath2(instance, kind, absolutePath, filename);
     if (!resolvedPath) continue;
     try {
-      const buf = await (0, import_utils90.readFileBuffer)(resolvedPath);
+      const buf = await (0, import_utils91.readFileBuffer)(resolvedPath);
       const text = (Buffer.isBuffer(buf) ? buf : Buffer.from(buf)).toString("utf-8");
       return parseSkillMdFrontmatter(text).body;
     } catch (err) {
@@ -54857,18 +55543,18 @@ async function tryResolvedSubFile(instance, kind, tail) {
   return void 0;
 }
 function resolveEntryPath2(instance, kind, absolutePath, filename) {
-  if (absolutePath && (0, import_utils90.isAbsolute)(absolutePath)) return absolutePath;
+  if (absolutePath && (0, import_utils91.isAbsolute)(absolutePath)) return absolutePath;
   if (!filename) return void 0;
   const baseDir = instance.getBaseDir();
   const configured = instance.getResources()?.[kind];
   let dir;
-  if (configured && (0, import_utils90.isAbsolute)(configured)) {
+  if (configured && (0, import_utils91.isAbsolute)(configured)) {
     dir = configured;
   } else if (baseDir) {
-    dir = configured ? (0, import_utils90.pathResolve)(baseDir, configured) : (0, import_utils90.joinPath)(baseDir, kind);
+    dir = configured ? (0, import_utils91.pathResolve)(baseDir, configured) : (0, import_utils91.joinPath)(baseDir, kind);
   }
   if (!dir) return void 0;
-  const resolved = (0, import_utils90.pathResolve)(dir, filename);
+  const resolved = (0, import_utils91.pathResolve)(dir, filename);
   if (!isInside(resolved, dir)) return void 0;
   return resolved;
 }
@@ -54900,11 +55586,11 @@ function isInside(child, parent) {
   const parentPrefix = normParent.endsWith("/") ? normParent : `${normParent}/`;
   return normChild === normParent || normChild.startsWith(parentPrefix);
 }
-var import_utils90;
+var import_utils91;
 var init_sep_2640_resource_helpers = __esm({
   "libs/sdk/src/skill/sep-2640/sep-2640.resource-helpers.ts"() {
     "use strict";
-    import_utils90 = require("@frontmcp/utils");
+    import_utils91 = require("@frontmcp/utils");
     init_errors();
     init_skill_filter_helper();
     init_skill_md_parser();
@@ -55131,17 +55817,17 @@ async function resolveLastModifiedForSkill(skill) {
     return void 0;
   }
   try {
-    const s = await (0, import_utils91.stat)(record.filePath);
+    const s = await (0, import_utils92.stat)(record.filePath);
     return s.mtime instanceof Date ? s.mtime.toISOString() : void 0;
   } catch {
     return void 0;
   }
 }
-var import_utils91;
+var import_utils92;
 var init_sep_2640_last_modified = __esm({
   "libs/sdk/src/skill/sep-2640/sep-2640.last-modified.ts"() {
     "use strict";
-    import_utils91 = require("@frontmcp/utils");
+    import_utils92 = require("@frontmcp/utils");
   }
 });
 
@@ -55331,7 +56017,7 @@ function createDefaultSigner(mod, logger) {
       "[skill-audit] refusing to use the default HS256 signer in production. Configure skillsConfig.audit.signer with a host-managed key (e.g. RS256 pointing at the same key registry your bundle signing uses)."
     );
   }
-  const bytes = (0, import_utils92.randomBytes)(32);
+  const bytes = (0, import_utils93.randomBytes)(32);
   logger.warn(
     "[skill-audit] no audit signer configured \u2014 using process-local HS256 with a CSPRNG-generated secret. Records signed by this instance cannot be verified after restart. Configure skillsConfig.audit.signer for production."
   );
@@ -55343,12 +56029,12 @@ function createDefaultStore(mod, logger) {
   );
   return new mod.MemoryAuditStore();
 }
-var import_di39, import_utils92, injectedFactory;
+var import_di39, import_utils93, injectedFactory;
 var init_skill_audit_helper = __esm({
   "libs/sdk/src/skill/skill-audit.helper.ts"() {
     "use strict";
     import_di39 = require("@frontmcp/di");
-    import_utils92 = require("@frontmcp/utils");
+    import_utils93 = require("@frontmcp/utils");
   }
 });
 
@@ -55988,11 +56674,11 @@ function createSqliteSessionStore(options, logger) {
   logger?.info("[SessionStoreFactory] Creating SQLite session store", { path: options.path });
   return new SqliteSessionStore(options);
 }
-var import_utils93;
+var import_utils94;
 var init_session_store_factory = __esm({
   "libs/sdk/src/auth/session/session-store.factory.ts"() {
     "use strict";
-    import_utils93 = require("@frontmcp/utils");
+    import_utils94 = require("@frontmcp/utils");
     init_common();
   }
 });
@@ -56067,14 +56753,14 @@ function toClientInfo(value) {
   const { name: name44, version } = value;
   return typeof name44 === "string" && typeof version === "string" ? { name: name44, version } : void 0;
 }
-var import_auth55, import_lazy_zod102, import_protocol52, import_utils94, plan37, subscriptionParamsSchema, requestIdSchema, stateSchema37, name38, Stage38, encoder3, TRACE_META_KEYS, HandleMcp20260728Flow;
+var import_auth55, import_lazy_zod102, import_protocol52, import_utils95, plan37, subscriptionParamsSchema, requestIdSchema, stateSchema37, name38, Stage38, encoder3, TRACE_META_KEYS, HandleMcp20260728Flow;
 var init_handle_mcp_20260728_flow = __esm({
   "libs/sdk/src/transport/flows/handle.mcp-20260728.flow.ts"() {
     "use strict";
     import_auth55 = require("@frontmcp/auth");
     import_lazy_zod102 = require("@frontmcp/lazy-zod");
     import_protocol52 = require("@frontmcp/protocol");
-    import_utils94 = require("@frontmcp/utils");
+    import_utils95 = require("@frontmcp/utils");
     init_common();
     init_context();
     init_notification();
@@ -56098,7 +56784,9 @@ var init_handle_mcp_20260728_flow = __esm({
       /** Negotiated protocol version for this request. */
       version: import_lazy_zod102.z.string().optional(),
       requestType: import_lazy_zod102.z.enum(["notification", "subscriptions", "message"]).optional(),
-      isAnonymous: import_lazy_zod102.z.boolean().default(true)
+      isAnonymous: import_lazy_zod102.z.boolean().default(true),
+      /** Whether the client declared this revision itself (not served under it by default). */
+      clientDeclaredRevision: import_lazy_zod102.z.boolean().optional()
     });
     name38 = "handle:mcp-202607280728";
     ({ Stage: Stage38 } = FlowHooksOf(name38));
@@ -56145,6 +56833,7 @@ var init_handle_mcp_20260728_flow = __esm({
           return;
         }
         this.state.set("version", result.version);
+        this.state.set("clientDeclaredRevision", strictHeaders);
       }
       /**
        * Resolve a tool's input JSON Schema so `x-mcp-header` annotations can be
@@ -56169,7 +56858,7 @@ var init_handle_mcp_20260728_flow = __esm({
         if (!context) return (fn) => fn();
         const storage = this.scope.providers.get(FrontMcpContextStorage);
         return async (fn) => {
-          await (0, import_utils94.runRequestExclusive)(() => storage.runWithContext(context, fn));
+          await (0, import_utils95.runRequestExclusive)(() => storage.runWithContext(context, fn));
         };
       }
       findToolSchema(scope, toolName) {
@@ -56260,10 +56949,12 @@ var init_handle_mcp_20260728_flow = __esm({
             // authenticated caller.
             ...authInfoFromAuthorization(auth),
             // The shared handlers still key per-request state (provider views, notifications)
-            // off an id. This one names the request only; the request context does not vouch for it.
-            sessionId: auth.session?.id
+            // off an id. It names the request only, the same per-request id as the request
+            // context's `sessionId`; the request context does not vouch for it (#629).
+            sessionId: auth.session?.id ?? this.tryGetContext()?.sessionId
           } : void 0,
           isAnonymous: this.state.required.isAnonymous,
+          clientDeclaredRevision: this.state.clientDeclaredRevision !== false,
           composeInstructions: () => this.scope.metadata.instructions,
           notificationSink: sink,
           traceContext: extractTraceContext(meta)
@@ -56370,12 +57061,36 @@ function getQuerySessionId2(urlPath) {
     return void 0;
   }
 }
-var import_lazy_zod103, import_utils95, plan38, stateSessionSchema, stateSchema38, name39, Stage39, HandleSseFlow;
+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 import_lazy_zod103, import_utils96, plan38, stateSessionSchema, stateSchema38, name39, Stage39, HandleSseFlow;
 var init_handle_sse_flow = __esm({
   "libs/sdk/src/transport/flows/handle.sse.flow.ts"() {
     "use strict";
     import_lazy_zod103 = require("@frontmcp/lazy-zod");
-    import_utils95 = require("@frontmcp/utils");
+    import_utils96 = require("@frontmcp/utils");
     init_session_id_utils();
     init_common();
     init_errors();
@@ -56411,39 +57126,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() {
@@ -56466,10 +57168,10 @@ 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 ((0, import_utils95.getRuntimeContext)().deployment === "distributed") {
-          const nodeId = (0, import_utils95.getMachineId)();
+        if ((0, import_utils96.getRuntimeContext)().deployment === "distributed") {
+          const nodeId = (0, import_utils96.getMachineId)();
           response.setHeader(DEFAULT_FRONTMCP_MACHINE_ID_HEADER, nodeId);
-          const cookie = (0, import_utils95.buildSetCookie)({ name: DEFAULT_FRONTMCP_NODE_COOKIE, value: nodeId }, request);
+          const cookie = (0, import_utils96.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)] : [];
@@ -56491,12 +57193,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 && (0, import_utils95.getRuntimeContext)().deployment === "distributed") {
+        if (!transport && (0, import_utils96.getRuntimeContext)().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 !== (0, import_utils95.getMachineId)()) {
+            if (relay && storedSession.session.nodeId && storedSession.session.nodeId !== (0, import_utils96.getMachineId)()) {
               const isAlive2 = await haManager.isNodeAlive(storedSession.session.nodeId);
               if (isAlive2) {
                 try {
@@ -56722,11 +57424,11 @@ var init_ext_apps_types = __esm({
 function createExtAppsMessageHandler(options) {
   return new ExtAppsMessageHandler(options);
 }
-var import_utils96, ExtAppsMessageHandler, ExtAppsError, ExtAppsMethodNotFoundError, ExtAppsInvalidParamsError, ExtAppsNotSupportedError, ExtAppsToolNotFoundError;
+var import_utils97, ExtAppsMessageHandler, ExtAppsError, ExtAppsMethodNotFoundError, ExtAppsInvalidParamsError, ExtAppsNotSupportedError, ExtAppsToolNotFoundError;
 var init_ext_apps_handler = __esm({
   "libs/sdk/src/ext-apps/ext-apps.handler.ts"() {
     "use strict";
-    import_utils96 = require("@frontmcp/utils");
+    import_utils97 = require("@frontmcp/utils");
     init_ext_apps_types();
     ExtAppsMessageHandler = class {
       context;
@@ -56770,7 +57472,7 @@ var init_ext_apps_handler = __esm({
               code: errorCode,
               message: errorMessage,
               // Only include stack traces in development to avoid leaking internals in production
-              data: (0, import_utils96.isDevelopment)() && error instanceof Error ? { stack: error.stack } : void 0
+              data: (0, import_utils97.isDevelopment)() && error instanceof Error ? { stack: error.stack } : void 0
             }
           };
         }
@@ -57056,7 +57758,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 };
@@ -57132,13 +57834,13 @@ async function lookupStreamableHttpTransport(params) {
   }
   return { kind: "session-not-initialized", recreationError };
 }
-var import_lazy_zod105, import_protocol54, import_utils97, plan40, stateSessionSchema2, stateSchema40, name41, Stage41, HandleStreamableHttpFlow;
+var import_lazy_zod105, import_protocol54, import_utils98, plan40, stateSessionSchema2, stateSchema40, name41, Stage41, HandleStreamableHttpFlow;
 var init_handle_streamable_http_flow = __esm({
   "libs/sdk/src/transport/flows/handle.streamable-http.flow.ts"() {
     "use strict";
     import_lazy_zod105 = require("@frontmcp/lazy-zod");
     import_protocol54 = require("@frontmcp/protocol");
-    import_utils97 = require("@frontmcp/utils");
+    import_utils98 = require("@frontmcp/utils");
     init_session_id_utils();
     init_common();
     init_errors();
@@ -57204,7 +57906,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;
         }
@@ -57271,10 +57973,10 @@ var init_handle_streamable_http_flow = __esm({
               return;
             }
           }
-          if ((0, import_utils97.getRuntimeContext)().deployment === "distributed") {
-            const nodeId = (0, import_utils97.getMachineId)();
+          if ((0, import_utils98.getRuntimeContext)().deployment === "distributed") {
+            const nodeId = (0, import_utils98.getMachineId)();
             response.setHeader(DEFAULT_FRONTMCP_MACHINE_ID_HEADER, nodeId);
-            const cookie = (0, import_utils97.buildSetCookie)({ name: DEFAULT_FRONTMCP_NODE_COOKIE, value: nodeId }, request);
+            const cookie = (0, import_utils98.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)] : [];
@@ -57593,21 +58295,21 @@ var init_handle_streamable_http_flow = __esm({
 });
 
 // libs/sdk/src/transport/transport.error.ts
-var import_utils98, JSON_RPC2, rpcError, rpcRequest;
+var import_utils99, JSON_RPC2, rpcError, rpcRequest;
 var init_transport_error = __esm({
   "libs/sdk/src/transport/transport.error.ts"() {
     "use strict";
-    import_utils98 = require("@frontmcp/utils");
+    import_utils99 = require("@frontmcp/utils");
     JSON_RPC2 = "2.0";
     rpcError = (message, requestId) => ({
       jsonrpc: JSON_RPC2,
       error: { code: -32e3, message },
-      id: requestId ?? (0, import_utils98.randomUUID)()
+      id: requestId ?? (0, import_utils99.randomUUID)()
       // change it to request id + random
     });
     rpcRequest = (requestId, method, params) => ({
       jsonrpc: JSON_RPC2,
-      id: requestId ?? (0, import_utils98.randomUUID)(),
+      id: requestId ?? (0, import_utils99.randomUUID)(),
       method,
       ...params !== void 0 && { params }
     });
@@ -57670,14 +58372,14 @@ var init_host_validation = __esm({
 });
 
 // libs/sdk/src/transport/adapters/base-sse-transport.ts
-var import_content_type, import_raw_body, import_protocol55, import_utils99, MAXIMUM_MESSAGE_SIZE, SSEServerTransport;
+var import_content_type, import_raw_body, import_protocol55, import_utils100, MAXIMUM_MESSAGE_SIZE, SSEServerTransport;
 var init_base_sse_transport = __esm({
   "libs/sdk/src/transport/adapters/base-sse-transport.ts"() {
     "use strict";
     import_content_type = __toESM(require("content-type"));
     import_raw_body = __toESM(require("raw-body"));
     import_protocol55 = require("@frontmcp/protocol");
-    import_utils99 = require("@frontmcp/utils");
+    import_utils100 = require("@frontmcp/utils");
     init_transport_errors();
     init_host_validation();
     MAXIMUM_MESSAGE_SIZE = "4mb";
@@ -57688,7 +58390,7 @@ var init_base_sse_transport = __esm({
       constructor(_endpoint, res, options) {
         this._endpoint = _endpoint;
         this.res = res;
-        this._sessionId = options?.sessionId ?? (0, import_utils99.randomUUID)();
+        this._sessionId = options?.sessionId ?? (0, import_utils100.randomUUID)();
         this._options = options || { enableDnsRebindingProtection: false };
       }
       _endpoint;
@@ -59134,11 +59836,11 @@ var init_transport_remote = __esm({
 });
 
 // libs/sdk/src/transport/transport.registry.ts
-var import_utils100, TransportService;
+var import_utils101, TransportService;
 var init_transport_registry = __esm({
   "libs/sdk/src/transport/transport.registry.ts"() {
     "use strict";
-    import_utils100 = require("@frontmcp/utils");
+    import_utils101 = require("@frontmcp/utils");
     init_session_store_factory();
     init_transport_errors();
     init_handle_mcp_20260728_flow();
@@ -59430,7 +60132,7 @@ var init_transport_registry = __esm({
           protocol: storedSession.session.protocol,
           createdAt: storedSession.createdAt
         });
-        const currentNodeId = (0, import_utils100.getMachineId)();
+        const currentNodeId = (0, import_utils101.getMachineId)();
         if (this.scope.haManager && storedSession.session.nodeId && storedSession.session.nodeId !== currentNodeId) {
           const sessionKey = `${this.transportKeyPrefix}${sessionId}`;
           const result = await this.scope.haManager.attemptTakeover(sessionKey, storedSession.session.nodeId);
@@ -59525,7 +60227,7 @@ var init_transport_registry = __esm({
               authorizationId: key.tokenHash,
               protocol: type === "sse" ? "sse" : "streamable-http",
               createdAt: Date.now(),
-              nodeId: (0, import_utils100.getMachineId)()
+              nodeId: (0, import_utils101.getMachineId)()
             },
             authorizationId: key.tokenHash,
             createdAt: Date.now(),
@@ -59671,7 +60373,7 @@ var init_transport_registry = __esm({
       }
       /* --------------------------------- internals -------------------------------- */
       sha256(value) {
-        return (0, import_utils100.sha256Hex)(value);
+        return (0, import_utils101.sha256Hex)(value);
       }
       /**
        * Create a history key from components.
@@ -59855,9 +60557,9 @@ function persistentSessionCallerKey(authorization) {
   const sub = authorization?.user?.sub;
   if (!(0, import_auth56.isAnonymousSubject)(sub)) {
     const iss = authorization?.user?.iss;
-    return `sub:${(0, import_utils101.sha256Hex)(JSON.stringify([typeof iss === "string" ? iss : "", sub]))}`;
+    return `sub:${(0, import_utils102.sha256Hex)(JSON.stringify([typeof iss === "string" ? iss : "", sub]))}`;
   }
-  if (authorization?.token) return `token:${(0, import_utils101.sha256Hex)(authorization.token)}`;
+  if (authorization?.token) return `token:${(0, import_utils102.sha256Hex)(authorization.token)}`;
   return null;
 }
 function claimPersistentSession(session, callerKey, store) {
@@ -59870,12 +60572,12 @@ function claimPersistentSession(session, callerKey, store) {
   }
   return owners.get(session) === callerKey ? "owner" : "refused";
 }
-var import_auth56, import_utils101, owners;
+var import_auth56, import_utils102, owners;
 var init_persistent_session_owner = __esm({
   "libs/sdk/src/transport/persistent-session-owner.ts"() {
     "use strict";
     import_auth56 = require("@frontmcp/auth");
-    import_utils101 = require("@frontmcp/utils");
+    import_utils102 = require("@frontmcp/utils");
     owners = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -59912,7 +60614,7 @@ async function runWebStandardMcp(scope, request, options) {
   if (options.persistent) {
     return options.persistent.transport.handleRequest(request, { authInfo: options.authInfo });
   }
-  const sessionId = `web:${(0, import_utils102.randomUUID)()}`;
+  const sessionId = `web:${(0, import_utils103.randomUUID)()}`;
   const accept = request.headers.get("accept") ?? "";
   const wantsStream = request.method === "GET" || options.sse && accept.includes("text/event-stream");
   const { mcpServer, transport } = await wireServer(scope, options.serverOptions, sessionId, void 0, !wantsStream);
@@ -59935,23 +60637,23 @@ async function runWebStandardMcp(scope, request, options) {
   }
   return response;
 }
-var import_utils102;
+var import_utils103;
 var init_web_standard_mcp = __esm({
   "libs/sdk/src/transport/web-standard-mcp.ts"() {
     "use strict";
-    import_utils102 = require("@frontmcp/utils");
+    import_utils103 = require("@frontmcp/utils");
     init_build_scoped_server_options();
   }
 });
 
 // libs/sdk/src/scope/flows/http.request.flow.ts
-var import_auth57, import_lazy_zod108, import_utils103, plan42, httpRequestStateSchema, name43, Stage43, HttpRequestFlow;
+var import_auth57, import_lazy_zod108, import_utils104, plan42, httpRequestStateSchema, name43, Stage43, HttpRequestFlow;
 var init_http_request_flow = __esm({
   "libs/sdk/src/scope/flows/http.request.flow.ts"() {
     "use strict";
     import_auth57 = require("@frontmcp/auth");
     import_lazy_zod108 = require("@frontmcp/lazy-zod");
-    import_utils103 = require("@frontmcp/utils");
+    import_utils104 = require("@frontmcp/utils");
     init_session_verify_flow();
     init_common();
     init_schema7();
@@ -60030,7 +60732,7 @@ var init_http_request_flow = __esm({
         const { request } = this.rawInput;
         this.requestStartTime = Date.now();
         const ctx = this.tryGetContext();
-        this.requestId = ctx?.requestId ?? `req-${(0, import_utils103.randomUUID)()}`;
+        this.requestId = ctx?.requestId ?? `req-${(0, import_utils104.randomUUID)()}`;
         const headers = request.headers ?? {};
         const body = request.body;
         const userAgent = headers["user-agent"];
@@ -60102,7 +60804,10 @@ var init_http_request_flow = __esm({
         const { request } = this.rawInput;
         this.logger.verbose(`[${this.requestId}] checkAuthorization: verifying session`);
         try {
-          const result = await this.scope.runFlow("session:verify", { request });
+          const result = await this.scope.runFlow("session:verify", {
+            request,
+            sessionless: this.servesProtocol20260728()
+          });
           if (!result) {
             this.logger.error(`[${this.requestId}] failed to verify session`);
             throw new SessionVerificationFailedError();
@@ -60712,13 +61417,13 @@ var init_http_request_flow = __esm({
 });
 
 // libs/sdk/src/scope/scope.instance.ts
-var import_reflect_metadata25, import_guard8, import_utils104, SCOPE_NON_DISPATCHABLE_FLOWS, Scope;
+var import_reflect_metadata25, import_guard8, import_utils105, SCOPE_NON_DISPATCHABLE_FLOWS, Scope;
 var init_scope_instance = __esm({
   "libs/sdk/src/scope/scope.instance.ts"() {
     "use strict";
     import_reflect_metadata25 = require("reflect-metadata");
     import_guard8 = require("@frontmcp/guard");
-    import_utils104 = require("@frontmcp/utils");
+    import_utils105 = require("@frontmcp/utils");
     init_agent_registry();
     init_call_agent_flow();
     init_app_registry();
@@ -60761,6 +61466,7 @@ var init_scope_instance = __esm({
     init_ui();
     init_bus();
     init_event_stores();
+    init_request_state();
     init_transport_registry();
     init_http_ip_filter_flow();
     init_http_request_flow();
@@ -60851,7 +61557,7 @@ var init_scope_instance = __esm({
         await this.scopeProviders.ready;
         const scopeRef = { kind: "scope", id: this.id, ref: _Scope };
         const scopeProviders = this.scopeProviders;
-        const perf = (0, import_utils104.getEnvFlag)("FRONTMCP_PERF");
+        const perf = (0, import_utils105.getEnvFlag)("FRONTMCP_PERF");
         const t0 = perf ? performance.now() : 0;
         const mark = perf ? (label) => this.logger.info(`[PERF] ${label}: ${(performance.now() - t0).toFixed(1)}ms`) : () => {
         };
@@ -60861,13 +61567,13 @@ var init_scope_instance = __esm({
         this.scopeApps = new AppRegistry(this.scopeProviders, this.metadata.apps, scopeRef);
         this.logger.info(`Initializing ${this.metadata.apps.length} app(s)...`);
         const transportConfig = this.metadata.transport;
-        const isDistributed = (0, import_utils104.getRuntimeContext)().deployment === "distributed";
+        const isDistributed = (0, import_utils105.getRuntimeContext)().deployment === "distributed";
         if (isDistributed && this.metadata.redis && !this.cliMode) {
           try {
             const haRedis = this.metadata.redis;
             this.haManager = HaManager.create({
               redis: haRedis,
-              nodeId: (0, import_utils104.getMachineId)(),
+              nodeId: (0, import_utils105.getMachineId)(),
               logger: this.logger
             });
             await this.haManager.start();
@@ -60878,7 +61584,7 @@ var init_scope_instance = __esm({
         }
         let transportBus;
         if (this.haManager && isDistributed && this.metadata.redis) {
-          transportBus = new RedisTransportBus(this.metadata.redis, (0, import_utils104.getMachineId)(), {
+          transportBus = new RedisTransportBus(this.metadata.redis, (0, import_utils105.getMachineId)(), {
             logger: this.logger
           });
           this.logger.info("[HA] Transport bus created for distributed session routing");
@@ -60889,6 +61595,7 @@ var init_scope_instance = __esm({
           effectivePersistence = { sqlite: resolvedTopLevelSqlite };
         }
         this.transportService = new TransportService(this, effectivePersistence, transportBus);
+        warnIfRequestStateKeyNotShared({ logger: this.logger, metadata: this.metadata });
         if (this.haManager && isDistributed) {
           const persistCfg = transportConfig?.persistence;
           const resolvedPrefix = persistCfg && typeof persistCfg === "object" && persistCfg.redis?.keyPrefix ? persistCfg.redis.keyPrefix : "mcp:transport:";
@@ -60901,7 +61608,7 @@ var init_scope_instance = __esm({
             }
           });
         }
-        if ((0, import_utils104.getRuntimeContext)().deployment === "serverless") {
+        if ((0, import_utils105.getRuntimeContext)().deployment === "serverless") {
           const protocolCfg = transportConfig?.protocol;
           const hasSSE = typeof protocolCfg === "string" ? protocolCfg !== "stateless-api" : protocolCfg?.sse === true;
           if (hasSSE) {
@@ -60928,7 +61635,7 @@ var init_scope_instance = __esm({
             sqlite: elicitationSqlite,
             keyPrefix: elicitationRedis?.keyPrefix ?? "mcp:elicit:",
             logger: this.logger,
-            isEdgeRuntime: (0, import_utils104.isEdgeRuntime)()
+            isEdgeRuntime: (0, import_utils105.isEdgeRuntime)()
           });
           this._elicitationStore = elicitStore;
           this.elicitationBackendType = elicitType;
@@ -60942,7 +61649,7 @@ var init_scope_instance = __esm({
         );
         const tasksEnabledForCli = this.cliMode && hasPersistentBackend;
         const hasDistributedTaskBackend = Boolean(tasksConfig?.redis ?? this.metadata.redis);
-        const onEdgeRuntime = (0, import_utils104.isEdgeRuntime)();
+        const onEdgeRuntime = (0, import_utils105.isEdgeRuntime)();
         const tasksUnavailableOnEdge = onEdgeRuntime && !hasDistributedTaskBackend && !tasksExplicitlyEnabled;
         if (tasksUnavailableOnEdge) {
           this.logger.info(
@@ -61386,6 +62093,15 @@ var init_scope_instance = __esm({
             notificationService: this.notificationService,
             flowRegistry: this.scopeFlows,
             toolRegistry: this.scopeTools,
+            http: {
+              server: this.server,
+              checkClientIp: (request, response) => this.runFlow("http:ip-filter", {
+                request,
+                response
+              }),
+              entryPath: this.entryPath,
+              routeBase: this.routeBase
+            },
             logger: this.logger
           });
           this._scopeChannels = channelResult.channelRegistry;
@@ -61790,12 +62506,12 @@ var init_scope_instance = __esm({
         return this._authoritiesScopeMapping;
       }
       /**
-       * Collect all supported OAuth scopes from base OIDC scopes and
-       * tool-level authProvider scope declarations.
-       * Used by PRM endpoint to populate `scopes_supported` (RFC 9728).
+       * Collect the OAuth scopes entries declare on their `authProviders`. The PRM
+       * endpoint advertises them in `scopes_supported` (RFC 9728) next to the scopes
+       * the auth mode grants (`resourceScopesFor`), not a fixed OIDC list (#629).
        */
       getAllSupportedScopes() {
-        const scopes = /* @__PURE__ */ new Set(["openid", "profile", "email"]);
+        const scopes = /* @__PURE__ */ new Set();
         const collectScopes = (metadata) => {
           const authProviders = metadata?.["authProviders"];
           if (!Array.isArray(authProviders)) return;
@@ -63362,7 +64078,7 @@ async function runHttpRequestFlowWeb(scope, request, opts = {}) {
   const serverRequest = await toServerRequest(request, url, opts.ctx, opts.persistent, opts.env);
   let output;
   try {
-    output = await (0, import_utils105.runRequestExclusive)(
+    output = await (0, import_utils106.runRequestExclusive)(
       () => scope.runFlow("http:request", {
         request: serverRequest,
         response: {}
@@ -63380,7 +64096,7 @@ async function runMatchingHttpFlowWeb(scope, request, opts = {}) {
   if (!flowName) return void 0;
   let output;
   try {
-    output = await (0, import_utils105.runRequestExclusive)(
+    output = await (0, import_utils106.runRequestExclusive)(
       () => scope.runFlow(flowName, {
         request: serverRequest,
         response: {}
@@ -63458,10 +64174,57 @@ function findMisconfiguration(error) {
     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;
 }
+function createDeferredServerBuild(build, options = {}) {
+  const now = options.now ?? Date.now;
+  let built;
+  let inFlight;
+  let failure;
+  return {
+    get(arg) {
+      if (built) return Promise.resolve(built.value);
+      if (inFlight) return inFlight;
+      if (failure && now() < failure.retryAt) return Promise.reject(failure.error);
+      const failures = failure?.count ?? 0;
+      inFlight = build(arg).then(
+        (value) => {
+          built = { value };
+          failure = void 0;
+          inFlight = void 0;
+          return value;
+        },
+        (error) => {
+          const delay = Math.min(STARTUP_RETRY_MAX_MS, STARTUP_RETRY_MIN_MS * 2 ** failures);
+          failure = { error, retryAt: now() + delay, count: failures + 1 };
+          inFlight = void 0;
+          options.onFailure?.(error);
+          throw error;
+        }
+      );
+      return inFlight;
+    },
+    retryAfterSeconds() {
+      if (!failure) return 0;
+      return Math.max(1, Math.ceil((failure.retryAt - now()) / 1e3));
+    }
+  };
+}
+function startupFailureResponse(error, retryAfterSeconds = 1) {
+  const misconfigured = misconfigurationResponse(error);
+  if (misconfigured) return misconfigured;
+  return Response.json(
+    {
+      error: "server_unavailable",
+      code: "SERVER_START_FAILED",
+      message: "The server failed to start, so it refuses requests. Its log has the cause; a request after the Retry-After delay tries to start it again."
+    },
+    { status: 503, headers: { "Retry-After": String(Math.max(1, retryAfterSeconds)) } }
+  );
+}
 function flowErrorToHttpOutput(error) {
   const misconfiguration = findMisconfiguration(error);
   if (misconfiguration) {
@@ -63495,11 +64258,11 @@ function flowErrorToHttpOutput(error) {
   }
   return { kind: "text", status: 500, body: "Internal Server Error", contentType: "text/plain; charset=utf-8" };
 }
-var import_utils105, CLOUDFLARE_WORKERS_USER_AGENT, MISCONFIGURATION_REMEDIES;
+var import_utils106, CLOUDFLARE_WORKERS_USER_AGENT, MISCONFIGURATION_REMEDIES, CONFIG_INVALID_REMEDY, STARTUP_RETRY_MIN_MS, STARTUP_RETRY_MAX_MS;
 var init_web_fetch_handler = __esm({
   "libs/sdk/src/transport/web-fetch-handler.ts"() {
     "use strict";
-    import_utils105 = require("@frontmcp/utils");
+    import_utils106 = require("@frontmcp/utils");
     init_common();
     init_server_tokens();
     init_path_utils();
@@ -63515,6 +64278,9 @@ var init_web_fetch_handler = __esm({
       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.";
+    STARTUP_RETRY_MIN_MS = 1e3;
+    STARTUP_RETRY_MAX_MS = 6e4;
   }
 });
 
@@ -63544,9 +64310,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;
@@ -63780,14 +64546,14 @@ var init_base_host_adapter = __esm({
 });
 
 // libs/sdk/src/server/adapters/express.host.adapter.ts
-var http, import_cors, import_express, import_utils106, DEFAULT_EXPRESS_BODY_LIMIT, ExpressHostAdapter;
+var http, import_cors, import_express, import_utils107, DEFAULT_EXPRESS_BODY_LIMIT, ExpressHostAdapter;
 var init_express_host_adapter = __esm({
   "libs/sdk/src/server/adapters/express.host.adapter.ts"() {
     "use strict";
     http = __toESM(require("node:http"));
     import_cors = __toESM(require("cors"));
     import_express = __toESM(require("express"));
-    import_utils106 = require("@frontmcp/utils");
+    import_utils107 = require("@frontmcp/utils");
     init_mcp_error();
     init_host_validation_middleware();
     init_resolve_allowed_hosts();
@@ -63970,8 +64736,8 @@ var init_express_host_adapter = __esm({
       }
       async cleanupStaleSocket(socketPath) {
         try {
-          if (await (0, import_utils106.fileExists)(socketPath)) {
-            await (0, import_utils106.unlink)(socketPath);
+          if (await (0, import_utils107.fileExists)(socketPath)) {
+            await (0, import_utils107.unlink)(socketPath);
           }
         } catch {
         }
@@ -63994,11 +64760,11 @@ var init_node_express_host = __esm({
 });
 
 // libs/sdk/src/server/server.instance.ts
-var import_utils107, DEFAULT_CORS, FrontMcpServerInstance;
+var import_utils108, DEFAULT_CORS, FrontMcpServerInstance;
 var init_server_instance = __esm({
   "libs/sdk/src/server/server.instance.ts"() {
     "use strict";
-    import_utils107 = require("@frontmcp/utils");
+    import_utils108 = require("@frontmcp/utils");
     init_common();
     init_health2();
     init_metrics2();
@@ -64100,9 +64866,9 @@ var init_server_instance = __esm({
       }
       async start() {
         this.prepare();
-        const deploymentMode = (0, import_utils107.getRuntimeContext)().deployment;
+        const deploymentMode = (0, import_utils108.getRuntimeContext)().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,
@@ -64110,7 +64876,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);
@@ -64338,11 +65104,11 @@ function resolveConfigInput(optionsOrClass) {
   }
   return optionsOrClass;
 }
-var import_utils108, stdioServing, FrontMcpInstance;
+var import_utils109, stdioServing, FrontMcpInstance;
 var init_front_mcp = __esm({
   "libs/sdk/src/front-mcp/front-mcp.ts"() {
     "use strict";
-    import_utils108 = require("@frontmcp/utils");
+    import_utils109 = require("@frontmcp/utils");
     init_common();
     init_direct();
     init_errors();
@@ -64527,11 +65293,16 @@ var init_front_mcp = __esm({
        */
       static async createFetchHandler(options) {
         const build = async (deferred) => {
-          const frontMcp = new _FrontMcpInstance2(frontMcpMetadataSchema.parse(options));
+          let frontMcp;
           try {
+            frontMcp = new _FrontMcpInstance2(frontMcpMetadataSchema.parse(options));
             await frontMcp.ready;
           } catch (err) {
-            if (deferred) frontMcp.log?.error("FrontMCP failed to start; requests are refused until it does", err);
+            if (deferred) {
+              const message = "FrontMCP failed to start; requests are refused until a retry succeeds";
+              if (frontMcp?.log) frontMcp.log.error(message, err);
+              else console.error(`[frontmcp] ${message}`, err);
+            }
             throw err;
           }
           const scope = frontMcp.getPrimaryScope();
@@ -64541,25 +65312,15 @@ var init_front_mcp = __esm({
           frontMcp.log?.info("FrontMCP fetch handler created (web-standard transport)");
           return createWebFetchHandler(scope);
         };
-        if (!(0, import_utils108.isEdgeRuntime)()) return build(false);
+        if (!(0, import_utils109.isEdgeRuntime)()) return build(false);
         assertStaticStartupConfig(options);
-        let inner;
-        let building;
+        const server = createDeferredServerBuild(() => build(true));
         return async (request, ctx, env) => {
-          if (!inner) {
-            if (!building) {
-              building = build(true).catch((err) => {
-                building = void 0;
-                throw err;
-              });
-            }
-            try {
-              inner = await building;
-            } catch (err) {
-              const misconfigured = misconfigurationResponse(err);
-              if (misconfigured) return misconfigured;
-              throw err;
-            }
+          let inner;
+          try {
+            inner = await server.get();
+          } catch (err) {
+            return startupFailureResponse(err, server.retryAfterSeconds());
           }
           return inner(request, ctx, env);
         };
@@ -64696,8 +65457,8 @@ var init_front_mcp = __esm({
         frontMcp.log?.info(`MCP server listening on unix://${socketPath}`);
         const cleanup = async () => {
           try {
-            if (await (0, import_utils108.fileExists)(socketPath)) {
-              await (0, import_utils108.unlink)(socketPath);
+            if (await (0, import_utils109.fileExists)(socketPath)) {
+              await (0, import_utils109.unlink)(socketPath);
             }
           } catch {
           }
@@ -64841,7 +65602,7 @@ var init_front_mcp = __esm({
           };
           const mcpServer = new McpServer2(scope.metadata.info, serverOptions);
           startupCleanups.push(() => mcpServer.close());
-          const sessionId = `stdio:${(0, import_utils108.randomUUID)()}`;
+          const sessionId = `stdio:${(0, import_utils109.randomUUID)()}`;
           const handlers = createMcpHandlers2({ scope, serverOptions, composeInstructions });
           for (const handler of handlers) {
             const originalHandler = handler.handler;
@@ -65161,9 +65922,9 @@ function FrontMcp(providedMetadata) {
       Reflect.defineMetadata(FrontMcpTokens[property] ?? property, metadata[property], target);
     }
     Reflect.defineMetadata(FRONTMCP_CONFIG_METADATA_KEY, metadata, target);
-    const isServerless2 = (0, import_utils109.getEnvFlag)("FRONTMCP_SERVERLESS");
-    const isSchemaExtract = (0, import_utils109.getEnvFlag)("FRONTMCP_SCHEMA_EXTRACT");
-    const isStdio = (0, import_utils109.getEnvFlag)("FRONTMCP_STDIO");
+    const isServerless2 = (0, import_utils110.getEnvFlag)("FRONTMCP_SERVERLESS");
+    const isSchemaExtract = (0, import_utils110.getEnvFlag)("FRONTMCP_SCHEMA_EXTRACT");
+    const isStdio = (0, import_utils110.getEnvFlag)("FRONTMCP_STDIO");
     const taskWorkerId = typeof process !== "undefined" ? process.env?.["FRONTMCP_RUN_TASK_ID"] : void 0;
     if (taskWorkerId && metadata.serve !== false) {
       void (async () => {
@@ -65189,7 +65950,7 @@ function FrontMcp(providedMetadata) {
     } else if (isServerless2) {
       const ServerlessInstance = getFrontMcpInstance();
       const { setServerlessHandler: setServerlessHandler2, setServerlessHandlerPromise: setServerlessHandlerPromise2, setServerlessHandlerError: setServerlessHandlerError2 } = getServerlessHandlerFns();
-      const isWorker = (0, import_utils109.getEnvFlag)("FRONTMCP_WORKER");
+      const isWorker = (0, import_utils110.getEnvFlag)("FRONTMCP_WORKER");
       const handlerPromise = isWorker ? ServerlessInstance.createFetchHandler(metadata) : ServerlessInstance.createHandler(metadata);
       setServerlessHandlerPromise2(handlerPromise);
       handlerPromise.then(setServerlessHandler2).catch((err) => {
@@ -65202,12 +65963,12 @@ function FrontMcp(providedMetadata) {
     }
   };
 }
-var import_reflect_metadata28, import_utils109, FRONT_MCP_DECORATOR_BASENAMES, FRONTMCP_CONFIG_METADATA_KEY, _FrontMcpInstance, _serverlessHandlerFns;
+var import_reflect_metadata28, import_utils110, FRONT_MCP_DECORATOR_BASENAMES, FRONTMCP_CONFIG_METADATA_KEY, _FrontMcpInstance, _serverlessHandlerFns;
 var init_front_mcp_decorator = __esm({
   "libs/sdk/src/common/decorators/front-mcp.decorator.ts"() {
     "use strict";
     import_reflect_metadata28 = require("reflect-metadata");
-    import_utils109 = require("@frontmcp/utils");
+    import_utils110 = require("@frontmcp/utils");
     init_decorator_errors();
     init_mcp_error();
     init_metadata();
@@ -65960,49 +66721,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"() {
@@ -66166,12 +66884,12 @@ var init_adapter_entry = __esm({
 });
 
 // libs/sdk/src/common/entries/tool.entry.ts
-var import_lazy_zod109, import_utils111, ToolEntry;
+var import_lazy_zod109, import_utils112, ToolEntry;
 var init_tool_entry = __esm({
   "libs/sdk/src/common/entries/tool.entry.ts"() {
     "use strict";
     import_lazy_zod109 = require("@frontmcp/lazy-zod");
-    import_utils111 = require("@frontmcp/utils");
+    import_utils112 = require("@frontmcp/utils");
     init_base_entry();
     ToolEntry = class extends BaseEntry {
       owner;
@@ -66238,7 +66956,7 @@ var init_tool_entry = __esm({
           try {
             return (0, import_lazy_zod109.toJSONSchema)(import_lazy_zod109.z.object(this.inputSchema), { io: "input", unrepresentable: "any" });
           } catch (error) {
-            if ((0, import_utils111.isDebug)() || (0, import_utils111.isDevelopment)()) {
+            if ((0, import_utils112.isDebug)() || (0, import_utils112.isDevelopment)()) {
               console.warn("[ToolEntry] Failed to convert Zod schema to JSON Schema:", error);
             }
             return { type: "object", properties: {} };
@@ -66284,7 +67002,7 @@ var init_tool_entry = __esm({
           const json = (0, import_lazy_zod109.toJSONSchema)(zodSchema);
           return json && json["type"] === "object" ? json : null;
         } catch (error) {
-          if ((0, import_utils111.isDebug)() || (0, import_utils111.isDevelopment)()) {
+          if ((0, import_utils112.isDebug)() || (0, import_utils112.isDevelopment)()) {
             console.warn("[ToolEntry] Failed to convert output Zod schema to JSON Schema:", error);
           }
           return null;
@@ -67476,6 +68194,7 @@ __export(index_exports, {
   create: () => create,
   createChildSpanContext: () => createChildSpanContext,
   createContextResolver: () => createContextResolver,
+  createDeferredServerBuild: () => createDeferredServerBuild,
   createDirectResolver: () => createDirectResolver,
   createElicitationStore: () => createElicitationStore,
   createElicitationStoreFromStorage: () => createElicitationStoreFromStorage,
@@ -67583,6 +68302,7 @@ __export(index_exports, {
   getElicitationSecret: () => getElicitationSecret,
   getGlobalStoreConfig: () => getGlobalStoreConfig,
   getNestedValue: () => getNestedValue,
+  getPinnedPublicUrl: () => getPinnedPublicUrl,
   getRegistryUrl: () => getRegistryUrl,
   getRequestBaseUrl: () => getRequestBaseUrl,
   getRunningTool: () => getRunningTool,
@@ -67600,6 +68320,7 @@ __export(index_exports, {
   httpRequestInputSchema: () => httpRequestInputSchema,
   httpRespond: () => httpRespond,
   incrementalAuthConfigSchema: () => import_auth5.incrementalAuthConfigSchema,
+  initOptionsOf: () => initOptionsOf,
   intentSchema: () => intentSchema,
   isAlive: () => isAlive,
   isAnonymousSubject: () => import_auth61.isAnonymousSubject,
@@ -67758,6 +68479,7 @@ __export(index_exports, {
   skillsConfigOptionsSchema: () => skillsConfigOptionsSchema,
   skippedAppBehaviorSchema: () => import_auth5.skippedAppBehaviorSchema,
   sqliteOptionsSchema: () => sqliteOptionsSchema,
+  startupFailureResponse: () => startupFailureResponse,
   staticAuthOptionsSchema: () => import_auth7.staticAuthOptionsSchema,
   storageProviderSchema: () => storageProviderSchema,
   supportsStreaming: () => supportsStreaming,
@@ -67945,22 +68667,22 @@ function createMemorySkillProvider(options = {}) {
 init_skill_utils();
 
 // libs/sdk/src/skill/skill-directory-loader.ts
-var import_utils112 = require("@frontmcp/utils");
+var import_utils113 = require("@frontmcp/utils");
 init_skill_metadata();
 init_sdk_errors();
 init_skill_md_parser();
 async function scanSkillResources(dirPath) {
   const resources = {};
-  const scriptsPath = (0, import_utils112.joinPath)(dirPath, "scripts");
-  const referencesPath = (0, import_utils112.joinPath)(dirPath, "references");
-  const assetsPath = (0, import_utils112.joinPath)(dirPath, "assets");
-  const examplesPath = (0, import_utils112.joinPath)(dirPath, "examples");
+  const scriptsPath = (0, import_utils113.joinPath)(dirPath, "scripts");
+  const referencesPath = (0, import_utils113.joinPath)(dirPath, "references");
+  const assetsPath = (0, import_utils113.joinPath)(dirPath, "assets");
+  const examplesPath = (0, import_utils113.joinPath)(dirPath, "examples");
   const checks = await Promise.all([
     checkDirectory(scriptsPath),
     checkDirectory(referencesPath),
     checkDirectory(assetsPath),
     checkDirectory(examplesPath),
-    (0, import_utils112.fileExists)((0, import_utils112.joinPath)(dirPath, "SKILL.md"))
+    (0, import_utils113.fileExists)((0, import_utils113.joinPath)(dirPath, "SKILL.md"))
   ]);
   if (checks[0]) resources.scripts = scriptsPath;
   if (checks[1]) resources.references = referencesPath;
@@ -67973,7 +68695,7 @@ async function scanSkillResources(dirPath) {
 }
 async function checkDirectory(path3) {
   try {
-    const s = await (0, import_utils112.stat)(path3);
+    const s = await (0, import_utils113.stat)(path3);
     return s.isDirectory();
   } catch (err) {
     if (err.code === "ENOENT") return false;
@@ -67986,16 +68708,16 @@ async function findNestedSkillMd(dirPath, maxDepth = Number.POSITIVE_INFINITY) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = await (0, import_utils112.readdir)(current);
+      entries = await (0, import_utils113.readdir)(current);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
     }
     for (const entry of entries) {
-      const full = (0, import_utils112.joinPath)(current, entry);
+      const full = (0, import_utils113.joinPath)(current, entry);
       let entryStat;
       try {
-        entryStat = await (0, import_utils112.stat)(full);
+        entryStat = await (0, import_utils113.stat)(full);
       } catch (err) {
         if (err.code === "ENOENT") continue;
         throw err;
@@ -68011,19 +68733,19 @@ async function findNestedSkillMd(dirPath, maxDepth = Number.POSITIVE_INFINITY) {
   return found.sort();
 }
 async function loadSkillDirectory(dirPath, logger) {
-  const skillMdPath = (0, import_utils112.joinPath)(dirPath, "SKILL.md");
-  const exists = await (0, import_utils112.fileExists)(skillMdPath);
+  const skillMdPath = (0, import_utils113.joinPath)(dirPath, "SKILL.md");
+  const exists = await (0, import_utils113.fileExists)(skillMdPath);
   if (!exists) {
-    throw new InvalidSkillError((0, import_utils112.basename)(dirPath), "SKILL.md not found in directory");
+    throw new InvalidSkillError((0, import_utils113.basename)(dirPath), "SKILL.md not found in directory");
   }
   let content;
   let partialMetadata;
   try {
-    content = await (0, import_utils112.readFile)(skillMdPath, "utf-8");
+    content = await (0, import_utils113.readFile)(skillMdPath, "utf-8");
     const { frontmatter, body } = parseSkillMdFrontmatter(content);
     partialMetadata = skillMdFrontmatterToMetadata(frontmatter, body);
   } catch (err) {
-    const name44 = (0, import_utils112.basename)(dirPath);
+    const name44 = (0, import_utils113.basename)(dirPath);
     const message = err instanceof Error ? err.message : String(err);
     throw new InvalidSkillError(name44, `Failed to read or parse SKILL.md: ${message}`);
   }
@@ -68034,13 +68756,13 @@ async function loadSkillDirectory(dirPath, logger) {
   }
   const nested = await findNestedSkillMd(dirPath);
   if (nested.length > 0) {
-    const skillName2 = partialMetadata.name ?? (0, import_utils112.basename)(dirPath);
+    const skillName2 = partialMetadata.name ?? (0, import_utils113.basename)(dirPath);
     throw new InvalidSkillError(
       skillName2,
       `Skill directory contains nested SKILL.md files (forbidden by SEP-2640 \xA7Resource Mapping): ${nested.join(", ")}`
     );
   }
-  const dirName = (0, import_utils112.basename)(dirPath);
+  const dirName = (0, import_utils113.basename)(dirPath);
   if (partialMetadata.name && dirName && partialMetadata.name !== dirName) {
     const msg = `Skill name "${partialMetadata.name}" does not match directory name "${dirName}"`;
     if (logger) {
@@ -68716,6 +69438,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   create,
   createChildSpanContext,
   createContextResolver,
+  createDeferredServerBuild,
   createDirectResolver,
   createElicitationStore,
   createElicitationStoreFromStorage,
@@ -68822,6 +69545,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   getElicitationSecret,
   getGlobalStoreConfig,
   getNestedValue,
+  getPinnedPublicUrl,
   getRegistryUrl,
   getRequestBaseUrl,
   getRunningTool,
@@ -68839,6 +69563,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   httpRequestInputSchema,
   httpRespond,
   incrementalAuthConfigSchema,
+  initOptionsOf,
   intentSchema,
   isAlive,
   isAnonymousSubject,
@@ -68997,6 +69722,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   skillsConfigOptionsSchema,
   skippedAppBehaviorSchema,
   sqliteOptionsSchema,
+  startupFailureResponse,
   staticAuthOptionsSchema,
   storageProviderSchema,
   supportsStreaming,