@frontmcp/sdk 1.0.0-beta.1 → 1.0.0-beta.11

package/esm/index.mjs

@@ -623,7 +623,7 @@ var init_schema3 = __esm({
       maxAge: z4.number().optional()
     });
     httpOptionsSchema = z4.object({
-      port: z4.number().optional().default(3001),
+      port: z4.number().optional().default(Number(process.env["PORT"]) || 3e3),
       entryPath: z4.string().default(""),
       // Using z.any() because hostFactory accepts FrontMcpServer | ((config) => FrontMcpServer)
       // which Zod cannot validate at runtime - type safety is enforced via TypeScript interface
@@ -1794,19 +1794,11 @@ var init_schema10 = __esm({
   }
 });
 
-// libs/sdk/src/common/types/options/ext-apps/interfaces.ts
-var init_interfaces2 = __esm({
-  "libs/sdk/src/common/types/options/ext-apps/interfaces.ts"() {
-    "use strict";
-  }
-});
-
 // libs/sdk/src/common/types/options/ext-apps/index.ts
 var init_ext_apps = __esm({
   "libs/sdk/src/common/types/options/ext-apps/index.ts"() {
     "use strict";
     init_schema10();
-    init_interfaces2();
   }
 });
 
@@ -2392,6 +2384,7 @@ var init_logger_metadata = __esm({
 
 // libs/sdk/src/common/metadata/agent.metadata.ts
 import { z as z29 } from "zod";
+import { rateLimitConfigSchema as rateLimitConfigSchema2, concurrencyConfigSchema as concurrencyConfigSchema2, timeoutConfigSchema as timeoutConfigSchema2 } from "@frontmcp/guard";
 function withConfig(configPath, options) {
   if (typeof options === "function") {
     return { configPath, transform: options };
@@ -2480,9 +2473,9 @@ var init_agent_metadata = __esm({
       execution: executionConfigSchema.optional(),
       tags: z29.array(z29.string().min(1)).optional(),
       hideFromDiscovery: z29.boolean().optional().default(false),
-      rateLimit: z29.looseObject({ maxRequests: z29.number() }).optional(),
-      concurrency: z29.looseObject({ maxConcurrent: z29.number() }).optional(),
-      timeout: z29.looseObject({ executeMs: z29.number() }).optional()
+      rateLimit: rateLimitConfigSchema2.optional(),
+      concurrency: concurrencyConfigSchema2.optional(),
+      timeout: timeoutConfigSchema2.optional()
     }).passthrough();
   }
 });
@@ -4105,7 +4098,7 @@ var init_provider_errors = __esm({
 });
 
 // libs/sdk/src/errors/transport.errors.ts
-var MethodNotImplementedError, UnsupportedTransportTypeError, TransportBusRequiredError, InvalidTransportSessionError, TransportNotConnectedError, TransportAlreadyStartedError, UnsupportedContentTypeError;
+var MethodNotImplementedError, UnsupportedTransportTypeError, TransportBusRequiredError, InvalidTransportSessionError, TransportNotConnectedError, TransportAlreadyStartedError, UnsupportedContentTypeError, TransportServiceNotAvailableError;
 var init_transport_errors = __esm({
   "libs/sdk/src/errors/transport.errors.ts"() {
     "use strict";
@@ -4148,6 +4141,11 @@ var init_transport_errors = __esm({
         this.contentType = contentType2;
       }
     };
+    TransportServiceNotAvailableError = class extends InternalMcpError {
+      constructor() {
+        super("Transport service not available", "TRANSPORT_SERVICE_NOT_AVAILABLE");
+      }
+    };
   }
 });
 
@@ -4570,6 +4568,7 @@ __export(errors_exports, {
   TransportAlreadyStartedError: () => TransportAlreadyStartedError,
   TransportBusRequiredError: () => TransportBusRequiredError,
   TransportNotConnectedError: () => TransportNotConnectedError,
+  TransportServiceNotAvailableError: () => TransportServiceNotAvailableError,
   UnauthorizedError: () => UnauthorizedError,
   UnsupportedClientVersionError: () => UnsupportedClientVersionError,
   UnsupportedContentTypeError: () => UnsupportedContentTypeError,
@@ -6628,12 +6627,12 @@ var init_provider_registry = __esm({
        */
       getProviderInfo(token) {
         const def = this.defs.get(token);
-        const instance = this.instances.get(token);
-        if (!def || !instance)
+        if (!def)
           throw new ProviderNotRegisteredError(
             tokenName2(token),
             "not a registered DEFAULT provider and not a constructable class"
           );
+        const instance = this.instances.get(token);
         return {
           token,
           def,
@@ -7642,7 +7641,7 @@ function supportsElicitation(capabilities, mode) {
   if (mode === "url") {
     return capabilities.elicitation.url !== void 0;
   }
-  return capabilities.elicitation.form !== void 0 || capabilities.elicitation.url !== void 0;
+  return true;
 }
 function matchCustomMappings(clientName, mappings) {
   if (!mappings || mappings.length === 0) {
@@ -7729,8 +7728,9 @@ var init_notification_service = __esm({
       emergency: 7
     };
     NotificationService = class _NotificationService {
-      constructor(scope) {
+      constructor(scope, options = {}) {
         this.scope = scope;
+        this.options = options;
         this.logger = scope.logger.child("NotificationService");
       }
       logger;
@@ -7747,6 +7747,9 @@ var init_notification_service = __esm({
       terminatedSessions = /* @__PURE__ */ new Set();
       /** Maximum number of terminated sessions to track before eviction */
       static MAX_TERMINATED_SESSIONS = 1e4;
+      get maxTerminatedSessions() {
+        return this.options.maxTerminatedSessions ?? _NotificationService.MAX_TERMINATED_SESSIONS;
+      }
       /**
        * Initialize the notification service and subscribe to registry changes.
        * Called after all registries are ready.
@@ -7828,7 +7831,7 @@ var init_notification_service = __esm({
         const wasRegistered = this.unregisterServer(sessionId);
         this.scope.providers.cleanupSession(sessionId);
         this.logger.verbose(`Cleaned up provider cache for terminated session: ${sessionId.slice(0, 20)}...`);
-        if (this.terminatedSessions.size >= _NotificationService.MAX_TERMINATED_SESSIONS) {
+        if (this.terminatedSessions.size >= this.maxTerminatedSessions) {
           const oldest = this.terminatedSessions.values().next().value;
           if (oldest) {
             this.terminatedSessions.delete(oldest);
@@ -8510,7 +8513,14 @@ async function handleWaitingFallback(deps, error) {
         );
       }
     }, ttl);
-    scope.elicitationStore.subscribeFallbackResult(
+    const store = scope.elicitationStore;
+    if (!store) {
+      resolved = true;
+      clearTimeout(timeoutHandle);
+      reject(new ElicitationStoreNotInitializedError());
+      return;
+    }
+    store.subscribeFallbackResult(
       error.elicitId,
       (result) => {
         if (!resolved) {
@@ -8591,7 +8601,7 @@ var init_tool_instance = __esm({
         this.name = record.metadata.id || record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         const meta = record.metadata;
         this.rawInputSchema = meta["rawInputSchema"];
@@ -9016,7 +9026,7 @@ function resourceRemote(url, targetName, options) {
     }
   };
 }
-var Resource;
+var Resource, _ResourceTemplate;
 var init_resource_decorator = __esm({
   "libs/sdk/src/common/decorators/resource.decorator.ts"() {
     "use strict";
@@ -9029,6 +9039,7 @@ var init_resource_decorator = __esm({
       remote: resourceRemote
     });
     Resource = FrontMcpResource;
+    _ResourceTemplate = FrontMcpResourceTemplate;
   }
 });
 
@@ -9201,8 +9212,7 @@ var init_tools_list_flow = __esm({
           );
         }
         const sessionId = authInfo.sessionId;
-        const scope = this.scope;
-        const platformType = authInfo.sessionIdPayload?.platformType ?? (sessionId ? scope.notifications?.getPlatformType(sessionId) : void 0) ?? "unknown";
+        const platformType = authInfo.sessionIdPayload?.platformType ?? (sessionId ? this.scope.notifications?.getPlatformType(sessionId) : void 0) ?? "unknown";
         this.logger.verbose(`parseInput: detected platform=${platformType}`);
         const cursor = params?.cursor;
         if (cursor) this.logger.verbose(`parseInput: cursor=${cursor}`);
@@ -9309,8 +9319,7 @@ var init_tools_list_flow = __esm({
         try {
           const allResolved = this.state.required.resolvedTools;
           const platformType = this.state.platformType ?? "unknown";
-          const scope = this.scope;
-          const paginationConfig = scope.pagination?.tools;
+          const paginationConfig = this.scope.metadata.pagination?.tools;
           const usePagination = this.shouldPaginate(allResolved.length, paginationConfig);
           const sortedResolved = [...allResolved].sort((a, b) => a.finalName.localeCompare(b.finalName));
           let resolved = sortedResolved;
@@ -9370,12 +9379,12 @@ var init_tools_list_flow = __esm({
                 this.logger.warn(`parseTools: toolUI not available in scope for ${finalName}`);
                 return item;
               }
-              const scope2 = this.scope;
+              const scope = this.scope;
               let manifest;
               let detectedType;
               try {
-                manifest = scope2.toolUI.getManifest(finalName);
-                detectedType = scope2.toolUI.detectUIType(uiConfig.template);
+                manifest = scope.toolUI.getManifest(finalName);
+                detectedType = scope.toolUI.detectUIType(uiConfig.template);
               } catch (error) {
                 this.logger.warn(`parseTools: failed to access toolUI for ${finalName}`, error);
                 return item;
@@ -9897,8 +9906,11 @@ var init_call_tool_flow = __esm({
             const authInfo = this.state.authInfo;
             const authInfoWithTransport = authInfo;
             const sessionId = authInfo?.sessionId ?? "anonymous";
-            const scope = this.scope;
-            await scope.elicitationStore.setPendingFallback({
+            const store = this.scope.elicitationStore;
+            if (!store) {
+              throw new InternalMcpError("Elicitation store not initialized");
+            }
+            await store.setPendingFallback({
               elicitId: error.elicitId,
               sessionId,
               toolName: error.toolName,
@@ -9909,11 +9921,11 @@ var init_call_tool_flow = __esm({
               expiresAt: Date.now() + error.ttl
             });
             const transportType = authInfoWithTransport?.transport?.type;
-            if (transportType === "streamable-http" && canDeliverNotifications(scope, sessionId)) {
+            if (transportType === "streamable-http" && canDeliverNotifications(this.scope, sessionId)) {
               this.logger.info("execute: using waiting fallback for streamable-http", {
                 elicitId: error.elicitId
               });
-              const deps = { scope, sessionId, logger: this.logger };
+              const deps = { scope: this.scope, sessionId, logger: this.logger };
               const result = await handleWaitingFallback(deps, error);
               toolContext.output = result;
               this.logger.verbose("execute:done (elicitation waiting fallback)");
@@ -10023,6 +10035,10 @@ ${JSON.stringify(error.schema, null, 2)}
           const useStructuredContent = resolvedMode.useStructuredContent;
           let htmlContent;
           let uiMeta = {};
+          if (!scope.toolUI) {
+            this.logger.verbose("applyUI: toolUI not available, skipping UI rendering");
+            return;
+          }
           if (servingMode === "static") {
             this.logger.verbose("applyUI: UI using static mode (structured data only)", {
               tool: tool.metadata.name,
@@ -10240,8 +10256,8 @@ var init_send_elicitation_result_tool = __esm({
       async execute(input) {
         const { elicitId, action, content } = input;
         this.logger.info("sendElicitationResult: processing", { elicitId, action });
-        const scope = this.scope;
-        if (!scope?.elicitationStore) {
+        const store = this.scope.elicitationStore;
+        if (!store) {
           this.logger.error("sendElicitationResult: scope or elicitationStore not available");
           return {
             content: [
@@ -10253,7 +10269,7 @@ var init_send_elicitation_result_tool = __esm({
             isError: true
           };
         }
-        const pending = await scope.elicitationStore.getPendingFallback(elicitId);
+        const pending = await store.getPendingFallback(elicitId);
         if (!pending) {
           this.logger.warn("sendElicitationResult: no pending elicitation found", { elicitId });
           return {
@@ -10267,7 +10283,7 @@ var init_send_elicitation_result_tool = __esm({
           };
         }
         if (Date.now() > pending.expiresAt) {
-          await scope.elicitationStore.deletePendingFallback(elicitId);
+          await store.deletePendingFallback(elicitId);
           this.logger.warn("sendElicitationResult: elicitation expired", { elicitId });
           return {
             content: [
@@ -10283,8 +10299,8 @@ var init_send_elicitation_result_tool = __esm({
           status: action,
           ...action === "accept" && content !== void 0 && { content }
         };
-        await scope.elicitationStore.setResolvedResult(elicitId, elicitResult, pending.sessionId);
-        await scope.elicitationStore.deletePendingFallback(elicitId);
+        await store.setResolvedResult(elicitId, elicitResult, pending.sessionId);
+        await store.deletePendingFallback(elicitId);
         this.logger.info("sendElicitationResult: re-invoking original tool", {
           elicitId,
           toolName: pending.toolName
@@ -10294,7 +10310,7 @@ var init_send_elicitation_result_tool = __esm({
           ctx.setPreResolvedElicitResult(elicitResult);
         }
         try {
-          const toolResult = await scope.runFlowForOutput("tools:call-tool", {
+          const toolResult = await this.scope.runFlowForOutput("tools:call-tool", {
             request: {
               method: "tools/call",
               params: {
@@ -10309,19 +10325,19 @@ var init_send_elicitation_result_tool = __esm({
             elicitId,
             toolName: pending.toolName
           });
-          await scope.elicitationStore.publishFallbackResult(elicitId, pending.sessionId, {
+          await store.publishFallbackResult(elicitId, pending.sessionId, {
             success: true,
             result: toolResult
           });
-          await scope.elicitationStore.deleteResolvedResult(elicitId);
+          await store.deleteResolvedResult(elicitId);
           return toolResult;
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          await scope.elicitationStore.publishFallbackResult(elicitId, pending.sessionId, {
+          await store.publishFallbackResult(elicitId, pending.sessionId, {
             success: false,
             error: errorMessage
           });
-          await scope.elicitationStore.deleteResolvedResult(elicitId);
+          await store.deleteResolvedResult(elicitId);
           this.logger.error("sendElicitationResult: original tool failed", {
             elicitId,
             toolName: pending.toolName,
@@ -11010,19 +11026,26 @@ var init_resource_instance = __esm({
     init_mcp_error();
     init_errors();
     ResourceInstance = class extends ResourceEntry2 {
-      providers;
+      _providers;
       scope;
       hooks;
+      /**
+       * Get the provider registry for this resource.
+       * Used by flows to build context-aware providers for CONTEXT-scoped dependencies.
+       */
+      get providers() {
+        return this._providers;
+      }
       /** Parsed URI template info for template resources */
       templateInfo;
       constructor(record, providers, owner) {
         super(record);
         this.owner = owner;
-        this.providers = providers;
+        this._providers = providers;
         this.name = record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this.providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.isTemplate = "uriTemplate" in record.metadata;
         if (this.isTemplate) {
           const templateMetadata = record.metadata;
@@ -11053,6 +11076,18 @@ var init_resource_instance = __esm({
       getMetadata() {
         return this.record.metadata;
       }
+      /**
+       * Get an argument completer from the resource class prototype.
+       * Returns a completer function if the resource class overrides getArgumentCompleter,
+       * or null if no completer is available.
+       */
+      getArgumentCompleter(argName) {
+        const cls = this.record.provide;
+        if (typeof cls === "function" && cls.prototype && typeof cls.prototype.getArgumentCompleter === "function") {
+          return cls.prototype.getArgumentCompleter.call(cls.prototype, argName);
+        }
+        return null;
+      }
       /**
        * Match a URI against this resource.
        * For static resources: exact match against uri
@@ -11168,6 +11203,7 @@ var init_resource_types = __esm({
 // libs/sdk/src/resource/flows/read-resource.flow.ts
 import { z as z40 } from "zod";
 import { ReadResourceRequestSchema, ReadResourceResultSchema } from "@frontmcp/protocol";
+import { randomBytes as randomBytes2 } from "@frontmcp/utils";
 var inputSchema4, outputSchema3, stateSchema3, plan3, name3, Stage3, ReadResourceFlow;
 var init_read_resource_flow = __esm({
   "libs/sdk/src/resource/flows/read-resource.flow.ts"() {
@@ -11277,11 +11313,14 @@ var init_read_resource_flow = __esm({
         this.logger.info(`findResource: looking for resource with URI "${uri}"`);
         if (isUIResourceUri(uri)) {
           this.logger.info(`findResource: detected UI resource URI "${uri}"`);
-          const scope = this.scope;
           const { sessionId, authInfo } = this.state;
-          const platformType = authInfo?.sessionIdPayload?.platformType ?? (sessionId ? scope.notifications.getPlatformType(sessionId) : void 0);
+          const platformType = authInfo?.sessionIdPayload?.platformType ?? (sessionId ? this.scope.notifications.getPlatformType(sessionId) : void 0);
           this.logger.verbose(`findResource: platform type for session: ${platformType ?? "unknown"}`);
-          const uiResult = handleUIResourceRead(uri, scope.toolUI, platformType);
+          if (!this.scope.toolUI) {
+            this.logger.verbose("findResource: toolUI not available, skipping UI resource handling");
+            throw new ResourceNotFoundError(uri);
+          }
+          const uiResult = handleUIResourceRead(uri, this.scope.toolUI, platformType);
           if (uiResult.handled) {
             if (uiResult.error) {
               this.logger.warn(`findResource: UI resource error - ${uiResult.error}`);
@@ -11317,7 +11356,15 @@ var init_read_resource_flow = __esm({
         const { ctx } = this.input;
         const { resource, input, params } = this.state.required;
         try {
-          const contextProviders = new FlowContextProviders(this.scope.providers, this.deps);
+          const sessionKey = this.state.sessionId ?? ctx.authInfo?.sessionId ?? `req-${Date.now()}-${Buffer.from(randomBytes2(16)).toString("hex")}`;
+          const resourceViews = await resource.providers.buildViews(sessionKey, new Map(this.deps));
+          const mergedContextDeps = new Map(this.deps);
+          for (const [token, instance] of resourceViews.context) {
+            if (!mergedContextDeps.has(token)) {
+              mergedContextDeps.set(token, instance);
+            }
+          }
+          const contextProviders = new FlowContextProviders(resource.providers, mergedContextDeps);
           const context = resource.create(input.uri, params, { ...ctx, contextProviders });
           const resourceHooks = this.scope.hooks.getClsHooks(resource.record.provide).map((hook) => {
             hook.run = async () => {
@@ -12759,7 +12806,7 @@ var init_prompt_instance = __esm({
         this.name = record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.ready = this.initialize();
       }
       async initialize() {
@@ -14225,7 +14272,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 } from "@frontmcp/utils";
+import { readFile as readFile2, readdir, fileExists } from "@frontmcp/utils";
 function collectSkillMetadata(cls) {
   const extended = getMetadata13(extendedSkillMetadata, cls);
   const seed = extended ? { ...extended } : {};
@@ -14305,12 +14352,16 @@ async function loadInstructions(source, basePath) {
   }
   throw new InvalidInstructionSourceError();
 }
-function buildSkillContent(metadata, instructions) {
+function buildSkillContent(metadata, instructions, resolvedReferences) {
+  let finalInstructions = instructions;
+  if (resolvedReferences && resolvedReferences.length > 0) {
+    finalInstructions += buildReferencesTable(resolvedReferences);
+  }
   return {
     id: metadata.id ?? metadata.name,
     name: metadata.name,
     description: metadata.description,
-    instructions,
+    instructions: finalInstructions,
     tools: normalizeToolRefs(metadata.tools),
     parameters: metadata.parameters,
     examples: metadata.examples,
@@ -14318,9 +14369,73 @@ function buildSkillContent(metadata, instructions) {
     compatibility: metadata.compatibility,
     specMetadata: metadata.specMetadata,
     allowedTools: metadata.allowedTools,
-    resources: metadata.resources
+    resources: metadata.resources,
+    resolvedReferences
   };
 }
+function buildReferencesTable(refs) {
+  const lines = ["", "", "## References", "", "| Reference | Description |", "| --------- | ----------- |"];
+  for (const ref of refs) {
+    lines.push(`| \`${ref.name}\` | ${ref.description} |`);
+  }
+  return lines.join("\n");
+}
+async function resolveReferences(refsDir) {
+  if (!await fileExists(refsDir)) return void 0;
+  let files;
+  try {
+    files = (await readdir(refsDir)).filter((f) => f.endsWith(".md")).sort();
+  } catch {
+    return void 0;
+  }
+  if (files.length === 0) return void 0;
+  const refs = [];
+  for (const file of files) {
+    const content = await readFile2(`${refsDir}/${file}`, "utf-8");
+    const filenameWithoutExt = file.replace(/\.md$/, "");
+    let name33 = filenameWithoutExt;
+    let description = "";
+    const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (fmMatch) {
+      const fmLines = fmMatch[1].split(/\r?\n/);
+      for (const line of fmLines) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1) continue;
+        const key = line.slice(0, colonIdx).trim();
+        const val = line.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, "");
+        if (key === "name" && val) name33 = val;
+        if (key === "description" && val) description = val;
+      }
+    }
+    if (!description) {
+      const body = fmMatch ? content.substring(content.indexOf("---", 3) + 3).trim() : content.trim();
+      description = extractFirstParagraph(body);
+    }
+    refs.push({ name: name33, description, filename: file });
+  }
+  return refs;
+}
+function extractFirstParagraph(body) {
+  const lines = body.split(/\r?\n/);
+  let foundHeading = false;
+  const paragraphLines = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!foundHeading && trimmed.startsWith("#")) {
+      foundHeading = true;
+      continue;
+    }
+    if (foundHeading) {
+      if (trimmed === "") {
+        if (paragraphLines.length > 0) break;
+        continue;
+      }
+      if (trimmed.startsWith("#") || trimmed.startsWith("|") || trimmed.startsWith("-")) break;
+      paragraphLines.push(trimmed);
+    }
+  }
+  return paragraphLines.join(" ").slice(0, 200) || "";
+}
 function normalizeToolRefs(tools) {
   if (!tools) return [];
   return tools.map((tool) => {
@@ -14439,6 +14554,7 @@ var init_skill_utils = __esm({
 });
 
 // libs/sdk/src/skill/skill.instance.ts
+import { dirname, pathResolve } from "@frontmcp/utils";
 function createSkillInstance(record, providers, owner) {
   return new SkillInstance(record, providers, owner);
 }
@@ -14500,6 +14616,8 @@ var init_skill_instance = __esm({
           const filePath = this.record.filePath;
           const lastSlash = filePath.lastIndexOf("/");
           basePath = lastSlash > 0 ? filePath.substring(0, lastSlash) : void 0;
+        } else if (this.record.kind === "VALUE" /* VALUE */ && this.record.callerDir) {
+          basePath = this.record.callerDir;
         }
         this.cachedInstructions = await loadInstructions(this.metadata.instructions, basePath);
         return this.cachedInstructions;
@@ -14508,12 +14626,33 @@ var init_skill_instance = __esm({
        * Load the full skill content.
        * Results are cached after the first load.
        */
+      /**
+       * Resolve the base directory for this skill (for file/reference resolution).
+       */
+      getBaseDir() {
+        if (this.record.kind === "FILE" /* FILE */) {
+          return dirname(this.record.filePath) || void 0;
+        }
+        if (this.record.kind === "VALUE" /* VALUE */ && this.record.callerDir) {
+          return this.record.callerDir;
+        }
+        return void 0;
+      }
       async load() {
         if (this.cachedContent !== void 0) {
           return this.cachedContent;
         }
         const instructions = await this.loadInstructions();
-        const baseContent = buildSkillContent(this.metadata, instructions);
+        const refsPath = this.metadata.resources?.references;
+        let resolvedRefs;
+        if (refsPath) {
+          const baseDir = this.getBaseDir();
+          const refsDir = refsPath.startsWith("/") ? refsPath : baseDir ? pathResolve(baseDir, refsPath) : void 0;
+          if (refsDir) {
+            resolvedRefs = await resolveReferences(refsDir);
+          }
+        }
+        const baseContent = buildSkillContent(this.metadata, instructions, resolvedRefs);
         this.cachedContent = {
           ...baseContent,
           tags: this.tags,
@@ -15793,6 +15932,13 @@ var init_plugin_registry = __esm({
       getPluginNames() {
         return [...this.defs.values()].map((rec) => rec.metadata.name);
       }
+      /**
+       * Returns all ToolRegistries created by plugins in this registry.
+       * Used for propagating server-level plugin tools to the scope.
+       */
+      getToolRegistries() {
+        return [...this.pTools.values()];
+      }
       buildMap(list) {
         const tokens = /* @__PURE__ */ new Set();
         const defs = /* @__PURE__ */ new Map();
@@ -15809,12 +15955,14 @@ var init_plugin_registry = __esm({
       buildGraph() {
         for (const token of this.tokens) {
           const rec = this.defs.get(token);
+          if (!rec) throw new RegistryDependencyNotRegisteredError("Plugin", tokenName10(token), "self");
           const deps = pluginDiscoveryDeps(rec);
           for (const d of deps) {
             if (!this.providers.get(d)) {
               throw new RegistryDependencyNotRegisteredError("Plugin", tokenName10(token), tokenName10(d));
             }
-            this.graph.get(token).add(d);
+            const edges = this.graph.get(token);
+            if (edges) edges.add(d);
           }
         }
       }
@@ -15822,7 +15970,8 @@ var init_plugin_registry = __esm({
         this.logger?.verbose(`PluginRegistry: initializing ${this.tokens.size} plugin(s)`);
         for (const token of this.tokens) {
           const rec = this.defs.get(token);
-          const deps = this.graph.get(token);
+          if (!rec) continue;
+          const deps = this.graph.get(token) ?? /* @__PURE__ */ new Set();
           const providers = new ProviderRegistry(rec.metadata.providers ?? [], this.providers);
           await providers.ready;
           const pluginOwner = {
@@ -15865,9 +16014,9 @@ var init_plugin_registry = __esm({
             const klass = rec.provide;
             pluginInstance = new klass(...depsInstances);
           } else if (rec.kind === "FACTORY" /* FACTORY */) {
-            const deps2 = [...rec.inject()];
+            const factoryDeps = [...rec.inject()];
             const args = [];
-            for (const d of deps2) args.push(await this.providers.resolveBootstrapDep(d));
+            for (const d of factoryDeps) args.push(await this.providers.resolveBootstrapDep(d));
             pluginInstance = rec.useFactory(...args);
           } else if (rec.kind === "VALUE" /* VALUE */) {
             pluginInstance = rec.useValue;
@@ -17661,7 +17810,7 @@ var init_config_symbols = __esm({
 });
 
 // libs/sdk/src/builtin/config/providers/env-loader.ts
-import { readFile as readFile3, fileExists, getCwd, getEnv as getEnv2, setEnv, pathResolve } from "@frontmcp/utils";
+import { readFile as readFile3, fileExists as fileExists2, getCwd, getEnv as getEnv2, setEnv, pathResolve as pathResolve2 } from "@frontmcp/utils";
 function parseEnvContent(content) {
   const result = {};
   const lines = content.split("\n");
@@ -17689,13 +17838,13 @@ function parseEnvContent(content) {
 }
 async function loadEnvFiles(basePath = getCwd(), envPath = ".env", localEnvPath = ".env.local") {
   const result = {};
-  const envFile = pathResolve(basePath, envPath);
-  if (await fileExists(envFile)) {
+  const envFile = pathResolve2(basePath, envPath);
+  if (await fileExists2(envFile)) {
     const content = await readFile3(envFile);
     Object.assign(result, parseEnvContent(content));
   }
-  const localFile = pathResolve(basePath, localEnvPath);
-  if (await fileExists(localFile)) {
+  const localFile = pathResolve2(basePath, localEnvPath);
+  if (await fileExists2(localFile)) {
     const content = await readFile3(localFile);
     Object.assign(result, parseEnvContent(content));
   }
@@ -17816,7 +17965,7 @@ var init_env_loader = __esm({
 
 // libs/sdk/src/builtin/config/providers/config-loader.ts
 import * as yaml2 from "js-yaml";
-import { readFile as readFile4, fileExists as fileExists2, getCwd as getCwd2, pathResolve as pathResolve2 } from "@frontmcp/utils";
+import { readFile as readFile4, fileExists as fileExists3, getCwd as getCwd2, pathResolve as pathResolve3 } from "@frontmcp/utils";
 async function loadConfig(schema, options = {}) {
   const {
     basePath = getCwd2(),
@@ -17857,8 +18006,8 @@ async function loadYamlConfig(basePath, configPath) {
   const extensions = ["", ".yml", ".yaml"];
   const baseName = configPath.replace(/\.(ya?ml)$/, "");
   for (const ext of extensions) {
-    const fullPath = pathResolve2(basePath, baseName + ext);
-    if (await fileExists2(fullPath)) {
+    const fullPath = pathResolve3(basePath, baseName + ext);
+    if (await fileExists3(fullPath)) {
       const content = await readFile4(fullPath);
       const parsed = yaml2.load(content);
       if (parsed && typeof parsed === "object") {
@@ -18341,7 +18490,7 @@ var init_flow_instance = __esm({
         this.FlowClass = this.record.provide;
         this.ready = this.initialize();
         this.plan = this.record.metadata.plan;
-        this.hooks = scope.providers.getHooksRegistry();
+        this.hooks = scope.hooks;
         this.logger = scope.logger.child("FlowInstance");
       }
       async initialize() {
@@ -18709,8 +18858,8 @@ var init_flow_registry = __esm({
           const rec = this.defs.get(token);
           const deps = rec.metadata.dependsOn ?? [];
           for (const d of deps) {
-            if (d == ScopeEntry2) {
-              this.graph.get(token).add(ScopeEntry2);
+            if (d == ScopeEntry3) {
+              this.graph.get(token).add(ScopeEntry3);
             } else {
               if (!this.providers.get(d)) {
                 throw new RegistryDependencyNotRegisteredError("Flow", tokenName11(token), tokenName11(d));
@@ -19031,7 +19180,7 @@ var init_agent_scope = __esm({
             {
               scope: ProviderScope4.GLOBAL,
               name: "ScopeEntry",
-              provide: ScopeEntry2,
+              provide: ScopeEntry3,
               useValue: agentScopeEntry
             },
             // Also register as Scope so getActiveScope() returns the agent's scope
@@ -19142,6 +19291,12 @@ var init_agent_scope = __esm({
       get toolUI() {
         return this.parentScope.toolUI;
       }
+      get skills() {
+        return this.parentScope.skills;
+      }
+      get scopeMetadata() {
+        return this.parentScope.metadata;
+      }
       // ============================================================================
       // Flow Execution
       // ============================================================================
@@ -19200,18 +19355,42 @@ var init_agent_scope = __esm({
       get agents() {
         return this.agentScope.agents;
       }
+      get skills() {
+        return this.agentScope.skills;
+      }
       get notifications() {
         return this.agentScope.notifications;
       }
       get toolUI() {
         return this.agentScope.toolUI;
       }
+      get transportService() {
+        return void 0;
+      }
+      get rateLimitManager() {
+        return void 0;
+      }
+      get elicitationStore() {
+        return void 0;
+      }
+      get metadata() {
+        return this.agentScope.scopeMetadata;
+      }
+      get record() {
+        return void 0;
+      }
+      get ready() {
+        return this.agentScope.ready;
+      }
       registryFlows(...flows) {
         return this.agentScope.registryFlows(...flows);
       }
       runFlow(name33, input, deps) {
         return this.agentScope.runFlow(name33, input, deps);
       }
+      runFlowForOutput(name33, input, deps) {
+        return this.agentScope.runFlowForOutput(name33, input, deps);
+      }
     };
   }
 });
@@ -19259,7 +19438,7 @@ var init_agent_instance = __esm({
         this.id = record.metadata.id ?? record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this.providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         this.outputSchema = record.metadata.outputSchema;
         this.systemInstructions = record.metadata.systemInstructions;
@@ -22392,10 +22571,10 @@ var init_esm_cache = __esm({
         if (!this.cacheDir) return void 0;
         try {
           const path = __require("node:path");
-          const { fileExists: fileExists5, readJSON } = __require("@frontmcp/utils");
+          const { fileExists: fileExists6, readJSON } = __require("@frontmcp/utils");
           const entryDir = this.getEntryDir(packageName, version);
           const metaPath = path.join(entryDir, "meta.json");
-          if (!await fileExists5(metaPath)) {
+          if (!await fileExists6(metaPath)) {
             return void 0;
           }
           const meta = await readJSON(metaPath);
@@ -22405,7 +22584,7 @@ var init_esm_cache = __esm({
           if (Date.now() - meta.cachedAt > this.maxAgeMs) {
             return void 0;
           }
-          if (!await fileExists5(meta.bundlePath)) {
+          if (!await fileExists6(meta.bundlePath)) {
             return void 0;
           }
           this.memoryStore.set(memKey, meta);
@@ -22469,20 +22648,20 @@ var init_esm_cache = __esm({
         if (!this.cacheDir) return;
         try {
           const path = __require("node:path");
-          const { fileExists: fileExists5, readJSON, rm } = __require("@frontmcp/utils");
-          const { readdir } = __require("@frontmcp/utils");
-          if (!await fileExists5(this.cacheDir)) {
+          const { fileExists: fileExists6, readJSON, rm } = __require("@frontmcp/utils");
+          const { readdir: readdir2 } = __require("@frontmcp/utils");
+          if (!await fileExists6(this.cacheDir)) {
             return;
           }
           let entries;
           try {
-            entries = await readdir(this.cacheDir);
+            entries = await readdir2(this.cacheDir);
           } catch {
             return;
           }
           for (const dirEntry of entries) {
             const metaPath = path.join(this.cacheDir, dirEntry, "meta.json");
-            if (await fileExists5(metaPath)) {
+            if (await fileExists6(metaPath)) {
               const meta = await readJSON(metaPath);
               if (meta?.packageName === packageName) {
                 await rm(path.join(this.cacheDir, dirEntry), { recursive: true, force: true });
@@ -22508,20 +22687,20 @@ var init_esm_cache = __esm({
         if (!this.cacheDir) return removed;
         try {
           const path = __require("node:path");
-          const { fileExists: fileExists5, readJSON, rm } = __require("@frontmcp/utils");
-          const { readdir } = __require("@frontmcp/utils");
-          if (!await fileExists5(this.cacheDir)) {
+          const { fileExists: fileExists6, readJSON, rm } = __require("@frontmcp/utils");
+          const { readdir: readdir2 } = __require("@frontmcp/utils");
+          if (!await fileExists6(this.cacheDir)) {
             return removed;
           }
           let entries;
           try {
-            entries = await readdir(this.cacheDir);
+            entries = await readdir2(this.cacheDir);
           } catch {
             return removed;
           }
           for (const dirEntry of entries) {
             const metaPath = path.join(this.cacheDir, dirEntry, "meta.json");
-            if (await fileExists5(metaPath)) {
+            if (await fileExists6(metaPath)) {
               const meta = await readJSON(metaPath);
               if (meta && now - meta.cachedAt > threshold) {
                 await rm(path.join(this.cacheDir, dirEntry), { recursive: true, force: true });
@@ -24287,20 +24466,22 @@ function createSessionId(protocol, token, options) {
   return { id, payload };
 }
 function updateSessionPayload(sessionId, updates) {
+  let payload;
   const existing = cache.get(sessionId);
   if (existing) {
-    Object.assign(existing, updates);
-    cache.set(sessionId, existing);
-    return true;
-  }
-  const decrypted = safeDecrypt(sessionId);
-  if (hasValidSessionStructure(decrypted) || isValidPublicSessionPayload(decrypted)) {
-    const payload = decrypted;
-    Object.assign(payload, updates);
-    cache.set(sessionId, payload);
-    return true;
+    payload = existing;
+  } else {
+    const decrypted = safeDecrypt(sessionId);
+    if (hasValidSessionStructure(decrypted) || isValidPublicSessionPayload(decrypted)) {
+      payload = decrypted;
+    }
   }
-  return false;
+  if (!payload) return null;
+  Object.assign(payload, updates);
+  const newSessionId = encryptJson(payload);
+  cache.set(sessionId, payload);
+  cache.set(newSessionId, payload);
+  return newSessionId;
 }
 var cache;
 var init_session_id_utils = __esm({
@@ -25503,7 +25684,7 @@ var init_oauth_authorize_flow = __esm({
 
 // libs/sdk/src/auth/flows/oauth.register.flow.ts
 import { z as z56 } from "zod";
-import { randomUUID as randomUUID12, randomBytes as randomBytes2, base64urlEncode, isProduction as isProduction3 } from "@frontmcp/utils";
+import { randomUUID as randomUUID12, randomBytes as randomBytes3, base64urlEncode, isProduction as isProduction3 } from "@frontmcp/utils";
 var CLIENTS, inputSchema16, outputSchema14, registrationRequestSchema, stateSchema14, plan14, name15, Stage15, OauthRegisterFlow;
 var init_oauth_register_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.register.flow.ts"() {
@@ -25605,7 +25786,7 @@ var init_oauth_register_flow = __esm({
         const client_id = randomUUID12();
         let client_secret;
         if (token_endpoint_auth_method === "client_secret_post" || token_endpoint_auth_method === "client_secret_basic") {
-          client_secret = base64urlEncode(randomBytes2(24));
+          client_secret = base64urlEncode(randomBytes3(24));
         }
         this.registered = {
           client_id,
@@ -26831,7 +27012,7 @@ var init_oauth_provider_callback_flow = __esm({
 
 // libs/sdk/src/auth/instances/instance.local-primary-auth.ts
 import { SignJWT } from "jose";
-import { randomBytes as randomBytes3, randomUUID as randomUUID16, sha256Hex as sha256Hex4, getEnv as getEnv3, base64urlDecode } from "@frontmcp/utils";
+import { randomBytes as randomBytes4, randomUUID as randomUUID16, sha256Hex as sha256Hex4, getEnv as getEnv3, base64urlDecode } from "@frontmcp/utils";
 import { JwksService as JwksService4, InMemoryAuthorizationStore as InMemoryAuthorizationStore2, verifyPkce } from "@frontmcp/auth";
 import {
   InMemoryOrchestratedTokenStore,
@@ -26854,7 +27035,7 @@ var init_instance_local_primary_auth = __esm({
     init_cimd();
     init_oauth_provider_callback_flow();
     init_auth_internal_errors();
-    DEFAULT_NO_AUTH_SECRET = randomBytes3(32);
+    DEFAULT_NO_AUTH_SECRET = randomBytes4(32);
     LocalPrimaryAuth = class extends FrontMcpAuth {
       constructor(scope, providers, options) {
         super(options);
@@ -27772,11 +27953,21 @@ var init_http_request_flow = __esm({
               const sessionId = authorization.session.id;
               request[ServerRequestTokens.sessionId] = sessionId;
               if (this.scope.notifications.isSessionTerminated(sessionId)) {
-                this.logger.warn(`[${this.requestId}] Request to terminated session: ${sessionId.slice(0, 20)}...`);
-                this.respond(httpRespond.notFound("Session not found"));
-                return;
+                const body = request.body;
+                if (body?.method === "initialize") {
+                  this.logger.info(
+                    `[${this.requestId}] Initialize with terminated session ${sessionId.slice(0, 20)}... - allowing reconnect`
+                  );
+                  authorization.session = void 0;
+                  delete request[ServerRequestTokens.sessionId];
+                  delete request.headers["mcp-session-id"];
+                } else {
+                  this.logger.warn(`[${this.requestId}] Request to terminated session: ${sessionId.slice(0, 20)}...`);
+                  this.respond(httpRespond.notFound("Session not found"));
+                  return;
+                }
               }
-              const protocol = authorization.session.payload?.protocol;
+              const protocol = authorization.session?.payload?.protocol;
               if (protocol) {
                 this.logger.info(`[${this.requestId}] decision from session: ${protocol}`);
                 this.state.set("intent", protocol);
@@ -27899,6 +28090,18 @@ var init_http_request_flow = __esm({
             this.respond(httpRespond.notFound("Session not found"));
             return;
           }
+          const authorization = request[ServerRequestTokens.auth];
+          if (authorization?.token) {
+            const transportService = this.scope.transportService;
+            if (transportService) {
+              for (const protocol of ["streamable-http", "sse"]) {
+                try {
+                  await transportService.destroyTransporter(protocol, authorization.token, sessionId);
+                } catch {
+                }
+              }
+            }
+          }
           this.logger.info(`[${this.requestId}] Session terminated: ${sessionId}`);
           this.respond(httpRespond.noContent());
         } catch (error) {
@@ -28076,8 +28279,13 @@ var init_transport_remote = __esm({
       async destroy(_reason) {
         throw new MethodNotImplementedError("RemoteTransporter", "destroy");
       }
+      get isInitialized() {
+        return false;
+      }
       markAsInitialized() {
       }
+      resetForReinitialization() {
+      }
     };
   }
 });
@@ -28337,6 +28545,11 @@ var init_sse_transport = __esm({
 // libs/sdk/src/transport/mcp-handlers/initialize-request.handler.ts
 import { InitializeRequestSchema } from "@frontmcp/protocol";
 import { LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS } from "@frontmcp/protocol";
+function persistInitPayload(sessionId, initPayload, ctx) {
+  updateSessionPayload(sessionId, initPayload);
+  const transport = ctx.authInfo?.transport;
+  transport?.setInitSessionPayload(initPayload);
+}
 function guardClientVersion(clientVersion) {
   const parsed = new Date(clientVersion);
   if (isNaN(parsed.getTime())) {
@@ -28375,6 +28588,10 @@ function initializeRequestHandler({
             elicitation: request.params.capabilities.elicitation
           };
           scope.notifications.setClientCapabilities(sessionId, clientCapabilities);
+          await scope.transportService.updateStoredSessionCapabilities(
+            sessionId,
+            clientCapabilities
+          );
           detectedPlatform = detectPlatformFromCapabilities(clientCapabilities);
         }
         if (request.params.clientInfo) {
@@ -28393,22 +28610,30 @@ function initializeRequestHandler({
             if (finalPlatform) {
               ctx.authInfo.sessionIdPayload.platformType = finalPlatform;
             }
-            updateSessionPayload(sessionId, {
-              clientName,
-              clientVersion,
-              supportsElicitation: clientSupportsElicitation,
-              ...finalPlatform && { platformType: finalPlatform }
-            });
+            persistInitPayload(
+              sessionId,
+              {
+                clientName,
+                clientVersion,
+                supportsElicitation: clientSupportsElicitation,
+                ...finalPlatform && { platformType: finalPlatform }
+              },
+              ctx
+            );
           }
         } else if (ctx.authInfo?.sessionIdPayload) {
           ctx.authInfo.sessionIdPayload.supportsElicitation = clientSupportsElicitation;
           if (detectedPlatform) {
             ctx.authInfo.sessionIdPayload.platformType = detectedPlatform;
           }
-          updateSessionPayload(sessionId, {
-            supportsElicitation: clientSupportsElicitation,
-            ...detectedPlatform && { platformType: detectedPlatform }
-          });
+          persistInitPayload(
+            sessionId,
+            {
+              supportsElicitation: clientSupportsElicitation,
+              ...detectedPlatform && { platformType: detectedPlatform }
+            },
+            ctx
+          );
         }
       }
       const requestedVersion = request.params.protocolVersion;
@@ -29388,15 +29613,43 @@ var init_transport_local_adapter = __esm({
        * New elicit requests will cancel any pending one.
        */
       pendingElicit;
+      /**
+       * Session payload fields set during MCP initialize.
+       * Stored on the adapter instance so they survive across requests in SSE mode
+       * (where each POST creates a fresh anonymous HTTP session) and are available
+       * in distributed environments without relying on local in-memory caches.
+       */
+      initSessionPayload;
+      /**
+       * Called by the initialize request handler to persist initialization data
+       * on the transport adapter instance. This data is merged into the session
+       * payload on every subsequent request via ensureAuthInfo().
+       */
+      setInitSessionPayload(payload) {
+        this.initSessionPayload = payload;
+      }
       #requestId = 1;
       ready;
       server;
+      /**
+       * Whether this transport has already been initialized via the MCP initialize handshake.
+       * Override in subclasses that track initialization state.
+       */
+      get isInitialized() {
+        return false;
+      }
       /**
        * Marks this transport as pre-initialized for session recreation.
        * Override in subclasses that need to set the MCP SDK's _initialized flag.
        */
       markAsInitialized() {
       }
+      /**
+       * Resets initialization state to allow re-initialization.
+       * Override in subclasses that support session re-initialization.
+       */
+      resetForReinitialization() {
+      }
       connectServer() {
         const { info, apps } = this.scope.metadata;
         const hasRemoteApps = apps?.some((app) => this.isRemoteApp(app)) ?? false;
@@ -29406,6 +29659,7 @@ var init_transport_local_adapter = __esm({
         const hasAgents = this.scope.agents.hasAny();
         const completionsCapability = hasPrompts || hasResources ? { completions: {} } : {};
         const remoteCapabilities = hasRemoteApps ? this.buildRemoteCapabilities() : {};
+        const elicitationCapability = this.scope.metadata.elicitation?.enabled ? { elicitation: {} } : {};
         const serverOptions = {
           instructions: "",
           capabilities: {
@@ -29418,7 +29672,8 @@ var init_transport_local_adapter = __esm({
             // Include agent capabilities (agents as tools)
             ...completionsCapability,
             // MCP logging protocol support - allows clients to set log level via logging/setLevel
-            logging: {}
+            logging: {},
+            ...elicitationCapability
           },
           serverInfo: info
         };
@@ -29483,8 +29738,28 @@ var init_transport_local_adapter = __esm({
       }
       ensureAuthInfo(req, transport) {
         const { token, user, session } = req[ServerRequestTokens.auth];
-        const sessionId = session?.id ?? `fallback:${Date.now()}`;
-        const sessionPayload = session?.payload ?? { protocol: "streamable-http" };
+        if (!session?.id) {
+          throw new Error(
+            "Session ID is required in ensureAuthInfo. This indicates a bug in session propagation \u2014 the session should have been set by the flow."
+          );
+        }
+        const sessionId = session.id;
+        const sessionPayload = session.payload ?? { protocol: "streamable-http" };
+        if (this.initSessionPayload) {
+          const init = this.initSessionPayload;
+          if (init.supportsElicitation !== void 0 && sessionPayload.supportsElicitation === void 0) {
+            sessionPayload.supportsElicitation = init.supportsElicitation;
+          }
+          if (init.platformType !== void 0 && sessionPayload.platformType === void 0) {
+            sessionPayload["platformType"] = init.platformType;
+          }
+          if (init.clientName !== void 0 && sessionPayload.clientName === void 0) {
+            sessionPayload.clientName = init.clientName;
+          }
+          if (init.clientVersion !== void 0 && sessionPayload.clientVersion === void 0) {
+            sessionPayload.clientVersion = init.clientVersion;
+          }
+        }
         const authInfo = {
           token,
           user,
@@ -29504,6 +29779,17 @@ var init_transport_local_adapter = __esm({
       get elicitStore() {
         return this.scope.elicitationStore;
       }
+      /**
+       * Get the elicitation store, throwing if not initialized.
+       * Use in contexts where elicitation is required (sendElicitRequest, cancelPendingElicit).
+       */
+      requireElicitStore() {
+        const store = this.elicitStore;
+        if (!store) {
+          throw new Error("Elicitation store not initialized");
+        }
+        return store;
+      }
       /**
        * Cancel any pending elicitation request.
        * Called before sending a new elicit to enforce single-elicit-per-session.
@@ -29521,9 +29807,12 @@ var init_transport_local_adapter = __esm({
           clearTimeout(this.pendingElicit.timeoutHandle);
           this.pendingElicit.resolve({ status: "cancel" });
           const sessionId = this.key.sessionId;
-          const pending = await this.elicitStore.getPending(sessionId);
-          if (pending) {
-            await this.elicitStore.publishResult(pending.elicitId, sessionId, { status: "cancel" });
+          const store = this.elicitStore;
+          if (store) {
+            const pending = await store.getPending(sessionId);
+            if (pending) {
+              await store.publishResult(pending.elicitId, sessionId, { status: "cancel" });
+            }
           }
           this.pendingElicit = void 0;
           this.logger.info("Cancelled previous pending elicit");
@@ -30120,7 +30409,7 @@ import {
   hkdfSha256,
   encryptAesGcm,
   decryptAesGcm,
-  randomBytes as randomBytes4,
+  randomBytes as randomBytes5,
   base64urlEncode as base64urlEncode2,
   base64urlDecode as base64urlDecode2,
   getEnv as getEnv4
@@ -30144,7 +30433,7 @@ async function deriveElicitationKey(sessionId, secret) {
 async function encryptElicitationData(data, sessionId, secret) {
   const key = await deriveElicitationKey(sessionId, secret);
   const plaintext = textEncoder.encode(JSON.stringify(data));
-  const iv = randomBytes4(12);
+  const iv = randomBytes5(12);
   const { ciphertext, tag } = encryptAesGcm(key, plaintext, iv);
   return {
     alg: "A256GCM",
@@ -30880,7 +31169,8 @@ var init_transport_sse_adapter = __esm({
         const elicitId = elicitationId ?? `elicit-${this.newRequestId}`;
         const sessionId = this.key.sessionId;
         const expiresAt = Date.now() + ttl;
-        await this.elicitStore.setPending({
+        const store = this.requireElicitStore();
+        await store.setPending({
           elicitId,
           sessionId,
           createdAt: Date.now(),
@@ -30923,10 +31213,10 @@ var init_transport_sse_adapter = __esm({
             settled = true;
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(new ElicitationTimeoutError(elicitId, ttl));
           }, ttl);
-          this.elicitStore.subscribeResult(
+          store.subscribeResult(
             elicitId,
             (result) => {
               safeResolve(result);
@@ -30940,7 +31230,7 @@ var init_transport_sse_adapter = __esm({
             clearTimeout(timeoutHandle);
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(err);
           });
           this.pendingElicit = {
@@ -30974,9 +31264,16 @@ var init_streamable_http_transport = __esm({
        * so we need to create fresh instances for each request.
        */
       _constructorOptions;
+      /**
+       * When true, the transport recreates the internal transport for each request.
+       * Decoupled from sessionIdGenerator so stateless transports can still
+       * provide a session ID (e.g., '__stateless__') in the response header.
+       */
+      _isStateless;
       constructor(options = {}) {
         super(options);
         this._constructorOptions = options;
+        this._isStateless = options.isStateless ?? false;
       }
       /**
        * Returns whether the transport has been initialized.
@@ -31016,6 +31313,31 @@ var init_streamable_http_transport = __esm({
         }
         this._applyInitState(webTransport, sessionId);
       }
+      /**
+       * Resets the transport's initialization state to allow re-initialization.
+       *
+       * This is needed when a client reconnects after terminating its session:
+       * the cached transport is still marked as initialized, but the client
+       * needs to re-initialize. Resetting _initialized and sessionId allows
+       * the MCP SDK to process a fresh initialize request.
+       *
+       * This is the inverse of setInitializationState().
+       */
+      resetForReinitialization() {
+        const webTransport = this._webStandardTransport;
+        if (!webTransport) {
+          this._pendingInitState = void 0;
+          return;
+        }
+        if (!("_initialized" in webTransport)) {
+          throw new InvalidTransportSessionError(
+            "[RecreateableStreamableHTTPServerTransport] Expected _initialized field not found on internal transport. This may indicate an incompatible MCP SDK version."
+          );
+        }
+        webTransport._initialized = false;
+        webTransport.sessionId = void 0;
+        this._pendingInitState = void 0;
+      }
       /**
        * Applies initialization state to the internal transport.
        * @param webTransport - The internal _webStandardTransport object
@@ -31040,7 +31362,7 @@ var init_streamable_http_transport = __esm({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async handleRequest(req, res, body) {
         const oldWebTransport = this._webStandardTransport;
-        if (oldWebTransport && !oldWebTransport.sessionIdGenerator && oldWebTransport._hasHandledRequest) {
+        if (oldWebTransport && this._isStateless && oldWebTransport._hasHandledRequest) {
           const fresh = new WebStandardStreamableHTTPServerTransport(this._constructorOptions);
           fresh.onmessage = oldWebTransport.onmessage;
           fresh.onclose = oldWebTransport.onclose;
@@ -31072,14 +31394,16 @@ var init_transport_streamable_http_adapter = __esm({
     init_streamable_http_transport();
     init_errors();
     resolveSessionIdGenerator = (transportType, sessionId) => {
-      return transportType === "stateless-http" ? void 0 : () => sessionId;
+      return transportType === "stateless-http" ? () => "__stateless__" : () => sessionId;
     };
     TransportStreamableHttpAdapter = class extends LocalTransportAdapter {
       createTransport(sessionId, response) {
         const sessionIdGenerator = resolveSessionIdGenerator(this.key.type, sessionId);
         const eventStore = this.scope.eventStore;
+        const isStateless = this.key.type === "stateless-http";
         return new RecreateableStreamableHTTPServerTransport({
           sessionIdGenerator,
+          isStateless,
           onsessionclosed: () => {
           },
           onsessioninitialized: (sessionId2) => {
@@ -31173,6 +31497,7 @@ var init_transport_streamable_http_adapter = __esm({
        */
       async sendElicitRequest(relatedRequestId, message, requestedSchema, options) {
         await this.cancelPendingElicit();
+        const store = this.requireElicitStore();
         const sessionId = this.key.sessionId;
         const flowOutput = await this.scope.runFlowForOutput("elicitation:request", {
           relatedRequestId,
@@ -31197,7 +31522,7 @@ var init_transport_streamable_http_adapter = __esm({
         } catch (error) {
           this.logger.error("[StreamableHttpAdapter] sendElicitRequest: transport.send() failed", error);
           try {
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             this.logger.verbose("[StreamableHttpAdapter] sendElicitRequest: cleaned up pending record after send failure");
           } catch (cleanupError) {
             this.logger.warn("[StreamableHttpAdapter] sendElicitRequest: failed to clean up pending record", cleanupError);
@@ -31229,10 +31554,10 @@ var init_transport_streamable_http_adapter = __esm({
             settled = true;
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(new ElicitationTimeoutError(elicitId, ttl));
           }, ttl);
-          this.elicitStore.subscribeResult(
+          store.subscribeResult(
             elicitId,
             (result) => {
               safeResolve(result);
@@ -31246,7 +31571,7 @@ var init_transport_streamable_http_adapter = __esm({
             clearTimeout(timeoutHandle);
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(err);
           });
           this.pendingElicit = {
@@ -31257,6 +31582,20 @@ var init_transport_streamable_http_adapter = __esm({
           };
         });
       }
+      get isInitialized() {
+        return this.transport.isInitialized || this.transport.hasPendingInitState;
+      }
+      /**
+       * Resets the transport's initialization state to allow re-initialization.
+       * Used when a client retries initialize on an already-initialized session
+       * (e.g., after reconnect following session termination).
+       */
+      resetForReinitialization() {
+        this.transport.resetForReinitialization();
+        this.logger.info("[StreamableHttpAdapter] Reset transport for re-initialization", {
+          sessionId: this.key.sessionId?.slice(0, 20)
+        });
+      }
       /**
        * Marks this transport as pre-initialized for session recreation.
        * This is needed when recreating a transport from Redis because the
@@ -31331,6 +31670,9 @@ var init_transport_local = __esm({
           res.status(500).json(rpcError("Internal error"));
         }
       }
+      get isInitialized() {
+        return this.adapter.isInitialized;
+      }
       /**
        * Marks this transport as pre-initialized for session recreation.
        * This is needed when recreating a transport from Redis because the
@@ -31339,6 +31681,9 @@ var init_transport_local = __esm({
       markAsInitialized() {
         this.adapter.markAsInitialized();
       }
+      resetForReinitialization() {
+        this.adapter.resetForReinitialization();
+      }
       async destroy(reason) {
         try {
           await this.adapter.destroy(reason);
@@ -31725,6 +32070,79 @@ var init_ext_apps2 = __esm({
 // libs/sdk/src/transport/flows/handle.streamable-http.flow.ts
 import { z as z62 } from "zod";
 import { ElicitResultSchema as ElicitResultSchema2, RequestSchema, CallToolResultSchema as CallToolResultSchema3 } from "@frontmcp/protocol";
+function resolveStreamableHttpSession(params) {
+  const { rawHeader, authorizationSession, createSession } = params;
+  const rawMcpSessionHeader = typeof rawHeader === "string" ? rawHeader : void 0;
+  const mcpSessionHeader = validateMcpSessionHeader(rawMcpSessionHeader);
+  if (rawHeader !== void 0 && !mcpSessionHeader) {
+    return { responded404: true, createdNew: false };
+  }
+  if (mcpSessionHeader) {
+    if (authorizationSession?.id === mcpSessionHeader) {
+      return { session: authorizationSession, createdNew: false, responded404: false };
+    }
+    return { session: { id: mcpSessionHeader }, createdNew: false, responded404: false };
+  }
+  if (authorizationSession) {
+    return { session: authorizationSession, createdNew: false, responded404: false };
+  }
+  return { session: createSession(), createdNew: true, responded404: false };
+}
+function classifyStreamableHttpRequest(params) {
+  const { method, body } = params;
+  if (method.toUpperCase() === "GET") {
+    return { requestType: "sseListener" };
+  }
+  const jsonRpcMethod = body?.method;
+  if (jsonRpcMethod === "initialize") {
+    return { requestType: "initialize" };
+  }
+  if (typeof jsonRpcMethod === "string" && jsonRpcMethod.startsWith("ui/")) {
+    return { requestType: "extApps" };
+  }
+  if (ElicitResultSchema2.safeParse(body?.result).success) {
+    return { requestType: "elicitResult" };
+  }
+  if (jsonRpcMethod && RequestSchema.safeParse(body).success) {
+    return { requestType: "message" };
+  }
+  return { error: "Invalid Request" };
+}
+function syncStreamableHttpAuthorizationSession(authorization, session) {
+  if (!authorization.session) {
+    authorization.session = session;
+  }
+}
+async function lookupStreamableHttpTransport(params) {
+  const { transportService, token, sessionId, response } = params;
+  const inMemoryTransport = await transportService.getTransporter("streamable-http", token, sessionId);
+  if (inMemoryTransport) {
+    return { kind: "transport", source: "memory", transport: inMemoryTransport };
+  }
+  let recreationError;
+  try {
+    const storedSession = await transportService.getStoredSession("streamable-http", token, sessionId);
+    if (storedSession) {
+      const recreatedTransport = await transportService.recreateTransporter(
+        "streamable-http",
+        token,
+        sessionId,
+        storedSession,
+        response
+      );
+      if (recreatedTransport) {
+        return { kind: "transport", source: "redis", transport: recreatedTransport };
+      }
+    }
+  } catch (error) {
+    recreationError = error;
+  }
+  const wasCreated = await transportService.wasSessionCreatedAsync("streamable-http", token, sessionId);
+  if (wasCreated) {
+    return { kind: "session-expired", recreationError };
+  }
+  return { kind: "session-not-initialized", recreationError };
+}
 var plan19, stateSessionSchema, stateSchema18, name20, Stage20, HandleStreamableHttpFlow;
 var init_handle_streamable_http_flow = __esm({
   "libs/sdk/src/transport/flows/handle.streamable-http.flow.ts"() {
@@ -31766,64 +32184,60 @@ 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 raw = request.headers?.["mcp-session-id"];
-        const rawMcpSessionHeader = typeof raw === "string" ? raw : void 0;
-        const mcpSessionHeader = validateMcpSessionHeader(rawMcpSessionHeader);
-        if (raw !== void 0 && !mcpSessionHeader) {
+        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
+            });
+          }
+        });
+        if (sessionResolution.responded404 || !sessionResolution.session) {
           logger.warn("parseInput: invalid mcp-session-id header");
           this.respond(httpRespond.sessionNotFound("invalid session id"));
           return;
         }
-        let session;
-        if (mcpSessionHeader) {
-          if (authorization.session?.id === mcpSessionHeader) {
-            session = authorization.session;
-          } else {
-            session = { id: mcpSessionHeader };
-          }
-        } else if (authorization.session) {
-          session = authorization.session;
-        } else {
-          const query = request.query;
-          const skillsOnlyMode = detectSkillsOnlyMode(query);
-          session = createSessionId("streamable-http", token, {
-            userAgent: request.headers?.["user-agent"],
-            platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
-            skillsOnlyMode
-          });
-        }
+        const session = sessionResolution.session;
         this.state.set(stateSchema18.parse({ token, session }));
         logger.info("parseInput: session resolved", { sessionId: session.id?.slice(0, 20) });
       }
       async router() {
         const { request } = this.rawInput;
         const logger = this.scopeLogger.child("handle:streamable-http:router");
-        if (request.method.toUpperCase() === "GET") {
-          this.state.set("requestType", "sseListener");
-          logger.info("router: requestType=sseListener, method=GET");
+        const classification = classifyStreamableHttpRequest({
+          method: request.method,
+          body: request.body
+        });
+        if ("error" in classification) {
+          logger.warn("router: invalid request, no valid method");
+          this.respond(httpRespond.rpcError("Invalid Request"));
           return;
         }
-        const body = request.body;
-        const method = body?.method;
-        if (method === "initialize") {
-          this.state.set("requestType", "initialize");
+        this.state.set("requestType", classification.requestType);
+        if (classification.requestType === "sseListener") {
+          logger.info("router: requestType=sseListener, method=GET");
+        } else if (classification.requestType === "initialize") {
           logger.info("router: requestType=initialize, method=POST");
-        } else if (typeof method === "string" && method.startsWith("ui/")) {
-          this.state.set("requestType", "extApps");
+        } else if (classification.requestType === "extApps") {
+          const method = request.body?.method;
           logger.info(`router: requestType=extApps, method=${method}`);
-        } else if (ElicitResultSchema2.safeParse(request.body?.result).success) {
-          this.state.set("requestType", "elicitResult");
+        } else if (classification.requestType === "elicitResult") {
           logger.info("router: requestType=elicitResult, method=POST");
-        } else if (method && RequestSchema.safeParse(request.body).success) {
-          this.state.set("requestType", "message");
-          logger.info(`router: requestType=message, method=${method}`);
         } else {
-          logger.warn("router: invalid request, no valid method");
-          this.respond(httpRespond.rpcError("Invalid Request"));
+          const method = request.body?.method;
+          logger.info(`router: requestType=message, method=${method}`);
         }
       }
       async onInitialize() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scope.logger.child("handle:streamable-http:onInitialize");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -31833,7 +32247,15 @@ var init_handle_streamable_http_flow = __esm({
           tokenPrefix: token?.slice(0, 10)
         });
         try {
+          const authorization = request[ServerRequestTokens.auth];
+          syncStreamableHttpAuthorizationSession(authorization, session);
           const transport = await transportService.createTransporter("streamable-http", token, session.id, response);
+          if (transport.isInitialized) {
+            logger.info("onInitialize: transport already initialized, resetting for re-initialization", {
+              sessionId: session.id?.slice(0, 20)
+            });
+            transport.resetForReinitialization();
+          }
           logger.info("onInitialize: transport created, calling initialize");
           await transport.initialize(request, response);
           logger.info("onInitialize: completed successfully");
@@ -31851,6 +32273,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onElicitResult() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onElicitResult");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -31901,6 +32326,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onMessage() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onMessage");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -31908,44 +32336,21 @@ var init_handle_streamable_http_flow = __esm({
           sessionId: session.id?.slice(0, 20),
           hasToken: !!token
         });
-        let transport = await transportService.getTransporter("streamable-http", token, session.id);
-        logger.verbose("onMessage: getTransporter result", { found: !!transport });
-        if (!transport) {
-          try {
-            logger.verbose("onMessage: transport not in memory, checking Redis", {
-              sessionId: session.id?.slice(0, 20)
-            });
-            const storedSession = await transportService.getStoredSession("streamable-http", token, session.id);
-            logger.verbose("onMessage: getStoredSession result", {
-              found: !!storedSession,
-              initialized: storedSession?.initialized
-            });
-            if (storedSession) {
-              logger.verbose("onMessage: recreating transport from stored session", {
-                sessionId: session.id?.slice(0, 20),
-                createdAt: storedSession.createdAt,
-                initialized: storedSession.initialized
-              });
-              transport = await transportService.recreateTransporter(
-                "streamable-http",
-                token,
-                session.id,
-                storedSession,
-                response
-              );
-              logger.verbose("onMessage: transport recreated successfully");
-            }
-          } catch (error) {
+        const transportLookup = await lookupStreamableHttpTransport({
+          transportService,
+          token,
+          sessionId: session.id,
+          response
+        });
+        if (transportLookup.kind !== "transport") {
+          const body = request.body;
+          if (transportLookup.recreationError) {
             logger.warn("Failed to recreate transport from stored session", {
               sessionId: session.id?.slice(0, 20),
-              error: error instanceof Error ? error.message : String(error)
+              error: transportLookup.recreationError instanceof Error ? transportLookup.recreationError.message : String(transportLookup.recreationError)
             });
           }
-        }
-        if (!transport) {
-          const wasCreated = await transportService.wasSessionCreatedAsync("streamable-http", token, session.id);
-          const body = request.body;
-          if (wasCreated) {
+          if (transportLookup.kind === "session-expired") {
             logger.info("Session expired - client should re-initialize", {
               sessionId: session.id?.slice(0, 20),
               tokenHash: token.slice(0, 8),
@@ -31967,6 +32372,8 @@ var init_handle_streamable_http_flow = __esm({
           }
           return;
         }
+        const transport = transportLookup.transport;
+        logger.verbose("onMessage: transport resolved", { source: transportLookup.source });
         try {
           await transport.handleRequest(request, response);
           this.handled();
@@ -31985,6 +32392,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onSseListener() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onSseListener");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -32022,6 +32432,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onExtApps() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onExtApps");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -32072,8 +32485,7 @@ var init_handle_streamable_http_flow = __esm({
           }
           return;
         }
-        const scope = this.scope;
-        const configuredCapabilities = scope.metadata.extApps?.hostCapabilities;
+        const configuredCapabilities = this.scope.metadata.extApps?.hostCapabilities;
         const hostCapabilities = {
           serverToolProxy: configuredCapabilities?.serverToolProxy ?? true,
           logging: configuredCapabilities?.logging ?? true,
@@ -32082,9 +32494,9 @@ var init_handle_streamable_http_flow = __esm({
         const handler = createExtAppsMessageHandler({
           context: {
             sessionId: session.id,
-            logger: scope.logger,
+            logger: this.scope.logger,
             callTool: async (name33, args) => {
-              const result = await scope.runFlow("tools:call-tool", {
+              const result = await this.scope.runFlow("tools:call-tool", {
                 request: { method: "tools/call", params: { name: name33, arguments: args } },
                 ctx: {
                   authInfo: {
@@ -32170,6 +32582,7 @@ var init_handle_sse_flow = __esm({
   "libs/sdk/src/transport/flows/handle.sse.flow.ts"() {
     "use strict";
     init_common();
+    init_errors();
     init_session_id_utils();
     init_skill_mode_utils();
     plan20 = {
@@ -32239,10 +32652,9 @@ var init_handle_sse_flow = __esm({
       }
       async router() {
         const { request } = this.rawInput;
-        const scope = this.scope;
         const requestPath = normalizeEntryPrefix(request.path);
-        const prefix = normalizeEntryPrefix(scope.entryPath);
-        const scopePath = normalizeScopeBase(scope.routeBase);
+        const prefix = normalizeEntryPrefix(this.scope.entryPath);
+        const scopePath = normalizeScopeBase(this.scope.routeBase);
         const basePath = `${prefix}${scopePath}`;
         if (requestPath === `${basePath}/sse`) {
           this.state.set("requestType", "initialize");
@@ -32252,6 +32664,9 @@ var init_handle_sse_flow = __esm({
       }
       async onInitialize() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
         const transport = await transportService.createTransporter("sse", token, session.id, response);
@@ -32263,6 +32678,9 @@ var init_handle_sse_flow = __esm({
       }
       async onMessage() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:legacy-sse:onMessage");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -32335,6 +32753,7 @@ var init_handle_stateless_http_flow = __esm({
   "libs/sdk/src/transport/flows/handle.stateless-http.flow.ts"() {
     "use strict";
     init_common();
+    init_errors();
     plan21 = {
       pre: ["parseInput", "router"],
       execute: ["handleRequest"],
@@ -32382,6 +32801,9 @@ var init_handle_stateless_http_flow = __esm({
       }
       async handleRequest() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scope.logger.child("HandleStatelessHttpFlow");
         const { request, response } = this.rawInput;
         const { token, isAuthenticated, requestType } = this.state;
@@ -32717,6 +33139,12 @@ var init_transport_registry = __esm({
           transporter.markAsInitialized();
         }
         this.insertLocal(key, transporter);
+        if (storedSession.clientCapabilities) {
+          this.scope.notifications.setClientCapabilities(sessionId, storedSession.clientCapabilities);
+          this.scope.logger.verbose("[TransportService] Restored client capabilities from stored session", {
+            sessionId: sessionId.slice(0, 20)
+          });
+        }
         if (sessionStore) {
           const updatedSession = {
             ...storedSession,
@@ -32814,6 +33242,40 @@ var init_transport_registry = __esm({
         }
         throw new InvalidTransportSessionError("Invalid session: cannot destroy non-existent transporter.");
       }
+      /**
+       * Update the stored session in Redis with client capabilities from the initialize handshake.
+       * This ensures capabilities survive session recreation (e.g., after server restart or transport eviction).
+       *
+       * Best-effort: failures are logged but do not throw.
+       * No-op when sessionStore is not configured.
+       */
+      async updateStoredSessionCapabilities(sessionId, clientCapabilities) {
+        if (!this.sessionStore) return;
+        try {
+          const stored = await this.sessionStore.get(sessionId);
+          if (!stored) {
+            this.scope.logger.verbose("[TransportService] Cannot update capabilities: session not found in store", {
+              sessionId: sessionId.slice(0, 20)
+            });
+            return;
+          }
+          const updatedSession = {
+            ...stored,
+            clientCapabilities,
+            lastAccessedAt: Date.now()
+          };
+          const defaultTtlMs = this.getDefaultTtlMs();
+          await this.sessionStore.set(sessionId, updatedSession, defaultTtlMs);
+          this.scope.logger.verbose("[TransportService] Persisted client capabilities to session store", {
+            sessionId: sessionId.slice(0, 20)
+          });
+        } catch (err) {
+          this.scope.logger.warn("[TransportService] Failed to persist client capabilities", {
+            sessionId: sessionId.slice(0, 20),
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
       /**
        * Get or create a shared singleton transport for anonymous stateless requests.
        * All anonymous requests share the same transport instance.
@@ -35901,18 +36363,15 @@ var init_complete_flow = __esm({
           } else {
             const resourceMatch = this.scope.resources.findResourceForUri(uri);
             if (resourceMatch) {
-              const instance = resourceMatch.instance;
-              if (typeof instance.getArgumentCompleter === "function") {
-                const completer = instance.getArgumentCompleter(argName);
-                if (completer) {
-                  try {
-                    const result = await completer(argValue);
-                    values = result.values || [];
-                    total = result.total;
-                    hasMore = result.hasMore;
-                  } catch (e) {
-                    this.logger.warn(`complete: completer failed for resource "${uri}" argument "${argName}": ${e}`);
-                  }
+              const completer = resourceMatch.instance.getArgumentCompleter(argName);
+              if (completer) {
+                try {
+                  const result = await completer(argValue);
+                  values = result.values || [];
+                  total = result.total;
+                  hasMore = result.hasMore;
+                } catch (e) {
+                  this.logger.warn(`complete: completer failed for resource "${uri}" argument "${argName}": ${e}`);
                 }
               }
             } else {
@@ -36031,11 +36490,10 @@ var init_call_agent_flow = __esm({
           throw new InvalidMethodError(method, "tools/call");
         }
         const { name: toolName } = params;
-        const scope = this.scope;
         const agentId = toolName;
         let agent;
-        if (scope.agents) {
-          agent = scope.agents.findById(agentId) ?? scope.agents.findByName(agentId);
+        if (this.scope.agents) {
+          agent = this.scope.agents.findById(agentId) ?? this.scope.agents.findByName(agentId);
         }
         const agentOwnerId = agent?.owner?.id;
         const progressToken = params._meta?.progressToken;
@@ -36051,8 +36509,7 @@ var init_call_agent_flow = __esm({
       }
       async findAgent() {
         this.logger.verbose("findAgent:start");
-        const scope = this.scope;
-        const agents = scope.agents;
+        const agents = this.scope.agents;
         if (!agents) {
           this.logger.warn("findAgent: no agent registry available");
           throw new AgentNotFoundError(this.state.required.input.name);
@@ -36473,7 +36930,10 @@ var init_elicitation_request_flow = __esm({
       async storePendingRecord() {
         this.logger.verbose("storePendingRecord:start");
         const { elicitId, sessionId, message, mode, expiresAt, requestedSchema } = this.state.required;
-        const scope = this.scope;
+        const store = this.scope.elicitationStore;
+        if (!store) {
+          throw new ElicitationStoreNotInitializedError();
+        }
         const pendingRecord = {
           elicitId,
           sessionId,
@@ -36483,7 +36943,7 @@ var init_elicitation_request_flow = __esm({
           mode,
           requestedSchema
         };
-        await scope.elicitationStore.setPending(pendingRecord);
+        await store.setPending(pendingRecord);
         this.state.set("pendingRecord", pendingRecord);
         this.logger.verbose("storePendingRecord:done", { elicitId, sessionId });
       }
@@ -36610,8 +37070,11 @@ var init_elicitation_result_flow = __esm({
       async lookupPending() {
         this.logger.verbose("lookupPending:start");
         const { sessionId } = this.state.required;
-        const scope = this.scope;
-        const pendingRecord = await scope.elicitationStore.getPending(sessionId);
+        const store = this.scope.elicitationStore;
+        if (!store) {
+          throw new ElicitationStoreNotInitializedError();
+        }
+        const pendingRecord = await store.getPending(sessionId);
         this.state.set("pendingRecord", pendingRecord ?? void 0);
         if (!pendingRecord) {
           this.logger.verbose("lookupPending:notFound", { sessionId });
@@ -36663,14 +37126,14 @@ var init_elicitation_result_flow = __esm({
         this.logger.verbose("publishResult:start");
         const { pendingRecord, elicitResult } = this.state;
         const { sessionId } = this.state.required;
-        const scope = this.scope;
-        if (!pendingRecord || !elicitResult) {
+        const store = this.scope.elicitationStore;
+        if (!pendingRecord || !elicitResult || !store) {
           this.state.set("handled", false);
           this.logger.verbose("publishResult:skip (no pending or no result)");
           return;
         }
         try {
-          await scope.elicitationStore.publishResult(pendingRecord.elicitId, sessionId, elicitResult);
+          await store.publishResult(pendingRecord.elicitId, sessionId, elicitResult);
           this.state.set("handled", true);
           this.logger.verbose("publishResult:done", {
             elicitId: pendingRecord.elicitId,
@@ -36767,30 +37230,30 @@ var require_dist = __commonJS({
       sqliteStorageOptionsSchema: () => sqliteStorageOptionsSchema
     });
     module.exports = __toCommonJS2(index_exports);
-    var import_utils74 = __require("@frontmcp/utils");
+    var import_utils77 = __require("@frontmcp/utils");
     var HKDF_SALT = new TextEncoder().encode("frontmcp-sqlite-storage-v1");
     var HKDF_INFO = new TextEncoder().encode("aes-256-gcm-value-encryption");
     var KEY_LENGTH = 32;
     function deriveEncryptionKey(secret) {
       const ikm = new TextEncoder().encode(secret);
-      return (0, import_utils74.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
+      return (0, import_utils77.hkdfSha256)(ikm, HKDF_SALT, HKDF_INFO, KEY_LENGTH);
     }
     var SEPARATOR = ":";
     function encryptValue(key, plaintext) {
-      const iv = (0, import_utils74.randomBytes)(12);
+      const iv = (0, import_utils77.randomBytes)(12);
       const plaintextBytes = new TextEncoder().encode(plaintext);
-      const { ciphertext, tag } = (0, import_utils74.encryptAesGcm)(key, plaintextBytes, iv);
-      return [(0, import_utils74.base64urlEncode)(iv), (0, import_utils74.base64urlEncode)(tag), (0, import_utils74.base64urlEncode)(ciphertext)].join(SEPARATOR);
+      const { ciphertext, tag } = (0, import_utils77.encryptAesGcm)(key, plaintextBytes, iv);
+      return [(0, import_utils77.base64urlEncode)(iv), (0, import_utils77.base64urlEncode)(tag), (0, import_utils77.base64urlEncode)(ciphertext)].join(SEPARATOR);
     }
     function decryptValue(key, encrypted) {
       const parts = encrypted.split(SEPARATOR);
       if (parts.length !== 3) {
         throw new Error("Invalid encrypted value format");
       }
-      const iv = (0, import_utils74.base64urlDecode)(parts[0]);
-      const tag = (0, import_utils74.base64urlDecode)(parts[1]);
-      const ciphertext = (0, import_utils74.base64urlDecode)(parts[2]);
-      const plaintext = (0, import_utils74.decryptAesGcm)(key, ciphertext, iv, tag);
+      const iv = (0, import_utils77.base64urlDecode)(parts[0]);
+      const tag = (0, import_utils77.base64urlDecode)(parts[1]);
+      const ciphertext = (0, import_utils77.base64urlDecode)(parts[2]);
+      const plaintext = (0, import_utils77.decryptAesGcm)(key, ciphertext, iv, tag);
       return new TextDecoder().decode(plaintext);
     }
     var SqliteKvStore = class {
@@ -38063,7 +38526,7 @@ var init_job_instance = __esm({
         this.name = record.metadata.id || record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         this.outputSchema = record.metadata.outputSchema ?? {};
         this.ready = this.initialize();
@@ -38449,7 +38912,7 @@ var init_workflow_instance = __esm({
         this.name = record.metadata.id || record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.ready = this.initialize();
       }
       async initialize() {
@@ -40107,13 +40570,12 @@ var init_scope_instance = __esm({
     init_plugin_registry();
     init_elicitation2();
     init_flows2();
-    init_elicitation_error();
     init_send_elicitation_result_tool();
     init_tool_utils();
     init_tool_instance();
     init_event_stores();
     init_job_scope_helper();
-    Scope = class _Scope extends ScopeEntry2 {
+    Scope = class _Scope extends ScopeEntry3 {
       id;
       globalProviders;
       logger;
@@ -40237,20 +40699,21 @@ var init_scope_instance = __esm({
           };
           this.scopePlugins = new PluginRegistry(this.scopeProviders, serverPlugins, scopeRef, serverPluginScopeInfo);
         }
+        if (this.scopePlugins) {
+          await this.scopePlugins.ready;
+        }
         this.scopeTools = new ToolRegistry(this.scopeProviders, [], scopeRef);
         this.scopeResources = new ResourceRegistry(this.scopeProviders, [], scopeRef);
         this.scopePrompts = new PromptRegistry(this.scopeProviders, [], scopeRef);
         this.scopeAgents = new AgentRegistry(this.scopeProviders, [], scopeRef);
         this.scopeSkills = new SkillRegistry(this.scopeProviders, this.metadata.skills ?? [], scopeRef);
-        const batch2 = [
+        await Promise.all([
           this.scopeTools.ready,
           this.scopeResources.ready,
           this.scopePrompts.ready,
           this.scopeAgents.ready,
           this.scopeSkills.ready
-        ];
-        if (this.scopePlugins) batch2.push(this.scopePlugins.ready);
-        await Promise.all(batch2);
+        ]);
         if (this.scopePlugins) {
           const pluginNames = this.scopePlugins.getPluginNames();
           this.logger.verbose(`PluginRegistry initialized (${pluginNames.length} plugin(s): [${pluginNames.join(", ")}])`);
@@ -40522,7 +40985,7 @@ var init_scope_instance = __esm({
           {
             scope: ProviderScope2.GLOBAL,
             name: "ScopeEntry",
-            provide: ScopeEntry2,
+            provide: ScopeEntry3,
             useValue: this
           },
           {
@@ -40619,9 +41082,6 @@ var init_scope_instance = __esm({
        * @see createElicitationStore for factory implementation details
        */
       get elicitationStore() {
-        if (!this._elicitationStore) {
-          throw new ElicitationStoreNotInitializedError();
-        }
         return this._elicitationStore;
       }
       /**
@@ -40655,7 +41115,7 @@ var init_scope_instance = __esm({
        * Register the sendElicitationResult system tool.
        * This tool is hidden by default and only shown to clients that don't support elicitation.
        */
-      registerSendElicitationResultTool(scopeRef) {
+      registerSendElicitationResultTool(_scopeRef) {
         try {
           const toolRecord = normalizeTool(SendElicitationResultTool);
           const systemToolEntry = new ToolInstance(toolRecord, this.scopeProviders, {
@@ -40866,7 +41326,7 @@ var init_base_host_adapter = __esm({
 import * as http from "node:http";
 import express from "express";
 import cors from "cors";
-import { fileExists as fileExists3, unlink } from "@frontmcp/utils";
+import { fileExists as fileExists4, unlink } from "@frontmcp/utils";
 var ExpressHostAdapter;
 var init_express_host_adapter = __esm({
   "libs/sdk/src/server/adapters/express.host.adapter.ts"() {
@@ -40963,7 +41423,7 @@ var init_express_host_adapter = __esm({
       }
       async cleanupStaleSocket(socketPath) {
         try {
-          if (await fileExists3(socketPath)) {
+          if (await fileExists4(socketPath)) {
             await unlink(socketPath);
           }
         } catch {
@@ -41088,7 +41548,7 @@ var init_front_mcp_providers = __esm({
         useValue: metadata
       })
     };
-    DEFAULT_HTTP_OPTIONS = { port: 3e3, entryPath: "/mcp" };
+    DEFAULT_HTTP_OPTIONS = { port: Number(process.env["PORT"]) || 3e3, entryPath: "/mcp" };
     frontMcpServer = AsyncProvider({
       name: "frontmcp:server",
       scope: ProviderScope5.GLOBAL,
@@ -42421,7 +42881,7 @@ var front_mcp_exports = {};
 __export(front_mcp_exports, {
   FrontMcpInstance: () => FrontMcpInstance
 });
-import { randomUUID as randomUUID25, fileExists as fileExists4, unlink as unlink2 } from "@frontmcp/utils";
+import { randomUUID as randomUUID25, fileExists as fileExists5, unlink as unlink2 } from "@frontmcp/utils";
 var FrontMcpInstance;
 var init_front_mcp = __esm({
   "libs/sdk/src/front-mcp/front-mcp.ts"() {
@@ -42464,6 +42924,9 @@ var init_front_mcp = __esm({
           throw new ServerNotFoundError();
         }
         await server.start();
+        for (const scope of this.getScopes()) {
+          await scope.emitServerStarted();
+        }
       }
       /**
        * Get the configuration used to create this FrontMCP instance.
@@ -42479,7 +42942,13 @@ var init_front_mcp = __esm({
         return this.scopes.getScopes();
       }
       static async bootstrap(options) {
-        const frontMcp = new _FrontMcpInstance2(options);
+        const parsedConfig = frontMcpMetadataSchema.parse(options);
+        const daemonSocket = process.env["FRONTMCP_DAEMON_SOCKET"];
+        if (daemonSocket) {
+          await _FrontMcpInstance2.runUnixSocket({ ...parsedConfig, socketPath: daemonSocket });
+          return;
+        }
+        const frontMcp = new _FrontMcpInstance2(parsedConfig);
         await frontMcp.ready;
         await frontMcp.start();
         frontMcp.log?.info("FrontMCP bootstrap complete");
@@ -42650,7 +43119,7 @@ var init_front_mcp = __esm({
         frontMcp.log?.info(`MCP server listening on unix://${socketPath}`);
         const cleanup = async () => {
           try {
-            if (await fileExists4(socketPath)) {
+            if (await fileExists5(socketPath)) {
               await unlink2(socketPath);
             }
           } catch {
@@ -43294,6 +43763,7 @@ var init_agent_decorator = __esm({
 
 // libs/sdk/src/common/decorators/skill.decorator.ts
 import "reflect-metadata";
+import { dirname as dirname2 } from "@frontmcp/utils";
 function FrontMcpSkill(providedMetadata) {
   return (target) => {
     const metadata = skillMetadataSchema.parse(providedMetadata);
@@ -43313,13 +43783,33 @@ function FrontMcpSkill(providedMetadata) {
 function frontMcpSkill(providedMetadata) {
   const parsedMetadata = skillMetadataSchema.parse(providedMetadata);
   const skillToken = /* @__PURE__ */ Symbol(`skill:${parsedMetadata.name}`);
+  const callerDir = resolveCallerDir();
   return {
     kind: "VALUE" /* VALUE */,
     provide: skillToken,
     // Cast to SkillMetadata - Zod's output type has internal type markers that don't match exactly
-    metadata: parsedMetadata
+    metadata: parsedMetadata,
+    callerDir
   };
 }
+function resolveCallerDir() {
+  const err = new Error();
+  const stack = err.stack;
+  if (!stack) return void 0;
+  const lines = stack.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(/\(([^)]+):\d+:\d+\)/) || line.match(/at\s+([^\s:]+):\d+:\d+/);
+    if (match) {
+      const file = match[1];
+      if (file.includes("node_modules") || file.includes("skill.decorator")) {
+        continue;
+      }
+      return dirname2(file);
+    }
+  }
+  return void 0;
+}
 function skillEsm(specifier, targetName, options) {
   const parsed = parsePackageSpecifier(specifier);
   return {
@@ -43392,7 +43882,7 @@ var init_skill_decorator = __esm({
 
 // libs/sdk/src/common/decorators/job.decorator.ts
 import "reflect-metadata";
-function FrontMcpJob(providedMetadata) {
+function _FrontMcpJob(providedMetadata) {
   return (target) => {
     const metadata = frontMcpJobMetadataSchema.parse(providedMetadata);
     Reflect.defineMetadata(FrontMcpJobTokens.type, true, target);
@@ -43455,7 +43945,7 @@ function jobRemote(url, targetName, options) {
     }
   };
 }
-var Job;
+var FrontMcpJob, Job;
 var init_job_decorator = __esm({
   "libs/sdk/src/common/decorators/job.decorator.ts"() {
     "use strict";
@@ -43463,11 +43953,12 @@ var init_job_decorator = __esm({
     init_job_metadata();
     init_package_specifier();
     init_validate_remote_url();
-    Object.assign(FrontMcpJob, {
+    Object.assign(_FrontMcpJob, {
       esm: jobEsm,
       remote: jobRemote
     });
-    Job = FrontMcpJob;
+    FrontMcpJob = _FrontMcpJob;
+    Job = _FrontMcpJob;
   }
 });
 
@@ -43546,7 +44037,7 @@ var init_front_mcp_interface = __esm({
 
 // libs/sdk/src/common/interfaces/server.interface.ts
 import { IncomingMessage, HttpServerResponse } from "@frontmcp/protocol";
-var ServerRequest11, ServerResponse3, FrontMcpServer;
+var ServerRequest11, ServerResponse4, FrontMcpServer;
 var init_server_interface = __esm({
   "libs/sdk/src/common/interfaces/server.interface.ts"() {
     "use strict";
@@ -43556,7 +44047,7 @@ var init_server_interface = __esm({
       body;
       authSession;
     };
-    ServerResponse3 = class extends HttpServerResponse {
+    ServerResponse4 = class extends HttpServerResponse {
     };
     FrontMcpServer = class {
     };
@@ -43888,6 +44379,29 @@ var init_resource_interface = __esm({
         this.uri = uri;
         this.params = params;
       }
+      /**
+       * Override to provide autocompletion for resource template arguments.
+       * Called by the MCP `completion/complete` handler when a client requests
+       * suggestions for a template parameter.
+       *
+       * @param argName - The template parameter name (e.g., 'userId')
+       * @returns A completer function, or null if no completion is available for this argument
+       *
+       * @example
+       * ```typescript
+       * getArgumentCompleter(argName: string): ResourceArgumentCompleter | null {
+       *   if (argName === 'userId') {
+       *     return async (partial) => ({
+       *       values: await this.searchUsers(partial),
+       *     });
+       *   }
+       *   return null;
+       * }
+       * ```
+       */
+      getArgumentCompleter(_argName) {
+        return null;
+      }
       get output() {
         return this._output;
       }
@@ -45037,9 +45551,12 @@ var init_decide_request_intent_utils = __esm({
         outcome: { intent: "sse", reason: "GET /sse with Mcp-Session-Id." }
       },
       // D) Initialize (POST → SSE)
-      // D1) Stateless initialize (no session, stateless enabled) - must come before streamable rules
+      // D1) Stateless initialize (no session, stateless enabled, streamable NOT enabled)
+      // When streamable is also enabled, prefer streamable-http (which creates a session).
+      // Per MCP spec, first initialize naturally has no session — stateless should only
+      // match when it's the sole enabled protocol.
       {
-        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN,
+        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN | B_STREAMABLE_EN,
         match: CH_POST_INIT_SSE | B_STATELESS_EN,
         outcome: { intent: "stateless-http", reason: "Stateless initialize (no session)." }
       },
@@ -45058,9 +45575,9 @@ var init_decide_request_intent_utils = __esm({
         outcome: { intent: "streamable-http", reason: "Initialize with SSE." }
       },
       // E) Initialize (POST → JSON)
-      // E1) Stateless initialize JSON (no session, stateless enabled) - must come before stateful rules
+      // E1) Stateless initialize JSON (no session, stateless enabled, streamable NOT enabled)
       {
-        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN,
+        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN | B_STREAMABLE_EN,
         match: CH_POST_INIT_JSON | B_STATELESS_EN,
         outcome: { intent: "stateless-http", reason: "Stateless initialize JSON (no session)." }
       },
@@ -45089,7 +45606,7 @@ var init_decide_request_intent_utils = __esm({
         }
       },
       {
-        care: CH_MASK | B_STREAMABLE_EN,
+        care: CH_MASK | B_STREAMABLE_EN | B_STATELESS_EN,
         match: CH_POST_SSE,
         outcome: {
           intent: "unknown",
@@ -45097,8 +45614,9 @@ var init_decide_request_intent_utils = __esm({
           recommendation: { httpStatus: 405, message: "Streamable HTTP disabled" }
         }
       },
+      // Stateless short-lived SSE only when streamable is NOT enabled
       {
-        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN,
+        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN | B_STREAMABLE_EN,
         match: CH_POST_SSE | B_STATELESS_EN,
         outcome: { intent: "stateless-http", reason: "Stateless short-lived SSE." }
       },
@@ -45118,7 +45636,7 @@ var init_decide_request_intent_utils = __esm({
         }
       },
       {
-        care: CH_MASK | B_STATEFUL_EN | B_STREAMABLE_EN,
+        care: CH_MASK | B_STATEFUL_EN | B_STREAMABLE_EN | B_STATELESS_EN,
         match: CH_POST_JSON,
         outcome: {
           intent: "unknown",
@@ -45126,8 +45644,9 @@ var init_decide_request_intent_utils = __esm({
           recommendation: { httpStatus: 405, message: "JSON mode disabled" }
         }
       },
+      // Stateless JSON only when streamable is NOT enabled
       {
-        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN,
+        care: CH_MASK | B_HAS_SESSION | B_STATELESS_EN | B_STREAMABLE_EN,
         match: CH_POST_JSON | B_STATELESS_EN,
         outcome: { intent: "stateless-http", reason: "Stateless JSON request." }
       },
@@ -45331,7 +45850,7 @@ var init_internal = __esm({
 });
 
 // libs/sdk/src/common/interfaces/index.ts
-var init_interfaces3 = __esm({
+var init_interfaces2 = __esm({
   "libs/sdk/src/common/interfaces/index.ts"() {
     "use strict";
     init_base_interface();
@@ -45496,18 +46015,40 @@ var init_dynamic = __esm({
 });
 
 // libs/sdk/src/common/entries/scope.entry.ts
-var ScopeEntry2;
+var ScopeEntry3;
 var init_scope_entry = __esm({
   "libs/sdk/src/common/entries/scope.entry.ts"() {
     "use strict";
     init_base_entry();
     init_utils2();
-    ScopeEntry2 = class extends BaseEntry {
+    ScopeEntry3 = class extends BaseEntry {
       get fullPath() {
         const prefix = normalizeEntryPrefix(this.entryPath ?? "");
         const scope = normalizeScopeBase(this.routeBase ?? "");
         return `${prefix}${scope}`;
       }
+      /**
+       * Lifecycle callbacks registered by plugins via onServerStarted().
+       * Called after the HTTP server starts listening.
+       */
+      lifecycleCallbacks = [];
+      /**
+       * Register a callback to run after the server has started.
+       * Plugins can use this for post-startup initialization (e.g., warming caches,
+       * starting background jobs, logging readiness).
+       */
+      onServerStarted(callback) {
+        this.lifecycleCallbacks.push(callback);
+      }
+      /**
+       * Emit the server-started lifecycle event. Called by FrontMcpInstance after server.start().
+       * @internal
+       */
+      async emitServerStarted() {
+        for (const cb of this.lifecycleCallbacks) {
+          await cb();
+        }
+      }
     };
   }
 });
@@ -45738,6 +46279,14 @@ var init_resource_entry = __esm({
        * Whether this resource is a template (has uriTemplate instead of uri)
        */
       isTemplate;
+      /**
+       * Get an argument completer for resource template autocompletion.
+       * Override in subclasses to provide suggestions for template parameters.
+       * Returns null by default (no completion available).
+       */
+      getArgumentCompleter(_argName) {
+        return null;
+      }
     };
   }
 });
@@ -46228,7 +46777,7 @@ var init_common = __esm({
     init_decorators();
     init_types();
     init_metadata();
-    init_interfaces3();
+    init_interfaces2();
     init_tokens();
     init_dynamic();
     init_records();
@@ -46745,16 +47294,16 @@ export {
   ResourceNotFoundError,
   ResourceOutputSchema,
   ResourceReadError,
-  FrontMcpResourceTemplate as ResourceTemplate,
+  _ResourceTemplate as ResourceTemplate,
   ResourceTemplateKind,
   ScopeConfigurationError,
   ScopeDeniedError,
-  ScopeEntry2 as ScopeEntry,
+  ScopeEntry3 as ScopeEntry,
   ScopeKind,
   ServerNotFoundError,
   ServerRequest11 as ServerRequest,
   ServerRequestTokens,
-  ServerResponse3 as ServerResponse,
+  ServerResponse4 as ServerResponse,
   ServerlessHandlerNotInitializedError,
   SessionHookStage,
   SessionIdEmptyError,
@@ -46787,6 +47336,7 @@ export {
   TransportAlreadyStartedError,
   TransportBusRequiredError,
   TransportNotConnectedError,
+  TransportServiceNotAvailableError,
   UnauthorizedError,
   UnsupportedClientVersionError,
   UnsupportedContentTypeError,