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

package/index.js

@@ -115,7 +115,8 @@ var init_server_tokens = __esm({
       type: tokenFactory.type("serverRequest"),
       intent: tokenFactory.meta("intent"),
       auth: tokenFactory.meta("auth"),
-      sessionId: tokenFactory.meta("sessionId")
+      sessionId: tokenFactory.meta("sessionId"),
+      reinitialize: tokenFactory.meta("reinitialize")
     };
   }
 });
@@ -2935,7 +2936,8 @@ var init_skill_metadata = __esm({
     skillResourcesSchema = import_zod30.z.object({
       scripts: import_zod30.z.string().optional(),
       references: import_zod30.z.string().optional(),
-      assets: import_zod30.z.string().optional()
+      assets: import_zod30.z.string().optional(),
+      examples: import_zod30.z.string().optional()
     });
     skillMetadataSchema = import_zod30.z.object({
       id: import_zod30.z.string().optional(),
@@ -7820,6 +7822,13 @@ var init_notification_service = __esm({
       isSessionTerminated(sessionId) {
         return this.terminatedSessions.has(sessionId);
       }
+      /**
+       * Remove a session from the terminated set.
+       * Called when a terminated session is being re-initialized with the same session ID.
+       */
+      unmarkTerminated(sessionId) {
+        this.terminatedSessions.delete(sessionId);
+      }
       /**
        * Broadcast a notification to all registered servers.
        *
@@ -8652,8 +8661,8 @@ var init_tool_instance = __esm({
         if (isRemoteTool || hasRawJsonSchema) {
           return import_zod36.z.looseObject({}).parse(input.arguments ?? {});
         }
-        const inputSchema32 = import_zod36.z.object(this.inputSchema);
-        return inputSchema32.parse(input.arguments);
+        const inputSchema33 = import_zod36.z.object(this.inputSchema);
+        return inputSchema33.parse(input.arguments);
       }
       /**
        * Turn the raw tool function result into an MCP-compliant CallToolResult:
@@ -8792,7 +8801,8 @@ var init_ui_shared = __esm({
       }
       async renderAndRegisterAsync(options) {
         const toolName = options["toolName"];
-        const template = options["uiConfig"]?.["template"];
+        const uiConfig = options["uiConfig"];
+        const template = uiConfig?.["template"];
         const input = options["input"] ?? {};
         const output = options["output"] ?? {};
         const platformType = options["platformType"];
@@ -9315,29 +9325,29 @@ var init_tools_list_flow = __esm({
             );
           }
           const tools = resolved.map(({ finalName, tool }) => {
-            let inputSchema32;
+            let inputSchema33;
             if (tool.rawInputSchema) {
-              inputSchema32 = tool.rawInputSchema;
+              inputSchema33 = tool.rawInputSchema;
             } else if (tool.inputSchema && Object.keys(tool.inputSchema).length > 0) {
               try {
-                inputSchema32 = (0, import_v43.toJSONSchema)(import_zod37.z.object(tool.inputSchema));
+                inputSchema33 = (0, import_v43.toJSONSchema)(import_zod37.z.object(tool.inputSchema));
               } catch (e) {
                 this.logger.warn(`Failed to convert inputSchema for tool ${finalName}:`, e);
-                inputSchema32 = { type: "object", properties: {} };
+                inputSchema33 = { type: "object", properties: {} };
               }
             } else {
-              inputSchema32 = { type: "object", properties: {} };
+              inputSchema33 = { type: "object", properties: {} };
             }
             const item = {
               name: finalName,
               title: tool.metadata.name,
               description: tool.metadata.description,
               annotations: tool.metadata.annotations,
-              inputSchema: inputSchema32
+              inputSchema: inputSchema33
             };
-            const outputSchema30 = tool.getRawOutputSchema();
-            if (outputSchema30) {
-              item.outputSchema = outputSchema30;
+            const outputSchema31 = tool.getRawOutputSchema();
+            if (outputSchema31) {
+              item.outputSchema = outputSchema31;
             }
             if (hasUIConfig(tool.metadata)) {
               const uiConfig = tool.metadata.ui;
@@ -11045,16 +11055,50 @@ var init_resource_instance = __esm({
         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.
+       * Get an argument completer for a template parameter.
+       *
+       * Supports two patterns (both have full DI access via `this.get()`):
+       *
+       * 1. **Convention-based (preferred):** Define `${argName}Completer` on the resource class.
+       *    Example: `async accountNameCompleter(partial: string) { ... }`
+       *
+       * 2. **Override-based:** Override `getArgumentCompleter(argName)` on the resource class.
+       *
+       * Convention-based completers take priority over override-based ones.
        */
       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);
+        const record = this.record;
+        if (record.kind === "FUNCTION" /* FUNCTION */ || record.kind === "FUNCTION" /* FUNCTION */) {
+          return null;
         }
-        return null;
+        const cls = record.provide;
+        if (typeof cls !== "function" || !cls.prototype) {
+          return null;
+        }
+        const conventionMethodName = `${argName}Completer`;
+        const hasConventionMethod = typeof cls.prototype[conventionMethodName] === "function";
+        const hasOverride = typeof cls.prototype.getArgumentCompleter === "function" && cls.prototype.getArgumentCompleter !== ResourceContext.prototype.getArgumentCompleter;
+        if (!hasConventionMethod && !hasOverride) {
+          return null;
+        }
+        const providers = this._providers;
+        const scope = providers.getActiveScope();
+        const logger = scope.logger;
+        const metadata = this.getMetadata();
+        const uri = this.isTemplate ? this.uriTemplate ?? "" : this.uri ?? "";
+        const resourceCtorArgs = {
+          metadata,
+          uri,
+          params: {},
+          providers,
+          logger,
+          authInfo: {}
+        };
+        const instance = new cls(resourceCtorArgs);
+        if (hasConventionMethod) {
+          return (partial) => instance[conventionMethodName](partial);
+        }
+        return instance.getArgumentCompleter(argName);
       }
       /**
        * Match a URI against this resource.
@@ -14096,7 +14140,8 @@ function normalizePlugin(item) {
         throw new InvalidUseClassError("plugin", (0, import_di17.tokenName)(provide));
       }
       const decoratorMetadata = collectPluginMetadata(useClass);
-      const mergedMetadata = { ...decoratorMetadata, ...metadata };
+      const { providers: _dynamicProviders, ...inlineMetadata } = metadata;
+      const mergedMetadata = { ...decoratorMetadata, ...inlineMetadata };
       return {
         kind: "CLASS" /* CLASS */,
         provide,
@@ -14122,7 +14167,8 @@ function normalizePlugin(item) {
         throw new InvalidUseValueError("plugin", (0, import_di17.tokenName)(provide));
       }
       const decoratorMetadata = collectPluginMetadata(useValue.constructor);
-      const mergedMetadata = { ...decoratorMetadata, ...metadata };
+      const { providers: _dynamicProviders, ...inlineMetadata } = metadata;
+      const mergedMetadata = { ...decoratorMetadata, ...inlineMetadata };
       return {
         kind: "VALUE" /* VALUE */,
         provide,
@@ -14319,11 +14365,14 @@ async function loadInstructions(source, basePath) {
   }
   throw new InvalidInstructionSourceError();
 }
-function buildSkillContent(metadata, instructions, resolvedReferences) {
+function buildSkillContent(metadata, instructions, resolvedReferences, resolvedExamples) {
   let finalInstructions = instructions;
   if (resolvedReferences && resolvedReferences.length > 0) {
     finalInstructions += buildReferencesTable(resolvedReferences);
   }
+  if (resolvedExamples && resolvedExamples.length > 0) {
+    finalInstructions += buildExamplesTable(resolvedExamples);
+  }
   return {
     id: metadata.id ?? metadata.name,
     name: metadata.name,
@@ -14337,7 +14386,8 @@ function buildSkillContent(metadata, instructions, resolvedReferences) {
     specMetadata: metadata.specMetadata,
     allowedTools: metadata.allowedTools,
     resources: metadata.resources,
-    resolvedReferences
+    resolvedReferences,
+    resolvedExamples
   };
 }
 function buildReferencesTable(refs) {
@@ -14347,6 +14397,73 @@ function buildReferencesTable(refs) {
   }
   return lines.join("\n");
 }
+function buildExamplesTable(examples) {
+  const lines = [
+    "",
+    "",
+    "## Examples",
+    "",
+    "| Example | Reference | Level | Description |",
+    "| ------- | --------- | ----- | ----------- |"
+  ];
+  for (const ex of examples) {
+    lines.push(`| \`${ex.name}\` | \`${ex.reference}\` | ${ex.level} | ${ex.description} |`);
+  }
+  return lines.join("\n");
+}
+async function resolveExamples(examplesDir) {
+  if (!await (0, import_utils27.fileExists)(examplesDir)) return void 0;
+  let refDirs;
+  try {
+    refDirs = (await (0, import_utils27.readdir)(examplesDir)).sort();
+  } catch {
+    return void 0;
+  }
+  const examples = [];
+  for (const refDir of refDirs) {
+    const refPath = `${examplesDir}/${refDir}`;
+    try {
+      const s = await (0, import_utils27.stat)(refPath);
+      if (!s.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    let files;
+    try {
+      files = (await (0, import_utils27.readdir)(refPath)).filter((f) => f.endsWith(".md")).sort();
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const content = await (0, import_utils27.readFile)(`${refPath}/${file}`, "utf-8");
+      const filenameWithoutExt = file.replace(/\.md$/, "");
+      let name33 = filenameWithoutExt;
+      let description = "";
+      let reference = refDir;
+      let level = "basic";
+      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 (key === "reference" && val) reference = val;
+          if (key === "level" && val) level = val;
+        }
+      }
+      if (!description) {
+        const body = fmMatch ? content.substring(content.indexOf("---", 3) + 3).trim() : content.trim();
+        description = extractFirstParagraph(body);
+      }
+      examples.push({ name: name33, description, reference, level, filename: `${refDir}/${file}` });
+    }
+  }
+  return examples.length > 0 ? examples : void 0;
+}
 async function resolveReferences(refsDir) {
   if (!await (0, import_utils27.fileExists)(refsDir)) return void 0;
   let files;
@@ -14613,16 +14730,24 @@ var init_skill_instance = __esm({
           return this.cachedContent;
         }
         const instructions = await this.loadInstructions();
+        const baseDir = this.getBaseDir();
         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);
+        const examplesPath = this.metadata.resources?.examples;
+        let resolvedExs;
+        if (examplesPath) {
+          const exDir = examplesPath.startsWith("/") ? examplesPath : baseDir ? (0, import_utils28.pathResolve)(baseDir, examplesPath) : void 0;
+          if (exDir) {
+            resolvedExs = await resolveExamples(exDir);
+          }
+        }
+        const baseContent = buildSkillContent(this.metadata, instructions, resolvedRefs, resolvedExs);
         this.cachedContent = {
           ...baseContent,
           tags: this.tags,
@@ -19829,8 +19954,8 @@ var init_agent_instance = __esm({
         return content;
       }
       parseInput(input) {
-        const inputSchema32 = import_zod47.z.object(this.inputSchema ?? {});
-        return inputSchema32.parse(input.arguments);
+        const inputSchema33 = import_zod47.z.object(this.inputSchema ?? {});
+        return inputSchema33.parse(input.arguments);
       }
       parseOutput(raw) {
         const descriptor = this.outputSchema;
@@ -19851,13 +19976,13 @@ var init_agent_instance = __esm({
        */
       getToolDefinition() {
         const metadata = this.record.metadata;
-        let inputSchema32 = {
+        let inputSchema33 = {
           type: "object",
           properties: {}
         };
         if (this.inputSchema && Object.keys(this.inputSchema).length > 0) {
           try {
-            inputSchema32 = (0, import_v44.toJSONSchema)(import_zod47.z.object(this.inputSchema));
+            inputSchema33 = (0, import_v44.toJSONSchema)(import_zod47.z.object(this.inputSchema));
           } catch {
             this.scope.logger.warn(`Failed to convert input schema for agent ${this.name}`);
           }
@@ -19865,7 +19990,7 @@ var init_agent_instance = __esm({
         return {
           name: agentToolName(this.id),
           description: this.buildToolDescription(metadata),
-          inputSchema: inputSchema32
+          inputSchema: inputSchema33
         };
       }
       /**
@@ -22696,8 +22821,8 @@ var init_esm_cache = __esm({
         if (entry.bundleContent) {
           return toCachedBundle(entry.bundleContent).content;
         }
-        const { readFile: readFile5 } = require("@frontmcp/utils");
-        return readFile5(entry.bundlePath);
+        const { readFile: readFile6 } = require("@frontmcp/utils");
+        return readFile6(entry.bundlePath);
       }
       /**
        * Get the cache directory for a specific package+version combination.
@@ -22738,13 +22863,13 @@ function normalizeToolFromEsmExport(raw) {
   const obj = raw;
   if (typeof obj["execute"] === "function" && typeof obj["name"] === "string") {
     const description = obj["description"];
-    const inputSchema32 = obj["inputSchema"];
-    const outputSchema30 = obj["outputSchema"];
+    const inputSchema33 = obj["inputSchema"];
+    const outputSchema31 = obj["outputSchema"];
     return {
       name: obj["name"],
       description: typeof description === "string" ? description : void 0,
-      inputSchema: inputSchema32 && typeof inputSchema32 === "object" ? inputSchema32 : void 0,
-      outputSchema: outputSchema30 && typeof outputSchema30 === "object" ? outputSchema30 : void 0,
+      inputSchema: inputSchema33 && typeof inputSchema33 === "object" ? inputSchema33 : void 0,
+      outputSchema: outputSchema31 && typeof outputSchema31 === "object" ? outputSchema31 : void 0,
       execute: obj["execute"]
     };
   }
@@ -23440,11 +23565,11 @@ function isZodShape(schema) {
 function buildEsmToolRecord(tool, namespace) {
   const toolName = namespace ? `${namespace}:${tool.name}` : tool.name;
   const ContextClass = createEsmToolContextClass(tool.execute, tool.name);
-  let inputSchema32 = {};
+  let inputSchema33 = {};
   let rawInputSchema = void 0;
   if (tool.inputSchema) {
     if (isZodShape(tool.inputSchema)) {
-      inputSchema32 = tool.inputSchema;
+      inputSchema33 = tool.inputSchema;
     } else {
       rawInputSchema = tool.inputSchema;
     }
@@ -23453,7 +23578,7 @@ function buildEsmToolRecord(tool, namespace) {
     name: toolName,
     id: toolName,
     description: tool.description ?? `ESM tool: ${tool.name}`,
-    inputSchema: inputSchema32,
+    inputSchema: inputSchema33,
     rawInputSchema,
     outputSchema: tool.outputSchema ?? "json",
     annotations: {
@@ -27896,11 +28021,10 @@ var init_http_request_flow = __esm({
                 const body = request.body;
                 if (body?.method === "initialize") {
                   this.logger.info(
-                    `[${this.requestId}] Initialize with terminated session ${sessionId.slice(0, 20)}... - allowing reconnect`
+                    `[${this.requestId}] Initialize with terminated session ${sessionId.slice(0, 20)}... - re-initializing`
                   );
-                  authorization.session = void 0;
-                  delete request[ServerRequestTokens.sessionId];
-                  delete request.headers["mcp-session-id"];
+                  this.scope.notifications.unmarkTerminated(sessionId);
+                  request[ServerRequestTokens.reinitialize] = true;
                 } else {
                   this.logger.warn(`[${this.requestId}] Request to terminated session: ${sessionId.slice(0, 20)}...`);
                   this.respond(httpRespond.notFound("Session not found"));
@@ -28024,12 +28148,7 @@ var init_http_request_flow = __esm({
             return;
           }
           this.logger.info(`[${this.requestId}] DELETE session: ${sessionId}`);
-          const wasRegistered = this.scope.notifications.terminateSession(sessionId);
-          if (!wasRegistered) {
-            this.logger.warn(`[${this.requestId}] Session not found for DELETE: ${sessionId}`);
-            this.respond(httpRespond.notFound("Session not found"));
-            return;
-          }
+          this.scope.notifications.terminateSession(sessionId);
           const authorization = request[ServerRequestTokens.auth];
           if (authorization?.token) {
             const transportService = this.scope.transportService;
@@ -28226,6 +28345,8 @@ var init_transport_remote = __esm({
       }
       resetForReinitialization() {
       }
+      reregisterServer() {
+      }
     };
   }
 });
@@ -29246,20 +29367,20 @@ function formatSkillForLLMWithSchemas(skill, availableTools, missingTools, toolR
       if (isAvailable) {
         const toolEntry = toolEntryByName.get(tool.name);
         if (toolEntry) {
-          const inputSchema32 = getToolInputSchema(toolEntry);
-          const outputSchema30 = toolEntry.getRawOutputSchema?.() ?? toolEntry.rawOutputSchema;
-          if (inputSchema32) {
+          const inputSchema33 = getToolInputSchema(toolEntry);
+          const outputSchema31 = toolEntry.getRawOutputSchema?.() ?? toolEntry.rawOutputSchema;
+          if (inputSchema33) {
             parts.push("");
             parts.push("**Input Schema:**");
             parts.push("```json");
-            parts.push(JSON.stringify(inputSchema32, null, 2));
+            parts.push(JSON.stringify(inputSchema33, null, 2));
             parts.push("```");
           }
-          if (outputSchema30) {
+          if (outputSchema31) {
             parts.push("");
             parts.push("**Output Schema:**");
             parts.push("```json");
-            parts.push(JSON.stringify(outputSchema30, null, 2));
+            parts.push(JSON.stringify(outputSchema31, null, 2));
             parts.push("```");
           }
         }
@@ -29600,6 +29721,16 @@ var init_transport_local_adapter = __esm({
        */
       resetForReinitialization() {
       }
+      /**
+       * Re-register the MCP server with the notification service.
+       * Called after resetForReinitialization() to restore the server mapping
+       * that was removed by terminateSession → unregisterServer.
+       */
+      reregisterServer() {
+        if (this.server) {
+          this.scope.notifications.registerServer(this.key.sessionId, this.server);
+        }
+      }
       connectServer() {
         const { info, apps } = this.scope.metadata;
         const hasRemoteApps = apps?.some((app) => this.isRemoteApp(app)) ?? false;
@@ -31627,6 +31758,9 @@ var init_transport_local = __esm({
       resetForReinitialization() {
         this.adapter.resetForReinitialization();
       }
+      reregisterServer() {
+        this.adapter.reregisterServer();
+      }
       async destroy(reason) {
         try {
           await this.adapter.destroy(reason);
@@ -31919,18 +32053,18 @@ var init_ext_apps_handler = __esm({
         if (!this.context.registerTool) {
           throw new ExtAppsNotSupportedError("Widget tool registration not supported by host");
         }
-        const { name: name33, description, inputSchema: inputSchema32 } = params;
+        const { name: name33, description, inputSchema: inputSchema33 } = params;
         if (!name33 || typeof name33 !== "string") {
           throw new ExtAppsInvalidParamsError("Tool name is required");
         }
         if (!description || typeof description !== "string") {
           throw new ExtAppsInvalidParamsError("Tool description is required");
         }
-        if (!inputSchema32 || typeof inputSchema32 !== "object" || Array.isArray(inputSchema32)) {
+        if (!inputSchema33 || typeof inputSchema33 !== "object" || Array.isArray(inputSchema33)) {
           throw new ExtAppsInvalidParamsError("Tool input schema must be a non-null object");
         }
         this.logger.verbose(`handleRegisterTool: name=${name33}`);
-        await this.context.registerTool(name33, description, inputSchema32);
+        await this.context.registerTool(name33, description, inputSchema33);
       }
       /**
        * Handle ui/unregisterTool - Unregister a widget-defined tool.
@@ -32127,19 +32261,31 @@ var init_handle_streamable_http_flow = __esm({
         const authorization = request[ServerRequestTokens.auth];
         const { token } = authorization;
         const logger = this.scopeLogger.child("handle:streamable-http:parseInput");
-        const sessionResolution = resolveStreamableHttpSession({
-          rawHeader: request.headers?.["mcp-session-id"],
-          authorizationSession: authorization.session,
-          createSession: () => {
-            const query = request.query;
-            const skillsOnlyMode = detectSkillsOnlyMode(query);
-            return createSessionId("streamable-http", token, {
-              userAgent: request.headers?.["user-agent"],
-              platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
-              skillsOnlyMode
-            });
+        const body = request.body;
+        const isInitialize2 = body?.method === "initialize";
+        const createSession = () => {
+          const query = request.query;
+          const skillsOnlyMode = detectSkillsOnlyMode(query);
+          return createSessionId("streamable-http", token, {
+            userAgent: request.headers?.["user-agent"],
+            platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
+            skillsOnlyMode
+          });
+        };
+        let sessionResolution;
+        if (isInitialize2) {
+          if (authorization.session?.id) {
+            sessionResolution = { session: authorization.session, createdNew: false, responded404: false };
+          } else {
+            sessionResolution = { session: createSession(), createdNew: true, responded404: false };
           }
-        });
+        } else {
+          sessionResolution = resolveStreamableHttpSession({
+            rawHeader: request.headers?.["mcp-session-id"],
+            authorizationSession: authorization.session,
+            createSession
+          });
+        }
         if (sessionResolution.responded404 || !sessionResolution.session) {
           logger.warn("parseInput: invalid mcp-session-id header");
           this.respond(httpRespond.sessionNotFound("invalid session id"));
@@ -32193,11 +32339,13 @@ var init_handle_streamable_http_flow = __esm({
           const authorization = request[ServerRequestTokens.auth];
           syncStreamableHttpAuthorizationSession(authorization, session);
           const transport = await transportService.createTransporter("streamable-http", token, session.id, response);
-          if (transport.isInitialized) {
+          const isReinitialize = !!request[ServerRequestTokens.reinitialize];
+          if (transport.isInitialized && isReinitialize) {
             logger.info("onInitialize: transport already initialized, resetting for re-initialization", {
               sessionId: session.id?.slice(0, 20)
             });
             transport.resetForReinitialization();
+            transport.reregisterServer();
           }
           logger.info("onInitialize: transport created, calling initialize");
           await transport.initialize(request, response);
@@ -33747,9 +33895,9 @@ var init_load_skill_flow = __esm({
             if (isAvailable && toolEntryByName) {
               const toolEntry = toolEntryByName.get(t.name);
               if (toolEntry) {
-                const inputSchema32 = toolEntry.getInputJsonSchema?.() ?? toolEntry.rawInputSchema;
-                if (inputSchema32) {
-                  result.inputSchema = inputSchema32;
+                const inputSchema33 = toolEntry.getInputJsonSchema?.() ?? toolEntry.rawInputSchema;
+                if (inputSchema33) {
+                  result.inputSchema = inputSchema33;
                 }
                 const rawOutput = toolEntry.getRawOutputSchema?.() ?? toolEntry.rawOutputSchema;
                 if (rawOutput) {
@@ -35173,15 +35321,161 @@ var init_load_skills_tool = __esm({
   }
 });
 
+// libs/sdk/src/skill/tools/read-skill-content.tool.ts
+function flattenFrontmatter(fm) {
+  const result = {};
+  for (const [key, value] of Object.entries(fm)) {
+    if (value !== void 0 && value !== null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var import_zod72, import_utils59, inputSchema27, outputSchema25, ReadSkillContentTool;
+var init_read_skill_content_tool = __esm({
+  "libs/sdk/src/skill/tools/read-skill-content.tool.ts"() {
+    "use strict";
+    import_zod72 = require("zod");
+    init_common();
+    import_utils59 = require("@frontmcp/utils");
+    init_skill_md_parser();
+    inputSchema27 = {
+      skillId: import_zod72.z.string().min(1).describe("ID or name of the skill (as returned by searchSkills or loadSkills)"),
+      type: import_zod72.z.enum(["reference", "example"]).describe("Type of content to read: reference or example"),
+      name: import_zod72.z.string().min(1).describe("Name of the reference or example to read (as shown in the routing table from loadSkills)")
+    };
+    outputSchema25 = {
+      skillId: import_zod72.z.string(),
+      skillName: import_zod72.z.string(),
+      type: import_zod72.z.enum(["reference", "example"]),
+      name: import_zod72.z.string(),
+      description: import_zod72.z.string(),
+      content: import_zod72.z.string().describe("Markdown body with frontmatter stripped"),
+      frontmatter: import_zod72.z.record(import_zod72.z.string(), import_zod72.z.unknown()).optional().describe("Parsed YAML frontmatter fields from the file"),
+      reference: import_zod72.z.string().optional().describe("Parent reference name (examples only)"),
+      level: import_zod72.z.string().optional().describe("Complexity level: basic, intermediate, or advanced (examples only)"),
+      available: import_zod72.z.array(import_zod72.z.string()).optional().describe("Available names for the requested type (included when the requested name is not found)")
+    };
+    ReadSkillContentTool = class extends ToolContext2 {
+      async execute(input) {
+        const skillRegistry = this.scope.skills;
+        if (!skillRegistry) {
+          this.fail(new Error("Skills are not available in this scope"));
+        }
+        const loadResult = await skillRegistry.loadSkill(input.skillId);
+        if (!loadResult) {
+          this.fail(new Error(`Skill "${input.skillId}" not found. Use searchSkills to discover available skills.`));
+        }
+        const { skill } = loadResult;
+        const entry = skillRegistry.findByName(input.skillId);
+        if (!entry) {
+          this.fail(new Error(`Skill "${input.skillId}" entry not found.`));
+        }
+        if (input.type === "reference") {
+          return this.readReference(input, skill, entry);
+        }
+        return this.readExample(input, skill, entry);
+      }
+      async readReference(input, skill, instance) {
+        const refs = skill.resolvedReferences ?? [];
+        const refEntry = refs.find((r) => r.name === input.name);
+        if (!refEntry) {
+          const availableNames = refs.map((r) => r.name);
+          return {
+            skillId: skill.id,
+            skillName: skill.name,
+            type: "reference",
+            name: input.name,
+            description: `Reference "${input.name}" not found.`,
+            content: availableNames.length > 0 ? `Reference "${input.name}" not found. Available references: ${availableNames.join(", ")}` : `Skill "${skill.name}" has no references.`,
+            available: availableNames
+          };
+        }
+        const content = await this.readFileContent(instance, "references", refEntry.filename);
+        const { frontmatter, body } = parseSkillMdFrontmatter(content);
+        return {
+          skillId: skill.id,
+          skillName: skill.name,
+          type: "reference",
+          name: refEntry.name,
+          description: refEntry.description,
+          content: body,
+          frontmatter: flattenFrontmatter(frontmatter)
+        };
+      }
+      async readExample(input, skill, instance) {
+        const examples = skill.resolvedExamples ?? [];
+        const exEntry = examples.find((e) => e.name === input.name);
+        if (!exEntry) {
+          const availableNames = examples.map((e) => e.name);
+          return {
+            skillId: skill.id,
+            skillName: skill.name,
+            type: "example",
+            name: input.name,
+            description: `Example "${input.name}" not found.`,
+            content: availableNames.length > 0 ? `Example "${input.name}" not found. Available examples: ${availableNames.join(", ")}` : `Skill "${skill.name}" has no examples.`,
+            available: availableNames
+          };
+        }
+        const content = await this.readFileContent(instance, "examples", exEntry.filename);
+        const { frontmatter, body } = parseSkillMdFrontmatter(content);
+        return {
+          skillId: skill.id,
+          skillName: skill.name,
+          type: "example",
+          name: exEntry.name,
+          description: exEntry.description,
+          content: body,
+          frontmatter: flattenFrontmatter(frontmatter),
+          reference: exEntry.reference,
+          level: exEntry.level
+        };
+      }
+      async readFileContent(instance, resourceType, filename) {
+        const baseDir = instance.getBaseDir();
+        const resources = instance.getResources();
+        const resourcePath = resources?.[resourceType];
+        if (!baseDir || !resourcePath) {
+          this.fail(new Error(`Skill does not have a ${resourceType} directory configured.`));
+        }
+        const resourceDir = resourcePath.startsWith("/") ? resourcePath : (0, import_utils59.pathResolve)(baseDir, resourcePath);
+        const filePath = (0, import_utils59.pathResolve)(resourceDir, filename);
+        try {
+          return await (0, import_utils59.readFile)(filePath, "utf-8");
+        } catch {
+          this.fail(
+            new Error(`Failed to read ${resourceType} file "${filename}". The file may have been moved or deleted.`)
+          );
+        }
+      }
+    };
+    ReadSkillContentTool = __decorateClass([
+      FrontMcpTool({
+        name: "readSkillContent",
+        description: 'Read the full content of a specific reference or example from a skill. After loading a skill with loadSkills, the instructions include routing tables listing available references and examples by name. Use this tool to read the complete content of any listed item.\n\n**When to use:**\n- After loadSkills shows a reference you need to read for detailed guidance\n- When you need a worked example for a specific scenario\n- When the routing table lists a topic you want to explore further\n\n**Example flow:**\n1. loadSkills({ skillIds: ["frontmcp-deployment"] }) \u2014 see routing table\n2. readSkillContent({ skillId: "frontmcp-deployment", type: "reference", name: "deploy-to-vercel" })\n3. readSkillContent({ skillId: "frontmcp-deployment", type: "example", name: "vercel-with-kv" })',
+        inputSchema: inputSchema27,
+        outputSchema: outputSchema25,
+        tags: ["skills", "references", "examples", "content"],
+        annotations: {
+          title: "Read Skill Content",
+          readOnlyHint: true
+        }
+      })
+    ], ReadSkillContentTool);
+  }
+});
+
 // libs/sdk/src/skill/tools/index.ts
 function getSkillTools() {
-  return [SearchSkillsTool, LoadSkillsTool];
+  return [SearchSkillsTool, LoadSkillsTool, ReadSkillContentTool];
 }
 var init_tools = __esm({
   "libs/sdk/src/skill/tools/index.ts"() {
     "use strict";
     init_search_skills_tool();
     init_load_skills_tool();
+    init_read_skill_content_tool();
   }
 });
 
@@ -35257,15 +35551,15 @@ var init_skill_session_types = __esm({
 });
 
 // libs/sdk/src/skill/session/skill-session.manager.ts
-var import_utils59, SkillSessionManager;
+var import_utils60, SkillSessionManager;
 var init_skill_session_manager = __esm({
   "libs/sdk/src/skill/session/skill-session.manager.ts"() {
     "use strict";
-    import_utils59 = require("@frontmcp/utils");
+    import_utils60 = require("@frontmcp/utils");
     init_skill_session_types();
     init_errors();
-    SkillSessionManager = class extends import_utils59.EventEmitter {
-      storage = new import_utils59.AsyncLocalStorage();
+    SkillSessionManager = class extends import_utils60.EventEmitter {
+      storage = new import_utils60.AsyncLocalStorage();
       options;
       logger;
       store;
@@ -36096,25 +36390,25 @@ var init_hooks = __esm({
 });
 
 // libs/sdk/src/logging/flows/set-level.flow.ts
-var import_zod72, import_protocol40, inputSchema27, outputSchema25, stateSchema26, plan27, name28, Stage28, SetLevelFlow;
+var import_zod73, import_protocol40, inputSchema28, outputSchema26, stateSchema26, plan27, name28, Stage28, SetLevelFlow;
 var init_set_level_flow = __esm({
   "libs/sdk/src/logging/flows/set-level.flow.ts"() {
     "use strict";
     init_common();
-    import_zod72 = require("zod");
+    import_zod73 = require("zod");
     import_protocol40 = require("@frontmcp/protocol");
     init_errors();
-    inputSchema27 = import_zod72.z.object({
+    inputSchema28 = import_zod73.z.object({
       request: import_protocol40.SetLevelRequestSchema,
-      ctx: import_zod72.z.unknown()
+      ctx: import_zod73.z.unknown()
     });
-    outputSchema25 = import_protocol40.EmptyResultSchema;
-    stateSchema26 = import_zod72.z.object({
-      input: import_zod72.z.object({
+    outputSchema26 = import_protocol40.EmptyResultSchema;
+    stateSchema26 = import_zod73.z.object({
+      input: import_zod73.z.object({
         level: import_protocol40.LoggingLevelSchema
       }),
-      sessionId: import_zod72.z.string(),
-      output: outputSchema25
+      sessionId: import_zod73.z.string(),
+      output: outputSchema26
     });
     plan27 = {
       pre: ["parseInput"],
@@ -36131,12 +36425,12 @@ var init_set_level_flow = __esm({
         let params;
         let ctx;
         try {
-          const inputData = inputSchema27.parse(this.rawInput);
+          const inputData = inputSchema28.parse(this.rawInput);
           method = inputData.request.method;
           params = inputData.request.params;
           ctx = inputData.ctx;
         } catch (e) {
-          throw new InvalidInputError("Invalid Input", e instanceof import_zod72.z.ZodError ? e.issues : void 0);
+          throw new InvalidInputError("Invalid Input", e instanceof import_zod73.z.ZodError ? e.issues : void 0);
         }
         if (method !== "logging/setLevel") {
           this.logger.warn(`parseInput: invalid method "${method}"`);
@@ -36182,8 +36476,8 @@ var init_set_level_flow = __esm({
       FrontMcpFlow({
         name: name28,
         plan: plan27,
-        inputSchema: inputSchema27,
-        outputSchema: outputSchema25,
+        inputSchema: inputSchema28,
+        outputSchema: outputSchema26,
         access: "authorized"
       })
     ], SetLevelFlow);
@@ -36191,35 +36485,35 @@ var init_set_level_flow = __esm({
 });
 
 // libs/sdk/src/completion/flows/complete.flow.ts
-var import_zod73, import_protocol41, inputSchema28, outputSchema26, PromptRefSchema, ResourceRefSchema, stateSchema27, plan28, name29, Stage29, CompleteFlow;
+var import_zod74, import_protocol41, inputSchema29, outputSchema27, PromptRefSchema, ResourceRefSchema, stateSchema27, plan28, name29, Stage29, CompleteFlow;
 var init_complete_flow = __esm({
   "libs/sdk/src/completion/flows/complete.flow.ts"() {
     "use strict";
     init_common();
-    import_zod73 = require("zod");
+    import_zod74 = require("zod");
     import_protocol41 = require("@frontmcp/protocol");
     init_errors();
     init_ui();
-    inputSchema28 = import_zod73.z.object({
+    inputSchema29 = import_zod74.z.object({
       request: import_protocol41.CompleteRequestSchema,
-      ctx: import_zod73.z.unknown()
+      ctx: import_zod74.z.unknown()
     });
-    outputSchema26 = import_protocol41.CompleteResultSchema;
-    PromptRefSchema = import_zod73.z.object({
-      type: import_zod73.z.literal("ref/prompt"),
-      name: import_zod73.z.string()
+    outputSchema27 = import_protocol41.CompleteResultSchema;
+    PromptRefSchema = import_zod74.z.object({
+      type: import_zod74.z.literal("ref/prompt"),
+      name: import_zod74.z.string()
     });
-    ResourceRefSchema = import_zod73.z.object({
-      type: import_zod73.z.literal("ref/resource"),
-      uri: import_zod73.z.string()
+    ResourceRefSchema = import_zod74.z.object({
+      type: import_zod74.z.literal("ref/resource"),
+      uri: import_zod74.z.string()
     });
-    stateSchema27 = import_zod73.z.object({
-      ref: import_zod73.z.discriminatedUnion("type", [PromptRefSchema, ResourceRefSchema]),
-      argument: import_zod73.z.object({
-        name: import_zod73.z.string(),
-        value: import_zod73.z.string()
+    stateSchema27 = import_zod74.z.object({
+      ref: import_zod74.z.discriminatedUnion("type", [PromptRefSchema, ResourceRefSchema]),
+      argument: import_zod74.z.object({
+        name: import_zod74.z.string(),
+        value: import_zod74.z.string()
       }),
-      output: outputSchema26
+      output: outputSchema27
     });
     plan28 = {
       pre: ["parseInput"],
@@ -36235,11 +36529,11 @@ var init_complete_flow = __esm({
         let method;
         let params;
         try {
-          const inputData = inputSchema28.parse(this.rawInput);
+          const inputData = inputSchema29.parse(this.rawInput);
           method = inputData.request.method;
           params = inputData.request.params;
         } catch (e) {
-          throw new InvalidInputError("Invalid Input", e instanceof import_zod73.z.ZodError ? e.issues : void 0);
+          throw new InvalidInputError("Invalid Input", e instanceof import_zod74.z.ZodError ? e.issues : void 0);
         }
         if (method !== "completion/complete") {
           this.logger.warn(`parseInput: invalid method "${method}"`);
@@ -36353,8 +36647,8 @@ var init_complete_flow = __esm({
       FrontMcpFlow({
         name: name29,
         plan: plan28,
-        inputSchema: inputSchema28,
-        outputSchema: outputSchema26,
+        inputSchema: inputSchema29,
+        outputSchema: outputSchema27,
         access: "authorized"
       })
     ], CompleteFlow);
@@ -36362,50 +36656,50 @@ var init_complete_flow = __esm({
 });
 
 // libs/sdk/src/agent/flows/call-agent.flow.ts
-var import_zod74, import_protocol42, import_guard5, inputSchema29, outputSchema27, stateSchema28, plan29, name30, Stage30, CallAgentFlow;
+var import_zod75, import_protocol42, import_guard5, inputSchema30, outputSchema28, stateSchema28, plan29, name30, Stage30, CallAgentFlow;
 var init_call_agent_flow = __esm({
   "libs/sdk/src/agent/flows/call-agent.flow.ts"() {
     "use strict";
     init_common();
-    import_zod74 = require("zod");
+    import_zod75 = require("zod");
     import_protocol42 = require("@frontmcp/protocol");
     init_errors();
     import_guard5 = require("@frontmcp/guard");
-    inputSchema29 = import_zod74.z.object({
+    inputSchema30 = import_zod75.z.object({
       request: import_protocol42.CallToolRequestSchema,
       // z.any() used because ctx is the MCP SDK's ToolCallExtra type which varies by SDK version
-      ctx: import_zod74.z.any()
+      ctx: import_zod75.z.any()
     });
-    outputSchema27 = import_protocol42.CallToolResultSchema;
-    stateSchema28 = import_zod74.z.object({
-      input: import_zod74.z.looseObject({
-        name: import_zod74.z.string().min(1).max(128),
-        arguments: import_zod74.z.looseObject({}).optional()
+    outputSchema28 = import_protocol42.CallToolResultSchema;
+    stateSchema28 = import_zod75.z.object({
+      input: import_zod75.z.looseObject({
+        name: import_zod75.z.string().min(1).max(128),
+        arguments: import_zod75.z.looseObject({}).optional()
       }),
-      authInfo: import_zod74.z.any().optional(),
-      agent: import_zod74.z.instanceof(AgentEntry),
-      agentContext: import_zod74.z.instanceof(AgentContext),
+      authInfo: import_zod75.z.any().optional(),
+      agent: import_zod75.z.instanceof(AgentEntry),
+      agentContext: import_zod75.z.instanceof(AgentContext),
       // Store the raw executed output for plugins to see
-      rawOutput: import_zod74.z.any().optional(),
-      output: outputSchema27,
+      rawOutput: import_zod75.z.any().optional(),
+      output: outputSchema28,
       // Agent owner ID for hook filtering (set during parseInput)
-      _agentOwnerId: import_zod74.z.string().optional(),
+      _agentOwnerId: import_zod75.z.string().optional(),
       // Progress token from request's _meta (for progress notifications)
-      progressToken: import_zod74.z.union([import_zod74.z.string(), import_zod74.z.number()]).optional(),
+      progressToken: import_zod75.z.union([import_zod75.z.string(), import_zod75.z.number()]).optional(),
       // JSON-RPC request ID (for elicitation routing)
-      jsonRpcRequestId: import_zod74.z.union([import_zod74.z.string(), import_zod74.z.number()]).optional(),
+      jsonRpcRequestId: import_zod75.z.union([import_zod75.z.string(), import_zod75.z.number()]).optional(),
       // Execution metadata
-      executionMeta: import_zod74.z.object({
-        iterations: import_zod74.z.number().optional(),
-        durationMs: import_zod74.z.number().optional(),
-        usage: import_zod74.z.object({
-          promptTokens: import_zod74.z.number().optional(),
-          completionTokens: import_zod74.z.number().optional(),
-          totalTokens: import_zod74.z.number().optional()
+      executionMeta: import_zod75.z.object({
+        iterations: import_zod75.z.number().optional(),
+        durationMs: import_zod75.z.number().optional(),
+        usage: import_zod75.z.object({
+          promptTokens: import_zod75.z.number().optional(),
+          completionTokens: import_zod75.z.number().optional(),
+          totalTokens: import_zod75.z.number().optional()
         }).optional()
       }).optional(),
       // Semaphore ticket for concurrency control (set by acquireSemaphore, used by releaseSemaphore)
-      semaphoreTicket: import_zod74.z.any().optional()
+      semaphoreTicket: import_zod75.z.any().optional()
     });
     plan29 = {
       pre: ["parseInput", "findAgent", "checkAgentAuthorization", "createAgentContext", "acquireQuota", "acquireSemaphore"],
@@ -36422,12 +36716,12 @@ var init_call_agent_flow = __esm({
         let params;
         let ctx;
         try {
-          const inputData = inputSchema29.parse(this.rawInput);
+          const inputData = inputSchema30.parse(this.rawInput);
           method = inputData.request.method;
           params = inputData.request.params;
           ctx = inputData.ctx;
         } catch (e) {
-          throw new InvalidInputError("Invalid Input", e instanceof import_zod74.z.ZodError ? e.issues : void 0);
+          throw new InvalidInputError("Invalid Input", e instanceof import_zod75.z.ZodError ? e.issues : void 0);
         }
         if (method !== "tools/call") {
           this.logger.warn(`parseInput: invalid method "${method}"`);
@@ -36609,7 +36903,7 @@ var init_call_agent_flow = __esm({
           agentContext.input = agent.parseInput(input);
           this.logger.verbose("validateInput:done");
         } catch (err) {
-          if (err instanceof import_zod74.z.ZodError) {
+          if (err instanceof import_zod75.z.ZodError) {
             throw new InvalidInputError("Invalid agent input", err.issues);
           }
           this.logger.error("validateInput: failed to parse input", err);
@@ -36769,8 +37063,8 @@ var init_call_agent_flow = __esm({
       FrontMcpFlow({
         name: name30,
         plan: plan29,
-        inputSchema: inputSchema29,
-        outputSchema: outputSchema27,
+        inputSchema: inputSchema30,
+        outputSchema: outputSchema28,
         access: "authorized"
       })
     ], CallAgentFlow);
@@ -36778,58 +37072,58 @@ var init_call_agent_flow = __esm({
 });
 
 // libs/sdk/src/elicitation/flows/elicitation-request.flow.ts
-var import_zod75, import_utils60, inputSchema30, outputSchema28, stateSchema29, plan30, name31, Stage31, ElicitationRequestFlow;
+var import_zod76, import_utils61, inputSchema31, outputSchema29, 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_utils60 = require("@frontmcp/utils");
+    import_zod76 = require("zod");
+    import_utils61 = require("@frontmcp/utils");
     init_errors();
     init_elicitation_types();
-    inputSchema30 = import_zod75.z.object({
+    inputSchema31 = import_zod76.z.object({
       /** Related request ID from the transport */
-      relatedRequestId: import_zod75.z.union([import_zod75.z.string(), import_zod75.z.number()]),
+      relatedRequestId: import_zod76.z.union([import_zod76.z.string(), import_zod76.z.number()]),
       /** Session ID for the elicitation */
-      sessionId: import_zod75.z.string(),
+      sessionId: import_zod76.z.string(),
       /** Message to display to the user */
-      message: import_zod75.z.string(),
+      message: import_zod76.z.string(),
       /** JSON Schema for the expected response (already converted from Zod) */
-      requestedSchema: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.unknown()),
+      requestedSchema: import_zod76.z.record(import_zod76.z.string(), import_zod76.z.unknown()),
       /** Elicitation options */
-      options: import_zod75.z.object({
-        mode: import_zod75.z.enum(["form", "url"]).optional(),
-        ttl: import_zod75.z.number().optional(),
-        elicitationId: import_zod75.z.string().optional()
+      options: import_zod76.z.object({
+        mode: import_zod76.z.enum(["form", "url"]).optional(),
+        ttl: import_zod76.z.number().optional(),
+        elicitationId: import_zod76.z.string().optional()
       }).optional()
     });
-    outputSchema28 = import_zod75.z.object({
+    outputSchema29 = import_zod76.z.object({
       /** Generated or provided elicit ID */
-      elicitId: import_zod75.z.string(),
+      elicitId: import_zod76.z.string(),
       /** Session ID */
-      sessionId: import_zod75.z.string(),
+      sessionId: import_zod76.z.string(),
       /** Expiration timestamp */
-      expiresAt: import_zod75.z.number(),
+      expiresAt: import_zod76.z.number(),
       /** Elicitation mode */
-      mode: import_zod75.z.enum(["form", "url"]),
+      mode: import_zod76.z.enum(["form", "url"]),
       /** Request parameters to send to client */
-      requestParams: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.unknown()),
+      requestParams: import_zod76.z.record(import_zod76.z.string(), import_zod76.z.unknown()),
       /** The pending record that was stored */
-      pendingRecord: import_zod75.z.any()
+      pendingRecord: import_zod76.z.any()
     });
-    stateSchema29 = import_zod75.z.object({
-      relatedRequestId: import_zod75.z.union([import_zod75.z.string(), import_zod75.z.number()]),
-      sessionId: import_zod75.z.string(),
-      message: import_zod75.z.string(),
-      requestedSchema: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.unknown()),
-      mode: import_zod75.z.enum(["form", "url"]).default("form"),
-      ttl: import_zod75.z.number().default(DEFAULT_ELICIT_TTL),
-      elicitationId: import_zod75.z.string().optional(),
-      elicitId: import_zod75.z.string(),
-      expiresAt: import_zod75.z.number(),
-      pendingRecord: import_zod75.z.any().optional(),
-      requestParams: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.unknown()).optional(),
-      output: outputSchema28.optional()
+    stateSchema29 = import_zod76.z.object({
+      relatedRequestId: import_zod76.z.union([import_zod76.z.string(), import_zod76.z.number()]),
+      sessionId: import_zod76.z.string(),
+      message: import_zod76.z.string(),
+      requestedSchema: import_zod76.z.record(import_zod76.z.string(), import_zod76.z.unknown()),
+      mode: import_zod76.z.enum(["form", "url"]).default("form"),
+      ttl: import_zod76.z.number().default(DEFAULT_ELICIT_TTL),
+      elicitationId: import_zod76.z.string().optional(),
+      elicitId: import_zod76.z.string(),
+      expiresAt: import_zod76.z.number(),
+      pendingRecord: import_zod76.z.any().optional(),
+      requestParams: import_zod76.z.record(import_zod76.z.string(), import_zod76.z.unknown()).optional(),
+      output: outputSchema29.optional()
     });
     plan30 = {
       pre: ["parseInput", "validateRequest"],
@@ -36842,7 +37136,7 @@ var init_elicitation_request_flow = __esm({
       logger = this.scopeLogger.child("ElicitationRequestFlow");
       async parseInput() {
         this.logger.verbose("parseInput:start");
-        const input = inputSchema30.parse(this.rawInput);
+        const input = inputSchema31.parse(this.rawInput);
         const { mode = "form", ttl = DEFAULT_ELICIT_TTL, elicitationId } = input.options ?? {};
         this.state.set({
           relatedRequestId: input.relatedRequestId,
@@ -36866,7 +37160,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_utils60.randomUUID)()}`;
+        const elicitId = elicitationId ?? `elicit-${(0, import_utils61.randomUUID)()}`;
         const expiresAt = Date.now() + (ttl ?? DEFAULT_ELICIT_TTL);
         this.state.set({ elicitId, expiresAt });
         this.logger.verbose("generateElicitId:done", { elicitId });
@@ -36946,8 +37240,8 @@ var init_elicitation_request_flow = __esm({
       FrontMcpFlow({
         name: name31,
         plan: plan30,
-        inputSchema: inputSchema30,
-        outputSchema: outputSchema28,
+        inputSchema: inputSchema31,
+        outputSchema: outputSchema29,
         access: "authorized"
       })
     ], ElicitationRequestFlow);
@@ -36955,39 +37249,39 @@ var init_elicitation_request_flow = __esm({
 });
 
 // libs/sdk/src/elicitation/flows/elicitation-result.flow.ts
-var import_zod76, inputSchema31, outputSchema29, stateSchema30, plan31, name32, Stage32, ElicitationResultFlow;
+var import_zod77, inputSchema32, outputSchema30, stateSchema30, plan31, name32, Stage32, ElicitationResultFlow;
 var init_elicitation_result_flow = __esm({
   "libs/sdk/src/elicitation/flows/elicitation-result.flow.ts"() {
     "use strict";
     init_common();
-    import_zod76 = require("zod");
+    import_zod77 = require("zod");
     init_errors();
     init_helpers();
-    inputSchema31 = import_zod76.z.object({
+    inputSchema32 = import_zod77.z.object({
       /** Session ID for the elicitation */
-      sessionId: import_zod76.z.string(),
+      sessionId: import_zod77.z.string(),
       /** The result from the client */
-      result: import_zod76.z.object({
-        action: import_zod76.z.enum(["accept", "cancel", "decline"]),
-        content: import_zod76.z.unknown().optional()
+      result: import_zod77.z.object({
+        action: import_zod77.z.enum(["accept", "cancel", "decline"]),
+        content: import_zod77.z.unknown().optional()
       })
     });
-    outputSchema29 = import_zod76.z.object({
+    outputSchema30 = import_zod77.z.object({
       /** Whether the result was handled */
-      handled: import_zod76.z.boolean(),
+      handled: import_zod77.z.boolean(),
       /** The elicit ID (if pending was found) */
-      elicitId: import_zod76.z.string().optional(),
+      elicitId: import_zod77.z.string().optional(),
       /** The processed result */
-      result: import_zod76.z.any().optional()
+      result: import_zod77.z.any().optional()
     });
-    stateSchema30 = import_zod76.z.object({
-      sessionId: import_zod76.z.string(),
-      action: import_zod76.z.enum(["accept", "cancel", "decline"]),
-      content: import_zod76.z.unknown().optional(),
-      pendingRecord: import_zod76.z.any().optional(),
-      elicitResult: import_zod76.z.any().optional(),
-      handled: import_zod76.z.boolean().default(false),
-      output: outputSchema29.optional()
+    stateSchema30 = import_zod77.z.object({
+      sessionId: import_zod77.z.string(),
+      action: import_zod77.z.enum(["accept", "cancel", "decline"]),
+      content: import_zod77.z.unknown().optional(),
+      pendingRecord: import_zod77.z.any().optional(),
+      elicitResult: import_zod77.z.any().optional(),
+      handled: import_zod77.z.boolean().default(false),
+      output: outputSchema30.optional()
     });
     plan31 = {
       pre: ["parseInput"],
@@ -37000,7 +37294,7 @@ var init_elicitation_result_flow = __esm({
       logger = this.scopeLogger.child("ElicitationResultFlow");
       async parseInput() {
         this.logger.verbose("parseInput:start");
-        const input = inputSchema31.parse(this.rawInput);
+        const input = inputSchema32.parse(this.rawInput);
         this.state.set({
           sessionId: input.sessionId,
           action: input.result.action,
@@ -37124,8 +37418,8 @@ var init_elicitation_result_flow = __esm({
       FrontMcpFlow({
         name: name32,
         plan: plan31,
-        inputSchema: inputSchema31,
-        outputSchema: outputSchema29,
+        inputSchema: inputSchema32,
+        outputSchema: outputSchema30,
         access: "authorized"
       })
     ], ElicitationResultFlow);
@@ -37174,30 +37468,30 @@ var require_dist = __commonJS({
       sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema
     });
     module2.exports = __toCommonJS2(index_exports2);
-    var import_utils77 = require("@frontmcp/utils");
+    var import_utils78 = 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_utils77.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
+      return (0, import_utils78.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
     }
     var SEPARATOR = ":";
     function encryptValue(key, plaintext) {
-      const iv = (0, import_utils77.randomBytes)(12);
+      const iv = (0, import_utils78.randomBytes)(12);
       const plaintextBytes = new TextEncoder().encode(plaintext);
-      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);
+      const { ciphertext, tag } = (0, import_utils78.encryptAesGcm)(key, plaintextBytes, iv);
+      return [(0, import_utils78.base64urlEncode)(iv), (0, import_utils78.base64urlEncode)(tag), (0, import_utils78.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_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);
+      const iv = (0, import_utils78.base64urlDecode)(parts[0]);
+      const tag = (0, import_utils78.base64urlDecode)(parts[1]);
+      const ciphertext = (0, import_utils78.base64urlDecode)(parts[2]);
+      const plaintext = (0, import_utils78.decryptAesGcm)(key, ciphertext, iv, tag);
       return new TextDecoder().decode(plaintext);
     }
     var SqliteKvStore = class {
@@ -37669,14 +37963,14 @@ var require_dist = __commonJS({
         return row.count;
       }
     };
-    var import_zod91 = require("zod");
-    var sqliteStorageOptionsSchema = import_zod91.z.object({
-      path: import_zod91.z.string().min(1),
-      encryption: import_zod91.z.object({
-        secret: import_zod91.z.string().min(1)
+    var import_zod92 = require("zod");
+    var sqliteStorageOptionsSchema = import_zod92.z.object({
+      path: import_zod92.z.string().min(1),
+      encryption: import_zod92.z.object({
+        secret: import_zod92.z.string().min(1)
       }).optional(),
-      ttlCleanupIntervalMs: import_zod91.z.number().int().nonnegative().optional().default(6e4),
-      walMode: import_zod91.z.boolean().optional().default(true)
+      ttlCleanupIntervalMs: import_zod92.z.number().int().nonnegative().optional().default(6e4),
+      walMode: import_zod92.z.boolean().optional().default(true)
     });
   }
 });
@@ -38321,12 +38615,12 @@ var init_records = __esm({
 });
 
 // libs/sdk/src/common/entries/job.entry.ts
-var import_zod77, import_v47, JobEntry;
+var import_zod78, import_v47, JobEntry;
 var init_job_entry = __esm({
   "libs/sdk/src/common/entries/job.entry.ts"() {
     "use strict";
     init_base_entry();
-    import_zod77 = require("zod");
+    import_zod78 = require("zod");
     import_v47 = require("zod/v4");
     JobEntry = class extends BaseEntry {
       owner;
@@ -38352,7 +38646,7 @@ var init_job_entry = __esm({
       getInputJsonSchema() {
         if (this.inputSchema && Object.keys(this.inputSchema).length > 0) {
           try {
-            return (0, import_v47.toJSONSchema)(import_zod77.z.object(this.inputSchema));
+            return (0, import_v47.toJSONSchema)(import_zod78.z.object(this.inputSchema));
           } catch {
             return { type: "object", properties: {} };
           }
@@ -38366,11 +38660,11 @@ var init_job_entry = __esm({
         const outSchema = this.outputSchema;
         if (!outSchema) return null;
         try {
-          if (outSchema instanceof import_zod77.z.ZodType) {
+          if (outSchema instanceof import_zod78.z.ZodType) {
             return (0, import_v47.toJSONSchema)(outSchema);
           }
           if (outSchema && typeof outSchema === "object") {
-            return (0, import_v47.toJSONSchema)(import_zod77.z.object(outSchema));
+            return (0, import_v47.toJSONSchema)(import_zod78.z.object(outSchema));
           }
         } catch {
           return { type: "object", properties: {} };
@@ -38450,13 +38744,13 @@ var init_job_interface = __esm({
 });
 
 // libs/sdk/src/job/job.instance.ts
-var import_zod78, JobInstance, FunctionJobContext;
+var import_zod79, JobInstance, FunctionJobContext;
 var init_job_instance = __esm({
   "libs/sdk/src/job/job.instance.ts"() {
     "use strict";
     init_job_entry();
     init_job_interface();
-    import_zod78 = require("zod");
+    import_zod79 = require("zod");
     init_hooks_utils();
     init_mcp_error();
     init_errors();
@@ -38528,17 +38822,17 @@ var init_job_instance = __esm({
         }
       }
       parseInput(input) {
-        const inputSchema32 = import_zod78.z.object(this.inputSchema);
-        return inputSchema32.parse(input);
+        const inputSchema33 = import_zod79.z.object(this.inputSchema);
+        return inputSchema33.parse(input);
       }
       parseOutput(raw) {
         if (this.outputSchema) {
           const outSchema = this.outputSchema;
-          if (outSchema instanceof import_zod78.z.ZodType) {
+          if (outSchema instanceof import_zod79.z.ZodType) {
             return outSchema.parse(raw);
           }
           if (typeof outSchema === "object" && outSchema !== null) {
-            return import_zod78.z.object(outSchema).parse(raw);
+            return import_zod79.z.object(outSchema).parse(raw);
           }
         }
         return raw;
@@ -39294,11 +39588,11 @@ var init_workflow_engine = __esm({
 });
 
 // libs/sdk/src/job/execution/job-execution.manager.ts
-var import_utils61, JobExecutionManager;
+var import_utils62, JobExecutionManager;
 var init_job_execution_manager = __esm({
   "libs/sdk/src/job/execution/job-execution.manager.ts"() {
     "use strict";
-    import_utils61 = require("@frontmcp/utils");
+    import_utils62 = require("@frontmcp/utils");
     init_workflow_engine();
     JobExecutionManager = class {
       stateStore;
@@ -39313,7 +39607,7 @@ var init_job_execution_manager = __esm({
        * Execute a job inline (synchronous) or in background.
        */
       async executeJob(job, input, opts = {}) {
-        const runId = (0, import_utils61.randomUUID)();
+        const runId = (0, import_utils62.randomUUID)();
         const retryConfig = job.metadata.retry ?? {};
         const maxAttempts = retryConfig.maxAttempts ?? 1;
         const runRecord = {
@@ -39351,7 +39645,7 @@ var init_job_execution_manager = __esm({
        * Execute a workflow inline or in background.
        */
       async executeWorkflow(workflow, jobRegistry, opts = {}) {
-        const runId = (0, import_utils61.randomUUID)();
+        const runId = (0, import_utils62.randomUUID)();
         const runRecord = {
           runId,
           jobId: workflow.metadata.id ?? workflow.name,
@@ -39870,11 +40164,11 @@ var init_job_definition_store_factory = __esm({
 });
 
 // libs/sdk/src/job/tools/list-jobs.tool.ts
-var import_zod79, ListJobsTool;
+var import_zod80, ListJobsTool;
 var init_list_jobs_tool = __esm({
   "libs/sdk/src/job/tools/list-jobs.tool.ts"() {
     "use strict";
-    import_zod79 = require("zod");
+    import_zod80 = require("zod");
     init_common();
     ListJobsTool = class extends ToolContext2 {
       async execute(input) {
@@ -39904,21 +40198,21 @@ var init_list_jobs_tool = __esm({
         name: "list-jobs",
         description: "List registered jobs with optional filtering by tags or labels.",
         inputSchema: {
-          tags: import_zod79.z.array(import_zod79.z.string()).optional().describe("Filter by tags"),
-          labels: import_zod79.z.record(import_zod79.z.string(), import_zod79.z.string()).optional().describe("Filter by labels"),
-          query: import_zod79.z.string().optional().describe("Search query for name/description")
+          tags: import_zod80.z.array(import_zod80.z.string()).optional().describe("Filter by tags"),
+          labels: import_zod80.z.record(import_zod80.z.string(), import_zod80.z.string()).optional().describe("Filter by labels"),
+          query: import_zod80.z.string().optional().describe("Search query for name/description")
         },
         outputSchema: {
-          jobs: import_zod79.z.array(
-            import_zod79.z.object({
-              name: import_zod79.z.string(),
-              description: import_zod79.z.string().optional(),
-              tags: import_zod79.z.array(import_zod79.z.string()).optional(),
-              labels: import_zod79.z.record(import_zod79.z.string(), import_zod79.z.string()).optional(),
-              inputSchema: import_zod79.z.record(import_zod79.z.string(), import_zod79.z.unknown()).optional()
+          jobs: import_zod80.z.array(
+            import_zod80.z.object({
+              name: import_zod80.z.string(),
+              description: import_zod80.z.string().optional(),
+              tags: import_zod80.z.array(import_zod80.z.string()).optional(),
+              labels: import_zod80.z.record(import_zod80.z.string(), import_zod80.z.string()).optional(),
+              inputSchema: import_zod80.z.record(import_zod80.z.string(), import_zod80.z.unknown()).optional()
             })
           ),
-          count: import_zod79.z.number()
+          count: import_zod80.z.number()
         },
         hideFromDiscovery: true
       })
@@ -39927,11 +40221,11 @@ var init_list_jobs_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/execute-job.tool.ts
-var import_zod80, ExecuteJobTool;
+var import_zod81, ExecuteJobTool;
 var init_execute_job_tool = __esm({
   "libs/sdk/src/job/tools/execute-job.tool.ts"() {
     "use strict";
-    import_zod80 = require("zod");
+    import_zod81 = require("zod");
     init_common();
     ExecuteJobTool = class extends ToolContext2 {
       async execute(input) {
@@ -39958,15 +40252,15 @@ var init_execute_job_tool = __esm({
         name: "execute-job",
         description: "Execute a registered job by name. Supports inline (synchronous) and background execution.",
         inputSchema: {
-          name: import_zod80.z.string().describe("Job name to execute"),
-          input: import_zod80.z.record(import_zod80.z.string(), import_zod80.z.unknown()).optional().describe("Job input data"),
-          background: import_zod80.z.boolean().optional().default(false).describe("Run in background (returns runId for status polling)")
+          name: import_zod81.z.string().describe("Job name to execute"),
+          input: import_zod81.z.record(import_zod81.z.string(), import_zod81.z.unknown()).optional().describe("Job input data"),
+          background: import_zod81.z.boolean().optional().default(false).describe("Run in background (returns runId for status polling)")
         },
         outputSchema: {
-          runId: import_zod80.z.string(),
-          state: import_zod80.z.string(),
-          result: import_zod80.z.unknown().optional(),
-          logs: import_zod80.z.array(import_zod80.z.string()).optional()
+          runId: import_zod81.z.string(),
+          state: import_zod81.z.string(),
+          result: import_zod81.z.unknown().optional(),
+          logs: import_zod81.z.array(import_zod81.z.string()).optional()
         }
       })
     ], ExecuteJobTool);
@@ -39974,11 +40268,11 @@ var init_execute_job_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/get-job-status.tool.ts
-var import_zod81, GetJobStatusTool;
+var import_zod82, GetJobStatusTool;
 var init_get_job_status_tool = __esm({
   "libs/sdk/src/job/tools/get-job-status.tool.ts"() {
     "use strict";
-    import_zod81 = require("zod");
+    import_zod82 = require("zod");
     init_common();
     init_errors();
     GetJobStatusTool = class extends ToolContext2 {
@@ -40010,21 +40304,21 @@ var init_get_job_status_tool = __esm({
         name: "get-job-status",
         description: "Get the execution status of a job run by runId.",
         inputSchema: {
-          runId: import_zod81.z.string().describe("Run ID returned from execute-job or execute-workflow")
+          runId: import_zod82.z.string().describe("Run ID returned from execute-job or execute-workflow")
         },
         outputSchema: {
-          runId: import_zod81.z.string(),
-          jobName: import_zod81.z.string(),
-          state: import_zod81.z.string(),
-          result: import_zod81.z.unknown().optional(),
-          error: import_zod81.z.object({
-            message: import_zod81.z.string(),
-            name: import_zod81.z.string()
+          runId: import_zod82.z.string(),
+          jobName: import_zod82.z.string(),
+          state: import_zod82.z.string(),
+          result: import_zod82.z.unknown().optional(),
+          error: import_zod82.z.object({
+            message: import_zod82.z.string(),
+            name: import_zod82.z.string()
           }).optional(),
-          startedAt: import_zod81.z.number(),
-          completedAt: import_zod81.z.number().optional(),
-          attempt: import_zod81.z.number(),
-          logs: import_zod81.z.array(import_zod81.z.string())
+          startedAt: import_zod82.z.number(),
+          completedAt: import_zod82.z.number().optional(),
+          attempt: import_zod82.z.number(),
+          logs: import_zod82.z.array(import_zod82.z.string())
         }
       })
     ], GetJobStatusTool);
@@ -40032,11 +40326,11 @@ var init_get_job_status_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/register-job.tool.ts
-var import_zod82, RegisterJobTool;
+var import_zod83, RegisterJobTool;
 var init_register_job_tool = __esm({
   "libs/sdk/src/job/tools/register-job.tool.ts"() {
     "use strict";
-    import_zod82 = require("zod");
+    import_zod83 = require("zod");
     init_common();
     RegisterJobTool = class extends ToolContext2 {
       async execute(input) {
@@ -40073,16 +40367,16 @@ var init_register_job_tool = __esm({
         name: "register-job",
         description: "Register a dynamic job that runs in a sandboxed environment.",
         inputSchema: {
-          name: import_zod82.z.string().describe("Job name"),
-          description: import_zod82.z.string().optional().describe("Job description"),
-          script: import_zod82.z.string().describe("JavaScript source code for the job"),
-          inputSchema: import_zod82.z.record(import_zod82.z.string(), import_zod82.z.unknown()).optional().describe("JSON Schema for input"),
-          outputSchema: import_zod82.z.record(import_zod82.z.string(), import_zod82.z.unknown()).optional().describe("JSON Schema for output"),
-          tags: import_zod82.z.array(import_zod82.z.string()).optional().describe("Tags for categorization")
+          name: import_zod83.z.string().describe("Job name"),
+          description: import_zod83.z.string().optional().describe("Job description"),
+          script: import_zod83.z.string().describe("JavaScript source code for the job"),
+          inputSchema: import_zod83.z.record(import_zod83.z.string(), import_zod83.z.unknown()).optional().describe("JSON Schema for input"),
+          outputSchema: import_zod83.z.record(import_zod83.z.string(), import_zod83.z.unknown()).optional().describe("JSON Schema for output"),
+          tags: import_zod83.z.array(import_zod83.z.string()).optional().describe("Tags for categorization")
         },
         outputSchema: {
-          success: import_zod82.z.boolean(),
-          jobId: import_zod82.z.string()
+          success: import_zod83.z.boolean(),
+          jobId: import_zod83.z.string()
         },
         hideFromDiscovery: true
       })
@@ -40091,11 +40385,11 @@ var init_register_job_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/remove-job.tool.ts
-var import_zod83, RemoveJobTool;
+var import_zod84, RemoveJobTool;
 var init_remove_job_tool = __esm({
   "libs/sdk/src/job/tools/remove-job.tool.ts"() {
     "use strict";
-    import_zod83 = require("zod");
+    import_zod84 = require("zod");
     init_common();
     RemoveJobTool = class extends ToolContext2 {
       async execute(input) {
@@ -40123,11 +40417,11 @@ var init_remove_job_tool = __esm({
         name: "remove-job",
         description: "Remove a dynamic job by name.",
         inputSchema: {
-          name: import_zod83.z.string().describe("Job name to remove")
+          name: import_zod84.z.string().describe("Job name to remove")
         },
         outputSchema: {
-          success: import_zod83.z.boolean(),
-          message: import_zod83.z.string()
+          success: import_zod84.z.boolean(),
+          message: import_zod84.z.string()
         },
         hideFromDiscovery: true
       })
@@ -40136,11 +40430,11 @@ var init_remove_job_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/list-workflows.tool.ts
-var import_zod84, ListWorkflowsTool;
+var import_zod85, ListWorkflowsTool;
 var init_list_workflows_tool = __esm({
   "libs/sdk/src/workflow/tools/list-workflows.tool.ts"() {
     "use strict";
-    import_zod84 = require("zod");
+    import_zod85 = require("zod");
     init_common();
     ListWorkflowsTool = class extends ToolContext2 {
       async execute(input) {
@@ -40171,21 +40465,21 @@ var init_list_workflows_tool = __esm({
         name: "list-workflows",
         description: "List registered workflows with optional filtering by tags or labels.",
         inputSchema: {
-          tags: import_zod84.z.array(import_zod84.z.string()).optional().describe("Filter by tags"),
-          labels: import_zod84.z.record(import_zod84.z.string(), import_zod84.z.string()).optional().describe("Filter by labels"),
-          query: import_zod84.z.string().optional().describe("Search query for name/description")
+          tags: import_zod85.z.array(import_zod85.z.string()).optional().describe("Filter by tags"),
+          labels: import_zod85.z.record(import_zod85.z.string(), import_zod85.z.string()).optional().describe("Filter by labels"),
+          query: import_zod85.z.string().optional().describe("Search query for name/description")
         },
         outputSchema: {
-          workflows: import_zod84.z.array(
-            import_zod84.z.object({
-              name: import_zod84.z.string(),
-              description: import_zod84.z.string().optional(),
-              trigger: import_zod84.z.string(),
-              stepCount: import_zod84.z.number(),
-              tags: import_zod84.z.array(import_zod84.z.string()).optional()
+          workflows: import_zod85.z.array(
+            import_zod85.z.object({
+              name: import_zod85.z.string(),
+              description: import_zod85.z.string().optional(),
+              trigger: import_zod85.z.string(),
+              stepCount: import_zod85.z.number(),
+              tags: import_zod85.z.array(import_zod85.z.string()).optional()
             })
           ),
-          count: import_zod84.z.number()
+          count: import_zod85.z.number()
         },
         hideFromDiscovery: true
       })
@@ -40194,11 +40488,11 @@ var init_list_workflows_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/execute-workflow.tool.ts
-var import_zod85, ExecuteWorkflowTool;
+var import_zod86, ExecuteWorkflowTool;
 var init_execute_workflow_tool = __esm({
   "libs/sdk/src/workflow/tools/execute-workflow.tool.ts"() {
     "use strict";
-    import_zod85 = require("zod");
+    import_zod86 = require("zod");
     init_common();
     ExecuteWorkflowTool = class extends ToolContext2 {
       async execute(input) {
@@ -40227,14 +40521,14 @@ var init_execute_workflow_tool = __esm({
         name: "execute-workflow",
         description: "Execute a registered workflow by name. Supports inline and background execution.",
         inputSchema: {
-          name: import_zod85.z.string().describe("Workflow name to execute"),
-          input: import_zod85.z.record(import_zod85.z.string(), import_zod85.z.unknown()).optional().describe("Workflow input data"),
-          background: import_zod85.z.boolean().optional().default(false).describe("Run in background (returns runId)")
+          name: import_zod86.z.string().describe("Workflow name to execute"),
+          input: import_zod86.z.record(import_zod86.z.string(), import_zod86.z.unknown()).optional().describe("Workflow input data"),
+          background: import_zod86.z.boolean().optional().default(false).describe("Run in background (returns runId)")
         },
         outputSchema: {
-          runId: import_zod85.z.string(),
-          state: import_zod85.z.string(),
-          result: import_zod85.z.unknown().optional()
+          runId: import_zod86.z.string(),
+          state: import_zod86.z.string(),
+          result: import_zod86.z.unknown().optional()
         }
       })
     ], ExecuteWorkflowTool);
@@ -40242,11 +40536,11 @@ var init_execute_workflow_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/get-workflow-status.tool.ts
-var import_zod86, GetWorkflowStatusTool;
+var import_zod87, GetWorkflowStatusTool;
 var init_get_workflow_status_tool = __esm({
   "libs/sdk/src/workflow/tools/get-workflow-status.tool.ts"() {
     "use strict";
-    import_zod86 = require("zod");
+    import_zod87 = require("zod");
     init_common();
     GetWorkflowStatusTool = class extends ToolContext2 {
       async execute(input) {
@@ -40275,21 +40569,21 @@ var init_get_workflow_status_tool = __esm({
         name: "get-workflow-status",
         description: "Get the execution status of a workflow run with per-step results.",
         inputSchema: {
-          runId: import_zod86.z.string().describe("Run ID returned from execute-workflow")
+          runId: import_zod87.z.string().describe("Run ID returned from execute-workflow")
         },
         outputSchema: {
-          runId: import_zod86.z.string(),
-          workflowName: import_zod86.z.string().optional(),
-          state: import_zod86.z.string(),
-          stepResults: import_zod86.z.record(
-            import_zod86.z.string(),
-            import_zod86.z.object({
-              state: import_zod86.z.string(),
-              outputs: import_zod86.z.record(import_zod86.z.string(), import_zod86.z.unknown()).optional()
+          runId: import_zod87.z.string(),
+          workflowName: import_zod87.z.string().optional(),
+          state: import_zod87.z.string(),
+          stepResults: import_zod87.z.record(
+            import_zod87.z.string(),
+            import_zod87.z.object({
+              state: import_zod87.z.string(),
+              outputs: import_zod87.z.record(import_zod87.z.string(), import_zod87.z.unknown()).optional()
             })
           ).optional(),
-          startedAt: import_zod86.z.number(),
-          completedAt: import_zod86.z.number().optional()
+          startedAt: import_zod87.z.number(),
+          completedAt: import_zod87.z.number().optional()
         }
       })
     ], GetWorkflowStatusTool);
@@ -40297,11 +40591,11 @@ var init_get_workflow_status_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/register-workflow.tool.ts
-var import_zod87, RegisterWorkflowTool;
+var import_zod88, RegisterWorkflowTool;
 var init_register_workflow_tool = __esm({
   "libs/sdk/src/workflow/tools/register-workflow.tool.ts"() {
     "use strict";
-    import_zod87 = require("zod");
+    import_zod88 = require("zod");
     init_common();
     RegisterWorkflowTool = class extends ToolContext2 {
       async execute(input) {
@@ -40337,24 +40631,24 @@ var init_register_workflow_tool = __esm({
         name: "register-workflow",
         description: "Register a dynamic workflow with step definitions.",
         inputSchema: {
-          name: import_zod87.z.string().describe("Workflow name"),
-          description: import_zod87.z.string().optional().describe("Workflow description"),
-          steps: import_zod87.z.array(
-            import_zod87.z.object({
-              id: import_zod87.z.string().describe("Step identifier"),
-              jobName: import_zod87.z.string().describe("Job name to execute"),
-              input: import_zod87.z.record(import_zod87.z.string(), import_zod87.z.unknown()).optional().describe("Static input for the step"),
-              dependsOn: import_zod87.z.array(import_zod87.z.string()).optional().describe("Step IDs that must complete first"),
-              continueOnError: import_zod87.z.boolean().optional().describe("Continue on failure"),
-              timeout: import_zod87.z.number().optional().describe("Step timeout in ms")
+          name: import_zod88.z.string().describe("Workflow name"),
+          description: import_zod88.z.string().optional().describe("Workflow description"),
+          steps: import_zod88.z.array(
+            import_zod88.z.object({
+              id: import_zod88.z.string().describe("Step identifier"),
+              jobName: import_zod88.z.string().describe("Job name to execute"),
+              input: import_zod88.z.record(import_zod88.z.string(), import_zod88.z.unknown()).optional().describe("Static input for the step"),
+              dependsOn: import_zod88.z.array(import_zod88.z.string()).optional().describe("Step IDs that must complete first"),
+              continueOnError: import_zod88.z.boolean().optional().describe("Continue on failure"),
+              timeout: import_zod88.z.number().optional().describe("Step timeout in ms")
             })
           ).describe("Workflow step definitions"),
-          trigger: import_zod87.z.enum(["manual", "webhook", "event"]).optional().describe("Trigger type"),
-          tags: import_zod87.z.array(import_zod87.z.string()).optional().describe("Tags for categorization")
+          trigger: import_zod88.z.enum(["manual", "webhook", "event"]).optional().describe("Trigger type"),
+          tags: import_zod88.z.array(import_zod88.z.string()).optional().describe("Tags for categorization")
         },
         outputSchema: {
-          success: import_zod87.z.boolean(),
-          workflowId: import_zod87.z.string()
+          success: import_zod88.z.boolean(),
+          workflowId: import_zod88.z.string()
         },
         hideFromDiscovery: true
       })
@@ -40363,11 +40657,11 @@ var init_register_workflow_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/remove-workflow.tool.ts
-var import_zod88, RemoveWorkflowTool;
+var import_zod89, RemoveWorkflowTool;
 var init_remove_workflow_tool = __esm({
   "libs/sdk/src/workflow/tools/remove-workflow.tool.ts"() {
     "use strict";
-    import_zod88 = require("zod");
+    import_zod89 = require("zod");
     init_common();
     RemoveWorkflowTool = class extends ToolContext2 {
       async execute(input) {
@@ -40395,11 +40689,11 @@ var init_remove_workflow_tool = __esm({
         name: "remove-workflow",
         description: "Remove a dynamic workflow by name.",
         inputSchema: {
-          name: import_zod88.z.string().describe("Workflow name to remove")
+          name: import_zod89.z.string().describe("Workflow name to remove")
         },
         outputSchema: {
-          success: import_zod88.z.boolean(),
-          message: import_zod88.z.string()
+          success: import_zod89.z.boolean(),
+          message: import_zod89.z.string()
         },
         hideFromDiscovery: true
       })
@@ -40481,7 +40775,7 @@ var init_job_scope_helper = __esm({
 });
 
 // libs/sdk/src/scope/scope.instance.ts
-var import_reflect_metadata20, import_utils62, import_guard6, Scope;
+var import_reflect_metadata20, import_utils63, import_guard6, Scope;
 var init_scope_instance = __esm({
   "libs/sdk/src/scope/scope.instance.ts"() {
     "use strict";
@@ -40501,7 +40795,7 @@ var init_scope_instance = __esm({
     init_agent_registry();
     init_skill_registry();
     init_skill_validation_error();
-    import_utils62 = require("@frontmcp/utils");
+    import_utils63 = require("@frontmcp/utils");
     init_errors();
     init_skill_scope_helper();
     init_session2();
@@ -40585,7 +40879,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_utils62.getEnvFlag)("FRONTMCP_PERF");
+        const perf = (0, import_utils63.getEnvFlag)("FRONTMCP_PERF");
         const t0 = perf ? performance.now() : 0;
         const mark = perf ? (label) => this.logger.info(`[PERF] ${label}: ${(performance.now() - t0).toFixed(1)}ms`) : () => {
         };
@@ -40611,7 +40905,7 @@ var init_scope_instance = __esm({
             redis: elicitationRedis,
             keyPrefix: elicitationRedis?.keyPrefix ?? "mcp:elicit:",
             logger: this.logger,
-            isEdgeRuntime: (0, import_utils62.isEdgeRuntime)()
+            isEdgeRuntime: (0, import_utils63.isEdgeRuntime)()
           });
           this._elicitationStore = elicitStore;
         })() : void 0;
@@ -41270,7 +41564,7 @@ var init_base_host_adapter = __esm({
 });
 
 // libs/sdk/src/server/adapters/express.host.adapter.ts
-var http, import_express, import_cors, import_utils63, ExpressHostAdapter;
+var http, import_express, import_cors, import_utils64, ExpressHostAdapter;
 var init_express_host_adapter = __esm({
   "libs/sdk/src/server/adapters/express.host.adapter.ts"() {
     "use strict";
@@ -41278,7 +41572,7 @@ var init_express_host_adapter = __esm({
     import_express = __toESM(require("express"));
     import_cors = __toESM(require("cors"));
     init_base_host_adapter();
-    import_utils63 = require("@frontmcp/utils");
+    import_utils64 = require("@frontmcp/utils");
     ExpressHostAdapter = class extends HostServerAdapter {
       app = (0, import_express.default)();
       router = import_express.default.Router();
@@ -41370,8 +41664,8 @@ var init_express_host_adapter = __esm({
       }
       async cleanupStaleSocket(socketPath) {
         try {
-          if (await (0, import_utils63.fileExists)(socketPath)) {
-            await (0, import_utils63.unlink)(socketPath);
+          if (await (0, import_utils64.fileExists)(socketPath)) {
+            await (0, import_utils64.unlink)(socketPath);
           }
         } catch {
         }
@@ -41548,12 +41842,12 @@ var init_logger_utils = __esm({
 });
 
 // libs/sdk/src/logger/instances/instance.console-logger.ts
-var import_utils64, ConsoleLogTransportInstance;
+var import_utils65, ConsoleLogTransportInstance;
 var init_instance_console_logger = __esm({
   "libs/sdk/src/logger/instances/instance.console-logger.ts"() {
     "use strict";
     init_common();
-    import_utils64 = require("@frontmcp/utils");
+    import_utils65 = require("@frontmcp/utils");
     ConsoleLogTransportInstance = class extends LogTransportInterface {
       log(rec) {
         const fn = this.bind(rec.level, rec.prefix);
@@ -41581,7 +41875,7 @@ var init_instance_console_logger = __esm({
         const BOLD = "\x1B[1m";
         const DIM = "\x1B[2m";
         const GRAY = "\x1B[90m";
-        const useAnsi = (0, import_utils64.supportsAnsi)();
+        const useAnsi = (0, import_utils65.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;
@@ -41619,12 +41913,12 @@ var init_instance_console_logger = __esm({
 });
 
 // libs/sdk/src/logger/instances/instance.logger.ts
-var import_utils65, LoggerInstance;
+var import_utils66, LoggerInstance;
 var init_instance_logger = __esm({
   "libs/sdk/src/logger/instances/instance.logger.ts"() {
     "use strict";
     init_common();
-    import_utils65 = require("@frontmcp/utils");
+    import_utils66 = require("@frontmcp/utils");
     LoggerInstance = class _LoggerInstance extends FrontMcpLogger {
       constructor(config, getTransports) {
         super();
@@ -41679,7 +41973,7 @@ var init_instance_logger = __esm({
       }
       _getter(level) {
         if (level < this.level || this.level === 100 /* Off */) return () => void 0;
-        if ((0, import_utils65.isDevelopment)() && this.config.enableConsole && this.consoleTransport) {
+        if ((0, import_utils66.isDevelopment)() && this.config.enableConsole && this.consoleTransport) {
           return this.consoleTransport.bind(level, this.prefix);
         }
         const emit = this.emit.bind(this);
@@ -42009,7 +42303,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_utils66.randomUUID)()}`;
+  const sessionId = options?.sessionId ?? `in-memory:${(0, import_utils67.randomUUID)()}`;
   const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
   let currentAuthInfo = options?.authInfo ?? {};
   const hasRemoteApps = scope.apps?.getApps().some((app) => app.isRemote) ?? false;
@@ -42063,11 +42357,11 @@ async function createInMemoryServer(scope, options) {
     }
   };
 }
-var import_utils66;
+var import_utils67;
 var init_in_memory_server = __esm({
   "libs/sdk/src/transport/in-memory-server.ts"() {
     "use strict";
-    import_utils66 = require("@frontmcp/utils");
+    import_utils67 = require("@frontmcp/utils");
   }
 });
 
@@ -42076,13 +42370,13 @@ var direct_client_exports = {};
 __export(direct_client_exports, {
   DirectClientImpl: () => DirectClientImpl
 });
-var import_utils67, import_protocol43, DirectClientImpl;
+var import_utils68, import_protocol43, DirectClientImpl;
 var init_direct_client = __esm({
   "libs/sdk/src/direct/direct-client.ts"() {
     "use strict";
     init_llm_platform();
     init_errors();
-    import_utils67 = require("@frontmcp/utils");
+    import_utils68 = require("@frontmcp/utils");
     import_protocol43 = require("@frontmcp/protocol");
     init_skills_mcp_types();
     DirectClientImpl = class _DirectClientImpl {
@@ -42120,7 +42414,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_utils67.randomUUID)()}`;
+        const sessionId = options?.session?.id ?? `direct:${(0, import_utils68.randomUUID)()}`;
         const clientInfo = options?.clientInfo ?? { name: "mcp-client", version: "1.0.0" };
         const authInfo = {};
         if (options?.authToken) {
@@ -42535,7 +42829,7 @@ function buildAuthInfo(authContext, defaultSessionId) {
   if (!authContext && !defaultSessionId) {
     return void 0;
   }
-  const sessionId = authContext?.sessionId ?? defaultSessionId ?? `direct:${(0, import_utils68.randomUUID)()}`;
+  const sessionId = authContext?.sessionId ?? defaultSessionId ?? `direct:${(0, import_utils69.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 = {
@@ -42550,11 +42844,11 @@ function buildAuthInfo(authContext, defaultSessionId) {
   }
   return authInfo;
 }
-var import_utils68, DirectMcpServerImpl;
+var import_utils69, DirectMcpServerImpl;
 var init_direct_server = __esm({
   "libs/sdk/src/direct/direct-server.ts"() {
     "use strict";
-    import_utils68 = require("@frontmcp/utils");
+    import_utils69 = require("@frontmcp/utils");
     init_common();
     init_errors();
     DirectMcpServerImpl = class {
@@ -42564,7 +42858,7 @@ var init_direct_server = __esm({
       defaultSessionId;
       constructor(scope) {
         this.scope = scope;
-        this.defaultSessionId = `direct:${(0, import_utils68.randomUUID)()}`;
+        this.defaultSessionId = `direct:${(0, import_utils69.randomUUID)()}`;
         this.ready = Promise.resolve();
       }
       /**
@@ -42830,7 +43124,7 @@ var front_mcp_exports = {};
 __export(front_mcp_exports, {
   FrontMcpInstance: () => FrontMcpInstance
 });
-var import_utils69, FrontMcpInstance;
+var import_utils70, FrontMcpInstance;
 var init_front_mcp = __esm({
   "libs/sdk/src/front-mcp/front-mcp.ts"() {
     "use strict";
@@ -42841,7 +43135,7 @@ var init_front_mcp = __esm({
     init_logger_registry();
     init_direct();
     init_errors();
-    import_utils69 = require("@frontmcp/utils");
+    import_utils70 = require("@frontmcp/utils");
     FrontMcpInstance = class _FrontMcpInstance2 {
       config;
       ready;
@@ -43068,8 +43362,8 @@ var init_front_mcp = __esm({
         frontMcp.log?.info(`MCP server listening on unix://${socketPath}`);
         const cleanup = async () => {
           try {
-            if (await (0, import_utils69.fileExists)(socketPath)) {
-              await (0, import_utils69.unlink)(socketPath);
+            if (await (0, import_utils70.fileExists)(socketPath)) {
+              await (0, import_utils70.unlink)(socketPath);
             }
           } catch {
           }
@@ -43128,7 +43422,7 @@ var init_front_mcp = __esm({
           serverInfo: scope.metadata.info
         };
         const mcpServer = new McpServer2(scope.metadata.info, serverOptions);
-        const sessionId = `stdio:${(0, import_utils69.randomUUID)()}`;
+        const sessionId = `stdio:${(0, import_utils70.randomUUID)()}`;
         const handlers = createMcpHandlers2({ scope, serverOptions });
         for (const handler of handlers) {
           const originalHandler = handler.handler;
@@ -43271,8 +43565,8 @@ function FrontMcp(providedMetadata) {
       Reflect.defineMetadata(FrontMcpTokens[property] ?? property, metadata[property], target);
     }
     Reflect.defineMetadata("__frontmcp:config", metadata, target);
-    const isServerless2 = (0, import_utils70.getEnvFlag)("FRONTMCP_SERVERLESS");
-    const isSchemaExtract = (0, import_utils70.getEnvFlag)("FRONTMCP_SCHEMA_EXTRACT");
+    const isServerless2 = (0, import_utils71.getEnvFlag)("FRONTMCP_SERVERLESS");
+    const isSchemaExtract = (0, import_utils71.getEnvFlag)("FRONTMCP_SCHEMA_EXTRACT");
     if (isSchemaExtract) {
     } else if (isServerless2) {
       const ServerlessInstance = getFrontMcpInstance();
@@ -43289,14 +43583,14 @@ function FrontMcp(providedMetadata) {
     }
   };
 }
-var import_reflect_metadata25, import_utils70, _FrontMcpInstance, _serverlessHandlerFns;
+var import_reflect_metadata25, import_utils71, _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_utils70 = require("@frontmcp/utils");
+    import_utils71 = require("@frontmcp/utils");
     init_mcp_error();
     init_decorator_errors();
     _FrontMcpInstance = null;
@@ -43758,7 +44052,7 @@ function resolveCallerDir() {
       if (file.includes("node_modules") || file.includes("skill.decorator")) {
         continue;
       }
-      return (0, import_utils71.dirname)(file);
+      return (0, import_utils72.dirname)(file);
     }
   }
   return void 0;
@@ -43817,14 +44111,14 @@ function getSkillMetadata(target) {
   }
   return metadata;
 }
-var import_reflect_metadata34, import_utils71, Skill;
+var import_reflect_metadata34, import_utils72, 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_utils71 = require("@frontmcp/utils");
+    import_utils72 = require("@frontmcp/utils");
     init_package_specifier();
     init_validate_remote_url();
     Object.assign(FrontMcpSkill, {
@@ -44340,20 +44634,32 @@ var init_resource_interface = __esm({
        * Called by the MCP `completion/complete` handler when a client requests
        * suggestions for a template parameter.
        *
+       * There are two ways to provide completions (both have full DI access via `this.get()`):
+       *
+       * 1. **Convention-based (preferred):** Define a method named `${argName}Completer`.
+       *    The framework auto-discovers these methods.
+       *    ```typescript
+       *    async accountNameCompleter(partial: string): Promise<ResourceCompletionResult> {
+       *      const service = this.get(MyService);
+       *      const accounts = await service.listAccounts();
+       *      return { values: accounts.map(a => a.name).filter(n => n.startsWith(partial)) };
+       *    }
+       *    ```
+       *
+       * 2. **Override-based:** Override this method for dynamic dispatch.
+       *    ```typescript
+       *    getArgumentCompleter(argName: string): ResourceArgumentCompleter | null {
+       *      if (argName === 'userId') {
+       *        return async (partial) => ({
+       *          values: await this.get(UserService).search(partial),
+       *        });
+       *      }
+       *      return null;
+       *    }
+       *    ```
+       *
        * @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;
@@ -45384,32 +45690,32 @@ function decideIntent(req, cfg) {
     debug: { key, channel, flags }
   };
 }
-var import_zod89, intentSchema, decisionSchema, CH_OTHER, CH_GET_SSE, CH_POST_INIT_JSON, CH_POST_INIT_SSE, CH_POST_JSON, CH_POST_SSE, CH_POST_MESSAGE, CH_GET_SSE_PATH, CH_MASK, B_HAS_SESSION, B_STATELESS_EN, B_REQ_SESSION, B_LEGACY_HINT, B_SSE_LISTENER_EN, B_STREAMABLE_EN, B_STATEFUL_EN, B_LEGACY_EN, h, wantsSSE, wantsJSON, isInitialize, RULES;
+var import_zod90, intentSchema, decisionSchema, CH_OTHER, CH_GET_SSE, CH_POST_INIT_JSON, CH_POST_INIT_SSE, CH_POST_JSON, CH_POST_SSE, CH_POST_MESSAGE, CH_GET_SSE_PATH, CH_MASK, B_HAS_SESSION, B_STATELESS_EN, B_REQ_SESSION, B_LEGACY_HINT, B_SSE_LISTENER_EN, B_STREAMABLE_EN, B_STATEFUL_EN, B_LEGACY_EN, h, wantsSSE, wantsJSON, isInitialize, RULES;
 var init_decide_request_intent_utils = __esm({
   "libs/sdk/src/common/utils/decide-request-intent.utils.ts"() {
     "use strict";
-    import_zod89 = require("zod");
-    intentSchema = import_zod89.z.union([
-      import_zod89.z.literal("legacy-sse"),
-      import_zod89.z.literal("sse"),
-      import_zod89.z.literal("streamable-http"),
-      import_zod89.z.literal("stateful-http"),
-      import_zod89.z.literal("stateless-http"),
-      import_zod89.z.literal("delete-session"),
-      import_zod89.z.literal("unknown")
+    import_zod90 = require("zod");
+    intentSchema = import_zod90.z.union([
+      import_zod90.z.literal("legacy-sse"),
+      import_zod90.z.literal("sse"),
+      import_zod90.z.literal("streamable-http"),
+      import_zod90.z.literal("stateful-http"),
+      import_zod90.z.literal("stateless-http"),
+      import_zod90.z.literal("delete-session"),
+      import_zod90.z.literal("unknown")
     ]);
-    decisionSchema = import_zod89.z.object({
+    decisionSchema = import_zod90.z.object({
       intent: intentSchema,
-      reasons: import_zod89.z.array(import_zod89.z.string()),
-      recommendation: import_zod89.z.object({
-        httpStatus: import_zod89.z.number(),
-        message: import_zod89.z.string()
+      reasons: import_zod90.z.array(import_zod90.z.string()),
+      recommendation: import_zod90.z.object({
+        httpStatus: import_zod90.z.number(),
+        message: import_zod90.z.string()
       }).optional(),
       // Echo back bits for debugging/telemetry if you like
-      debug: import_zod89.z.object({
-        key: import_zod89.z.number(),
-        channel: import_zod89.z.number(),
-        flags: import_zod89.z.number()
+      debug: import_zod90.z.object({
+        key: import_zod90.z.number(),
+        channel: import_zod90.z.number(),
+        flags: import_zod90.z.number()
       }).optional()
     });
     CH_OTHER = 0;
@@ -45627,11 +45933,11 @@ var init_decide_request_intent_utils = __esm({
 
 // libs/sdk/src/common/utils/path.utils.ts
 function normalizeEntryPrefix(entryPath) {
-  const t = (0, import_utils72.trimSlashes)(entryPath ?? "");
+  const t = (0, import_utils73.trimSlashes)(entryPath ?? "");
   return t ? `/${t}` : "";
 }
 function normalizeScopeBase(scopeBase) {
-  const t = (0, import_utils72.trimSlashes)(scopeBase ?? "");
+  const t = (0, import_utils73.trimSlashes)(scopeBase ?? "");
   return t ? `/${t}` : "";
 }
 function getRequestBaseUrl(req, entryPath) {
@@ -45652,22 +45958,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_utils72.trimSlashes)(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
+  return (0, import_utils73.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_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)}`;
+  const reversed = (0, import_utils73.joinPath)(".well-known", name33) + `${prefix}${scope}`;
+  const inPrefixRoot = `${prefix}${(0, import_utils73.joinPath)(".well-known", name33)}${scope}`;
+  const inPrefixScope = `${prefix}${scope}${(0, import_utils73.joinPath)(".well-known", name33)}`;
   return /* @__PURE__ */ new Set([reversed, inPrefixRoot, inPrefixScope]);
 }
-var import_utils72, import_utils73;
+var import_utils73, import_utils74;
 var init_path_utils = __esm({
   "libs/sdk/src/common/utils/path.utils.ts"() {
     "use strict";
-    import_utils72 = require("@frontmcp/utils");
     import_utils73 = require("@frontmcp/utils");
+    import_utils74 = require("@frontmcp/utils");
   }
 });
 
@@ -46124,12 +46430,12 @@ var init_adapter_entry = __esm({
 });
 
 // libs/sdk/src/common/entries/tool.entry.ts
-var import_utils76, ToolEntry2;
+var import_utils77, ToolEntry2;
 var init_tool_entry = __esm({
   "libs/sdk/src/common/entries/tool.entry.ts"() {
     "use strict";
     init_base_entry();
-    import_utils76 = require("@frontmcp/utils");
+    import_utils77 = require("@frontmcp/utils");
     ToolEntry2 = class extends BaseEntry {
       owner;
       /**
@@ -46193,10 +46499,10 @@ var init_tool_entry = __esm({
         }
         if (this.inputSchema && Object.keys(this.inputSchema).length > 0) {
           try {
-            const { z: z91, toJSONSchema: toJSONSchema8 } = require("zod");
-            return toJSONSchema8(z91.object(this.inputSchema));
+            const { z: z92, toJSONSchema: toJSONSchema8 } = require("zod");
+            return toJSONSchema8(z92.object(this.inputSchema));
           } catch (error) {
-            if ((0, import_utils76.isDebug)() || (0, import_utils76.isDevelopment)()) {
+            if ((0, import_utils77.isDebug)() || (0, import_utils77.isDevelopment)()) {
               console.warn("[ToolEntry] Failed to convert Zod schema to JSON Schema:", error);
             }
             return { type: "object", properties: {} };
@@ -46457,7 +46763,7 @@ function parseListInput(rawInput, schema, expectedMethod) {
     method = inputData.request.method;
     params = inputData.request.params ?? {};
   } catch (e) {
-    throw new InvalidInputError("Invalid request format", e instanceof import_zod90.z.ZodError ? e.issues : void 0);
+    throw new InvalidInputError("Invalid request format", e instanceof import_zod91.z.ZodError ? e.issues : void 0);
   }
   if (method !== expectedMethod) {
     throw new InvalidMethodError(method, expectedMethod);
@@ -46498,11 +46804,11 @@ function detectConflicts(entries, getBaseName) {
     names: conflictNames
   };
 }
-var import_zod90;
+var import_zod91;
 var init_flow_utils3 = __esm({
   "libs/sdk/src/common/flow/flow.utils.ts"() {
     "use strict";
-    import_zod90 = require("zod");
+    import_zod91 = require("zod");
     init_errors();
   }
 });
@@ -47294,7 +47600,7 @@ __export(index_exports, {
   isValidVersion: () => isValidVersion,
   isVercelKvProvider: () => isVercelKvProvider,
   job: () => frontMcpJob,
-  joinPath: () => import_utils73.joinPath,
+  joinPath: () => import_utils74.joinPath,
   jsonWebKeySetSchema: () => import_auth.jsonWebKeySetSchema,
   jwkParametersSchema: () => import_auth.jwkParametersSchema,
   jwkSchema: () => import_auth.jwkSchema,
@@ -47380,7 +47686,7 @@ __export(index_exports, {
   toolPaginationOptionsSchema: () => toolPaginationOptionsSchema,
   transparentAuthOptionsSchema: () => import_auth6.transparentAuthOptionsSchema,
   transportOptionsSchema: () => transportOptionsSchema,
-  trimSlashes: () => import_utils73.trimSlashes,
+  trimSlashes: () => import_utils74.trimSlashes,
   tryDecryptStoredValue: () => tryDecryptStoredValue,
   tryGetConfig: () => tryGetConfig,
   urlToSafeId: () => urlToSafeId,