@frontmcp/sdk 1.0.0-beta.10 → 1.0.0-beta.12

package/index.js

@@ -6592,12 +6592,12 @@ var init_provider_registry = __esm({
        */
       getProviderInfo(token) {
         const def = this.defs.get(token);
-        const instance = this.instances.get(token);
-        if (!def || !instance)
+        if (!def)
           throw new ProviderNotRegisteredError(
             (0, import_di7.tokenName)(token),
             "not a registered DEFAULT provider and not a constructable class"
           );
+        const instance = this.instances.get(token);
         return {
           token,
           def,
@@ -10994,15 +10994,22 @@ var init_resource_instance = __esm({
     init_mcp_error();
     init_errors();
     ResourceInstance = class extends ResourceEntry2 {
-      providers;
+      _providers;
       scope;
       hooks;
+      /**
+       * Get the provider registry for this resource.
+       * Used by flows to build context-aware providers for CONTEXT-scoped dependencies.
+       */
+      get providers() {
+        return this._providers;
+      }
       /** Parsed URI template info for template resources */
       templateInfo;
       constructor(record, providers, owner) {
         super(record);
         this.owner = owner;
-        this.providers = providers;
+        this._providers = providers;
         this.name = record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this.providers.getActiveScope();
@@ -11037,6 +11044,18 @@ var init_resource_instance = __esm({
       getMetadata() {
         return this.record.metadata;
       }
+      /**
+       * Get an argument completer from the resource class prototype.
+       * Returns a completer function if the resource class overrides getArgumentCompleter,
+       * or null if no completer is available.
+       */
+      getArgumentCompleter(argName) {
+        const cls = this.record.provide;
+        if (typeof cls === "function" && cls.prototype && typeof cls.prototype.getArgumentCompleter === "function") {
+          return cls.prototype.getArgumentCompleter.call(cls.prototype, argName);
+        }
+        return null;
+      }
       /**
        * Match a URI against this resource.
        * For static resources: exact match against uri
@@ -11150,7 +11169,7 @@ var init_resource_types = __esm({
 });
 
 // libs/sdk/src/resource/flows/read-resource.flow.ts
-var import_zod40, import_protocol9, inputSchema4, outputSchema3, stateSchema3, plan3, name3, Stage3, ReadResourceFlow;
+var import_zod40, import_protocol9, import_utils22, inputSchema4, outputSchema3, stateSchema3, plan3, name3, Stage3, ReadResourceFlow;
 var init_read_resource_flow = __esm({
   "libs/sdk/src/resource/flows/read-resource.flow.ts"() {
     "use strict";
@@ -11160,6 +11179,7 @@ var init_read_resource_flow = __esm({
     init_errors();
     init_ui();
     init_flow_context_providers();
+    import_utils22 = require("@frontmcp/utils");
     inputSchema4 = import_zod40.z.object({
       request: import_protocol9.ReadResourceRequestSchema,
       // z.any() used because ctx is the MCP SDK's ResourceReadExtra type which varies by SDK version
@@ -11304,7 +11324,15 @@ var init_read_resource_flow = __esm({
         const { ctx } = this.input;
         const { resource, input, params } = this.state.required;
         try {
-          const contextProviders = new FlowContextProviders(this.scope.providers, this.deps);
+          const sessionKey = this.state.sessionId ?? ctx.authInfo?.sessionId ?? `req-${Date.now()}-${Buffer.from((0, import_utils22.randomBytes)(16)).toString("hex")}`;
+          const resourceViews = await resource.providers.buildViews(sessionKey, new Map(this.deps));
+          const mergedContextDeps = new Map(this.deps);
+          for (const [token, instance] of resourceViews.context) {
+            if (!mergedContextDeps.has(token)) {
+              mergedContextDeps.set(token, instance);
+            }
+          }
+          const contextProviders = new FlowContextProviders(resource.providers, mergedContextDeps);
           const context = resource.create(input.uri, params, { ...ctx, contextProviders });
           const resourceHooks = this.scope.hooks.getClsHooks(resource.record.provide).map((hook) => {
             hook.run = async () => {
@@ -12059,13 +12087,13 @@ function dedupLineage2(l) {
   }
   return out;
 }
-var import_di12, import_utils22, ResourceRegistry;
+var import_di12, import_utils23, ResourceRegistry;
 var init_resource_registry = __esm({
   "libs/sdk/src/resource/resource.registry.ts"() {
     "use strict";
     import_di12 = require("@frontmcp/di");
     init_resource_events();
-    import_utils22 = require("@frontmcp/utils");
+    import_utils23 = require("@frontmcp/utils");
     init_naming_utils();
     init_lineage_utils();
     init_resource_utils();
@@ -12359,31 +12387,31 @@ var init_resource_registry = __esm({
         for (const [base, group] of byBase.entries()) {
           if (group.length === 1) {
             const g = group[0];
-            out.set((0, import_utils22.ensureMaxLen)(base, cfg.maxLen), g.row.instance);
+            out.set((0, import_utils23.ensureMaxLen)(base, cfg.maxLen), g.row.instance);
             continue;
           }
           const locals = group.filter((g) => g.isLocal);
           const children = group.filter((g) => !g.isLocal);
           if (cfg.prefixChildrenOnConflict && locals.length > 0) {
             if (locals.length === 1) {
-              const localName = (0, import_utils22.ensureMaxLen)(base, cfg.maxLen);
+              const localName = (0, import_utils23.ensureMaxLen)(base, cfg.maxLen);
               out.set(disambiguate(localName, out, cfg), locals[0].row.instance);
             } else {
               for (const l of locals) {
                 const pref = normalizeOwnerPath(l.ownerPath, cfg.case);
-                const name33 = (0, import_utils22.ensureMaxLen)(`${pref}${(0, import_utils22.sepFor)(cfg.case)}${base}`, cfg.maxLen);
+                const name33 = (0, import_utils23.ensureMaxLen)(`${pref}${(0, import_utils23.sepFor)(cfg.case)}${base}`, cfg.maxLen);
                 out.set(disambiguate(name33, out, cfg), l.row.instance);
               }
             }
             for (const c of children) {
               const pre = cfg.prefixSource === "provider" ? c.provider ?? c.ownerPath : c.ownerPath;
-              const name33 = (0, import_utils22.ensureMaxLen)(`${pre}${(0, import_utils22.sepFor)(cfg.case)}${base}`, cfg.maxLen);
+              const name33 = (0, import_utils23.ensureMaxLen)(`${pre}${(0, import_utils23.sepFor)(cfg.case)}${base}`, cfg.maxLen);
               out.set(disambiguate(name33, out, cfg), c.row.instance);
             }
           } else {
             for (const r of group) {
               const pre = cfg.prefixSource === "provider" ? r.provider ?? r.ownerPath : r.ownerPath;
-              const name33 = (0, import_utils22.ensureMaxLen)(`${pre}${(0, import_utils22.sepFor)(cfg.case)}${base}`, cfg.maxLen);
+              const name33 = (0, import_utils23.ensureMaxLen)(`${pre}${(0, import_utils23.sepFor)(cfg.case)}${base}`, cfg.maxLen);
               out.set(disambiguate(name33, out, cfg), r.row.instance);
             }
           }
@@ -12394,7 +12422,7 @@ var init_resource_registry = __esm({
           const maxAttempts = 1e4;
           let n = 2;
           while (n <= maxAttempts) {
-            const withN = (0, import_utils22.ensureMaxLen)(`${candidate}${(0, import_utils22.sepFor)(cfg2.case)}${n}`, cfg2.maxLen);
+            const withN = (0, import_utils23.ensureMaxLen)(`${candidate}${(0, import_utils23.sepFor)(cfg2.case)}${n}`, cfg2.maxLen);
             if (!pool.has(withN)) return withN;
             n++;
           }
@@ -13303,13 +13331,13 @@ function dedupLineage3(l) {
   }
   return out;
 }
-var import_di14, import_utils23, MAX_DISAMBIGUATE_ATTEMPTS, PromptRegistry;
+var import_di14, import_utils24, MAX_DISAMBIGUATE_ATTEMPTS, PromptRegistry;
 var init_prompt_registry = __esm({
   "libs/sdk/src/prompt/prompt.registry.ts"() {
     "use strict";
     import_di14 = require("@frontmcp/di");
     init_prompt_events();
-    import_utils23 = require("@frontmcp/utils");
+    import_utils24 = require("@frontmcp/utils");
     init_utils();
     init_lineage_utils();
     init_prompt_utils();
@@ -13562,31 +13590,31 @@ var init_prompt_registry = __esm({
         for (const [base, group] of byBase.entries()) {
           if (group.length === 1) {
             const g = group[0];
-            out.set((0, import_utils23.ensureMaxLen)(base, cfg.maxLen), g.row.instance);
+            out.set((0, import_utils24.ensureMaxLen)(base, cfg.maxLen), g.row.instance);
             continue;
           }
           const locals = group.filter((g) => g.isLocal);
           const children = group.filter((g) => !g.isLocal);
           if (cfg.prefixChildrenOnConflict && locals.length > 0) {
             if (locals.length === 1) {
-              const localName = (0, import_utils23.ensureMaxLen)(base, cfg.maxLen);
+              const localName = (0, import_utils24.ensureMaxLen)(base, cfg.maxLen);
               out.set(disambiguate(localName, out, cfg), locals[0].row.instance);
             } else {
               for (const l of locals) {
                 const pref = normalizeOwnerPath(l.ownerPath, cfg.case);
-                const name33 = (0, import_utils23.ensureMaxLen)(`${pref}${(0, import_utils23.sepFor)(cfg.case)}${base}`, cfg.maxLen);
+                const name33 = (0, import_utils24.ensureMaxLen)(`${pref}${(0, import_utils24.sepFor)(cfg.case)}${base}`, cfg.maxLen);
                 out.set(disambiguate(name33, out, cfg), l.row.instance);
               }
             }
             for (const c of children) {
               const pre = cfg.prefixSource === "provider" ? c.provider ?? c.ownerPath : c.ownerPath;
-              const name33 = (0, import_utils23.ensureMaxLen)(`${pre}${(0, import_utils23.sepFor)(cfg.case)}${base}`, cfg.maxLen);
+              const name33 = (0, import_utils24.ensureMaxLen)(`${pre}${(0, import_utils24.sepFor)(cfg.case)}${base}`, cfg.maxLen);
               out.set(disambiguate(name33, out, cfg), c.row.instance);
             }
           } else {
             for (const r of group) {
               const pre = cfg.prefixSource === "provider" ? r.provider ?? r.ownerPath : r.ownerPath;
-              const name33 = (0, import_utils23.ensureMaxLen)(`${pre}${(0, import_utils23.sepFor)(cfg.case)}${base}`, cfg.maxLen);
+              const name33 = (0, import_utils24.ensureMaxLen)(`${pre}${(0, import_utils24.sepFor)(cfg.case)}${base}`, cfg.maxLen);
               out.set(disambiguate(name33, out, cfg), r.row.instance);
             }
           }
@@ -13596,7 +13624,7 @@ var init_prompt_registry = __esm({
           if (!pool.has(candidate)) return candidate;
           let n = 2;
           while (n <= MAX_DISAMBIGUATE_ATTEMPTS) {
-            const withN = (0, import_utils23.ensureMaxLen)(`${candidate}${(0, import_utils23.sepFor)(cfg2.case)}${n}`, cfg2.maxLen);
+            const withN = (0, import_utils24.ensureMaxLen)(`${candidate}${(0, import_utils24.sepFor)(cfg2.case)}${n}`, cfg2.maxLen);
             if (!pool.has(withN)) return withN;
             n++;
           }
@@ -14202,12 +14230,12 @@ function stripFrontmatter(content) {
   const { body } = parseSkillMdFrontmatter(content);
   return body;
 }
-var yaml, import_utils25;
+var yaml, import_utils26;
 var init_skill_md_parser = __esm({
   "libs/sdk/src/skill/skill-md-parser.ts"() {
     "use strict";
     yaml = __toESM(require("js-yaml"));
-    import_utils25 = require("@frontmcp/utils");
+    import_utils26 = require("@frontmcp/utils");
   }
 });
 
@@ -14279,7 +14307,7 @@ async function loadInstructions(source, basePath) {
   }
   if (isFileInstructions(source)) {
     const filePath = basePath ? `${basePath}/${source.file}` : source.file;
-    const content = await (0, import_utils26.readFile)(filePath, "utf-8");
+    const content = await (0, import_utils27.readFile)(filePath, "utf-8");
     return stripFrontmatter(content);
   }
   if (isUrlInstructions(source)) {
@@ -14291,12 +14319,16 @@ async function loadInstructions(source, basePath) {
   }
   throw new InvalidInstructionSourceError();
 }
-function buildSkillContent(metadata, instructions) {
+function buildSkillContent(metadata, instructions, resolvedReferences) {
+  let finalInstructions = instructions;
+  if (resolvedReferences && resolvedReferences.length > 0) {
+    finalInstructions += buildReferencesTable(resolvedReferences);
+  }
   return {
     id: metadata.id ?? metadata.name,
     name: metadata.name,
     description: metadata.description,
-    instructions,
+    instructions: finalInstructions,
     tools: normalizeToolRefs(metadata.tools),
     parameters: metadata.parameters,
     examples: metadata.examples,
@@ -14304,9 +14336,73 @@ function buildSkillContent(metadata, instructions) {
     compatibility: metadata.compatibility,
     specMetadata: metadata.specMetadata,
     allowedTools: metadata.allowedTools,
-    resources: metadata.resources
+    resources: metadata.resources,
+    resolvedReferences
   };
 }
+function buildReferencesTable(refs) {
+  const lines = ["", "", "## References", "", "| Reference | Description |", "| --------- | ----------- |"];
+  for (const ref of refs) {
+    lines.push(`| \`${ref.name}\` | ${ref.description} |`);
+  }
+  return lines.join("\n");
+}
+async function resolveReferences(refsDir) {
+  if (!await (0, import_utils27.fileExists)(refsDir)) return void 0;
+  let files;
+  try {
+    files = (await (0, import_utils27.readdir)(refsDir)).filter((f) => f.endsWith(".md")).sort();
+  } catch {
+    return void 0;
+  }
+  if (files.length === 0) return void 0;
+  const refs = [];
+  for (const file of files) {
+    const content = await (0, import_utils27.readFile)(`${refsDir}/${file}`, "utf-8");
+    const filenameWithoutExt = file.replace(/\.md$/, "");
+    let name33 = filenameWithoutExt;
+    let description = "";
+    const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (fmMatch) {
+      const fmLines = fmMatch[1].split(/\r?\n/);
+      for (const line of fmLines) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1) continue;
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, "");
+        if (key === "name" && val) name33 = val;
+        if (key === "description" && val) description = val;
+      }
+    }
+    if (!description) {
+      const body = fmMatch ? content.substring(content.indexOf("---", 3) + 3).trim() : content.trim();
+      description = extractFirstParagraph(body);
+    }
+    refs.push({ name: name33, description, filename: file });
+  }
+  return refs;
+}
+function extractFirstParagraph(body) {
+  const lines = body.split(/\r?\n/);
+  let foundHeading = false;
+  const paragraphLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!foundHeading && trimmed.startsWith("#")) {
+      foundHeading = true;
+      continue;
+    }
+    if (foundHeading) {
+      if (trimmed === "") {
+        if (paragraphLines.length > 0) break;
+        continue;
+      }
+      if (trimmed.startsWith("#") || trimmed.startsWith("|") || trimmed.startsWith("-")) break;
+      paragraphLines.push(trimmed);
+    }
+  }
+  return paragraphLines.join(" ").slice(0, 200) || "";
+}
 function normalizeToolRefs(tools) {
   if (!tools) return [];
   return tools.map((tool) => {
@@ -14415,13 +14511,13 @@ function generateSearchGuidance(skills, query) {
   }
   return `Found ${skills.length} skill(s), but some tools are missing. Try loadSkills({ skillIds: ["${topSkill.name}"] }) to see which tools are available. You may be able to partially execute the workflow.`;
 }
-var import_di18, import_utils26;
+var import_di18, import_utils27;
 var init_skill_utils = __esm({
   "libs/sdk/src/skill/skill.utils.ts"() {
     "use strict";
     import_di18 = require("@frontmcp/di");
     init_common();
-    import_utils26 = require("@frontmcp/utils");
+    import_utils27 = require("@frontmcp/utils");
     init_errors();
     init_skill_md_parser();
   }
@@ -14431,12 +14527,13 @@ var init_skill_utils = __esm({
 function createSkillInstance(record, providers, owner) {
   return new SkillInstance(record, providers, owner);
 }
-var SkillInstance;
+var import_utils28, SkillInstance;
 var init_skill_instance = __esm({
   "libs/sdk/src/skill/skill.instance.ts"() {
     "use strict";
     init_common();
     init_skill_utils();
+    import_utils28 = require("@frontmcp/utils");
     SkillInstance = class extends SkillEntry {
       /** The provider registry this skill is bound to */
       providersRef;
@@ -14499,12 +14596,33 @@ var init_skill_instance = __esm({
        * Load the full skill content.
        * Results are cached after the first load.
        */
+      /**
+       * Resolve the base directory for this skill (for file/reference resolution).
+       */
+      getBaseDir() {
+        if (this.record.kind === "FILE" /* FILE */) {
+          return (0, import_utils28.dirname)(this.record.filePath) || void 0;
+        }
+        if (this.record.kind === "VALUE" /* VALUE */ && this.record.callerDir) {
+          return this.record.callerDir;
+        }
+        return void 0;
+      }
       async load() {
         if (this.cachedContent !== void 0) {
           return this.cachedContent;
         }
         const instructions = await this.loadInstructions();
-        const baseContent = buildSkillContent(this.metadata, instructions);
+        const refsPath = this.metadata.resources?.references;
+        let resolvedRefs;
+        if (refsPath) {
+          const baseDir = this.getBaseDir();
+          const refsDir = refsPath.startsWith("/") ? refsPath : baseDir ? (0, import_utils28.pathResolve)(baseDir, refsPath) : void 0;
+          if (refsDir) {
+            resolvedRefs = await resolveReferences(refsDir);
+          }
+        }
+        const baseContent = buildSkillContent(this.metadata, instructions, resolvedRefs);
         this.cachedContent = {
           ...baseContent,
           tags: this.tags,
@@ -17492,7 +17610,7 @@ function resolveApiKey(config, configResolver, entityContext) {
     return config;
   }
   if ("env" in config) {
-    const value = (0, import_utils27.getEnv)(config.env);
+    const value = (0, import_utils29.getEnv)(config.env);
     if (!value) {
       throw new LlmAdapterError(`Environment variable ${config.env} is not set`, "config", "missing_env_var");
     }
@@ -17620,11 +17738,11 @@ function createBuiltinAdapter(config, configResolver, entityContext) {
     maxTokens
   });
 }
-var import_utils27;
+var import_utils29;
 var init_adapter_factory = __esm({
   "libs/sdk/src/agent/adapters/adapter.factory.ts"() {
     "use strict";
-    import_utils27 = require("@frontmcp/utils");
+    import_utils29 = require("@frontmcp/utils");
     init_base_adapter();
     init_providers();
     init_config_resolver();
@@ -17690,16 +17808,16 @@ function parseEnvContent(content) {
   }
   return result;
 }
-async function loadEnvFiles(basePath = (0, import_utils28.getCwd)(), envPath = ".env", localEnvPath = ".env.local") {
+async function loadEnvFiles(basePath = (0, import_utils30.getCwd)(), envPath = ".env", localEnvPath = ".env.local") {
   const result = {};
-  const envFile = (0, import_utils28.pathResolve)(basePath, envPath);
-  if (await (0, import_utils28.fileExists)(envFile)) {
-    const content = await (0, import_utils28.readFile)(envFile);
+  const envFile = (0, import_utils30.pathResolve)(basePath, envPath);
+  if (await (0, import_utils30.fileExists)(envFile)) {
+    const content = await (0, import_utils30.readFile)(envFile);
     Object.assign(result, parseEnvContent(content));
   }
-  const localFile = (0, import_utils28.pathResolve)(basePath, localEnvPath);
-  if (await (0, import_utils28.fileExists)(localFile)) {
-    const content = await (0, import_utils28.readFile)(localFile);
+  const localFile = (0, import_utils30.pathResolve)(basePath, localEnvPath);
+  if (await (0, import_utils30.fileExists)(localFile)) {
+    const content = await (0, import_utils30.readFile)(localFile);
     Object.assign(result, parseEnvContent(content));
   }
   return result;
@@ -17709,8 +17827,8 @@ function parseEnvContentSync(content) {
 }
 function populateProcessEnv(env, override = false) {
   for (const [key, value] of Object.entries(env)) {
-    if (override || (0, import_utils28.getEnv)(key) === void 0) {
-      (0, import_utils28.setEnv)(key, value);
+    if (override || (0, import_utils30.getEnv)(key) === void 0) {
+      (0, import_utils30.setEnv)(key, value);
     }
   }
 }
@@ -17809,11 +17927,11 @@ function mapEnvToNestedConfig(env, paths) {
   }
   return result;
 }
-var import_utils28, UNSAFE_KEYS;
+var import_utils30, UNSAFE_KEYS;
 var init_env_loader = __esm({
   "libs/sdk/src/builtin/config/providers/env-loader.ts"() {
     "use strict";
-    import_utils28 = require("@frontmcp/utils");
+    import_utils30 = require("@frontmcp/utils");
     UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
   }
 });
@@ -17821,7 +17939,7 @@ var init_env_loader = __esm({
 // libs/sdk/src/builtin/config/providers/config-loader.ts
 async function loadConfig(schema, options = {}) {
   const {
-    basePath = (0, import_utils29.getCwd)(),
+    basePath = (0, import_utils31.getCwd)(),
     envPath = ".env",
     localEnvPath = ".env.local",
     configPath = "config.yml",
@@ -17859,9 +17977,9 @@ async function loadYamlConfig(basePath, configPath) {
   const extensions = ["", ".yml", ".yaml"];
   const baseName = configPath.replace(/\.(ya?ml)$/, "");
   for (const ext of extensions) {
-    const fullPath = (0, import_utils29.pathResolve)(basePath, baseName + ext);
-    if (await (0, import_utils29.fileExists)(fullPath)) {
-      const content = await (0, import_utils29.readFile)(fullPath);
+    const fullPath = (0, import_utils31.pathResolve)(basePath, baseName + ext);
+    if (await (0, import_utils31.fileExists)(fullPath)) {
+      const content = await (0, import_utils31.readFile)(fullPath);
       const parsed = yaml2.load(content);
       if (parsed && typeof parsed === "object") {
         return parsed;
@@ -17886,24 +18004,24 @@ function deepMerge(target, source) {
   }
   return result;
 }
-var yaml2, import_utils29;
+var yaml2, import_utils31;
 var init_config_loader = __esm({
   "libs/sdk/src/builtin/config/providers/config-loader.ts"() {
     "use strict";
     yaml2 = __toESM(require("js-yaml"));
-    import_utils29 = require("@frontmcp/utils");
+    import_utils31 = require("@frontmcp/utils");
     init_env_loader();
     init_config_service();
   }
 });
 
 // libs/sdk/src/builtin/config/config.plugin.ts
-var import_utils30, ConfigPlugin;
+var import_utils32, ConfigPlugin;
 var init_config_plugin = __esm({
   "libs/sdk/src/builtin/config/config.plugin.ts"() {
     "use strict";
     init_common();
-    import_utils30 = require("@frontmcp/utils");
+    import_utils32 = require("@frontmcp/utils");
     init_config_symbols();
     init_config_service();
     init_config_loader();
@@ -17961,7 +18079,7 @@ var init_config_plugin = __esm({
           }
           let env = {};
           if (pluginConfig.loadEnv) {
-            const basePath = pluginConfig.basePath ?? (0, import_utils30.getCwd)();
+            const basePath = pluginConfig.basePath ?? (0, import_utils32.getCwd)();
             env = await loadEnvFiles(basePath, pluginConfig.envPath, pluginConfig.localEnvPath);
           }
           const merged = { ...env };
@@ -18174,7 +18292,7 @@ function stringToBytes(str, encoding) {
     return new TextEncoder().encode(str);
   }
   try {
-    return (0, import_utils31.base64Decode)(str);
+    return (0, import_utils33.base64Decode)(str);
   } catch (err) {
     throw new Error(`Invalid base64 body: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -18300,12 +18418,12 @@ async function writeHttpResponse(res, value) {
     }
   }
 }
-var import_utils31;
+var import_utils33;
 var init_server_validation = __esm({
   "libs/sdk/src/server/server.validation.ts"() {
     "use strict";
     init_common();
-    import_utils31 = require("@frontmcp/utils");
+    import_utils33 = require("@frontmcp/utils");
   }
 });
 
@@ -18318,7 +18436,7 @@ function parseTypedKey(k) {
     return { base: k.slice(6, 7).toLowerCase() + k.slice(7), type: "around" };
   return { base: k };
 }
-var import_reflect_metadata11, import_utils32, CAP, WILL, DID, AROUND, FlowInstance;
+var import_reflect_metadata11, import_utils34, CAP, WILL, DID, AROUND, FlowInstance;
 var init_flow_instance = __esm({
   "libs/sdk/src/flows/flow.instance.ts"() {
     "use strict";
@@ -18328,7 +18446,7 @@ var init_flow_instance = __esm({
     init_server_validation();
     init_context();
     init_errors();
-    import_utils32 = require("@frontmcp/utils");
+    import_utils34 = require("@frontmcp/utils");
     CAP = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
     WILL = (s) => `will${CAP(s)}`;
     DID = (s) => `did${CAP(s)}`;
@@ -18438,7 +18556,7 @@ var init_flow_instance = __esm({
         }
         const headers = request.headers ?? {};
         const headerSessionId = typeof headers["mcp-session-id"] === "string" ? headers["mcp-session-id"].trim() : "";
-        const sessionId = headerSessionId.length > 0 ? headerSessionId : `anon:${(0, import_utils32.randomUUID)()}`;
+        const sessionId = headerSessionId.length > 0 ? headerSessionId : `anon:${(0, import_utils34.randomUUID)()}`;
         const scope = this.globalProviders.getActiveScope();
         return storage.runFromHeaders(
           headers,
@@ -18682,7 +18800,7 @@ var init_flow_instance = __esm({
 });
 
 // libs/sdk/src/flows/flow.registry.ts
-var import_di22, import_utils33, FlowRegistry;
+var import_di22, import_utils35, FlowRegistry;
 var init_flow_registry = __esm({
   "libs/sdk/src/flows/flow.registry.ts"() {
     "use strict";
@@ -18692,7 +18810,7 @@ var init_flow_registry = __esm({
     init_flow_utils2();
     init_flow_instance();
     init_context();
-    import_utils33 = require("@frontmcp/utils");
+    import_utils35 = require("@frontmcp/utils");
     init_errors();
     FlowRegistry = class extends RegistryAbstract {
       constructor(providers, list) {
@@ -18771,7 +18889,7 @@ var init_flow_registry = __esm({
         const mcpCtx = input?.ctx;
         const authInfo = mcpCtx?.authInfo;
         const rawSessionId = authInfo?.sessionId;
-        const sessionId = typeof rawSessionId === "string" && rawSessionId.trim().length > 0 ? rawSessionId.trim() : `anon:${(0, import_utils33.randomUUID)()}`;
+        const sessionId = typeof rawSessionId === "string" && rawSessionId.trim().length > 0 ? rawSessionId.trim() : `anon:${(0, import_utils35.randomUUID)()}`;
         const scope = this.providers.getActiveScope();
         return Promise.resolve(
           contextStorage.run(
@@ -20159,12 +20277,12 @@ var init_agent_registry = __esm({
 });
 
 // libs/sdk/src/app/instances/app.local.instance.ts
-var import_utils34, AppLocalInstance;
+var import_utils36, AppLocalInstance;
 var init_app_local_instance = __esm({
   "libs/sdk/src/app/instances/app.local.instance.ts"() {
     "use strict";
     init_common();
-    import_utils34 = require("@frontmcp/utils");
+    import_utils36 = require("@frontmcp/utils");
     init_provider_registry();
     init_tool_registry();
     init_resource_registry();
@@ -20188,7 +20306,7 @@ var init_app_local_instance = __esm({
       constructor(record, scopeProviders) {
         super(record);
         this.scopeProviders = scopeProviders;
-        this.id = this.metadata.id ?? (0, import_utils34.idFromString)(this.metadata.name);
+        this.id = this.metadata.id ?? (0, import_utils36.idFromString)(this.metadata.name);
         try {
           this.logger = scopeProviders.get(FrontMcpLogger)?.child("AppLocalInstance");
         } catch {
@@ -21892,12 +22010,12 @@ var init_remote_mcp = __esm({
 });
 
 // libs/sdk/src/app/instances/app.remote.instance.ts
-var import_utils35, EmptyPluginRegistry, EmptyAdapterRegistry, EmptySkillRegistry, AppRemoteInstance;
+var import_utils37, EmptyPluginRegistry, EmptyAdapterRegistry, EmptySkillRegistry, AppRemoteInstance;
 var init_app_remote_instance = __esm({
   "libs/sdk/src/app/instances/app.remote.instance.ts"() {
     "use strict";
     init_common();
-    import_utils35 = require("@frontmcp/utils");
+    import_utils37 = require("@frontmcp/utils");
     init_tool_registry();
     init_resource_registry();
     init_prompt_registry();
@@ -21998,7 +22116,7 @@ var init_app_remote_instance = __esm({
       _unsubscribeCapability;
       constructor(record, scopeProviders) {
         super(record);
-        this.id = this.metadata.id ?? (0, import_utils35.idFromString)(this.metadata.name);
+        this.id = this.metadata.id ?? (0, import_utils37.idFromString)(this.metadata.name);
         this.scopeProviders = scopeProviders;
         this.appOwner = {
           kind: "app",
@@ -22400,11 +22518,11 @@ function getDefaultCacheDir() {
     return "";
   }
 }
-var import_utils36, DEFAULT_CACHE_DIR, DEFAULT_MAX_AGE_MS, EsmCacheManager;
+var import_utils38, DEFAULT_CACHE_DIR, DEFAULT_MAX_AGE_MS, EsmCacheManager;
 var init_esm_cache = __esm({
   "libs/sdk/src/esm-loader/esm-cache.ts"() {
     "use strict";
-    import_utils36 = require("@frontmcp/utils");
+    import_utils38 = require("@frontmcp/utils");
     DEFAULT_CACHE_DIR = getDefaultCacheDir();
     DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
     EsmCacheManager = class {
@@ -22430,10 +22548,10 @@ var init_esm_cache = __esm({
         if (!this.cacheDir) return void 0;
         try {
           const path = require("node:path");
-          const { fileExists: fileExists5, readJSON } = require("@frontmcp/utils");
+          const { fileExists: fileExists6, readJSON } = require("@frontmcp/utils");
           const entryDir = this.getEntryDir(packageName, version);
           const metaPath = path.join(entryDir, "meta.json");
-          if (!await fileExists5(metaPath)) {
+          if (!await fileExists6(metaPath)) {
             return void 0;
           }
           const meta = await readJSON(metaPath);
@@ -22443,7 +22561,7 @@ var init_esm_cache = __esm({
           if (Date.now() - meta.cachedAt > this.maxAgeMs) {
             return void 0;
           }
-          if (!await fileExists5(meta.bundlePath)) {
+          if (!await fileExists6(meta.bundlePath)) {
             return void 0;
           }
           this.memoryStore.set(memKey, meta);
@@ -22456,7 +22574,7 @@ var init_esm_cache = __esm({
        * Store an ESM bundle in the cache.
        */
       async put(packageName, version, bundleContent, packageUrl, etag) {
-        if (!(0, import_utils36.isValidMcpUri)(packageUrl)) {
+        if (!(0, import_utils38.isValidMcpUri)(packageUrl)) {
           throw new Error("URI must have a valid scheme (e.g., file://, https://, custom://)");
         }
         const memKey = `${packageName}@${version}`;
@@ -22507,20 +22625,20 @@ var init_esm_cache = __esm({
         if (!this.cacheDir) return;
         try {
           const path = require("node:path");
-          const { fileExists: fileExists5, readJSON, rm } = require("@frontmcp/utils");
-          const { readdir } = require("@frontmcp/utils");
-          if (!await fileExists5(this.cacheDir)) {
+          const { fileExists: fileExists6, readJSON, rm } = require("@frontmcp/utils");
+          const { readdir: readdir2 } = require("@frontmcp/utils");
+          if (!await fileExists6(this.cacheDir)) {
             return;
           }
           let entries;
           try {
-            entries = await readdir(this.cacheDir);
+            entries = await readdir2(this.cacheDir);
           } catch {
             return;
           }
           for (const dirEntry of entries) {
             const metaPath = path.join(this.cacheDir, dirEntry, "meta.json");
-            if (await fileExists5(metaPath)) {
+            if (await fileExists6(metaPath)) {
               const meta = await readJSON(metaPath);
               if (meta?.packageName === packageName) {
                 await rm(path.join(this.cacheDir, dirEntry), { recursive: true, force: true });
@@ -22546,20 +22664,20 @@ var init_esm_cache = __esm({
         if (!this.cacheDir) return removed;
         try {
           const path = require("node:path");
-          const { fileExists: fileExists5, readJSON, rm } = require("@frontmcp/utils");
-          const { readdir } = require("@frontmcp/utils");
-          if (!await fileExists5(this.cacheDir)) {
+          const { fileExists: fileExists6, readJSON, rm } = require("@frontmcp/utils");
+          const { readdir: readdir2 } = require("@frontmcp/utils");
+          if (!await fileExists6(this.cacheDir)) {
             return removed;
           }
           let entries;
           try {
-            entries = await readdir(this.cacheDir);
+            entries = await readdir2(this.cacheDir);
           } catch {
             return removed;
           }
           for (const dirEntry of entries) {
             const metaPath = path.join(this.cacheDir, dirEntry, "meta.json");
-            if (await fileExists5(metaPath)) {
+            if (await fileExists6(metaPath)) {
               const meta = await readJSON(metaPath);
               if (meta && now - meta.cachedAt > threshold) {
                 await rm(path.join(this.cacheDir, dirEntry), { recursive: true, force: true });
@@ -22586,7 +22704,7 @@ var init_esm_cache = __esm({
        */
       getEntryDir(packageName, version) {
         const path = require("node:path");
-        const hash = (0, import_utils36.sha256Hex)(`${packageName}@${version}`);
+        const hash = (0, import_utils38.sha256Hex)(`${packageName}@${version}`);
         return path.join(this.cacheDir, hash);
       }
     };
@@ -22637,7 +22755,7 @@ function normalizeResourceFromEsmExport(raw) {
   const obj = raw;
   if (typeof obj["read"] === "function" && typeof obj["name"] === "string" && typeof obj["uri"] === "string") {
     const uri = obj["uri"];
-    if (!(0, import_utils37.isValidMcpUri)(uri)) return void 0;
+    if (!(0, import_utils39.isValidMcpUri)(uri)) return void 0;
     const description = obj["description"];
     const mimeType = obj["mimeType"];
     return {
@@ -22665,12 +22783,12 @@ function normalizePromptFromEsmExport(raw) {
   }
   return void 0;
 }
-var import_di25, import_utils37;
+var import_di25, import_utils39;
 var init_esm_normalize_utils = __esm({
   "libs/sdk/src/app/instances/esm-normalize.utils.ts"() {
     "use strict";
     import_di25 = require("@frontmcp/di");
-    import_utils37 = require("@frontmcp/utils");
+    import_utils39 = require("@frontmcp/utils");
     init_tokens();
   }
 });
@@ -23441,12 +23559,12 @@ var init_esm_loader = __esm({
 });
 
 // libs/sdk/src/app/instances/app.esm.instance.ts
-var import_utils38, EmptyPluginRegistry2, EmptyAdapterRegistry2, EmptySkillRegistry2, AppEsmInstance;
+var import_utils40, EmptyPluginRegistry2, EmptyAdapterRegistry2, EmptySkillRegistry2, AppEsmInstance;
 var init_app_esm_instance = __esm({
   "libs/sdk/src/app/instances/app.esm.instance.ts"() {
     "use strict";
     init_common();
-    import_utils38 = require("@frontmcp/utils");
+    import_utils40 = require("@frontmcp/utils");
     init_tool_registry();
     init_resource_registry();
     init_prompt_registry();
@@ -23547,7 +23665,7 @@ var init_app_esm_instance = __esm({
       _skills;
       constructor(record, scopeProviders) {
         super(record);
-        this.id = this.metadata.id ?? (0, import_utils38.idFromString)(this.metadata.name);
+        this.id = this.metadata.id ?? (0, import_utils40.idFromString)(this.metadata.name);
         this.scopeProviders = scopeProviders;
         this.appOwner = {
           kind: "app",
@@ -24313,7 +24431,7 @@ function createSessionId(protocol, token, options) {
   const payload = {
     nodeId: (0, import_auth14.getMachineId)(),
     authSig,
-    uuid: (0, import_utils39.randomUUID)(),
+    uuid: (0, import_utils41.randomUUID)(),
     iat: nowSec(),
     protocol,
     platformType,
@@ -24342,11 +24460,11 @@ function updateSessionPayload(sessionId, updates) {
   cache.set(newSessionId, payload);
   return newSessionId;
 }
-var import_utils39, import_auth13, import_auth14, cache;
+var import_utils41, import_auth13, import_auth14, cache;
 var init_session_id_utils = __esm({
   "libs/sdk/src/auth/session/utils/session-id.utils.ts"() {
     "use strict";
-    import_utils39 = require("@frontmcp/utils");
+    import_utils41 = require("@frontmcp/utils");
     import_auth13 = require("@frontmcp/auth");
     init_notification_service();
     import_auth14 = require("@frontmcp/auth");
@@ -24355,7 +24473,7 @@ var init_session_id_utils = __esm({
 });
 
 // libs/sdk/src/auth/flows/session.verify.flow.ts
-var import_reflect_metadata17, import_zod54, import_auth15, import_auth16, import_auth17, import_auth18, import_utils40, inputSchema14, stateSchema12, UnauthorizedSchema, AuthorizedSchema, sessionVerifyOutputSchema, plan12, name13, Stage13, SessionVerifyFlow;
+var import_reflect_metadata17, import_zod54, import_auth15, import_auth16, import_auth17, import_auth18, import_utils42, inputSchema14, stateSchema12, UnauthorizedSchema, AuthorizedSchema, sessionVerifyOutputSchema, plan12, name13, Stage13, SessionVerifyFlow;
 var init_session_verify_flow = __esm({
   "libs/sdk/src/auth/flows/session.verify.flow.ts"() {
     "use strict";
@@ -24367,7 +24485,7 @@ var init_session_verify_flow = __esm({
     init_session_id_utils();
     import_auth17 = require("@frontmcp/auth");
     import_auth18 = require("@frontmcp/auth");
-    import_utils40 = require("@frontmcp/utils");
+    import_utils42 = require("@frontmcp/utils");
     init_notification_service();
     inputSchema14 = httpRequestInputSchema;
     stateSchema12 = import_zod54.z.object({
@@ -24418,7 +24536,7 @@ var init_session_verify_flow = __esm({
         const machineId = (0, import_auth18.getMachineId)();
         if (sessionIdHeader) {
           const existingPayload = decryptPublicSession(sessionIdHeader);
-          const user2 = existingPayload ? { sub: `anon:${existingPayload.iat * 1e3}`, iss: issuer, name: "Anonymous", scope: scopes.join(" ") } : { sub: `anon:${(0, import_utils40.randomUUID)()}`, iss: issuer, name: "Anonymous", scope: scopes.join(" ") };
+          const user2 = existingPayload ? { sub: `anon:${existingPayload.iat * 1e3}`, iss: issuer, name: "Anonymous", scope: scopes.join(" ") } : { sub: `anon:${(0, import_utils42.randomUUID)()}`, iss: issuer, name: "Anonymous", scope: scopes.join(" ") };
           const finalPayload = existingPayload && existingPayload.nodeId === machineId ? existingPayload : void 0;
           this.respond({
             kind: "authorized",
@@ -24435,12 +24553,12 @@ var init_session_verify_flow = __esm({
         }
         const now = Date.now();
         const user = {
-          sub: `anon:${(0, import_utils40.randomUUID)()}`,
+          sub: `anon:${(0, import_utils42.randomUUID)()}`,
           iss: issuer,
           name: "Anonymous",
           scope: scopes.join(" ")
         };
-        const uuid = (0, import_utils40.randomUUID)();
+        const uuid = (0, import_utils42.randomUUID)();
         const platformDetectionConfig = this.scope.metadata.transport?.platformDetection;
         const platformType = detectPlatformFromUserAgent(this.state.userAgent, platformDetectionConfig);
         const payload = {
@@ -25517,13 +25635,13 @@ var init_oauth_authorize_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.register.flow.ts
-var import_zod56, import_utils41, CLIENTS, inputSchema16, outputSchema14, registrationRequestSchema, stateSchema14, plan14, name15, Stage15, OauthRegisterFlow;
+var import_zod56, import_utils43, CLIENTS, inputSchema16, outputSchema14, registrationRequestSchema, stateSchema14, plan14, name15, Stage15, OauthRegisterFlow;
 var init_oauth_register_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.register.flow.ts"() {
     "use strict";
     init_common();
     import_zod56 = require("zod");
-    import_utils41 = require("@frontmcp/utils");
+    import_utils43 = require("@frontmcp/utils");
     CLIENTS = /* @__PURE__ */ new Map();
     inputSchema16 = httpInputSchema;
     outputSchema14 = HttpJsonSchema;
@@ -25550,7 +25668,7 @@ var init_oauth_register_flow = __esm({
     OauthRegisterFlow = class extends FlowBase {
       registered;
       async parseInput() {
-        const isDev = !(0, import_utils41.isProduction)();
+        const isDev = !(0, import_utils43.isProduction)();
         const { request } = this.rawInput;
         const parsed = registrationRequestSchema.parse(request.body || {});
         this.state.set({
@@ -25617,10 +25735,10 @@ var init_oauth_register_flow = __esm({
       async registerClient() {
         const now = Math.floor(Date.now() / 1e3);
         const { token_endpoint_auth_method, grant_types, response_types, redirect_uris, client_name, scope } = this.state.required.body;
-        const client_id = (0, import_utils41.randomUUID)();
+        const client_id = (0, import_utils43.randomUUID)();
         let client_secret;
         if (token_endpoint_auth_method === "client_secret_post" || token_endpoint_auth_method === "client_secret_basic") {
-          client_secret = (0, import_utils41.base64urlEncode)((0, import_utils41.randomBytes)(24));
+          client_secret = (0, import_utils43.base64urlEncode)((0, import_utils43.randomBytes)(24));
         }
         this.registered = {
           client_id,
@@ -25689,13 +25807,13 @@ var init_oauth_register_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.token.flow.ts
-var import_zod57, import_utils42, inputSchema17, pkceVerifierRegex, authorizationCodeGrant, refreshTokenGrant, anonymousGrant, tokenRequestSchema, stateSchema15, outputSchema15, plan15, name16, Stage16, OauthTokenFlow;
+var import_zod57, import_utils44, inputSchema17, pkceVerifierRegex, authorizationCodeGrant, refreshTokenGrant, anonymousGrant, tokenRequestSchema, stateSchema15, outputSchema15, plan15, name16, Stage16, OauthTokenFlow;
 var init_oauth_token_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.token.flow.ts"() {
     "use strict";
     init_common();
     import_zod57 = require("zod");
-    import_utils42 = require("@frontmcp/utils");
+    import_utils44 = require("@frontmcp/utils");
     inputSchema17 = httpInputSchema;
     pkceVerifierRegex = /^[A-Za-z0-9_.~-]{43,128}$/;
     authorizationCodeGrant = import_zod57.z.object({
@@ -25802,7 +25920,7 @@ var init_oauth_token_flow = __esm({
             access_token: accessToken,
             token_type: "Bearer",
             expires_in: 86400,
-            refresh_token: (0, import_utils42.randomUUID)()
+            refresh_token: (0, import_utils44.randomUUID)()
           });
           return;
         }
@@ -25839,7 +25957,7 @@ var init_oauth_token_flow = __esm({
             access_token: accessToken,
             token_type: "Bearer",
             expires_in: 86400,
-            refresh_token: (0, import_utils42.randomUUID)()
+            refresh_token: (0, import_utils44.randomUUID)()
           });
           return;
         }
@@ -25873,7 +25991,7 @@ var init_oauth_token_flow = __esm({
           access_token: accessToken,
           token_type: "Bearer",
           expires_in: 86400,
-          refresh_token: (0, import_utils42.randomUUID)()
+          refresh_token: (0, import_utils44.randomUUID)()
         });
       }
       async buildTokenResponse() {
@@ -25940,13 +26058,13 @@ var init_oauth_token_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.callback.flow.ts
-var import_zod58, import_utils43, import_auth22, inputSchema18, stateSchema16, outputSchema16, plan16, name17, Stage17, OauthCallbackFlow;
+var import_zod58, import_utils45, import_auth22, inputSchema18, stateSchema16, outputSchema16, plan16, name17, Stage17, OauthCallbackFlow;
 var init_oauth_callback_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.callback.flow.ts"() {
     "use strict";
     init_common();
     import_zod58 = require("zod");
-    import_utils43 = require("@frontmcp/utils");
+    import_utils45 = require("@frontmcp/utils");
     import_auth22 = require("@frontmcp/auth");
     inputSchema18 = httpInputSchema;
     stateSchema16 = import_zod58.z.object({
@@ -26158,7 +26276,7 @@ var init_oauth_callback_flow = __esm({
           return;
         }
         const federatedSession = (0, import_auth22.createFederatedAuthSession)({
-          pendingAuthId: this.state.required.pendingAuthId || (0, import_utils43.randomUUID)(),
+          pendingAuthId: this.state.required.pendingAuthId || (0, import_utils45.randomUUID)(),
           clientId,
           redirectUri,
           scopes: scopes ?? [],
@@ -26178,14 +26296,14 @@ var init_oauth_callback_flow = __esm({
         await sessionStore.store(federatedSession);
         this.logger.info(`Created federated session: ${federatedSession.id}`);
         const firstProviderId = selectedProviders[0];
-        const verifier = (0, import_utils43.generateCodeVerifier)();
-        const challenge = (0, import_utils43.sha256Base64url)(verifier);
+        const verifier = (0, import_utils45.generateCodeVerifier)();
+        const challenge = (0, import_utils45.sha256Base64url)(verifier);
         const pkce = {
           verifier,
           challenge,
           method: "S256"
         };
-        const providerState = `federated:${federatedSession.id}:${(0, import_utils43.randomUUID)()}`;
+        const providerState = `federated:${federatedSession.id}:${(0, import_utils45.randomUUID)()}`;
         (0, import_auth22.startNextProvider)(federatedSession, pkce, providerState);
         await sessionStore.update(federatedSession);
         const providerConfig = localAuth.getProviderConfig(firstProviderId);
@@ -26306,7 +26424,7 @@ var init_oauth_callback_flow = __esm({
        * In production, this would be the user's ID from the database
        */
       generateUserSub(email) {
-        const hash = (0, import_utils43.sha256Hex)(email.toLowerCase());
+        const hash = (0, import_utils45.sha256Hex)(email.toLowerCase());
         return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
       }
       /**
@@ -26399,7 +26517,7 @@ var init_oauth_callback_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.provider-callback.flow.ts
-var import_zod59, import_auth23, import_utils44, inputSchema19, stateSchema17, outputSchema17, plan17, name18, Stage18, OauthProviderCallbackFlow;
+var import_zod59, import_auth23, import_utils46, inputSchema19, stateSchema17, outputSchema17, plan17, name18, Stage18, OauthProviderCallbackFlow;
 var init_oauth_provider_callback_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.provider-callback.flow.ts"() {
     "use strict";
@@ -26407,7 +26525,7 @@ var init_oauth_provider_callback_flow = __esm({
     import_zod59 = require("zod");
     init_instance_local_primary_auth();
     import_auth23 = require("@frontmcp/auth");
-    import_utils44 = require("@frontmcp/utils");
+    import_utils46 = require("@frontmcp/utils");
     init_errors();
     inputSchema19 = httpInputSchema;
     stateSchema17 = import_zod59.z.object({
@@ -26663,14 +26781,14 @@ var init_oauth_provider_callback_flow = __esm({
         if (!nextProviderId) {
           return this.completeFederatedAuth(session);
         }
-        const verifier = (0, import_utils44.generateCodeVerifier)();
-        const challenge = (0, import_utils44.sha256Base64url)(verifier);
+        const verifier = (0, import_utils46.generateCodeVerifier)();
+        const challenge = (0, import_utils46.sha256Base64url)(verifier);
         const pkce = {
           verifier,
           challenge,
           method: "S256"
         };
-        const providerState = `federated:${session.id}:${(0, import_utils44.randomUUID)()}`;
+        const providerState = `federated:${session.id}:${(0, import_utils46.randomUUID)()}`;
         (0, import_auth23.startNextProvider)(session, pkce, providerState);
         const sessionStore = localAuth.federatedSessionStore;
         if (sessionStore) {
@@ -26737,9 +26855,9 @@ var init_oauth_provider_callback_flow = __esm({
        */
       generateUserSub(email) {
         if (!email) {
-          return `anon:${(0, import_utils44.randomUUID)()}`;
+          return `anon:${(0, import_utils46.randomUUID)()}`;
         }
-        const hash = (0, import_utils44.sha256Base64url)(email.toLowerCase());
+        const hash = (0, import_utils46.sha256Base64url)(email.toLowerCase());
         return `user:${hash.substring(0, 16)}`;
       }
       /**
@@ -26839,12 +26957,12 @@ var init_oauth_provider_callback_flow = __esm({
 });
 
 // libs/sdk/src/auth/instances/instance.local-primary-auth.ts
-var import_jose, import_utils45, import_auth25, import_auth26, DEFAULT_NO_AUTH_SECRET, LocalPrimaryAuth;
+var import_jose, import_utils47, import_auth25, import_auth26, DEFAULT_NO_AUTH_SECRET, LocalPrimaryAuth;
 var init_instance_local_primary_auth = __esm({
   "libs/sdk/src/auth/instances/instance.local-primary-auth.ts"() {
     "use strict";
     import_jose = require("jose");
-    import_utils45 = require("@frontmcp/utils");
+    import_utils47 = require("@frontmcp/utils");
     init_common();
     init_auth2();
     init_well_known_prm_flow();
@@ -26860,7 +26978,7 @@ var init_instance_local_primary_auth = __esm({
     import_auth26 = require("@frontmcp/auth");
     init_oauth_provider_callback_flow();
     init_auth_internal_errors();
-    DEFAULT_NO_AUTH_SECRET = (0, import_utils45.randomBytes)(32);
+    DEFAULT_NO_AUTH_SECRET = (0, import_utils47.randomBytes)(32);
     LocalPrimaryAuth = class extends FrontMcpAuth {
       constructor(scope, providers, options) {
         super(options);
@@ -26870,7 +26988,7 @@ var init_instance_local_primary_auth = __esm({
         this.port = this.providers.getActiveScope().metadata.http?.port ?? 3001;
         this.host = "localhost";
         this.issuer = this.deriveIssuer(options);
-        const jwtSecret = (0, import_utils45.getEnv)("JWT_SECRET");
+        const jwtSecret = (0, import_utils47.getEnv)("JWT_SECRET");
         if (jwtSecret) {
           this.secret = new TextEncoder().encode(jwtSecret);
         } else {
@@ -26936,7 +27054,7 @@ var init_instance_local_primary_auth = __esm({
         return basePath;
       }
       async signAnonymousJwt() {
-        const sub = (0, import_utils45.randomUUID)();
+        const sub = (0, import_utils47.randomUUID)();
         return new import_jose.SignJWT({ sub, role: "user", anonymous: true }).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuedAt().setIssuer(this.issuer).setExpirationTime("1d").sign(this.secret);
       }
       /**
@@ -26966,7 +27084,7 @@ var init_instance_local_primary_auth = __esm({
             };
           }
         }
-        const jwt = new import_jose.SignJWT(claims).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuedAt().setIssuer(this.issuer).setExpirationTime(`${this.accessTokenTtlSeconds}s`).setJti((0, import_utils45.randomUUID)());
+        const jwt = new import_jose.SignJWT(claims).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuedAt().setIssuer(this.issuer).setExpirationTime(`${this.accessTokenTtlSeconds}s`).setJti((0, import_utils47.randomUUID)());
         if (audience) {
           jwt.setAudience(audience);
         }
@@ -27032,7 +27150,7 @@ var init_instance_local_primary_auth = __esm({
             const pendingAuthId = `pending:${codeRecord.pendingAuthId}`;
             const parts = accessToken.split(".");
             const signature = parts[2] || accessToken;
-            const newAuthId = (0, import_utils45.sha256Hex)(signature).substring(0, 16);
+            const newAuthId = (0, import_utils47.sha256Hex)(signature).substring(0, 16);
             await this.orchestratedTokenStore.migrateTokens(pendingAuthId, newAuthId);
             this.logger.info(`Migrated tokens from ${pendingAuthId} to ${newAuthId}`);
           } catch (err) {
@@ -27261,7 +27379,7 @@ var init_instance_local_primary_auth = __esm({
         if (idToken) {
           try {
             const [, payloadB64] = idToken.split(".");
-            const payload = JSON.parse(new TextDecoder().decode((0, import_utils45.base64urlDecode)(payloadB64)));
+            const payload = JSON.parse(new TextDecoder().decode((0, import_utils47.base64urlDecode)(payloadB64)));
             return {
               sub: payload["sub"],
               email: payload["email"],
@@ -27566,14 +27684,14 @@ var init_auth_registry = __esm({
 });
 
 // libs/sdk/src/scope/flows/http.request.flow.ts
-var import_zod60, import_utils46, plan18, httpRequestStateSchema, name19, Stage19, HttpRequestFlow;
+var import_zod60, import_utils48, plan18, httpRequestStateSchema, name19, Stage19, HttpRequestFlow;
 var init_http_request_flow = __esm({
   "libs/sdk/src/scope/flows/http.request.flow.ts"() {
     "use strict";
     init_common();
     import_zod60 = require("zod");
     init_session_verify_flow();
-    import_utils46 = require("@frontmcp/utils");
+    import_utils48 = require("@frontmcp/utils");
     init_errors();
     plan18 = {
       pre: [
@@ -27629,7 +27747,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_utils46.randomUUID)()}`;
+        this.requestId = ctx?.requestId ?? `req-${(0, import_utils48.randomUUID)()}`;
         const headers = request.headers ?? {};
         const body = request.body;
         const userAgent = headers["user-agent"];
@@ -28113,11 +28231,11 @@ var init_transport_remote = __esm({
 });
 
 // libs/sdk/src/transport/adapters/base-sse-transport.ts
-var import_utils47, import_raw_body, import_content_type, import_protocol19, MAXIMUM_MESSAGE_SIZE, SSEServerTransport;
+var import_utils49, import_raw_body, import_content_type, import_protocol19, MAXIMUM_MESSAGE_SIZE, SSEServerTransport;
 var init_base_sse_transport = __esm({
   "libs/sdk/src/transport/adapters/base-sse-transport.ts"() {
     "use strict";
-    import_utils47 = require("@frontmcp/utils");
+    import_utils49 = require("@frontmcp/utils");
     import_raw_body = __toESM(require("raw-body"));
     import_content_type = __toESM(require("content-type"));
     import_protocol19 = require("@frontmcp/protocol");
@@ -28130,7 +28248,7 @@ var init_base_sse_transport = __esm({
       constructor(_endpoint, res, options) {
         this._endpoint = _endpoint;
         this.res = res;
-        this._sessionId = options?.sessionId ?? (0, import_utils47.randomUUID)();
+        this._sessionId = options?.sessionId ?? (0, import_utils49.randomUUID)();
         this._options = options || { enableDnsRebindingProtection: false };
       }
       _sseResponse;
@@ -29741,21 +29859,21 @@ var init_transport_local_adapter = __esm({
 });
 
 // libs/sdk/src/transport/transport.error.ts
-var import_utils48, JSON_RPC2, rpcError, rpcRequest;
+var import_utils50, JSON_RPC2, rpcError, rpcRequest;
 var init_transport_error = __esm({
   "libs/sdk/src/transport/transport.error.ts"() {
     "use strict";
-    import_utils48 = require("@frontmcp/utils");
+    import_utils50 = require("@frontmcp/utils");
     JSON_RPC2 = "2.0";
     rpcError = (message, requestId) => ({
       jsonrpc: JSON_RPC2,
       error: { code: -32e3, message },
-      id: requestId ?? (0, import_utils48.randomUUID)()
+      id: requestId ?? (0, import_utils50.randomUUID)()
       // change it to request id + random
     });
     rpcRequest = (requestId, method, params) => ({
       jsonrpc: JSON_RPC2,
-      id: requestId ?? (0, import_utils48.randomUUID)(),
+      id: requestId ?? (0, import_utils50.randomUUID)(),
       method,
       ...params !== void 0 && { params }
     });
@@ -29763,12 +29881,12 @@ var init_transport_error = __esm({
 });
 
 // libs/sdk/src/elicitation/store/storage-elicitation.store.ts
-var import_utils49, import_utils50, RESOLVED_RESULT_TTL_SECONDS, RESULT_CHANNEL_PREFIX, FALLBACK_RESULT_CHANNEL_PREFIX, StorageElicitationStore;
+var import_utils51, import_utils52, RESOLVED_RESULT_TTL_SECONDS, RESULT_CHANNEL_PREFIX, FALLBACK_RESULT_CHANNEL_PREFIX, StorageElicitationStore;
 var init_storage_elicitation_store = __esm({
   "libs/sdk/src/elicitation/store/storage-elicitation.store.ts"() {
     "use strict";
-    import_utils49 = require("@frontmcp/utils");
-    import_utils50 = require("@frontmcp/utils");
+    import_utils51 = require("@frontmcp/utils");
+    import_utils52 = require("@frontmcp/utils");
     RESOLVED_RESULT_TTL_SECONDS = 300;
     RESULT_CHANNEL_PREFIX = "result:";
     FALLBACK_RESULT_CHANNEL_PREFIX = "fallback-result:";
@@ -29793,9 +29911,9 @@ var init_storage_elicitation_store = __esm({
       constructor(storage, logger) {
         this.storage = storage;
         this.logger = logger;
-        this.pending = new import_utils49.TypedStorage(storage.namespace("pending"));
-        this.fallback = new import_utils49.TypedStorage(storage.namespace("fallback"));
-        this.resolved = new import_utils49.TypedStorage(storage.namespace("resolved"));
+        this.pending = new import_utils51.TypedStorage(storage.namespace("pending"));
+        this.fallback = new import_utils51.TypedStorage(storage.namespace("fallback"));
+        this.resolved = new import_utils51.TypedStorage(storage.namespace("resolved"));
       }
       // ============================================
       // Pending Elicitation Methods
@@ -29805,7 +29923,7 @@ var init_storage_elicitation_store = __esm({
        */
       async setPending(record) {
         const { sessionId, expiresAt } = record;
-        const ttlSeconds = (0, import_utils50.expiresAtToTTL)(expiresAt);
+        const ttlSeconds = (0, import_utils52.expiresAtToTTL)(expiresAt);
         if (ttlSeconds <= 0) {
           this.logger?.warn("[StorageElicitationStore] Record already expired, not storing", {
             sessionId,
@@ -29983,7 +30101,7 @@ var init_storage_elicitation_store = __esm({
        */
       async setPendingFallback(record) {
         const { elicitId, expiresAt } = record;
-        const ttlSeconds = (0, import_utils50.expiresAtToTTL)(expiresAt);
+        const ttlSeconds = (0, import_utils52.expiresAtToTTL)(expiresAt);
         if (ttlSeconds <= 0) {
           this.logger?.warn("[StorageElicitationStore] Fallback record already expired, not storing", { elicitId });
           return;
@@ -30238,7 +30356,7 @@ var init_storage_elicitation_store = __esm({
 
 // libs/sdk/src/elicitation/store/elicitation-encryption.ts
 function getElicitationSecret() {
-  return (0, import_utils51.getEnv)("MCP_ELICITATION_SECRET") || (0, import_utils51.getEnv)("MCP_SESSION_SECRET") || (0, import_utils51.getEnv)("MCP_SERVER_SECRET") || null;
+  return (0, import_utils53.getEnv)("MCP_ELICITATION_SECRET") || (0, import_utils53.getEnv)("MCP_SESSION_SECRET") || (0, import_utils53.getEnv)("MCP_SERVER_SECRET") || null;
 }
 function isElicitationEncryptionAvailable() {
   return getElicitationSecret() !== null;
@@ -30251,27 +30369,27 @@ async function deriveElicitationKey(sessionId, secret) {
   const ikm = textEncoder.encode(serverSecret + sessionId);
   const salt = textEncoder.encode(ELICITATION_SALT);
   const info = textEncoder.encode(`elicit:${sessionId}`);
-  return (0, import_utils51.hkdfSha256)(ikm, salt, info, 32);
+  return (0, import_utils53.hkdfSha256)(ikm, salt, info, 32);
 }
 async function encryptElicitationData(data, sessionId, secret) {
   const key = await deriveElicitationKey(sessionId, secret);
   const plaintext = textEncoder.encode(JSON.stringify(data));
-  const iv = (0, import_utils51.randomBytes)(12);
-  const { ciphertext, tag } = (0, import_utils51.encryptAesGcm)(key, plaintext, iv);
+  const iv = (0, import_utils53.randomBytes)(12);
+  const { ciphertext, tag } = (0, import_utils53.encryptAesGcm)(key, plaintext, iv);
   return {
     alg: "A256GCM",
-    iv: (0, import_utils51.base64urlEncode)(iv),
-    tag: (0, import_utils51.base64urlEncode)(tag),
-    data: (0, import_utils51.base64urlEncode)(ciphertext)
+    iv: (0, import_utils53.base64urlEncode)(iv),
+    tag: (0, import_utils53.base64urlEncode)(tag),
+    data: (0, import_utils53.base64urlEncode)(ciphertext)
   };
 }
 async function decryptElicitationData(blob, sessionId, secret) {
   try {
     const key = await deriveElicitationKey(sessionId, secret);
-    const iv = (0, import_utils51.base64urlDecode)(blob.iv);
-    const tag = (0, import_utils51.base64urlDecode)(blob.tag);
-    const ciphertext = (0, import_utils51.base64urlDecode)(blob.data);
-    const decrypted = (0, import_utils51.decryptAesGcm)(key, ciphertext, iv, tag);
+    const iv = (0, import_utils53.base64urlDecode)(blob.iv);
+    const tag = (0, import_utils53.base64urlDecode)(blob.tag);
+    const ciphertext = (0, import_utils53.base64urlDecode)(blob.data);
+    const decrypted = (0, import_utils53.decryptAesGcm)(key, ciphertext, iv, tag);
     return JSON.parse(textDecoder.decode(decrypted));
   } catch {
     return null;
@@ -30311,11 +30429,11 @@ async function tryDecryptStoredValue(value, sessionId, secret) {
   }
   return decryptElicitationData(value, sessionId, secret);
 }
-var import_utils51, ELICITATION_SALT, textEncoder, textDecoder;
+var import_utils53, ELICITATION_SALT, textEncoder, textDecoder;
 var init_elicitation_encryption = __esm({
   "libs/sdk/src/elicitation/store/elicitation-encryption.ts"() {
     "use strict";
-    import_utils51 = require("@frontmcp/utils");
+    import_utils53 = require("@frontmcp/utils");
     init_auth_internal_errors();
     ELICITATION_SALT = "elicitation-store-v1";
     textEncoder = new TextEncoder();
@@ -30717,10 +30835,10 @@ var init_encrypted_elicitation_store = __esm({
 
 // libs/sdk/src/elicitation/store/elicitation-store.factory.ts
 function detectStorageType(storage) {
-  if ((0, import_utils52.getEnv)("UPSTASH_REDIS_REST_URL")) {
+  if ((0, import_utils54.getEnv)("UPSTASH_REDIS_REST_URL")) {
     return "upstash";
   }
-  if ((0, import_utils52.getEnv)("REDIS_URL") || (0, import_utils52.getEnv)("REDIS_HOST")) {
+  if ((0, import_utils54.getEnv)("REDIS_URL") || (0, import_utils54.getEnv)("REDIS_HOST")) {
     return "redis";
   }
   return "memory";
@@ -30774,7 +30892,7 @@ async function createElicitationStore(options = {}) {
       });
     }
   }
-  if (finalStorageConfig?.type === "vercel-kv" || (0, import_utils52.getEnv)("KV_REST_API_URL")) {
+  if (finalStorageConfig?.type === "vercel-kv" || (0, import_utils54.getEnv)("KV_REST_API_URL")) {
     throw new ElicitationNotSupportedError(
       "Vercel KV is not supported for elicitation stores. Elicitation requires pub/sub for cross-node result routing, which Vercel KV does not support. Use Redis or Upstash instead."
     );
@@ -30784,7 +30902,7 @@ async function createElicitationStore(options = {}) {
       "Elicitation requires distributed storage when running on Edge runtime. Edge functions are stateless and cannot use in-memory elicitation. Configure Redis or Upstash storage."
     );
   }
-  const storage = await (0, import_utils52.createStorage)({
+  const storage = await (0, import_utils54.createStorage)({
     ...finalStorageConfig,
     prefix: keyPrefix,
     fallback: isEdgeRuntime2 ? "error" : "memory"
@@ -30822,7 +30940,7 @@ async function createElicitationStore(options = {}) {
 }
 function createMemoryElicitationStore(options = {}) {
   const { keyPrefix = "mcp:elicit:", logger, encryption } = options;
-  const storage = (0, import_utils52.createMemoryStorage)({ prefix: keyPrefix });
+  const storage = (0, import_utils54.createMemoryStorage)({ prefix: keyPrefix });
   let store = new StorageElicitationStore(storage, logger);
   const encryptionEnabled = encryption?.enabled ?? "auto";
   const encryptionSecret = encryption?.secret;
@@ -30866,11 +30984,11 @@ function createElicitationStoreFromStorage(storage, options = {}) {
   });
   return { store, type, storage, encrypted };
 }
-var import_utils52;
+var import_utils54;
 var init_elicitation_store_factory = __esm({
   "libs/sdk/src/elicitation/store/elicitation-store.factory.ts"() {
     "use strict";
-    import_utils52 = require("@frontmcp/utils");
+    import_utils54 = require("@frontmcp/utils");
     init_storage_elicitation_store();
     init_encrypted_elicitation_store();
     init_elicitation_encryption();
@@ -31570,11 +31688,11 @@ var init_ext_apps_types = __esm({
 function createExtAppsMessageHandler(options) {
   return new ExtAppsMessageHandler(options);
 }
-var import_utils53, ExtAppsMessageHandler, ExtAppsError, ExtAppsMethodNotFoundError, ExtAppsInvalidParamsError, ExtAppsNotSupportedError, ExtAppsToolNotFoundError;
+var import_utils55, ExtAppsMessageHandler, ExtAppsError, ExtAppsMethodNotFoundError, ExtAppsInvalidParamsError, ExtAppsNotSupportedError, ExtAppsToolNotFoundError;
 var init_ext_apps_handler = __esm({
   "libs/sdk/src/ext-apps/ext-apps.handler.ts"() {
     "use strict";
-    import_utils53 = require("@frontmcp/utils");
+    import_utils55 = require("@frontmcp/utils");
     init_ext_apps_types();
     ExtAppsMessageHandler = class {
       context;
@@ -31618,7 +31736,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_utils53.isDevelopment)() && error instanceof Error ? { stack: error.stack } : void 0
+              data: (0, import_utils55.isDevelopment)() && error instanceof Error ? { stack: error.stack } : void 0
             }
           };
         }
@@ -32716,21 +32834,21 @@ async function createVercelKvSessionStore(options, logger) {
   await store.connect();
   return store;
 }
-var import_utils54;
+var import_utils56;
 var init_session_store_factory = __esm({
   "libs/sdk/src/auth/session/session-store.factory.ts"() {
     "use strict";
-    import_utils54 = require("@frontmcp/utils");
+    import_utils56 = require("@frontmcp/utils");
     init_common();
   }
 });
 
 // libs/sdk/src/transport/transport.registry.ts
-var import_utils55, import_auth30, TransportService;
+var import_utils57, import_auth30, TransportService;
 var init_transport_registry = __esm({
   "libs/sdk/src/transport/transport.registry.ts"() {
     "use strict";
-    import_utils55 = require("@frontmcp/utils");
+    import_utils57 = require("@frontmcp/utils");
     init_transport_remote();
     init_transport_local();
     init_transport_errors();
@@ -33178,7 +33296,7 @@ var init_transport_registry = __esm({
       }
       /* --------------------------------- internals -------------------------------- */
       sha256(value) {
-        return (0, import_utils55.sha256Hex)(value);
+        return (0, import_utils57.sha256Hex)(value);
       }
       /**
        * Create a history key from components.
@@ -33743,11 +33861,11 @@ function createSkillHttpAuthValidator(skillsConfig, logger) {
   }
   return new SkillHttpAuthValidator({ skillsConfig, logger });
 }
-var import_utils56, SkillHttpAuthValidator;
+var import_utils58, SkillHttpAuthValidator;
 var init_skill_http_auth = __esm({
   "libs/sdk/src/skill/auth/skill-http-auth.ts"() {
     "use strict";
-    import_utils56 = require("@frontmcp/utils");
+    import_utils58 = require("@frontmcp/utils");
     SkillHttpAuthValidator = class {
       skillsConfig;
       logger;
@@ -33824,7 +33942,7 @@ var init_skill_http_auth = __esm({
           const keyBytes = encoder.encode(key);
           if (keyBytes.length === candidateBytes.length) {
             try {
-              if ((0, import_utils56.timingSafeEqual)(keyBytes, candidateBytes)) {
+              if ((0, import_utils58.timingSafeEqual)(keyBytes, candidateBytes)) {
                 found = true;
               }
             } catch {
@@ -35139,15 +35257,15 @@ var init_skill_session_types = __esm({
 });
 
 // libs/sdk/src/skill/session/skill-session.manager.ts
-var import_utils57, SkillSessionManager;
+var import_utils59, SkillSessionManager;
 var init_skill_session_manager = __esm({
   "libs/sdk/src/skill/session/skill-session.manager.ts"() {
     "use strict";
-    import_utils57 = require("@frontmcp/utils");
+    import_utils59 = require("@frontmcp/utils");
     init_skill_session_types();
     init_errors();
-    SkillSessionManager = class extends import_utils57.EventEmitter {
-      storage = new import_utils57.AsyncLocalStorage();
+    SkillSessionManager = class extends import_utils59.EventEmitter {
+      storage = new import_utils59.AsyncLocalStorage();
       options;
       logger;
       store;
@@ -36189,18 +36307,15 @@ var init_complete_flow = __esm({
           } else {
             const resourceMatch = this.scope.resources.findResourceForUri(uri);
             if (resourceMatch) {
-              const instance = resourceMatch.instance;
-              if (typeof instance.getArgumentCompleter === "function") {
-                const completer = instance.getArgumentCompleter(argName);
-                if (completer) {
-                  try {
-                    const result = await completer(argValue);
-                    values = result.values || [];
-                    total = result.total;
-                    hasMore = result.hasMore;
-                  } catch (e) {
-                    this.logger.warn(`complete: completer failed for resource "${uri}" argument "${argName}": ${e}`);
-                  }
+              const completer = resourceMatch.instance.getArgumentCompleter(argName);
+              if (completer) {
+                try {
+                  const result = await completer(argValue);
+                  values = result.values || [];
+                  total = result.total;
+                  hasMore = result.hasMore;
+                } catch (e) {
+                  this.logger.warn(`complete: completer failed for resource "${uri}" argument "${argName}": ${e}`);
                 }
               }
             } else {
@@ -36663,13 +36778,13 @@ var init_call_agent_flow = __esm({
 });
 
 // libs/sdk/src/elicitation/flows/elicitation-request.flow.ts
-var import_zod75, import_utils58, inputSchema30, outputSchema28, stateSchema29, plan30, name31, Stage31, ElicitationRequestFlow;
+var import_zod75, import_utils60, inputSchema30, outputSchema28, stateSchema29, plan30, name31, Stage31, ElicitationRequestFlow;
 var init_elicitation_request_flow = __esm({
   "libs/sdk/src/elicitation/flows/elicitation-request.flow.ts"() {
     "use strict";
     init_common();
     import_zod75 = require("zod");
-    import_utils58 = require("@frontmcp/utils");
+    import_utils60 = require("@frontmcp/utils");
     init_errors();
     init_elicitation_types();
     inputSchema30 = import_zod75.z.object({
@@ -36751,7 +36866,7 @@ var init_elicitation_request_flow = __esm({
       async generateElicitId() {
         this.logger.verbose("generateElicitId:start");
         const { elicitationId, ttl } = this.state;
-        const elicitId = elicitationId ?? `elicit-${(0, import_utils58.randomUUID)()}`;
+        const elicitId = elicitationId ?? `elicit-${(0, import_utils60.randomUUID)()}`;
         const expiresAt = Date.now() + (ttl ?? DEFAULT_ELICIT_TTL);
         this.state.set({ elicitId, expiresAt });
         this.logger.verbose("generateElicitId:done", { elicitId });
@@ -37059,30 +37174,30 @@ var require_dist = __commonJS({
       sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_utils75 = require("@frontmcp/utils");
+    var import_utils77 = 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_utils75.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
+      return (0, import_utils77.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
     }
     var SEPARATOR = ":";
     function encryptValue(key, plaintext) {
-      const iv = (0, import_utils75.randomBytes)(12);
+      const iv = (0, import_utils77.randomBytes)(12);
       const plaintextBytes = new TextEncoder().encode(plaintext);
-      const { ciphertext, tag } = (0, import_utils75.encryptAesGcm)(key, plaintextBytes, iv);
-      return [(0, import_utils75.base64urlEncode)(iv), (0, import_utils75.base64urlEncode)(tag), (0, import_utils75.base64urlEncode)(ciphertext)].join(SEPARATOR);
+      const { ciphertext, tag } = (0, import_utils77.encryptAesGcm)(key, plaintextBytes, iv);
+      return [(0, import_utils77.base64urlEncode)(iv), (0, import_utils77.base64urlEncode)(tag), (0, import_utils77.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_utils75.base64urlDecode)(parts[0]);
-      const tag = (0, import_utils75.base64urlDecode)(parts[1]);
-      const ciphertext = (0, import_utils75.base64urlDecode)(parts[2]);
-      const plaintext = (0, import_utils75.decryptAesGcm)(key, ciphertext, iv, tag);
+      const iv = (0, import_utils77.base64urlDecode)(parts[0]);
+      const tag = (0, import_utils77.base64urlDecode)(parts[1]);
+      const ciphertext = (0, import_utils77.base64urlDecode)(parts[2]);
+      const plaintext = (0, import_utils77.decryptAesGcm)(key, ciphertext, iv, tag);
       return new TextDecoder().decode(plaintext);
     }
     var SqliteKvStore = class {
@@ -39179,11 +39294,11 @@ var init_workflow_engine = __esm({
 });
 
 // libs/sdk/src/job/execution/job-execution.manager.ts
-var import_utils59, JobExecutionManager;
+var import_utils61, JobExecutionManager;
 var init_job_execution_manager = __esm({
   "libs/sdk/src/job/execution/job-execution.manager.ts"() {
     "use strict";
-    import_utils59 = require("@frontmcp/utils");
+    import_utils61 = require("@frontmcp/utils");
     init_workflow_engine();
     JobExecutionManager = class {
       stateStore;
@@ -39198,7 +39313,7 @@ var init_job_execution_manager = __esm({
        * Execute a job inline (synchronous) or in background.
        */
       async executeJob(job, input, opts = {}) {
-        const runId = (0, import_utils59.randomUUID)();
+        const runId = (0, import_utils61.randomUUID)();
         const retryConfig = job.metadata.retry ?? {};
         const maxAttempts = retryConfig.maxAttempts ?? 1;
         const runRecord = {
@@ -39236,7 +39351,7 @@ var init_job_execution_manager = __esm({
        * Execute a workflow inline or in background.
        */
       async executeWorkflow(workflow, jobRegistry, opts = {}) {
-        const runId = (0, import_utils59.randomUUID)();
+        const runId = (0, import_utils61.randomUUID)();
         const runRecord = {
           runId,
           jobId: workflow.metadata.id ?? workflow.name,
@@ -40366,7 +40481,7 @@ var init_job_scope_helper = __esm({
 });
 
 // libs/sdk/src/scope/scope.instance.ts
-var import_reflect_metadata20, import_utils60, import_guard6, Scope;
+var import_reflect_metadata20, import_utils62, import_guard6, Scope;
 var init_scope_instance = __esm({
   "libs/sdk/src/scope/scope.instance.ts"() {
     "use strict";
@@ -40386,7 +40501,7 @@ var init_scope_instance = __esm({
     init_agent_registry();
     init_skill_registry();
     init_skill_validation_error();
-    import_utils60 = require("@frontmcp/utils");
+    import_utils62 = require("@frontmcp/utils");
     init_errors();
     init_skill_scope_helper();
     init_session2();
@@ -40470,7 +40585,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_utils60.getEnvFlag)("FRONTMCP_PERF");
+        const perf = (0, import_utils62.getEnvFlag)("FRONTMCP_PERF");
         const t0 = perf ? performance.now() : 0;
         const mark = perf ? (label) => this.logger.info(`[PERF] ${label}: ${(performance.now() - t0).toFixed(1)}ms`) : () => {
         };
@@ -40496,7 +40611,7 @@ var init_scope_instance = __esm({
             redis: elicitationRedis,
             keyPrefix: elicitationRedis?.keyPrefix ?? "mcp:elicit:",
             logger: this.logger,
-            isEdgeRuntime: (0, import_utils60.isEdgeRuntime)()
+            isEdgeRuntime: (0, import_utils62.isEdgeRuntime)()
           });
           this._elicitationStore = elicitStore;
         })() : void 0;
@@ -41155,7 +41270,7 @@ var init_base_host_adapter = __esm({
 });
 
 // libs/sdk/src/server/adapters/express.host.adapter.ts
-var http, import_express, import_cors, import_utils61, ExpressHostAdapter;
+var http, import_express, import_cors, import_utils63, ExpressHostAdapter;
 var init_express_host_adapter = __esm({
   "libs/sdk/src/server/adapters/express.host.adapter.ts"() {
     "use strict";
@@ -41163,7 +41278,7 @@ var init_express_host_adapter = __esm({
     import_express = __toESM(require("express"));
     import_cors = __toESM(require("cors"));
     init_base_host_adapter();
-    import_utils61 = require("@frontmcp/utils");
+    import_utils63 = require("@frontmcp/utils");
     ExpressHostAdapter = class extends HostServerAdapter {
       app = (0, import_express.default)();
       router = import_express.default.Router();
@@ -41255,8 +41370,8 @@ var init_express_host_adapter = __esm({
       }
       async cleanupStaleSocket(socketPath) {
         try {
-          if (await (0, import_utils61.fileExists)(socketPath)) {
-            await (0, import_utils61.unlink)(socketPath);
+          if (await (0, import_utils63.fileExists)(socketPath)) {
+            await (0, import_utils63.unlink)(socketPath);
           }
         } catch {
         }
@@ -41433,12 +41548,12 @@ var init_logger_utils = __esm({
 });
 
 // libs/sdk/src/logger/instances/instance.console-logger.ts
-var import_utils62, ConsoleLogTransportInstance;
+var import_utils64, ConsoleLogTransportInstance;
 var init_instance_console_logger = __esm({
   "libs/sdk/src/logger/instances/instance.console-logger.ts"() {
     "use strict";
     init_common();
-    import_utils62 = require("@frontmcp/utils");
+    import_utils64 = require("@frontmcp/utils");
     ConsoleLogTransportInstance = class extends LogTransportInterface {
       log(rec) {
         const fn = this.bind(rec.level, rec.prefix);
@@ -41466,7 +41581,7 @@ var init_instance_console_logger = __esm({
         const BOLD = "\x1B[1m";
         const DIM = "\x1B[2m";
         const GRAY = "\x1B[90m";
-        const useAnsi = (0, import_utils62.supportsAnsi)();
+        const useAnsi = (0, import_utils64.supportsAnsi)();
         const timePart = useAnsi ? `${DIM}[${ts}]${RESET}` : `[${ts}]`;
         const scopePart = loggerPrefix ? useAnsi ? `${BOLD}[${loggerPrefix}]${RESET}` : `[${loggerPrefix}]` : void 0;
         const levelPart = useAnsi ? `${BOLD}${meta.ansi}${meta.label}${RESET}` : meta.label;
@@ -41504,12 +41619,12 @@ var init_instance_console_logger = __esm({
 });
 
 // libs/sdk/src/logger/instances/instance.logger.ts
-var import_utils63, LoggerInstance;
+var import_utils65, LoggerInstance;
 var init_instance_logger = __esm({
   "libs/sdk/src/logger/instances/instance.logger.ts"() {
     "use strict";
     init_common();
-    import_utils63 = require("@frontmcp/utils");
+    import_utils65 = require("@frontmcp/utils");
     LoggerInstance = class _LoggerInstance extends FrontMcpLogger {
       constructor(config, getTransports) {
         super();
@@ -41564,7 +41679,7 @@ var init_instance_logger = __esm({
       }
       _getter(level) {
         if (level < this.level || this.level === 100 /* Off */) return () => void 0;
-        if ((0, import_utils63.isDevelopment)() && this.config.enableConsole && this.consoleTransport) {
+        if ((0, import_utils65.isDevelopment)() && this.config.enableConsole && this.consoleTransport) {
           return this.consoleTransport.bind(level, this.prefix);
         }
         const emit = this.emit.bind(this);
@@ -41894,7 +42009,7 @@ __export(in_memory_server_exports, {
 async function createInMemoryServer(scope, options) {
   const { InMemoryTransport, McpServer: McpServer2 } = await import("@frontmcp/protocol");
   const { createMcpHandlers: createMcpHandlers2 } = await Promise.resolve().then(() => (init_mcp_handlers(), mcp_handlers_exports));
-  const sessionId = options?.sessionId ?? `in-memory:${(0, import_utils64.randomUUID)()}`;
+  const sessionId = options?.sessionId ?? `in-memory:${(0, import_utils66.randomUUID)()}`;
   const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
   let currentAuthInfo = options?.authInfo ?? {};
   const hasRemoteApps = scope.apps?.getApps().some((app) => app.isRemote) ?? false;
@@ -41948,11 +42063,11 @@ async function createInMemoryServer(scope, options) {
     }
   };
 }
-var import_utils64;
+var import_utils66;
 var init_in_memory_server = __esm({
   "libs/sdk/src/transport/in-memory-server.ts"() {
     "use strict";
-    import_utils64 = require("@frontmcp/utils");
+    import_utils66 = require("@frontmcp/utils");
   }
 });
 
@@ -41961,13 +42076,13 @@ var direct_client_exports = {};
 __export(direct_client_exports, {
   DirectClientImpl: () => DirectClientImpl
 });
-var import_utils65, import_protocol43, DirectClientImpl;
+var import_utils67, import_protocol43, DirectClientImpl;
 var init_direct_client = __esm({
   "libs/sdk/src/direct/direct-client.ts"() {
     "use strict";
     init_llm_platform();
     init_errors();
-    import_utils65 = require("@frontmcp/utils");
+    import_utils67 = require("@frontmcp/utils");
     import_protocol43 = require("@frontmcp/protocol");
     init_skills_mcp_types();
     DirectClientImpl = class _DirectClientImpl {
@@ -42005,7 +42120,7 @@ var init_direct_client = __esm({
        */
       static async create(scope, options) {
         const { createInMemoryServer: createInMemoryServer2 } = await Promise.resolve().then(() => (init_in_memory_server(), in_memory_server_exports));
-        const sessionId = options?.session?.id ?? `direct:${(0, import_utils65.randomUUID)()}`;
+        const sessionId = options?.session?.id ?? `direct:${(0, import_utils67.randomUUID)()}`;
         const clientInfo = options?.clientInfo ?? { name: "mcp-client", version: "1.0.0" };
         const authInfo = {};
         if (options?.authToken) {
@@ -42420,7 +42535,7 @@ function buildAuthInfo(authContext, defaultSessionId) {
   if (!authContext && !defaultSessionId) {
     return void 0;
   }
-  const sessionId = authContext?.sessionId ?? defaultSessionId ?? `direct:${(0, import_utils66.randomUUID)()}`;
+  const sessionId = authContext?.sessionId ?? defaultSessionId ?? `direct:${(0, import_utils68.randomUUID)()}`;
   const user = authContext?.user ? { iss: "direct", sub: authContext.user.sub ?? "direct", ...authContext.user } : { iss: "direct", sub: "direct" };
   const clientId = user.sub ?? "direct";
   const authInfo = {
@@ -42435,11 +42550,11 @@ function buildAuthInfo(authContext, defaultSessionId) {
   }
   return authInfo;
 }
-var import_utils66, DirectMcpServerImpl;
+var import_utils68, DirectMcpServerImpl;
 var init_direct_server = __esm({
   "libs/sdk/src/direct/direct-server.ts"() {
     "use strict";
-    import_utils66 = require("@frontmcp/utils");
+    import_utils68 = require("@frontmcp/utils");
     init_common();
     init_errors();
     DirectMcpServerImpl = class {
@@ -42449,7 +42564,7 @@ var init_direct_server = __esm({
       defaultSessionId;
       constructor(scope) {
         this.scope = scope;
-        this.defaultSessionId = `direct:${(0, import_utils66.randomUUID)()}`;
+        this.defaultSessionId = `direct:${(0, import_utils68.randomUUID)()}`;
         this.ready = Promise.resolve();
       }
       /**
@@ -42715,7 +42830,7 @@ var front_mcp_exports = {};
 __export(front_mcp_exports, {
   FrontMcpInstance: () => FrontMcpInstance
 });
-var import_utils67, FrontMcpInstance;
+var import_utils69, FrontMcpInstance;
 var init_front_mcp = __esm({
   "libs/sdk/src/front-mcp/front-mcp.ts"() {
     "use strict";
@@ -42726,7 +42841,7 @@ var init_front_mcp = __esm({
     init_logger_registry();
     init_direct();
     init_errors();
-    import_utils67 = require("@frontmcp/utils");
+    import_utils69 = require("@frontmcp/utils");
     FrontMcpInstance = class _FrontMcpInstance2 {
       config;
       ready;
@@ -42758,6 +42873,9 @@ var init_front_mcp = __esm({
           throw new ServerNotFoundError();
         }
         await server.start();
+        for (const scope of this.getScopes()) {
+          await scope.emitServerStarted();
+        }
       }
       /**
        * Get the configuration used to create this FrontMCP instance.
@@ -42950,8 +43068,8 @@ var init_front_mcp = __esm({
         frontMcp.log?.info(`MCP server listening on unix://${socketPath}`);
         const cleanup = async () => {
           try {
-            if (await (0, import_utils67.fileExists)(socketPath)) {
-              await (0, import_utils67.unlink)(socketPath);
+            if (await (0, import_utils69.fileExists)(socketPath)) {
+              await (0, import_utils69.unlink)(socketPath);
             }
           } catch {
           }
@@ -43010,7 +43128,7 @@ var init_front_mcp = __esm({
           serverInfo: scope.metadata.info
         };
         const mcpServer = new McpServer2(scope.metadata.info, serverOptions);
-        const sessionId = `stdio:${(0, import_utils67.randomUUID)()}`;
+        const sessionId = `stdio:${(0, import_utils69.randomUUID)()}`;
         const handlers = createMcpHandlers2({ scope, serverOptions });
         for (const handler of handlers) {
           const originalHandler = handler.handler;
@@ -43153,8 +43271,8 @@ function FrontMcp(providedMetadata) {
       Reflect.defineMetadata(FrontMcpTokens[property] ?? property, metadata[property], target);
     }
     Reflect.defineMetadata("__frontmcp:config", metadata, target);
-    const isServerless2 = (0, import_utils68.getEnvFlag)("FRONTMCP_SERVERLESS");
-    const isSchemaExtract = (0, import_utils68.getEnvFlag)("FRONTMCP_SCHEMA_EXTRACT");
+    const isServerless2 = (0, import_utils70.getEnvFlag)("FRONTMCP_SERVERLESS");
+    const isSchemaExtract = (0, import_utils70.getEnvFlag)("FRONTMCP_SCHEMA_EXTRACT");
     if (isSchemaExtract) {
     } else if (isServerless2) {
       const ServerlessInstance = getFrontMcpInstance();
@@ -43171,14 +43289,14 @@ function FrontMcp(providedMetadata) {
     }
   };
 }
-var import_reflect_metadata25, import_utils68, _FrontMcpInstance, _serverlessHandlerFns;
+var import_reflect_metadata25, import_utils70, _FrontMcpInstance, _serverlessHandlerFns;
 var init_front_mcp_decorator = __esm({
   "libs/sdk/src/common/decorators/front-mcp.decorator.ts"() {
     "use strict";
     import_reflect_metadata25 = require("reflect-metadata");
     init_tokens();
     init_metadata();
-    import_utils68 = require("@frontmcp/utils");
+    import_utils70 = require("@frontmcp/utils");
     init_mcp_error();
     init_decorator_errors();
     _FrontMcpInstance = null;
@@ -43640,7 +43758,7 @@ function resolveCallerDir() {
       if (file.includes("node_modules") || file.includes("skill.decorator")) {
         continue;
       }
-      return (0, import_utils69.dirname)(file);
+      return (0, import_utils71.dirname)(file);
     }
   }
   return void 0;
@@ -43699,14 +43817,14 @@ function getSkillMetadata(target) {
   }
   return metadata;
 }
-var import_reflect_metadata34, import_utils69, Skill;
+var import_reflect_metadata34, import_utils71, Skill;
 var init_skill_decorator = __esm({
   "libs/sdk/src/common/decorators/skill.decorator.ts"() {
     "use strict";
     import_reflect_metadata34 = require("reflect-metadata");
     init_tokens();
     init_metadata();
-    import_utils69 = require("@frontmcp/utils");
+    import_utils71 = require("@frontmcp/utils");
     init_package_specifier();
     init_validate_remote_url();
     Object.assign(FrontMcpSkill, {
@@ -44217,6 +44335,29 @@ var init_resource_interface = __esm({
         this.uri = uri;
         this.params = params;
       }
+      /**
+       * Override to provide autocompletion for resource template arguments.
+       * Called by the MCP `completion/complete` handler when a client requests
+       * suggestions for a template parameter.
+       *
+       * @param argName - The template parameter name (e.g., 'userId')
+       * @returns A completer function, or null if no completion is available for this argument
+       *
+       * @example
+       * ```typescript
+       * getArgumentCompleter(argName: string): ResourceArgumentCompleter | null {
+       *   if (argName === 'userId') {
+       *     return async (partial) => ({
+       *       values: await this.searchUsers(partial),
+       *     });
+       *   }
+       *   return null;
+       * }
+       * ```
+       */
+      getArgumentCompleter(_argName) {
+        return null;
+      }
       get output() {
         return this._output;
       }
@@ -45486,11 +45627,11 @@ var init_decide_request_intent_utils = __esm({
 
 // libs/sdk/src/common/utils/path.utils.ts
 function normalizeEntryPrefix(entryPath) {
-  const t = (0, import_utils70.trimSlashes)(entryPath ?? "");
+  const t = (0, import_utils72.trimSlashes)(entryPath ?? "");
   return t ? `/${t}` : "";
 }
 function normalizeScopeBase(scopeBase) {
-  const t = (0, import_utils70.trimSlashes)(scopeBase ?? "");
+  const t = (0, import_utils72.trimSlashes)(scopeBase ?? "");
   return t ? `/${t}` : "";
 }
 function getRequestBaseUrl(req, entryPath) {
@@ -45511,22 +45652,22 @@ function computeResource(req, entryPath, scopeBase) {
 function urlToSafeId(url) {
   const u = new URL(url);
   const raw = (u.host + (u.pathname && u.pathname !== "/" ? u.pathname : "")).replace(/\/+$/, "");
-  return (0, import_utils70.trimSlashes)(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
+  return (0, import_utils72.trimSlashes)(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
 }
 function makeWellKnownPaths(name33, entryPrefix, scopeBase = "") {
   const prefix = normalizeEntryPrefix(entryPrefix);
   const scope = normalizeScopeBase(scopeBase);
-  const reversed = (0, import_utils70.joinPath)(".well-known", name33) + `${prefix}${scope}`;
-  const inPrefixRoot = `${prefix}${(0, import_utils70.joinPath)(".well-known", name33)}${scope}`;
-  const inPrefixScope = `${prefix}${scope}${(0, import_utils70.joinPath)(".well-known", name33)}`;
+  const reversed = (0, import_utils72.joinPath)(".well-known", name33) + `${prefix}${scope}`;
+  const inPrefixRoot = `${prefix}${(0, import_utils72.joinPath)(".well-known", name33)}${scope}`;
+  const inPrefixScope = `${prefix}${scope}${(0, import_utils72.joinPath)(".well-known", name33)}`;
   return /* @__PURE__ */ new Set([reversed, inPrefixRoot, inPrefixScope]);
 }
-var import_utils70, import_utils71;
+var import_utils72, import_utils73;
 var init_path_utils = __esm({
   "libs/sdk/src/common/utils/path.utils.ts"() {
     "use strict";
-    import_utils70 = require("@frontmcp/utils");
-    import_utils71 = require("@frontmcp/utils");
+    import_utils72 = require("@frontmcp/utils");
+    import_utils73 = require("@frontmcp/utils");
   }
 });
 
@@ -45843,6 +45984,28 @@ var init_scope_entry = __esm({
         const scope = normalizeScopeBase(this.routeBase ?? "");
         return `${prefix}${scope}`;
       }
+      /**
+       * Lifecycle callbacks registered by plugins via onServerStarted().
+       * Called after the HTTP server starts listening.
+       */
+      lifecycleCallbacks = [];
+      /**
+       * Register a callback to run after the server has started.
+       * Plugins can use this for post-startup initialization (e.g., warming caches,
+       * starting background jobs, logging readiness).
+       */
+      onServerStarted(callback) {
+        this.lifecycleCallbacks.push(callback);
+      }
+      /**
+       * Emit the server-started lifecycle event. Called by FrontMcpInstance after server.start().
+       * @internal
+       */
+      async emitServerStarted() {
+        for (const cb of this.lifecycleCallbacks) {
+          await cb();
+        }
+      }
     };
   }
 });
@@ -45961,12 +46124,12 @@ var init_adapter_entry = __esm({
 });
 
 // libs/sdk/src/common/entries/tool.entry.ts
-var import_utils74, ToolEntry2;
+var import_utils76, ToolEntry2;
 var init_tool_entry = __esm({
   "libs/sdk/src/common/entries/tool.entry.ts"() {
     "use strict";
     init_base_entry();
-    import_utils74 = require("@frontmcp/utils");
+    import_utils76 = require("@frontmcp/utils");
     ToolEntry2 = class extends BaseEntry {
       owner;
       /**
@@ -46033,7 +46196,7 @@ var init_tool_entry = __esm({
             const { z: z91, toJSONSchema: toJSONSchema8 } = require("zod");
             return toJSONSchema8(z91.object(this.inputSchema));
           } catch (error) {
-            if ((0, import_utils74.isDebug)() || (0, import_utils74.isDevelopment)()) {
+            if ((0, import_utils76.isDebug)() || (0, import_utils76.isDevelopment)()) {
               console.warn("[ToolEntry] Failed to convert Zod schema to JSON Schema:", error);
             }
             return { type: "object", properties: {} };
@@ -46073,6 +46236,14 @@ var init_resource_entry = __esm({
        * Whether this resource is a template (has uriTemplate instead of uri)
        */
       isTemplate;
+      /**
+       * Get an argument completer for resource template autocompletion.
+       * Override in subclasses to provide suggestions for template parameters.
+       * Returns null by default (no completion available).
+       */
+      getArgumentCompleter(_argName) {
+        return null;
+      }
     };
   }
 });
@@ -47123,7 +47294,7 @@ __export(index_exports, {
   isValidVersion: () => isValidVersion,
   isVercelKvProvider: () => isVercelKvProvider,
   job: () => frontMcpJob,
-  joinPath: () => import_utils71.joinPath,
+  joinPath: () => import_utils73.joinPath,
   jsonWebKeySetSchema: () => import_auth.jsonWebKeySetSchema,
   jwkParametersSchema: () => import_auth.jwkParametersSchema,
   jwkSchema: () => import_auth.jwkSchema,
@@ -47209,7 +47380,7 @@ __export(index_exports, {
   toolPaginationOptionsSchema: () => toolPaginationOptionsSchema,
   transparentAuthOptionsSchema: () => import_auth6.transparentAuthOptionsSchema,
   transportOptionsSchema: () => transportOptionsSchema,
-  trimSlashes: () => import_utils71.trimSlashes,
+  trimSlashes: () => import_utils73.trimSlashes,
   tryDecryptStoredValue: () => tryDecryptStoredValue,
   tryGetConfig: () => tryGetConfig,
   urlToSafeId: () => urlToSafeId,