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

package/esm/index.mjs

@@ -109,7 +109,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")
     };
   }
 });
@@ -2949,7 +2950,8 @@ var init_skill_metadata = __esm({
     skillResourcesSchema = z30.object({
       scripts: z30.string().optional(),
       references: z30.string().optional(),
-      assets: z30.string().optional()
+      assets: z30.string().optional(),
+      examples: z30.string().optional()
     });
     skillMetadataSchema = z30.object({
       id: z30.string().optional(),
@@ -7854,6 +7856,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.
        *
@@ -8684,8 +8693,8 @@ var init_tool_instance = __esm({
         if (isRemoteTool || hasRawJsonSchema) {
           return z36.looseObject({}).parse(input.arguments ?? {});
         }
-        const inputSchema32 = z36.object(this.inputSchema);
-        return inputSchema32.parse(input.arguments);
+        const inputSchema33 = z36.object(this.inputSchema);
+        return inputSchema33.parse(input.arguments);
       }
       /**
        * Turn the raw tool function result into an MCP-compliant CallToolResult:
@@ -8824,7 +8833,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"];
@@ -9343,29 +9353,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 = toJSONSchema3(z37.object(tool.inputSchema));
+                inputSchema33 = toJSONSchema3(z37.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;
@@ -11077,16 +11087,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.
@@ -14274,7 +14318,7 @@ var init_skill_md_parser = __esm({
 
 // libs/sdk/src/skill/skill.utils.ts
 import { isClass as isClass11, getMetadata as getMetadata13, depsOfClass as depsOfClass8 } from "@frontmcp/di";
-import { readFile as readFile2, readdir, fileExists } from "@frontmcp/utils";
+import { readFile as readFile2, readdir, fileExists, stat } from "@frontmcp/utils";
 function collectSkillMetadata(cls) {
   const extended = getMetadata13(extendedSkillMetadata, cls);
   const seed = extended ? { ...extended } : {};
@@ -14354,11 +14398,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,
@@ -14372,7 +14419,8 @@ function buildSkillContent(metadata, instructions, resolvedReferences) {
     specMetadata: metadata.specMetadata,
     allowedTools: metadata.allowedTools,
     resources: metadata.resources,
-    resolvedReferences
+    resolvedReferences,
+    resolvedExamples
   };
 }
 function buildReferencesTable(refs) {
@@ -14382,6 +14430,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 fileExists(examplesDir)) return void 0;
+  let refDirs;
+  try {
+    refDirs = (await readdir(examplesDir)).sort();
+  } catch {
+    return void 0;
+  }
+  const examples = [];
+  for (const refDir of refDirs) {
+    const refPath = `${examplesDir}/${refDir}`;
+    try {
+      const s = await stat(refPath);
+      if (!s.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    let files;
+    try {
+      files = (await readdir(refPath)).filter((f) => f.endsWith(".md")).sort();
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const content = await readFile2(`${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 fileExists(refsDir)) return void 0;
   let files;
@@ -14645,16 +14760,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 ? 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 ? 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,
@@ -19855,8 +19978,8 @@ var init_agent_instance = __esm({
         return content;
       }
       parseInput(input) {
-        const inputSchema32 = z47.object(this.inputSchema ?? {});
-        return inputSchema32.parse(input.arguments);
+        const inputSchema33 = z47.object(this.inputSchema ?? {});
+        return inputSchema33.parse(input.arguments);
       }
       parseOutput(raw) {
         const descriptor = this.outputSchema;
@@ -19877,13 +20000,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 = toJSONSchema4(z47.object(this.inputSchema));
+            inputSchema33 = toJSONSchema4(z47.object(this.inputSchema));
           } catch {
             this.scope.logger.warn(`Failed to convert input schema for agent ${this.name}`);
           }
@@ -19891,7 +20014,7 @@ var init_agent_instance = __esm({
         return {
           name: agentToolName(this.id),
           description: this.buildToolDescription(metadata),
-          inputSchema: inputSchema32
+          inputSchema: inputSchema33
         };
       }
       /**
@@ -22721,8 +22844,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.
@@ -22765,13 +22888,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"]
     };
   }
@@ -23465,11 +23588,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;
     }
@@ -23478,7 +23601,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: {
@@ -27958,11 +28081,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"));
@@ -28086,12 +28208,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;
@@ -28288,6 +28405,8 @@ var init_transport_remote = __esm({
       }
       resetForReinitialization() {
       }
+      reregisterServer() {
+      }
     };
   }
 });
@@ -29298,20 +29417,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("```");
           }
         }
@@ -29652,6 +29771,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;
@@ -31686,6 +31815,9 @@ var init_transport_local = __esm({
       resetForReinitialization() {
         this.adapter.resetForReinitialization();
       }
+      reregisterServer() {
+        this.adapter.reregisterServer();
+      }
       async destroy(reason) {
         try {
           await this.adapter.destroy(reason);
@@ -31978,18 +32110,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.
@@ -32186,19 +32318,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"));
@@ -32252,11 +32396,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);
@@ -33805,9 +33951,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) {
@@ -35231,15 +35377,161 @@ var init_load_skills_tool = __esm({
   }
 });
 
+// libs/sdk/src/skill/tools/read-skill-content.tool.ts
+import { z as z72 } from "zod";
+import { readFile as readFile5, pathResolve as pathResolve4 } from "@frontmcp/utils";
+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 inputSchema27, outputSchema25, ReadSkillContentTool;
+var init_read_skill_content_tool = __esm({
+  "libs/sdk/src/skill/tools/read-skill-content.tool.ts"() {
+    "use strict";
+    init_common();
+    init_skill_md_parser();
+    inputSchema27 = {
+      skillId: z72.string().min(1).describe("ID or name of the skill (as returned by searchSkills or loadSkills)"),
+      type: z72.enum(["reference", "example"]).describe("Type of content to read: reference or example"),
+      name: z72.string().min(1).describe("Name of the reference or example to read (as shown in the routing table from loadSkills)")
+    };
+    outputSchema25 = {
+      skillId: z72.string(),
+      skillName: z72.string(),
+      type: z72.enum(["reference", "example"]),
+      name: z72.string(),
+      description: z72.string(),
+      content: z72.string().describe("Markdown body with frontmatter stripped"),
+      frontmatter: z72.record(z72.string(), z72.unknown()).optional().describe("Parsed YAML frontmatter fields from the file"),
+      reference: z72.string().optional().describe("Parent reference name (examples only)"),
+      level: z72.string().optional().describe("Complexity level: basic, intermediate, or advanced (examples only)"),
+      available: z72.array(z72.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 : pathResolve4(baseDir, resourcePath);
+        const filePath = pathResolve4(resourceDir, filename);
+        try {
+          return await readFile5(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();
   }
 });
 
@@ -36154,25 +36446,25 @@ var init_hooks = __esm({
 });
 
 // libs/sdk/src/logging/flows/set-level.flow.ts
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 import { SetLevelRequestSchema as SetLevelRequestSchema2, EmptyResultSchema as EmptyResultSchema4, LoggingLevelSchema } from "@frontmcp/protocol";
-var inputSchema27, outputSchema25, stateSchema26, plan27, name28, Stage28, SetLevelFlow;
+var 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();
     init_errors();
-    inputSchema27 = z72.object({
+    inputSchema28 = z73.object({
       request: SetLevelRequestSchema2,
-      ctx: z72.unknown()
+      ctx: z73.unknown()
     });
-    outputSchema25 = EmptyResultSchema4;
-    stateSchema26 = z72.object({
-      input: z72.object({
+    outputSchema26 = EmptyResultSchema4;
+    stateSchema26 = z73.object({
+      input: z73.object({
         level: LoggingLevelSchema
       }),
-      sessionId: z72.string(),
-      output: outputSchema25
+      sessionId: z73.string(),
+      output: outputSchema26
     });
     plan27 = {
       pre: ["parseInput"],
@@ -36189,12 +36481,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 z72.ZodError ? e.issues : void 0);
+          throw new InvalidInputError("Invalid Input", e instanceof z73.ZodError ? e.issues : void 0);
         }
         if (method !== "logging/setLevel") {
           this.logger.warn(`parseInput: invalid method "${method}"`);
@@ -36240,8 +36532,8 @@ var init_set_level_flow = __esm({
       FrontMcpFlow({
         name: name28,
         plan: plan27,
-        inputSchema: inputSchema27,
-        outputSchema: outputSchema25,
+        inputSchema: inputSchema28,
+        outputSchema: outputSchema26,
         access: "authorized"
       })
     ], SetLevelFlow);
@@ -36249,35 +36541,35 @@ var init_set_level_flow = __esm({
 });
 
 // libs/sdk/src/completion/flows/complete.flow.ts
-import { z as z73 } from "zod";
+import { z as z74 } from "zod";
 import { CompleteRequestSchema as CompleteRequestSchema2, CompleteResultSchema } from "@frontmcp/protocol";
-var inputSchema28, outputSchema26, PromptRefSchema, ResourceRefSchema, stateSchema27, plan28, name29, Stage29, CompleteFlow;
+var 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();
     init_errors();
     init_ui();
-    inputSchema28 = z73.object({
+    inputSchema29 = z74.object({
       request: CompleteRequestSchema2,
-      ctx: z73.unknown()
+      ctx: z74.unknown()
     });
-    outputSchema26 = CompleteResultSchema;
-    PromptRefSchema = z73.object({
-      type: z73.literal("ref/prompt"),
-      name: z73.string()
+    outputSchema27 = CompleteResultSchema;
+    PromptRefSchema = z74.object({
+      type: z74.literal("ref/prompt"),
+      name: z74.string()
     });
-    ResourceRefSchema = z73.object({
-      type: z73.literal("ref/resource"),
-      uri: z73.string()
+    ResourceRefSchema = z74.object({
+      type: z74.literal("ref/resource"),
+      uri: z74.string()
     });
-    stateSchema27 = z73.object({
-      ref: z73.discriminatedUnion("type", [PromptRefSchema, ResourceRefSchema]),
-      argument: z73.object({
-        name: z73.string(),
-        value: z73.string()
+    stateSchema27 = z74.object({
+      ref: z74.discriminatedUnion("type", [PromptRefSchema, ResourceRefSchema]),
+      argument: z74.object({
+        name: z74.string(),
+        value: z74.string()
       }),
-      output: outputSchema26
+      output: outputSchema27
     });
     plan28 = {
       pre: ["parseInput"],
@@ -36293,11 +36585,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 z73.ZodError ? e.issues : void 0);
+          throw new InvalidInputError("Invalid Input", e instanceof z74.ZodError ? e.issues : void 0);
         }
         if (method !== "completion/complete") {
           this.logger.warn(`parseInput: invalid method "${method}"`);
@@ -36411,8 +36703,8 @@ var init_complete_flow = __esm({
       FrontMcpFlow({
         name: name29,
         plan: plan28,
-        inputSchema: inputSchema28,
-        outputSchema: outputSchema26,
+        inputSchema: inputSchema29,
+        outputSchema: outputSchema27,
         access: "authorized"
       })
     ], CompleteFlow);
@@ -36420,50 +36712,50 @@ var init_complete_flow = __esm({
 });
 
 // libs/sdk/src/agent/flows/call-agent.flow.ts
-import { z as z74 } from "zod";
+import { z as z75 } from "zod";
 import { CallToolRequestSchema as CallToolRequestSchema3, CallToolResultSchema as CallToolResultSchema4 } from "@frontmcp/protocol";
 import { ExecutionTimeoutError as ExecutionTimeoutError2, ConcurrencyLimitError as ConcurrencyLimitError2, withTimeout as withTimeout2 } from "@frontmcp/guard";
-var inputSchema29, outputSchema27, stateSchema28, plan29, name30, Stage30, CallAgentFlow;
+var 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();
     init_errors();
-    inputSchema29 = z74.object({
+    inputSchema30 = z75.object({
       request: CallToolRequestSchema3,
       // z.any() used because ctx is the MCP SDK's ToolCallExtra type which varies by SDK version
-      ctx: z74.any()
+      ctx: z75.any()
     });
-    outputSchema27 = CallToolResultSchema4;
-    stateSchema28 = z74.object({
-      input: z74.looseObject({
-        name: z74.string().min(1).max(128),
-        arguments: z74.looseObject({}).optional()
+    outputSchema28 = CallToolResultSchema4;
+    stateSchema28 = z75.object({
+      input: z75.looseObject({
+        name: z75.string().min(1).max(128),
+        arguments: z75.looseObject({}).optional()
       }),
-      authInfo: z74.any().optional(),
-      agent: z74.instanceof(AgentEntry),
-      agentContext: z74.instanceof(AgentContext),
+      authInfo: z75.any().optional(),
+      agent: z75.instanceof(AgentEntry),
+      agentContext: z75.instanceof(AgentContext),
       // Store the raw executed output for plugins to see
-      rawOutput: z74.any().optional(),
-      output: outputSchema27,
+      rawOutput: z75.any().optional(),
+      output: outputSchema28,
       // Agent owner ID for hook filtering (set during parseInput)
-      _agentOwnerId: z74.string().optional(),
+      _agentOwnerId: z75.string().optional(),
       // Progress token from request's _meta (for progress notifications)
-      progressToken: z74.union([z74.string(), z74.number()]).optional(),
+      progressToken: z75.union([z75.string(), z75.number()]).optional(),
       // JSON-RPC request ID (for elicitation routing)
-      jsonRpcRequestId: z74.union([z74.string(), z74.number()]).optional(),
+      jsonRpcRequestId: z75.union([z75.string(), z75.number()]).optional(),
       // Execution metadata
-      executionMeta: z74.object({
-        iterations: z74.number().optional(),
-        durationMs: z74.number().optional(),
-        usage: z74.object({
-          promptTokens: z74.number().optional(),
-          completionTokens: z74.number().optional(),
-          totalTokens: z74.number().optional()
+      executionMeta: z75.object({
+        iterations: z75.number().optional(),
+        durationMs: z75.number().optional(),
+        usage: z75.object({
+          promptTokens: z75.number().optional(),
+          completionTokens: z75.number().optional(),
+          totalTokens: z75.number().optional()
         }).optional()
       }).optional(),
       // Semaphore ticket for concurrency control (set by acquireSemaphore, used by releaseSemaphore)
-      semaphoreTicket: z74.any().optional()
+      semaphoreTicket: z75.any().optional()
     });
     plan29 = {
       pre: ["parseInput", "findAgent", "checkAgentAuthorization", "createAgentContext", "acquireQuota", "acquireSemaphore"],
@@ -36480,12 +36772,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 z74.ZodError ? e.issues : void 0);
+          throw new InvalidInputError("Invalid Input", e instanceof z75.ZodError ? e.issues : void 0);
         }
         if (method !== "tools/call") {
           this.logger.warn(`parseInput: invalid method "${method}"`);
@@ -36667,7 +36959,7 @@ var init_call_agent_flow = __esm({
           agentContext.input = agent.parseInput(input);
           this.logger.verbose("validateInput:done");
         } catch (err) {
-          if (err instanceof z74.ZodError) {
+          if (err instanceof z75.ZodError) {
             throw new InvalidInputError("Invalid agent input", err.issues);
           }
           this.logger.error("validateInput: failed to parse input", err);
@@ -36827,8 +37119,8 @@ var init_call_agent_flow = __esm({
       FrontMcpFlow({
         name: name30,
         plan: plan29,
-        inputSchema: inputSchema29,
-        outputSchema: outputSchema27,
+        inputSchema: inputSchema30,
+        outputSchema: outputSchema28,
         access: "authorized"
       })
     ], CallAgentFlow);
@@ -36836,58 +37128,58 @@ var init_call_agent_flow = __esm({
 });
 
 // libs/sdk/src/elicitation/flows/elicitation-request.flow.ts
-import { z as z75 } from "zod";
+import { z as z76 } from "zod";
 import { randomUUID as randomUUID20 } from "@frontmcp/utils";
-var inputSchema30, outputSchema28, stateSchema29, plan30, name31, Stage31, ElicitationRequestFlow;
+var 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();
     init_errors();
     init_elicitation_types();
-    inputSchema30 = z75.object({
+    inputSchema31 = z76.object({
       /** Related request ID from the transport */
-      relatedRequestId: z75.union([z75.string(), z75.number()]),
+      relatedRequestId: z76.union([z76.string(), z76.number()]),
       /** Session ID for the elicitation */
-      sessionId: z75.string(),
+      sessionId: z76.string(),
       /** Message to display to the user */
-      message: z75.string(),
+      message: z76.string(),
       /** JSON Schema for the expected response (already converted from Zod) */
-      requestedSchema: z75.record(z75.string(), z75.unknown()),
+      requestedSchema: z76.record(z76.string(), z76.unknown()),
       /** Elicitation options */
-      options: z75.object({
-        mode: z75.enum(["form", "url"]).optional(),
-        ttl: z75.number().optional(),
-        elicitationId: z75.string().optional()
+      options: z76.object({
+        mode: z76.enum(["form", "url"]).optional(),
+        ttl: z76.number().optional(),
+        elicitationId: z76.string().optional()
       }).optional()
     });
-    outputSchema28 = z75.object({
+    outputSchema29 = z76.object({
       /** Generated or provided elicit ID */
-      elicitId: z75.string(),
+      elicitId: z76.string(),
       /** Session ID */
-      sessionId: z75.string(),
+      sessionId: z76.string(),
       /** Expiration timestamp */
-      expiresAt: z75.number(),
+      expiresAt: z76.number(),
       /** Elicitation mode */
-      mode: z75.enum(["form", "url"]),
+      mode: z76.enum(["form", "url"]),
       /** Request parameters to send to client */
-      requestParams: z75.record(z75.string(), z75.unknown()),
+      requestParams: z76.record(z76.string(), z76.unknown()),
       /** The pending record that was stored */
-      pendingRecord: z75.any()
+      pendingRecord: z76.any()
     });
-    stateSchema29 = z75.object({
-      relatedRequestId: z75.union([z75.string(), z75.number()]),
-      sessionId: z75.string(),
-      message: z75.string(),
-      requestedSchema: z75.record(z75.string(), z75.unknown()),
-      mode: z75.enum(["form", "url"]).default("form"),
-      ttl: z75.number().default(DEFAULT_ELICIT_TTL),
-      elicitationId: z75.string().optional(),
-      elicitId: z75.string(),
-      expiresAt: z75.number(),
-      pendingRecord: z75.any().optional(),
-      requestParams: z75.record(z75.string(), z75.unknown()).optional(),
-      output: outputSchema28.optional()
+    stateSchema29 = z76.object({
+      relatedRequestId: z76.union([z76.string(), z76.number()]),
+      sessionId: z76.string(),
+      message: z76.string(),
+      requestedSchema: z76.record(z76.string(), z76.unknown()),
+      mode: z76.enum(["form", "url"]).default("form"),
+      ttl: z76.number().default(DEFAULT_ELICIT_TTL),
+      elicitationId: z76.string().optional(),
+      elicitId: z76.string(),
+      expiresAt: z76.number(),
+      pendingRecord: z76.any().optional(),
+      requestParams: z76.record(z76.string(), z76.unknown()).optional(),
+      output: outputSchema29.optional()
     });
     plan30 = {
       pre: ["parseInput", "validateRequest"],
@@ -36900,7 +37192,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,
@@ -37004,8 +37296,8 @@ var init_elicitation_request_flow = __esm({
       FrontMcpFlow({
         name: name31,
         plan: plan30,
-        inputSchema: inputSchema30,
-        outputSchema: outputSchema28,
+        inputSchema: inputSchema31,
+        outputSchema: outputSchema29,
         access: "authorized"
       })
     ], ElicitationRequestFlow);
@@ -37013,39 +37305,39 @@ var init_elicitation_request_flow = __esm({
 });
 
 // libs/sdk/src/elicitation/flows/elicitation-result.flow.ts
-import { z as z76 } from "zod";
-var inputSchema31, outputSchema29, stateSchema30, plan31, name32, Stage32, ElicitationResultFlow;
+import { z as z77 } from "zod";
+var 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();
     init_errors();
     init_helpers();
-    inputSchema31 = z76.object({
+    inputSchema32 = z77.object({
       /** Session ID for the elicitation */
-      sessionId: z76.string(),
+      sessionId: z77.string(),
       /** The result from the client */
-      result: z76.object({
-        action: z76.enum(["accept", "cancel", "decline"]),
-        content: z76.unknown().optional()
+      result: z77.object({
+        action: z77.enum(["accept", "cancel", "decline"]),
+        content: z77.unknown().optional()
       })
     });
-    outputSchema29 = z76.object({
+    outputSchema30 = z77.object({
       /** Whether the result was handled */
-      handled: z76.boolean(),
+      handled: z77.boolean(),
       /** The elicit ID (if pending was found) */
-      elicitId: z76.string().optional(),
+      elicitId: z77.string().optional(),
       /** The processed result */
-      result: z76.any().optional()
+      result: z77.any().optional()
     });
-    stateSchema30 = z76.object({
-      sessionId: z76.string(),
-      action: z76.enum(["accept", "cancel", "decline"]),
-      content: z76.unknown().optional(),
-      pendingRecord: z76.any().optional(),
-      elicitResult: z76.any().optional(),
-      handled: z76.boolean().default(false),
-      output: outputSchema29.optional()
+    stateSchema30 = z77.object({
+      sessionId: z77.string(),
+      action: z77.enum(["accept", "cancel", "decline"]),
+      content: z77.unknown().optional(),
+      pendingRecord: z77.any().optional(),
+      elicitResult: z77.any().optional(),
+      handled: z77.boolean().default(false),
+      output: outputSchema30.optional()
     });
     plan31 = {
       pre: ["parseInput"],
@@ -37058,7 +37350,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,
@@ -37182,8 +37474,8 @@ var init_elicitation_result_flow = __esm({
       FrontMcpFlow({
         name: name32,
         plan: plan31,
-        inputSchema: inputSchema31,
-        outputSchema: outputSchema29,
+        inputSchema: inputSchema32,
+        outputSchema: outputSchema30,
         access: "authorized"
       })
     ], ElicitationResultFlow);
@@ -37232,30 +37524,30 @@ var require_dist = __commonJS({
       sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema
     });
     module.exports = __toCommonJS2(index_exports);
-    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 {
@@ -37727,14 +38019,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)
     });
   }
 });
@@ -38378,7 +38670,7 @@ var init_records = __esm({
 });
 
 // libs/sdk/src/common/entries/job.entry.ts
-import { z as z77 } from "zod";
+import { z as z78 } from "zod";
 import { toJSONSchema as toJSONSchema7 } from "zod/v4";
 var JobEntry;
 var init_job_entry = __esm({
@@ -38409,7 +38701,7 @@ var init_job_entry = __esm({
       getInputJsonSchema() {
         if (this.inputSchema && Object.keys(this.inputSchema).length > 0) {
           try {
-            return toJSONSchema7(z77.object(this.inputSchema));
+            return toJSONSchema7(z78.object(this.inputSchema));
           } catch {
             return { type: "object", properties: {} };
           }
@@ -38423,11 +38715,11 @@ var init_job_entry = __esm({
         const outSchema = this.outputSchema;
         if (!outSchema) return null;
         try {
-          if (outSchema instanceof z77.ZodType) {
+          if (outSchema instanceof z78.ZodType) {
             return toJSONSchema7(outSchema);
           }
           if (outSchema && typeof outSchema === "object") {
-            return toJSONSchema7(z77.object(outSchema));
+            return toJSONSchema7(z78.object(outSchema));
           }
         } catch {
           return { type: "object", properties: {} };
@@ -38507,7 +38799,7 @@ var init_job_interface = __esm({
 });
 
 // libs/sdk/src/job/job.instance.ts
-import { z as z78 } from "zod";
+import { z as z79 } from "zod";
 var JobInstance, FunctionJobContext;
 var init_job_instance = __esm({
   "libs/sdk/src/job/job.instance.ts"() {
@@ -38585,17 +38877,17 @@ var init_job_instance = __esm({
         }
       }
       parseInput(input) {
-        const inputSchema32 = z78.object(this.inputSchema);
-        return inputSchema32.parse(input);
+        const inputSchema33 = z79.object(this.inputSchema);
+        return inputSchema33.parse(input);
       }
       parseOutput(raw) {
         if (this.outputSchema) {
           const outSchema = this.outputSchema;
-          if (outSchema instanceof z78.ZodType) {
+          if (outSchema instanceof z79.ZodType) {
             return outSchema.parse(raw);
           }
           if (typeof outSchema === "object" && outSchema !== null) {
-            return z78.object(outSchema).parse(raw);
+            return z79.object(outSchema).parse(raw);
           }
         }
         return raw;
@@ -39926,7 +40218,7 @@ var init_job_definition_store_factory = __esm({
 });
 
 // libs/sdk/src/job/tools/list-jobs.tool.ts
-import { z as z79 } from "zod";
+import { z as z80 } from "zod";
 var ListJobsTool;
 var init_list_jobs_tool = __esm({
   "libs/sdk/src/job/tools/list-jobs.tool.ts"() {
@@ -39960,21 +40252,21 @@ var init_list_jobs_tool = __esm({
         name: "list-jobs",
         description: "List registered jobs with optional filtering by tags or labels.",
         inputSchema: {
-          tags: z79.array(z79.string()).optional().describe("Filter by tags"),
-          labels: z79.record(z79.string(), z79.string()).optional().describe("Filter by labels"),
-          query: z79.string().optional().describe("Search query for name/description")
+          tags: z80.array(z80.string()).optional().describe("Filter by tags"),
+          labels: z80.record(z80.string(), z80.string()).optional().describe("Filter by labels"),
+          query: z80.string().optional().describe("Search query for name/description")
         },
         outputSchema: {
-          jobs: z79.array(
-            z79.object({
-              name: z79.string(),
-              description: z79.string().optional(),
-              tags: z79.array(z79.string()).optional(),
-              labels: z79.record(z79.string(), z79.string()).optional(),
-              inputSchema: z79.record(z79.string(), z79.unknown()).optional()
+          jobs: z80.array(
+            z80.object({
+              name: z80.string(),
+              description: z80.string().optional(),
+              tags: z80.array(z80.string()).optional(),
+              labels: z80.record(z80.string(), z80.string()).optional(),
+              inputSchema: z80.record(z80.string(), z80.unknown()).optional()
             })
           ),
-          count: z79.number()
+          count: z80.number()
         },
         hideFromDiscovery: true
       })
@@ -39983,7 +40275,7 @@ var init_list_jobs_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/execute-job.tool.ts
-import { z as z80 } from "zod";
+import { z as z81 } from "zod";
 var ExecuteJobTool;
 var init_execute_job_tool = __esm({
   "libs/sdk/src/job/tools/execute-job.tool.ts"() {
@@ -40014,15 +40306,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: z80.string().describe("Job name to execute"),
-          input: z80.record(z80.string(), z80.unknown()).optional().describe("Job input data"),
-          background: z80.boolean().optional().default(false).describe("Run in background (returns runId for status polling)")
+          name: z81.string().describe("Job name to execute"),
+          input: z81.record(z81.string(), z81.unknown()).optional().describe("Job input data"),
+          background: z81.boolean().optional().default(false).describe("Run in background (returns runId for status polling)")
         },
         outputSchema: {
-          runId: z80.string(),
-          state: z80.string(),
-          result: z80.unknown().optional(),
-          logs: z80.array(z80.string()).optional()
+          runId: z81.string(),
+          state: z81.string(),
+          result: z81.unknown().optional(),
+          logs: z81.array(z81.string()).optional()
         }
       })
     ], ExecuteJobTool);
@@ -40030,7 +40322,7 @@ var init_execute_job_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/get-job-status.tool.ts
-import { z as z81 } from "zod";
+import { z as z82 } from "zod";
 var GetJobStatusTool;
 var init_get_job_status_tool = __esm({
   "libs/sdk/src/job/tools/get-job-status.tool.ts"() {
@@ -40066,21 +40358,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: z81.string().describe("Run ID returned from execute-job or execute-workflow")
+          runId: z82.string().describe("Run ID returned from execute-job or execute-workflow")
         },
         outputSchema: {
-          runId: z81.string(),
-          jobName: z81.string(),
-          state: z81.string(),
-          result: z81.unknown().optional(),
-          error: z81.object({
-            message: z81.string(),
-            name: z81.string()
+          runId: z82.string(),
+          jobName: z82.string(),
+          state: z82.string(),
+          result: z82.unknown().optional(),
+          error: z82.object({
+            message: z82.string(),
+            name: z82.string()
           }).optional(),
-          startedAt: z81.number(),
-          completedAt: z81.number().optional(),
-          attempt: z81.number(),
-          logs: z81.array(z81.string())
+          startedAt: z82.number(),
+          completedAt: z82.number().optional(),
+          attempt: z82.number(),
+          logs: z82.array(z82.string())
         }
       })
     ], GetJobStatusTool);
@@ -40088,7 +40380,7 @@ var init_get_job_status_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/register-job.tool.ts
-import { z as z82 } from "zod";
+import { z as z83 } from "zod";
 var RegisterJobTool;
 var init_register_job_tool = __esm({
   "libs/sdk/src/job/tools/register-job.tool.ts"() {
@@ -40129,16 +40421,16 @@ var init_register_job_tool = __esm({
         name: "register-job",
         description: "Register a dynamic job that runs in a sandboxed environment.",
         inputSchema: {
-          name: z82.string().describe("Job name"),
-          description: z82.string().optional().describe("Job description"),
-          script: z82.string().describe("JavaScript source code for the job"),
-          inputSchema: z82.record(z82.string(), z82.unknown()).optional().describe("JSON Schema for input"),
-          outputSchema: z82.record(z82.string(), z82.unknown()).optional().describe("JSON Schema for output"),
-          tags: z82.array(z82.string()).optional().describe("Tags for categorization")
+          name: z83.string().describe("Job name"),
+          description: z83.string().optional().describe("Job description"),
+          script: z83.string().describe("JavaScript source code for the job"),
+          inputSchema: z83.record(z83.string(), z83.unknown()).optional().describe("JSON Schema for input"),
+          outputSchema: z83.record(z83.string(), z83.unknown()).optional().describe("JSON Schema for output"),
+          tags: z83.array(z83.string()).optional().describe("Tags for categorization")
         },
         outputSchema: {
-          success: z82.boolean(),
-          jobId: z82.string()
+          success: z83.boolean(),
+          jobId: z83.string()
         },
         hideFromDiscovery: true
       })
@@ -40147,7 +40439,7 @@ var init_register_job_tool = __esm({
 });
 
 // libs/sdk/src/job/tools/remove-job.tool.ts
-import { z as z83 } from "zod";
+import { z as z84 } from "zod";
 var RemoveJobTool;
 var init_remove_job_tool = __esm({
   "libs/sdk/src/job/tools/remove-job.tool.ts"() {
@@ -40179,11 +40471,11 @@ var init_remove_job_tool = __esm({
         name: "remove-job",
         description: "Remove a dynamic job by name.",
         inputSchema: {
-          name: z83.string().describe("Job name to remove")
+          name: z84.string().describe("Job name to remove")
         },
         outputSchema: {
-          success: z83.boolean(),
-          message: z83.string()
+          success: z84.boolean(),
+          message: z84.string()
         },
         hideFromDiscovery: true
       })
@@ -40192,7 +40484,7 @@ var init_remove_job_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/list-workflows.tool.ts
-import { z as z84 } from "zod";
+import { z as z85 } from "zod";
 var ListWorkflowsTool;
 var init_list_workflows_tool = __esm({
   "libs/sdk/src/workflow/tools/list-workflows.tool.ts"() {
@@ -40227,21 +40519,21 @@ var init_list_workflows_tool = __esm({
         name: "list-workflows",
         description: "List registered workflows with optional filtering by tags or labels.",
         inputSchema: {
-          tags: z84.array(z84.string()).optional().describe("Filter by tags"),
-          labels: z84.record(z84.string(), z84.string()).optional().describe("Filter by labels"),
-          query: z84.string().optional().describe("Search query for name/description")
+          tags: z85.array(z85.string()).optional().describe("Filter by tags"),
+          labels: z85.record(z85.string(), z85.string()).optional().describe("Filter by labels"),
+          query: z85.string().optional().describe("Search query for name/description")
         },
         outputSchema: {
-          workflows: z84.array(
-            z84.object({
-              name: z84.string(),
-              description: z84.string().optional(),
-              trigger: z84.string(),
-              stepCount: z84.number(),
-              tags: z84.array(z84.string()).optional()
+          workflows: z85.array(
+            z85.object({
+              name: z85.string(),
+              description: z85.string().optional(),
+              trigger: z85.string(),
+              stepCount: z85.number(),
+              tags: z85.array(z85.string()).optional()
             })
           ),
-          count: z84.number()
+          count: z85.number()
         },
         hideFromDiscovery: true
       })
@@ -40250,7 +40542,7 @@ var init_list_workflows_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/execute-workflow.tool.ts
-import { z as z85 } from "zod";
+import { z as z86 } from "zod";
 var ExecuteWorkflowTool;
 var init_execute_workflow_tool = __esm({
   "libs/sdk/src/workflow/tools/execute-workflow.tool.ts"() {
@@ -40283,14 +40575,14 @@ var init_execute_workflow_tool = __esm({
         name: "execute-workflow",
         description: "Execute a registered workflow by name. Supports inline and background execution.",
         inputSchema: {
-          name: z85.string().describe("Workflow name to execute"),
-          input: z85.record(z85.string(), z85.unknown()).optional().describe("Workflow input data"),
-          background: z85.boolean().optional().default(false).describe("Run in background (returns runId)")
+          name: z86.string().describe("Workflow name to execute"),
+          input: z86.record(z86.string(), z86.unknown()).optional().describe("Workflow input data"),
+          background: z86.boolean().optional().default(false).describe("Run in background (returns runId)")
         },
         outputSchema: {
-          runId: z85.string(),
-          state: z85.string(),
-          result: z85.unknown().optional()
+          runId: z86.string(),
+          state: z86.string(),
+          result: z86.unknown().optional()
         }
       })
     ], ExecuteWorkflowTool);
@@ -40298,7 +40590,7 @@ var init_execute_workflow_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/get-workflow-status.tool.ts
-import { z as z86 } from "zod";
+import { z as z87 } from "zod";
 var GetWorkflowStatusTool;
 var init_get_workflow_status_tool = __esm({
   "libs/sdk/src/workflow/tools/get-workflow-status.tool.ts"() {
@@ -40331,21 +40623,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: z86.string().describe("Run ID returned from execute-workflow")
+          runId: z87.string().describe("Run ID returned from execute-workflow")
         },
         outputSchema: {
-          runId: z86.string(),
-          workflowName: z86.string().optional(),
-          state: z86.string(),
-          stepResults: z86.record(
-            z86.string(),
-            z86.object({
-              state: z86.string(),
-              outputs: z86.record(z86.string(), z86.unknown()).optional()
+          runId: z87.string(),
+          workflowName: z87.string().optional(),
+          state: z87.string(),
+          stepResults: z87.record(
+            z87.string(),
+            z87.object({
+              state: z87.string(),
+              outputs: z87.record(z87.string(), z87.unknown()).optional()
             })
           ).optional(),
-          startedAt: z86.number(),
-          completedAt: z86.number().optional()
+          startedAt: z87.number(),
+          completedAt: z87.number().optional()
         }
       })
     ], GetWorkflowStatusTool);
@@ -40353,7 +40645,7 @@ var init_get_workflow_status_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/register-workflow.tool.ts
-import { z as z87 } from "zod";
+import { z as z88 } from "zod";
 var RegisterWorkflowTool;
 var init_register_workflow_tool = __esm({
   "libs/sdk/src/workflow/tools/register-workflow.tool.ts"() {
@@ -40393,24 +40685,24 @@ var init_register_workflow_tool = __esm({
         name: "register-workflow",
         description: "Register a dynamic workflow with step definitions.",
         inputSchema: {
-          name: z87.string().describe("Workflow name"),
-          description: z87.string().optional().describe("Workflow description"),
-          steps: z87.array(
-            z87.object({
-              id: z87.string().describe("Step identifier"),
-              jobName: z87.string().describe("Job name to execute"),
-              input: z87.record(z87.string(), z87.unknown()).optional().describe("Static input for the step"),
-              dependsOn: z87.array(z87.string()).optional().describe("Step IDs that must complete first"),
-              continueOnError: z87.boolean().optional().describe("Continue on failure"),
-              timeout: z87.number().optional().describe("Step timeout in ms")
+          name: z88.string().describe("Workflow name"),
+          description: z88.string().optional().describe("Workflow description"),
+          steps: z88.array(
+            z88.object({
+              id: z88.string().describe("Step identifier"),
+              jobName: z88.string().describe("Job name to execute"),
+              input: z88.record(z88.string(), z88.unknown()).optional().describe("Static input for the step"),
+              dependsOn: z88.array(z88.string()).optional().describe("Step IDs that must complete first"),
+              continueOnError: z88.boolean().optional().describe("Continue on failure"),
+              timeout: z88.number().optional().describe("Step timeout in ms")
             })
           ).describe("Workflow step definitions"),
-          trigger: z87.enum(["manual", "webhook", "event"]).optional().describe("Trigger type"),
-          tags: z87.array(z87.string()).optional().describe("Tags for categorization")
+          trigger: z88.enum(["manual", "webhook", "event"]).optional().describe("Trigger type"),
+          tags: z88.array(z88.string()).optional().describe("Tags for categorization")
         },
         outputSchema: {
-          success: z87.boolean(),
-          workflowId: z87.string()
+          success: z88.boolean(),
+          workflowId: z88.string()
         },
         hideFromDiscovery: true
       })
@@ -40419,7 +40711,7 @@ var init_register_workflow_tool = __esm({
 });
 
 // libs/sdk/src/workflow/tools/remove-workflow.tool.ts
-import { z as z88 } from "zod";
+import { z as z89 } from "zod";
 var RemoveWorkflowTool;
 var init_remove_workflow_tool = __esm({
   "libs/sdk/src/workflow/tools/remove-workflow.tool.ts"() {
@@ -40451,11 +40743,11 @@ var init_remove_workflow_tool = __esm({
         name: "remove-workflow",
         description: "Remove a dynamic workflow by name.",
         inputSchema: {
-          name: z88.string().describe("Workflow name to remove")
+          name: z89.string().describe("Workflow name to remove")
         },
         outputSchema: {
-          success: z88.boolean(),
-          message: z88.string()
+          success: z89.boolean(),
+          message: z89.string()
         },
         hideFromDiscovery: true
       })
@@ -44386,20 +44678,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;
@@ -45323,7 +45627,7 @@ var init_workflow_interface = __esm({
 });
 
 // libs/sdk/src/common/utils/decide-request-intent.utils.ts
-import { z as z89 } from "zod";
+import { z as z90 } from "zod";
 function pathOf(req) {
   const anyReq = req;
   const raw = anyReq.path ?? anyReq.pathname ?? anyReq.url ?? "/";
@@ -45435,27 +45739,27 @@ var intentSchema, decisionSchema, CH_OTHER, CH_GET_SSE, CH_POST_INIT_JSON, CH_PO
 var init_decide_request_intent_utils = __esm({
   "libs/sdk/src/common/utils/decide-request-intent.utils.ts"() {
     "use strict";
-    intentSchema = z89.union([
-      z89.literal("legacy-sse"),
-      z89.literal("sse"),
-      z89.literal("streamable-http"),
-      z89.literal("stateful-http"),
-      z89.literal("stateless-http"),
-      z89.literal("delete-session"),
-      z89.literal("unknown")
+    intentSchema = z90.union([
+      z90.literal("legacy-sse"),
+      z90.literal("sse"),
+      z90.literal("streamable-http"),
+      z90.literal("stateful-http"),
+      z90.literal("stateless-http"),
+      z90.literal("delete-session"),
+      z90.literal("unknown")
     ]);
-    decisionSchema = z89.object({
+    decisionSchema = z90.object({
       intent: intentSchema,
-      reasons: z89.array(z89.string()),
-      recommendation: z89.object({
-        httpStatus: z89.number(),
-        message: z89.string()
+      reasons: z90.array(z90.string()),
+      recommendation: z90.object({
+        httpStatus: z90.number(),
+        message: z90.string()
       }).optional(),
       // Echo back bits for debugging/telemetry if you like
-      debug: z89.object({
-        key: z89.number(),
-        channel: z89.number(),
-        flags: z89.number()
+      debug: z90.object({
+        key: z90.number(),
+        channel: z90.number(),
+        flags: z90.number()
       }).optional()
     });
     CH_OTHER = 0;
@@ -46238,8 +46542,8 @@ 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 (isDebug2() || isDevelopment4()) {
               console.warn("[ToolEntry] Failed to convert Zod schema to JSON Schema:", error);
@@ -46494,7 +46798,7 @@ var init_entries = __esm({
 });
 
 // libs/sdk/src/common/flow/flow.utils.ts
-import { z as z90 } from "zod";
+import { z as z91 } from "zod";
 function parseListInput(rawInput, schema, expectedMethod) {
   let method;
   let params;
@@ -46503,7 +46807,7 @@ function parseListInput(rawInput, schema, expectedMethod) {
     method = inputData.request.method;
     params = inputData.request.params ?? {};
   } catch (e) {
-    throw new InvalidInputError("Invalid request format", e instanceof z90.ZodError ? e.issues : void 0);
+    throw new InvalidInputError("Invalid request format", e instanceof z91.ZodError ? e.issues : void 0);
   }
   if (method !== expectedMethod) {
     throw new InvalidMethodError(method, expectedMethod);