@frontmcp/sdk 1.7.2 → 1.8.0

package/index.js

@@ -683,6 +683,7 @@ var init_server_tokens = __esm({
       reinitialize: tokenFactory.meta("reinitialize"),
       webRequest: tokenFactory.meta("webRequest"),
       webCtx: tokenFactory.meta("webCtx"),
+      webEnv: tokenFactory.meta("webEnv"),
       webTransport: tokenFactory.meta("webTransport")
     };
   }
@@ -1915,7 +1916,7 @@ var init_http = __esm({
 });
 
 // libs/sdk/src/common/types/options/auth/index.ts
-var import_auth4, import_auth5, import_auth6, import_auth7, import_auth8, import_auth9, import_auth10;
+var import_auth4, import_auth5, import_auth6, import_auth7, import_auth8, import_auth9, import_auth10, import_auth11;
 var init_auth2 = __esm({
   "libs/sdk/src/common/types/options/auth/index.ts"() {
     "use strict";
@@ -1926,6 +1927,7 @@ var init_auth2 = __esm({
     import_auth8 = require("@frontmcp/auth");
     import_auth9 = require("@frontmcp/auth");
     import_auth10 = require("@frontmcp/auth");
+    import_auth11 = require("@frontmcp/auth");
   }
 });
 
@@ -2875,7 +2877,7 @@ var init_app_metadata = __esm({
       jobs: import_lazy_zod22.z.array(annotatedFrontMcpJobsSchema).optional(),
       workflows: import_lazy_zod22.z.array(annotatedFrontMcpWorkflowsSchema).optional(),
       channels: import_lazy_zod22.z.array(annotatedFrontMcpChannelsSchema).optional(),
-      auth: import_auth8.authOptionsSchema.optional(),
+      auth: import_auth9.authOptionsSchema.optional(),
       output: outputPolicySchema.optional(),
       standalone: import_lazy_zod22.z.union([import_lazy_zod22.z.literal("includeInParent"), import_lazy_zod22.z.boolean()]).optional().default(false)
     });
@@ -2930,7 +2932,7 @@ var init_app_metadata = __esm({
       namespace: import_lazy_zod22.z.string().optional(),
       transportOptions: remoteTransportOptionsSchema.optional(),
       remoteAuth: remoteAuthConfigSchema.optional(),
-      auth: import_auth8.authOptionsSchema.optional(),
+      auth: import_auth9.authOptionsSchema.optional(),
       refreshInterval: import_lazy_zod22.z.number().optional(),
       cacheTTL: import_lazy_zod22.z.number().optional(),
       packageConfig: packageConfigSchema.optional(),
@@ -3116,6 +3118,10 @@ var init_front_mcp_metadata = __esm({
       output: outputPolicySchema.optional(),
       jobs: import_lazy_zod24.z.object({
         enabled: import_lazy_zod24.z.boolean(),
+        // Opt-in for `register_job` / `register_workflow` (GHSA-58v2-gpcc-jmqv).
+        // Omitting it here would let Zod strip the flag before the scope reads
+        // it, leaving the documented escape hatch permanently off.
+        allowDynamicRegistration: import_lazy_zod24.z.boolean().optional(),
         store: import_lazy_zod24.z.object({
           redis: redisOptionsSchema.optional(),
           keyPrefix: import_lazy_zod24.z.string().optional()
@@ -3164,11 +3170,11 @@ var init_front_mcp_metadata = __esm({
     });
     frontMcpMultiAppSchema = frontMcpBaseSchema.extend({
       splitByApp: import_lazy_zod24.z.literal(false).default(false).describe("If true, each app gets its own scope & basePath."),
-      auth: import_auth8.authOptionsSchema.optional().describe("Configures the server's default authentication provider.")
+      auth: import_auth9.authOptionsSchema.optional().describe("Configures the server's default authentication provider.")
     });
     frontMcpSplitByAppSchema = frontMcpBaseSchema.extend({
       splitByApp: import_lazy_zod24.z.literal(true).describe("If false, apps are grouped under the same scope & basePath."),
-      auth: import_auth8.authOptionsSchema.optional().describe("Configures the server's default authentication provider.")
+      auth: import_auth9.authOptionsSchema.optional().describe("Configures the server's default authentication provider.")
     });
     frontMcpMetadataSchema = frontMcpMultiAppSchema.or(frontMcpSplitByAppSchema).transform(applyAutoTransportPersistence);
     frontMcpLiteSchema = import_lazy_zod24.z.object({
@@ -3186,7 +3192,7 @@ var init_front_mcp_metadata = __esm({
       apps: import_lazy_zod24.z.array(annotatedFrontMcpAppSchema),
       serve: import_lazy_zod24.z.boolean().optional().default(false),
       splitByApp: import_lazy_zod24.z.boolean().optional().default(false),
-      auth: import_auth8.authOptionsSchema.optional(),
+      auth: import_auth9.authOptionsSchema.optional(),
       logging: loggingOptionsSchema.optional(),
       skillsConfig: skillsConfigOptionsSchema.optional(),
       loader: packageLoaderSchema.optional(),
@@ -5300,11 +5306,11 @@ var init_transport_errors = __esm({
 });
 
 // libs/sdk/src/errors/auth-internal.errors.ts
-var import_auth11;
+var import_auth12;
 var init_auth_internal_errors = __esm({
   "libs/sdk/src/errors/auth-internal.errors.ts"() {
     "use strict";
-    import_auth11 = require("@frontmcp/auth");
+    import_auth12 = require("@frontmcp/auth");
   }
 });
 
@@ -5621,11 +5627,11 @@ __export(errors_exports, {
   AgentToolNotFoundError: () => AgentToolNotFoundError,
   AgentVisibilityError: () => AgentVisibilityError,
   AuthConfigurationError: () => AuthConfigurationError,
-  AuthProvidersNotConfiguredError: () => import_auth11.AuthProvidersNotConfiguredError,
+  AuthProvidersNotConfiguredError: () => import_auth12.AuthProvidersNotConfiguredError,
   AuthorizationRequiredError: () => AuthorizationRequiredError,
   ConfigNotFoundError: () => ConfigNotFoundError,
   ContextExtensionNotAvailableError: () => ContextExtensionNotAvailableError,
-  CredentialProviderAlreadyRegisteredError: () => import_auth11.CredentialProviderAlreadyRegisteredError,
+  CredentialProviderAlreadyRegisteredError: () => import_auth12.CredentialProviderAlreadyRegisteredError,
   DependencyCycleError: () => DependencyCycleError,
   DependencyNotFoundError: () => DependencyNotFoundError,
   DynamicAdapterNameError: () => DynamicAdapterNameError,
@@ -5635,13 +5641,13 @@ __export(errors_exports, {
   ElicitationEncryptionError: () => ElicitationEncryptionError,
   ElicitationFallbackRequired: () => ElicitationFallbackRequired,
   ElicitationNotSupportedError: () => ElicitationNotSupportedError,
-  ElicitationSecretRequiredError: () => import_auth11.ElicitationSecretRequiredError,
+  ElicitationSecretRequiredError: () => import_auth12.ElicitationSecretRequiredError,
   ElicitationStoreNotInitializedError: () => ElicitationStoreNotInitializedError,
   ElicitationSubscriptionError: () => ElicitationSubscriptionError,
   ElicitationTimeoutError: () => ElicitationTimeoutError,
   EnclaveExecutionError: () => EnclaveExecutionError,
-  EncryptionContextNotSetError: () => import_auth11.EncryptionContextNotSetError,
-  EncryptionKeyNotConfiguredError: () => import_auth11.EncryptionKeyNotConfiguredError,
+  EncryptionContextNotSetError: () => import_auth12.EncryptionContextNotSetError,
+  EncryptionKeyNotConfiguredError: () => import_auth12.EncryptionKeyNotConfiguredError,
   EntryUnavailableError: () => EntryUnavailableError,
   EntryValidationError: () => EntryValidationError,
   ErrorHandler: () => ErrorHandler,
@@ -5658,7 +5664,7 @@ __export(errors_exports, {
   GlobalConfigNotFoundError: () => GlobalConfigNotFoundError,
   HaConfigurationError: () => HaConfigurationError,
   HookTargetNotDefinedError: () => HookTargetNotDefinedError,
-  InMemoryStoreRequiredError: () => import_auth11.InMemoryStoreRequiredError,
+  InMemoryStoreRequiredError: () => import_auth12.InMemoryStoreRequiredError,
   InputRequiredSignal: () => InputRequiredSignal,
   InternalMcpError: () => InternalMcpError,
   InvalidDecoratorMetadataError: () => InvalidDecoratorMetadataError,
@@ -5680,6 +5686,8 @@ __export(errors_exports, {
   InvalidUseValueError: () => InvalidUseValueError,
   InvokeStateMissingKeyError: () => InvokeStateMissingKeyError,
   JobNotAuthorizedError: () => JobNotAuthorizedError,
+  JwtSecretRequiredError: () => import_auth12.JwtSecretRequiredError,
+  JwtSecretWeakError: () => import_auth12.JwtSecretWeakError,
   MCP_ERROR_CODES: () => MCP_ERROR_CODES,
   McpError: () => McpError,
   MethodNotImplementedError: () => MethodNotImplementedError,
@@ -5687,9 +5695,9 @@ __export(errors_exports, {
   MissingPromptArgumentError: () => MissingPromptArgumentError,
   MissingProvideError: () => MissingProvideError,
   NameDisambiguationError: () => NameDisambiguationError,
-  NoProviderIdError: () => import_auth11.NoProviderIdError,
-  OrchestratedAuthNotAvailableError: () => import_auth11.OrchestratedAuthNotAvailableError,
-  OrchestratorJwksNotAvailableError: () => import_auth11.OrchestratorJwksNotAvailableError,
+  NoProviderIdError: () => import_auth12.NoProviderIdError,
+  OrchestratedAuthNotAvailableError: () => import_auth12.OrchestratedAuthNotAvailableError,
+  OrchestratorJwksNotAvailableError: () => import_auth12.OrchestratorJwksNotAvailableError,
   PayloadTooLargeError: () => PayloadTooLargeError,
   PluginDependencyError: () => PluginDependencyError,
   PromptExecutionError: () => PromptExecutionError,
@@ -5731,13 +5739,13 @@ __export(errors_exports, {
   ResourceReadError: () => ResourceReadError,
   SamplingNotAvailableError: () => SamplingNotAvailableError,
   ScopeConfigurationError: () => ScopeConfigurationError,
-  ScopeDeniedError: () => import_auth11.ScopeDeniedError,
+  ScopeDeniedError: () => import_auth12.ScopeDeniedError,
   ServerNotFoundError: () => ServerNotFoundError,
   ServerlessHandlerNotInitializedError: () => ServerlessHandlerNotInitializedError,
   SessionClaimConflictError: () => SessionClaimConflictError,
-  SessionIdEmptyError: () => import_auth11.SessionIdEmptyError,
+  SessionIdEmptyError: () => import_auth12.SessionIdEmptyError,
   SessionMissingError: () => SessionMissingError,
-  SessionSecretRequiredError: () => import_auth11.SessionSecretRequiredError,
+  SessionSecretRequiredError: () => import_auth12.SessionSecretRequiredError,
   SessionVerificationFailedError: () => SessionVerificationFailedError,
   SkillContextNotImplementedError: () => SkillContextNotImplementedError,
   SkillInstructionFetchError: () => SkillInstructionFetchError,
@@ -5747,9 +5755,9 @@ __export(errors_exports, {
   TaskAugmentationRequiredError: () => TaskAugmentationRequiredError,
   TaskNotFoundError: () => TaskNotFoundError,
   TaskStoreNotInitializedError: () => TaskStoreNotInitializedError,
-  TokenLeakDetectedError: () => import_auth11.TokenLeakDetectedError,
-  TokenNotAvailableError: () => import_auth11.TokenNotAvailableError,
-  TokenStoreRequiredError: () => import_auth11.TokenStoreRequiredError,
+  TokenLeakDetectedError: () => import_auth12.TokenLeakDetectedError,
+  TokenNotAvailableError: () => import_auth12.TokenNotAvailableError,
+  TokenStoreRequiredError: () => import_auth12.TokenStoreRequiredError,
   ToolCredentialsRequiredError: () => ToolCredentialsRequiredError,
   ToolExecutionError: () => ToolExecutionError,
   ToolNotConsentedError: () => ToolNotConsentedError,
@@ -5763,8 +5771,8 @@ __export(errors_exports, {
   UnsupportedContentTypeError: () => UnsupportedContentTypeError,
   UnsupportedHookOwnerKindError: () => UnsupportedHookOwnerKindError,
   UnsupportedTransportTypeError: () => UnsupportedTransportTypeError,
-  VaultLoadError: () => import_auth11.VaultLoadError,
-  VaultNotFoundError: () => import_auth11.VaultNotFoundError,
+  VaultLoadError: () => import_auth12.VaultLoadError,
+  VaultNotFoundError: () => import_auth12.VaultNotFoundError,
   VercelKvAsyncInitRequiredError: () => VercelKvAsyncInitRequiredError,
   VercelKvNotSupportedError: () => VercelKvNotSupportedError,
   WorkflowDagValidationError: () => WorkflowDagValidationError,
@@ -9277,22 +9285,24 @@ function hasValidSessionStructure(dec) {
 function isValidSessionPayload(dec, sig) {
   return hasValidSessionStructure(dec) && dec.authSig === sig;
 }
-function isValidPublicSessionPayload(dec) {
+function isValidPublicSessionPayload(dec, expectedAuthSig = "public") {
   if (typeof dec !== "object" || dec === null) return false;
   const d = dec;
-  return typeof d["nodeId"] === "string" && d["authSig"] === "public" && typeof d["uuid"] === "string" && typeof d["iat"] === "number" && d["isPublic"] === true;
+  return typeof d["nodeId"] === "string" && d["authSig"] === expectedAuthSig && typeof d["uuid"] === "string" && typeof d["iat"] === "number" && // `isPublic` is set only for public mode, so it must track the signature —
+  // a static-mode session must never decrypt as a public one.
+  d["isPublic"] === (expectedAuthSig === "public");
 }
 function decryptSessionId(sessionId, sig) {
-  const dec = (0, import_auth12.safeDecrypt)(sessionId);
+  const dec = (0, import_auth13.safeDecrypt)(sessionId);
   return isValidSessionPayload(dec, sig) ? dec : null;
 }
-function decryptPublicSession(sessionId) {
+function decryptPublicSession(sessionId, expectedAuthSig = "public") {
   const cached = cache.get(sessionId);
-  if (cached && isValidPublicSessionPayload(cached)) {
+  if (cached && isValidPublicSessionPayload(cached, expectedAuthSig)) {
     return cached;
   }
-  const dec = (0, import_auth12.safeDecrypt)(sessionId);
-  if (isValidPublicSessionPayload(dec)) {
+  const dec = (0, import_auth13.safeDecrypt)(sessionId);
+  if (isValidPublicSessionPayload(dec, expectedAuthSig)) {
     cache.set(sessionId, dec);
     return dec;
   }
@@ -9302,7 +9312,7 @@ function nowSec() {
   return Math.floor(Date.now() / 1e3);
 }
 function parseSessionHeader(sessionHeader, token) {
-  const currentAuthSig = (0, import_auth12.getTokenSignatureFingerprint)(token);
+  const currentAuthSig = (0, import_auth13.getTokenSignatureFingerprint)(token);
   if (sessionHeader) {
     const cached = cache.get(sessionHeader);
     if (cached) {
@@ -9319,7 +9329,7 @@ function parseSessionHeader(sessionHeader, token) {
   return void 0;
 }
 function createSessionId(protocol, token, options) {
-  const authSig = (0, import_auth12.getTokenSignatureFingerprint)(token);
+  const authSig = (0, import_auth13.getTokenSignatureFingerprint)(token);
   let platformType;
   if (options?.userAgent) {
     platformType = detectPlatformFromUserAgent(options.userAgent, options.platformDetectionConfig);
@@ -9337,7 +9347,7 @@ function createSessionId(protocol, token, options) {
     // Add skillsOnlyMode if provided
     ...options?.skillsOnlyMode && { skillsOnlyMode: true }
   };
-  const id = (0, import_auth12.encryptJson)(payload);
+  const id = (0, import_auth13.encryptJson)(payload);
   cache.set(id, payload);
   return { id, payload };
 }
@@ -9347,26 +9357,26 @@ function updateSessionPayload(sessionId, updates) {
   if (existing) {
     payload = existing;
   } else {
-    const decrypted = (0, import_auth12.safeDecrypt)(sessionId);
+    const decrypted = (0, import_auth13.safeDecrypt)(sessionId);
     if (hasValidSessionStructure(decrypted) || isValidPublicSessionPayload(decrypted)) {
       payload = decrypted;
     }
   }
   if (!payload) return null;
   Object.assign(payload, updates);
-  const newSessionId = (0, import_auth12.encryptJson)(payload);
+  const newSessionId = (0, import_auth13.encryptJson)(payload);
   cache.set(sessionId, payload);
   cache.set(newSessionId, payload);
   return newSessionId;
 }
-var import_auth12, import_utils18, cache;
+var import_auth13, import_utils18, cache;
 var init_session_id_utils = __esm({
   "libs/sdk/src/auth/session/utils/session-id.utils.ts"() {
     "use strict";
-    import_auth12 = require("@frontmcp/auth");
+    import_auth13 = require("@frontmcp/auth");
     import_utils18 = require("@frontmcp/utils");
     init_notification_service();
-    cache = new import_auth12.TinyTtlCache(5e3);
+    cache = new import_auth13.TinyTtlCache(5e3);
   }
 });
 
@@ -12999,11 +13009,11 @@ function validateSessionId(value) {
     );
   }
 }
-var import_auth13, import_utils29, PRE_RESOLVED_ELICIT_KEY, MRTR_EXCHANGE_KEY, REQUEST_NOTIFICATION_SINK_KEY, SESSION_ID_MAX_LENGTH, SESSION_ID_VALID_PATTERN, FrontMcpContext;
+var import_auth14, import_utils29, PRE_RESOLVED_ELICIT_KEY, MRTR_EXCHANGE_KEY, REQUEST_NOTIFICATION_SINK_KEY, SESSION_ID_MAX_LENGTH, SESSION_ID_VALID_PATTERN, FrontMcpContext;
 var init_frontmcp_context = __esm({
   "libs/sdk/src/context/frontmcp-context.ts"() {
     "use strict";
-    import_auth13 = require("@frontmcp/auth");
+    import_auth14 = require("@frontmcp/auth");
     import_utils29 = require("@frontmcp/utils");
     init_mcp_error();
     init_trace_context();
@@ -13418,7 +13428,7 @@ var init_frontmcp_context = __esm({
         let providerCredentialsUsed = false;
         if (init) {
           const creds = init.credentials;
-          if ((0, import_auth13.isFrontMcpCredentials)(creds)) {
+          if ((0, import_auth14.isFrontMcpCredentials)(creds)) {
             providerCredentialsUsed = true;
             if (this._credentialMiddleware) {
               const result = await this._credentialMiddleware.applyCredentials(
@@ -18134,7 +18144,7 @@ function isUIResourceUri(uri) {
   return uri.startsWith("ui://");
 }
 function parseWidgetUri(uri) {
-  const match = uri.match(/^ui:\/\/widget\/([^.]+)\.(\w+)$/);
+  const match = uri.match(WIDGET_URI_PATTERN);
   if (!match) return null;
   return { toolName: match[1], extension: match[2] };
 }
@@ -18143,7 +18153,7 @@ function getUIResourceMimeType(_platformOrUri) {
   if (_platformOrUri?.endsWith(".css")) return "text/css";
   return import_adapters.MCP_APPS_MIME_TYPE;
 }
-var import_adapters, ToolUIRegistry;
+var import_adapters, ToolUIRegistry, WIDGET_URI_PATTERN;
 var init_ui_shared = __esm({
   "libs/sdk/src/tool/ui/ui-shared.ts"() {
     "use strict";
@@ -18269,6 +18279,7 @@ var init_ui_shared = __esm({
         return { meta: result.meta };
       }
     };
+    WIDGET_URI_PATTERN = /^ui:\/\/widget\/([A-Za-z0-9_:@-]+)\.(html|js|css)$/;
   }
 });
 
@@ -20649,15 +20660,15 @@ function asAppIdList(value) {
 }
 function getAuthorizedAppIds(authInfo) {
   if (!authInfo) return void 0;
-  const list = asAppIdList(readAuthorizedApps(readUser(authInfo.extra))) ?? asAppIdList(readAuthorizedApps(authInfo.extra)) ?? asAppIdList(readAuthorizedApps(authInfo.user)) ?? asAppIdList((0, import_auth14.decodeJwtPayloadSafe)(authInfo.token)?.["authorized_apps"]);
+  const list = asAppIdList(readAuthorizedApps(readUser(authInfo.extra))) ?? asAppIdList(readAuthorizedApps(authInfo.extra)) ?? asAppIdList(readAuthorizedApps(authInfo.user)) ?? asAppIdList((0, import_auth15.decodeJwtPayloadSafe)(authInfo.token)?.["authorized_apps"]);
   if (!list) return void 0;
   return new Set(list);
 }
-var import_auth14;
+var import_auth15;
 var init_authorized_apps_utils = __esm({
   "libs/sdk/src/auth/authorized-apps.utils.ts"() {
     "use strict";
-    import_auth14 = require("@frontmcp/auth");
+    import_auth15 = require("@frontmcp/auth");
   }
 });
 
@@ -20678,7 +20689,7 @@ function asConsentClaim(value) {
 }
 function getConsentedToolIds(authInfo) {
   if (!authInfo) return void 0;
-  const claim = asConsentClaim(readConsent(readUser2(authInfo.extra))) ?? asConsentClaim(readConsent(authInfo.extra)) ?? asConsentClaim(readConsent(authInfo.user)) ?? asConsentClaim((0, import_auth15.decodeJwtPayloadSafe)(authInfo.token)?.["consent"]);
+  const claim = asConsentClaim(readConsent(readUser2(authInfo.extra))) ?? asConsentClaim(readConsent(authInfo.extra)) ?? asConsentClaim(readConsent(authInfo.user)) ?? asConsentClaim((0, import_auth16.decodeJwtPayloadSafe)(authInfo.token)?.["consent"]);
   if (!claim) return void 0;
   const selected = Array.isArray(claim.selectedTools) ? claim.selectedTools.filter((t) => typeof t === "string") : [];
   return new Set(selected);
@@ -20687,11 +20698,11 @@ function isToolConsented(consented, ...toolIds) {
   if (!consented) return true;
   return toolIds.some((id) => id !== void 0 && consented.has(id));
 }
-var import_auth15;
+var import_auth16;
 var init_consent_utils = __esm({
   "libs/sdk/src/auth/consent.utils.ts"() {
     "use strict";
-    import_auth15 = require("@frontmcp/auth");
+    import_auth16 = require("@frontmcp/auth");
   }
 });
 
@@ -20707,8 +20718,8 @@ async function evaluateToolCredentialGate(providers, tryGet) {
   if (required.length === 0) {
     return { evaluated: true, missing: [] };
   }
-  const authProviders = resolveAccessor(tryGet, import_auth16.AUTH_PROVIDERS_ACCESSOR, isAuthProvidersLike);
-  const credentials = resolveAccessor(tryGet, import_auth16.CREDENTIALS_ACCESSOR, isCredentialsLike);
+  const authProviders = resolveAccessor(tryGet, import_auth17.AUTH_PROVIDERS_ACCESSOR, isAuthProvidersLike);
+  const credentials = resolveAccessor(tryGet, import_auth17.CREDENTIALS_ACCESSOR, isCredentialsLike);
   if (!authProviders && !credentials) {
     return { evaluated: false, missing: [] };
   }
@@ -20748,20 +20759,20 @@ async function checkProvider(name42, authProviders, credentials) {
   }
   return { available: false };
 }
-var import_auth16;
+var import_auth17;
 var init_tool_credentials_gate = __esm({
   "libs/sdk/src/tool/flows/tool-credentials.gate.ts"() {
     "use strict";
-    import_auth16 = require("@frontmcp/auth");
+    import_auth17 = require("@frontmcp/auth");
   }
 });
 
 // libs/sdk/src/tool/flows/call-tool.flow.ts
-var import_auth17, import_guard4, import_lazy_zod56, import_protocol38, import_adapters4, import_utils45, inputSchema13, outputSchema12, stateSchema12, plan12, name12, Stage12, CallToolFlow;
+var import_auth18, import_guard4, import_lazy_zod56, import_protocol38, import_adapters4, import_utils45, inputSchema13, outputSchema12, stateSchema12, plan12, name12, Stage12, CallToolFlow;
 var init_call_tool_flow = __esm({
   "libs/sdk/src/tool/flows/call-tool.flow.ts"() {
     "use strict";
-    import_auth17 = require("@frontmcp/auth");
+    import_auth18 = require("@frontmcp/auth");
     import_guard4 = require("@frontmcp/guard");
     import_lazy_zod56 = require("@frontmcp/lazy-zod");
     import_protocol38 = require("@frontmcp/protocol");
@@ -21120,7 +21131,7 @@ var init_call_tool_flow = __esm({
           const app = apps.find((a) => a.metadata.id === appId);
           const authOptions = this.scope.auth?.options;
           let skippedBehavior = "anonymous";
-          if (authOptions && (0, import_auth10.isOrchestratedMode)(authOptions)) {
+          if (authOptions && (0, import_auth11.isOrchestratedMode)(authOptions)) {
             const incrementalConfig = authOptions.incrementalAuth;
             if (incrementalConfig) {
               if (incrementalConfig.enabled === false) {
@@ -21182,7 +21193,7 @@ var init_call_tool_flow = __esm({
         if (!sub) return void 0;
         const secret = this.scope.auth?.signingSecret;
         if (!secret) return void 0;
-        return (0, import_auth17.signIncrementalAuthTicket)(
+        return (0, import_auth18.signIncrementalAuthTicket)(
           {
             sub,
             appId,
@@ -23148,8 +23159,181 @@ var init_adapter_registry = __esm({
   }
 });
 
+// libs/sdk/src/common/utils/path.utils.ts
+function normalizeEntryPrefix(entryPath) {
+  const t = (0, import_utils47.trimSlashes)(entryPath ?? "");
+  return t ? `/${t}` : "";
+}
+function resolveEntryPath(entryPath) {
+  if (entryPath !== void 0) return entryPath;
+  return process.env["FRONTMCP_HTTP_ENTRY_PATH"] ?? "";
+}
+function normalizeScopeBase(scopeBase) {
+  const t = (0, import_utils47.trimSlashes)(scopeBase ?? "");
+  return t ? `/${t}` : "";
+}
+function readPublicUrlPin() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env["FRONTMCP_PUBLIC_URL"];
+      if (typeof v === "string" && v.trim()) {
+        return v.trim().replace(/\/+$/, "");
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function isPublicUrlPinned() {
+  return readPublicUrlPin() !== void 0;
+}
+function isProxyTrusted() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env["FRONTMCP_TRUST_PROXY"];
+      return typeof v === "string" && /^(1|true|yes|on)$/i.test(v.trim());
+    }
+  } catch {
+  }
+  return false;
+}
+function getRequestBaseUrl(req, entryPath) {
+  const pin = readPublicUrlPin();
+  if (pin) {
+    return `${pin}${entryPath ?? ""}`;
+  }
+  const trustProxy = isProxyTrusted();
+  const fwdProto = trustProxy ? req.headers["x-forwarded-proto"] : void 0;
+  const fwdHost = trustProxy ? req.headers["x-forwarded-host"] : void 0;
+  const proto = fwdProto || req.protocol || "http";
+  const host = fwdHost || req.headers["host"];
+  return `${proto}://${host}${entryPath ?? ""}`;
+}
+function computeIssuer(req, entryPath, scopeBase) {
+  const entryPrefix = normalizeEntryPrefix(entryPath);
+  const scope = normalizeScopeBase(scopeBase);
+  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
+}
+function computeResource(req, entryPath, scopeBase) {
+  const entryPrefix = normalizeEntryPrefix(entryPath);
+  const scope = normalizeScopeBase(scopeBase);
+  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
+}
+function normalizeResourceUri(uri) {
+  try {
+    const url = new URL(uri);
+    let normalized = `${url.protocol}//${url.hostname}`;
+    const isDefaultPort = url.protocol === "https:" && url.port === "443" || url.protocol === "http:" && url.port === "80";
+    if (url.port && !isDefaultPort) {
+      normalized += `:${url.port}`;
+    }
+    let path3 = url.pathname;
+    if (path3.length > 1 && path3.endsWith("/")) {
+      path3 = path3.slice(0, -1);
+    }
+    normalized += path3;
+    return normalized;
+  } catch {
+    return uri;
+  }
+}
+function resourceUriMatches(provided, canonical) {
+  return normalizeResourceUri(provided) === normalizeResourceUri(canonical);
+}
+function urlToSafeId(url) {
+  const u = new URL(url);
+  const raw = (u.host + (u.pathname && u.pathname !== "/" ? u.pathname : "")).replace(/\/+$/, "");
+  return (0, import_utils47.trimSlashes)(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function makeWellKnownPaths(name42, entryPrefix, scopeBase = "") {
+  const prefix = normalizeEntryPrefix(entryPrefix);
+  const scope = normalizeScopeBase(scopeBase);
+  const reversed = (0, import_utils47.joinPath)(".well-known", name42) + `${prefix}${scope}`;
+  const inPrefixRoot = `${prefix}${(0, import_utils47.joinPath)(".well-known", name42)}${scope}`;
+  const inPrefixScope = `${prefix}${scope}${(0, import_utils47.joinPath)(".well-known", name42)}`;
+  return /* @__PURE__ */ new Set([reversed, inPrefixRoot, inPrefixScope]);
+}
+var import_utils47, import_utils48;
+var init_path_utils = __esm({
+  "libs/sdk/src/common/utils/path.utils.ts"() {
+    "use strict";
+    import_utils47 = require("@frontmcp/utils");
+    import_utils48 = require("@frontmcp/utils");
+  }
+});
+
 // libs/sdk/src/context/metadata.utils.ts
-function extractMetadata(headers) {
+function isIpv4(value) {
+  const match = IPV4_PATTERN.exec(value);
+  if (!match) return false;
+  return match.slice(1).every((octet) => {
+    if (octet.length > 1 && octet.startsWith("0")) return false;
+    return Number(octet) <= 255;
+  });
+}
+function isIpv6(value) {
+  const text = value.includes("%") ? value.slice(0, value.indexOf("%")) : value;
+  if (text.length === 0) return false;
+  let head = text;
+  let embedded = 0;
+  const lastColon = head.lastIndexOf(":");
+  const tail = lastColon === -1 ? "" : head.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    if (!isIpv4(tail)) return false;
+    head = head.slice(0, lastColon + 1);
+    embedded = 2;
+  }
+  const halves = head.split("::");
+  if (halves.length > 2) return false;
+  const countGroups = (part) => {
+    if (part === "") return 0;
+    const groups = part.split(":").filter((group, index, all) => !(group === "" && index === all.length - 1));
+    for (const group of groups) {
+      if (!/^[0-9A-Fa-f]{1,4}$/.test(group)) return null;
+    }
+    return groups.length;
+  };
+  const headCount = countGroups(halves[0]);
+  if (headCount === null) return false;
+  if (halves.length === 1) {
+    return headCount + embedded === 8;
+  }
+  const tailCount = countGroups(halves[1]);
+  if (tailCount === null) return false;
+  return headCount + tailCount + embedded <= 7;
+}
+function isIpAddress(value) {
+  const candidate = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
+  return candidate.includes(":") ? isIpv6(candidate) : isIpv4(candidate);
+}
+function normalizeIp(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return isIpAddress(trimmed) ? trimmed : void 0;
+}
+function readTrustedProxyDepth() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const parsed = Number(process.env["FRONTMCP_TRUSTED_PROXY_DEPTH"]);
+      if (Number.isInteger(parsed) && parsed > 0) return parsed;
+    }
+  } catch {
+  }
+  return 1;
+}
+function normalizeDepth(depth) {
+  if (depth === void 0) return readTrustedProxyDepth();
+  return Number.isInteger(depth) && depth > 0 ? depth : readTrustedProxyDepth();
+}
+function headerValues(header) {
+  if (typeof header === "string") return header.split(",");
+  if (Array.isArray(header)) {
+    return header.filter((entry) => typeof entry === "string").flatMap((entry) => entry.split(","));
+  }
+  return [];
+}
+function extractMetadata(headers, options) {
   const customHeaders = {};
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase().startsWith("x-frontmcp-") && typeof value === "string") {
@@ -23160,30 +23344,34 @@ function extractMetadata(headers) {
     userAgent: typeof headers["user-agent"] === "string" ? headers["user-agent"] : void 0,
     contentType: typeof headers["content-type"] === "string" ? headers["content-type"] : void 0,
     accept: typeof headers["accept"] === "string" ? headers["accept"] : void 0,
-    clientIp: extractClientIp(headers),
+    clientIp: extractClientIp(headers, options),
     customHeaders
   };
 }
-function extractClientIp(headers) {
-  const xff = headers["x-forwarded-for"];
-  if (typeof xff === "string") {
-    return xff.split(",")[0]?.trim();
+function extractClientIp(headers, options) {
+  const peerIp = normalizeIp(options?.peerAddress);
+  const trustProxy = options?.trustProxy ?? isProxyTrusted();
+  if (!trustProxy) {
+    return peerIp;
   }
-  if (Array.isArray(xff) && typeof xff[0] === "string") {
-    return xff[0].split(",")[0]?.trim();
+  const depth = normalizeDepth(options?.trustedProxyDepth);
+  const forwarded = headerValues(headers["x-forwarded-for"]).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (forwarded.length > 0) {
+    if (forwarded.length < depth) return peerIp;
+    return normalizeIp(forwarded[forwarded.length - depth]) ?? peerIp;
   }
-  const realIp = headers["x-real-ip"];
-  if (typeof realIp === "string") {
-    return realIp;
+  if (depth === 1) {
+    const realIp = normalizeIp(headerValues(headers["x-real-ip"])[0]);
+    if (realIp) return realIp;
   }
-  if (Array.isArray(realIp) && typeof realIp[0] === "string") {
-    return realIp[0];
-  }
-  return void 0;
+  return peerIp;
 }
+var IPV4_PATTERN;
 var init_metadata_utils = __esm({
   "libs/sdk/src/context/metadata.utils.ts"() {
     "use strict";
+    init_path_utils();
+    IPV4_PATTERN = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
   }
 });
 
@@ -23192,18 +23380,18 @@ var frontmcp_context_storage_exports = {};
 __export(frontmcp_context_storage_exports, {
   FrontMcpContextStorage: () => FrontMcpContextStorage
 });
-var import_utils47, frontmcpContextStorage, FrontMcpContextStorage;
+var import_utils49, frontmcpContextStorage, FrontMcpContextStorage;
 var init_frontmcp_context_storage = __esm({
   "libs/sdk/src/context/frontmcp-context-storage.ts"() {
     "use strict";
-    import_utils47 = require("@frontmcp/utils");
+    import_utils49 = require("@frontmcp/utils");
     init_decorators();
     init_metadata();
     init_mcp_error();
     init_frontmcp_context();
     init_metadata_utils();
     init_trace_context();
-    frontmcpContextStorage = new import_utils47.AsyncLocalStorage();
+    frontmcpContextStorage = new import_utils49.AsyncLocalStorage();
     FrontMcpContextStorage = class {
       /**
        * Run a callback with a new FrontMcpContext.
@@ -23228,10 +23416,11 @@ var init_frontmcp_context_storage = __esm({
        * @returns Result of the callback
        */
       runFromHeaders(headers, args, fn) {
+        const { peerAddress, ...contextArgs } = args;
         const traceContext = parseTraceContext(headers);
-        const metadata = extractMetadata(headers);
+        const metadata = extractMetadata(headers, { peerAddress });
         const context = new FrontMcpContext({
-          ...args,
+          ...contextArgs,
           traceContext,
           metadata
         });
@@ -23521,11 +23710,11 @@ var init_flow_interface = __esm({
 });
 
 // libs/sdk/src/common/interfaces/execution-context.interface.ts
-var import_utils48, ExecutionContextBase;
+var import_utils50, ExecutionContextBase;
 var init_execution_context_interface = __esm({
   "libs/sdk/src/common/interfaces/execution-context.interface.ts"() {
     "use strict";
-    import_utils48 = require("@frontmcp/utils");
+    import_utils50 = require("@frontmcp/utils");
     init_config_service();
     init_context();
     init_mcp_error();
@@ -23547,7 +23736,7 @@ var init_execution_context_interface = __esm({
       _authContext;
       constructor(args) {
         const { providers, logger, authInfo } = args;
-        this.runId = (0, import_utils48.randomUUID)();
+        this.runId = (0, import_utils50.randomUUID)();
         this.providers = providers;
         this.logger = logger;
         this._authInfo = authInfo;
@@ -23767,7 +23956,7 @@ var init_execution_context_interface = __esm({
        * Get the current runtime context (platform, runtime, deployment, env).
        */
       get runtimeContext() {
-        return (0, import_utils48.getRuntimeContext)();
+        return (0, import_utils50.getRuntimeContext)();
       }
       /**
        * Check if running on a specific OS platform.
@@ -23802,11 +23991,11 @@ var init_execution_context_interface = __esm({
 });
 
 // libs/sdk/src/common/interfaces/prompt.interface.ts
-var import_utils49, PromptContext;
+var import_utils51, PromptContext;
 var init_prompt_interface = __esm({
   "libs/sdk/src/common/interfaces/prompt.interface.ts"() {
     "use strict";
-    import_utils49 = require("@frontmcp/utils");
+    import_utils51 = require("@frontmcp/utils");
     init_flow_interface();
     PromptContext = class {
       providers;
@@ -23826,7 +24015,7 @@ var init_prompt_interface = __esm({
       _outputHistory = [];
       constructor(ctorArgs) {
         const { metadata, args, providers, logger, authInfo } = ctorArgs;
-        this.runId = (0, import_utils49.randomUUID)();
+        this.runId = (0, import_utils51.randomUUID)();
         this.promptName = metadata.name;
         this.promptId = metadata.name;
         this.metadata = metadata;
@@ -23879,7 +24068,7 @@ var init_prompt_interface = __esm({
       // ---- Runtime context helpers ----
       /** Get the current runtime context (platform, runtime, deployment, env). */
       get runtimeContext() {
-        return (0, import_utils49.getRuntimeContext)();
+        return (0, import_utils51.getRuntimeContext)();
       }
       /** Check if running on a specific OS platform. */
       isPlatform(platform) {
@@ -24000,7 +24189,7 @@ function stringToBytes(str, encoding) {
     return new TextEncoder().encode(str);
   }
   try {
-    return (0, import_utils50.base64Decode)(str);
+    return (0, import_utils52.base64Decode)(str);
   } catch (err) {
     throw new Error(`Invalid base64 body: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -24138,11 +24327,11 @@ async function writeHttpResponse(res, value) {
     }
   }
 }
-var import_utils50;
+var import_utils52;
 var init_server_validation = __esm({
   "libs/sdk/src/server/server.validation.ts"() {
     "use strict";
-    import_utils50 = require("@frontmcp/utils");
+    import_utils52 = require("@frontmcp/utils");
     init_common();
   }
 });
@@ -24247,12 +24436,12 @@ function parseTypedKey(k) {
     return { base: k.slice(6, 7).toLowerCase() + k.slice(7), type: "around" };
   return { base: k };
 }
-var import_reflect_metadata11, import_utils51, CAP, WILL, DID, AROUND, FlowInstance;
+var import_reflect_metadata11, import_utils53, CAP, WILL, DID, AROUND, FlowInstance;
 var init_flow_instance = __esm({
   "libs/sdk/src/flows/flow.instance.ts"() {
     "use strict";
     import_reflect_metadata11 = require("reflect-metadata");
-    import_utils51 = require("@frontmcp/utils");
+    import_utils53 = require("@frontmcp/utils");
     init_common();
     init_context();
     init_errors();
@@ -24410,13 +24599,15 @@ var init_flow_instance = __esm({
         }
         const headers = request.headers ?? {};
         const headerSessionId = typeof headers["mcp-session-id"] === "string" ? headers["mcp-session-id"].trim() : "";
-        const sessionId = headerSessionId.length > 0 ? headerSessionId : `anon:${(0, import_utils51.randomUUID)()}`;
+        const sessionId = headerSessionId.length > 0 ? headerSessionId : `anon:${(0, import_utils53.randomUUID)()}`;
         const scope = this.globalProviders.getActiveScope();
+        const peerAddress = request.socket?.remoteAddress;
         return storage.runFromHeaders(
           headers,
           {
             sessionId,
-            scopeId: scope.id
+            scopeId: scope.id,
+            peerAddress
           },
           async () => {
             return this.run(input, deps);
@@ -24680,12 +24871,12 @@ var init_flow_utils2 = __esm({
 });
 
 // libs/sdk/src/flows/flow.registry.ts
-var import_di18, import_utils52, FlowRegistry;
+var import_di18, import_utils54, FlowRegistry;
 var init_flow_registry = __esm({
   "libs/sdk/src/flows/flow.registry.ts"() {
     "use strict";
     import_di18 = require("@frontmcp/di");
-    import_utils52 = require("@frontmcp/utils");
+    import_utils54 = require("@frontmcp/utils");
     init_common();
     init_context();
     init_errors();
@@ -24769,7 +24960,7 @@ var init_flow_registry = __esm({
         const mcpCtx = input?.ctx;
         const authInfo = mcpCtx?.authInfo;
         const rawSessionId = authInfo?.sessionId;
-        const sessionId = typeof rawSessionId === "string" && rawSessionId.trim().length > 0 ? rawSessionId.trim() : `anon:${(0, import_utils52.randomUUID)()}`;
+        const sessionId = typeof rawSessionId === "string" && rawSessionId.trim().length > 0 ? rawSessionId.trim() : `anon:${(0, import_utils54.randomUUID)()}`;
         const scope = this.providers.getActiveScope();
         return Promise.resolve(
           contextStorage.run(
@@ -25427,11 +25618,11 @@ function isSnapshotCapable(db) {
   const d = db;
   return typeof d.toSnapshot === "function" && typeof d.loadSnapshot === "function";
 }
-var import_utils53, STOP_WORDS, MemorySkillProvider;
+var import_utils55, STOP_WORDS, MemorySkillProvider;
 var init_memory_skill_provider = __esm({
   "libs/sdk/src/skill/providers/memory-skill.provider.ts"() {
     "use strict";
-    import_utils53 = require("@frontmcp/utils");
+    import_utils55 = require("@frontmcp/utils");
     init_optional_dependency_util();
     STOP_WORDS = /* @__PURE__ */ new Set([
       // Articles & Determiners
@@ -25611,7 +25802,7 @@ var init_memory_skill_provider = __esm({
       async computeIndexKey() {
         const parts = Array.from(this.skills.values()).map((s) => `${s.id}\0${this.buildSearchableText(s)}`).sort();
         const canonical = `frontmcp-skill-index:v1|${this.scoring}|${this.skills.size}|${parts.join("
")}`;
-        return (0, import_utils53.sha256Hex)(canonical);
+        return (0, import_utils55.sha256Hex)(canonical);
       }
       /** Await the lazy vectoriadb load (throws the clear install hint if absent). */
       async db() {
@@ -26263,7 +26454,7 @@ function createSkillInstance(record, providers, owner) {
 }
 function getSkillManifestMainDir() {
   try {
-    const cwd = (0, import_utils54.getCwd)();
+    const cwd = (0, import_utils56.getCwd)();
     return cwd && cwd.length > 0 ? cwd : void 0;
   } catch {
     return void 0;
@@ -26271,7 +26462,7 @@ function getSkillManifestMainDir() {
 }
 async function loadResourceWithManifestFallback(resourcePath, baseDir, skillName, resourceType, loader) {
   if (!resourcePath) return void 0;
-  let dir = resourcePath.startsWith("/") ? resourcePath : baseDir ? (0, import_utils54.pathResolve)(baseDir, resourcePath) : void 0;
+  let dir = resourcePath.startsWith("/") ? resourcePath : baseDir ? (0, import_utils56.pathResolve)(baseDir, resourcePath) : void 0;
   if (dir) {
     try {
       return await loader(dir);
@@ -26295,9 +26486,9 @@ async function resolveFromSkillManifest(skillName) {
       return void 0;
     }
     try {
-      const manifestPath = (0, import_utils54.pathJoin)(mainDir2, "_skills", "manifest.json");
-      if (await (0, import_utils54.fileExists)(manifestPath)) {
-        skillManifestCache = await (0, import_utils54.readJSON)(manifestPath);
+      const manifestPath = (0, import_utils56.pathJoin)(mainDir2, "_skills", "manifest.json");
+      if (await (0, import_utils56.fileExists)(manifestPath)) {
+        skillManifestCache = await (0, import_utils56.readJSON)(manifestPath);
       } else {
         skillManifestCache = null;
         return void 0;
@@ -26315,7 +26506,7 @@ async function resolveFromSkillManifest(skillName) {
   if (!entry?.instructions) return void 0;
   const mainDir = getSkillManifestMainDir();
   if (!mainDir) return void 0;
-  return (0, import_utils54.pathResolve)(mainDir, entry.instructions);
+  return (0, import_utils56.pathResolve)(mainDir, entry.instructions);
 }
 async function resolveResourceFromManifest(skillName, resourceType) {
   await resolveFromSkillManifest(skillName);
@@ -26325,13 +26516,13 @@ async function resolveResourceFromManifest(skillName, resourceType) {
   if (!relPath) return void 0;
   const mainDir = getSkillManifestMainDir();
   if (!mainDir) return void 0;
-  return (0, import_utils54.pathResolve)(mainDir, relPath);
+  return (0, import_utils56.pathResolve)(mainDir, relPath);
 }
-var import_utils54, SkillInstance, skillManifestCache;
+var import_utils56, SkillInstance, skillManifestCache;
 var init_skill_instance = __esm({
   "libs/sdk/src/skill/skill.instance.ts"() {
     "use strict";
-    import_utils54 = require("@frontmcp/utils");
+    import_utils56 = require("@frontmcp/utils");
     init_common();
     init_skill_utils();
     SkillInstance = class extends SkillEntry {
@@ -26414,7 +26605,7 @@ var init_skill_instance = __esm({
        */
       getBaseDir() {
         if (this.record.kind === "FILE" /* FILE */) {
-          return (0, import_utils54.dirname)(this.record.filePath) || void 0;
+          return (0, import_utils56.dirname)(this.record.filePath) || void 0;
         }
         if ((this.record.kind === "VALUE" /* VALUE */ || this.record.kind === "CLASS_TOKEN" /* CLASS_TOKEN */) && this.record.callerDir) {
           return this.record.callerDir;
@@ -26517,12 +26708,12 @@ var init_skill_instance = __esm({
 });
 
 // libs/sdk/src/skill/skill.registry.ts
-var import_di22, import_utils55, SkillRegistry;
+var import_di22, import_utils57, SkillRegistry;
 var init_skill_registry = __esm({
   "libs/sdk/src/skill/skill.registry.ts"() {
     "use strict";
     import_di22 = require("@frontmcp/di");
-    import_utils55 = require("@frontmcp/utils");
+    import_utils57 = require("@frontmcp/utils");
     init_availability();
     init_errors();
     init_regsitry();
@@ -26727,8 +26918,8 @@ var init_skill_registry = __esm({
             return skillVis === visibility;
           });
         }
-        const ctx = (0, import_utils55.getRuntimeContext)();
-        skills = skills.filter((s) => (0, import_utils55.isEntryAvailable)(s.metadata.availableWhen, ctx));
+        const ctx = (0, import_utils57.getRuntimeContext)();
+        skills = skills.filter((s) => (0, import_utils57.isEntryAvailable)(s.metadata.availableWhen, ctx));
         return skills;
       }
       /**
@@ -26749,8 +26940,8 @@ var init_skill_registry = __esm({
       getAlwaysLoadedSkills() {
         let skills = this.listAllIndexed().map((r) => r.instance);
         skills = skills.filter((s) => s.isAlwaysLoaded());
-        const ctx = (0, import_utils55.getRuntimeContext)();
-        skills = skills.filter((s) => (0, import_utils55.isEntryAvailable)(s.metadata.availableWhen, ctx));
+        const ctx = (0, import_utils57.getRuntimeContext)();
+        skills = skills.filter((s) => (0, import_utils57.isEntryAvailable)(s.metadata.availableWhen, ctx));
         return skills;
       }
       /**
@@ -26874,8 +27065,8 @@ var init_skill_registry = __esm({
           }
         }
         if (localSkill) {
-          const ctx = (0, import_utils55.getRuntimeContext)();
-          if (!(0, import_utils55.isEntryAvailable)(localSkill.metadata.availableWhen, ctx)) {
+          const ctx = (0, import_utils57.getRuntimeContext)();
+          if (!(0, import_utils57.isEntryAvailable)(localSkill.metadata.availableWhen, ctx)) {
             return void 0;
           }
           const dynamicResolved = this.dynamicContents.get(localSkill.metadata.id ?? localSkill.metadata.name);
@@ -28801,12 +28992,12 @@ function dedupLineage4(l) {
   }
   return out;
 }
-var import_di26, import_utils56, AgentRegistry;
+var import_di26, import_utils58, AgentRegistry;
 var init_agent_registry = __esm({
   "libs/sdk/src/agent/agent.registry.ts"() {
     "use strict";
     import_di26 = require("@frontmcp/di");
-    import_utils56 = require("@frontmcp/utils");
+    import_utils58 = require("@frontmcp/utils");
     init_availability();
     init_mcp_error();
     init_regsitry();
@@ -29001,11 +29192,11 @@ var init_agent_registry = __esm({
        */
       // NOTE: `any` is intentional - heterogeneous agent collections
       getAgents(includeHidden = false) {
-        const ctx = (0, import_utils56.getRuntimeContext)();
+        const ctx = (0, import_utils58.getRuntimeContext)();
         const local = [...this.localRows].map((a) => a.instance);
         const adopted = [...this.adopted.values()].flat().map((a) => a.instance);
         return [...local, ...adopted].filter((a) => {
-          if (!(0, import_utils56.isEntryAvailable)(a.metadata.availableWhen, ctx)) return false;
+          if (!(0, import_utils58.isEntryAvailable)(a.metadata.availableWhen, ctx)) return false;
           if (!includeHidden && a.metadata.hideFromDiscovery === true) return false;
           return true;
         });
@@ -29034,8 +29225,8 @@ var init_agent_registry = __esm({
        * Used by discovery/listing APIs to enforce registry-level constraints.
        */
       getAvailableInstances() {
-        const ctx = (0, import_utils56.getRuntimeContext)();
-        return [...this.listAllInstances()].filter((a) => (0, import_utils56.isEntryAvailable)(a.metadata.availableWhen, ctx));
+        const ctx = (0, import_utils58.getRuntimeContext)();
+        return [...this.listAllInstances()].filter((a) => (0, import_utils58.isEntryAvailable)(a.metadata.availableWhen, ctx));
       }
       /**
        * Find an agent by ID.
@@ -29665,7 +29856,7 @@ function isRemoteAppConfig(item) {
     return true;
   }
   if (obj["urlType"] === "url" || obj["urlType"] === "worker") {
-    return (0, import_utils57.isValidMcpUri)(obj["url"]);
+    return (0, import_utils59.isValidMcpUri)(obj["url"]);
   }
   return false;
 }
@@ -29713,23 +29904,23 @@ function appDiscoveryDeps(rec) {
       return (0, import_di27.depsOfClass)(rec.provide, "discovery");
   }
 }
-var import_di27, import_utils57;
+var import_di27, import_utils59;
 var init_app_utils = __esm({
   "libs/sdk/src/app/app.utils.ts"() {
     "use strict";
     import_di27 = require("@frontmcp/di");
-    import_utils57 = require("@frontmcp/utils");
+    import_utils59 = require("@frontmcp/utils");
     init_common();
     init_errors();
   }
 });
 
 // libs/sdk/src/app/instances/app.local.instance.ts
-var import_utils58, AppLocalInstance;
+var import_utils60, AppLocalInstance;
 var init_app_local_instance = __esm({
   "libs/sdk/src/app/instances/app.local.instance.ts"() {
     "use strict";
-    import_utils58 = require("@frontmcp/utils");
+    import_utils60 = require("@frontmcp/utils");
     init_adapter_registry();
     init_agent_registry();
     init_common();
@@ -29754,7 +29945,7 @@ var init_app_local_instance = __esm({
       constructor(record, scopeProviders) {
         super(record);
         this.scopeProviders = scopeProviders;
-        this.id = this.metadata.id ?? (0, import_utils58.idFromString)(this.metadata.name);
+        this.id = this.metadata.id ?? (0, import_utils60.idFromString)(this.metadata.name);
         try {
           this.logger = scopeProviders.get(FrontMcpLogger)?.child("AppLocalInstance");
         } catch {
@@ -30132,7 +30323,7 @@ var init_request_validation = __esm({
 function getRequestStateKey() {
   if (cachedKey) return cachedKey;
   const secret = process.env["VAULT_SECRET"] ?? process.env["JWT_SECRET"];
-  cachedKey = secret ? encoder.encode(secret) : (0, import_utils59.randomBytes)(32);
+  cachedKey = secret ? encoder.encode(secret) : (0, import_utils61.randomBytes)(32);
   return cachedKey;
 }
 function computeRequestBinding(method, params) {
@@ -30140,17 +30331,17 @@ function computeRequestBinding(method, params) {
   for (const key of ["name", "uri", "arguments"]) {
     if (params?.[key] !== void 0) salient[key] = params[key];
   }
-  return (0, import_utils59.sha256Hex)(`${method}\0${JSON.stringify(salient)}`);
+  return (0, import_utils61.sha256Hex)(`${method}\0${JSON.stringify(salient)}`);
 }
 function base64urlEncodeJson(value) {
-  return (0, import_utils59.base64urlEncode)(encoder.encode(JSON.stringify(value)));
+  return (0, import_utils61.base64urlEncode)(encoder.encode(JSON.stringify(value)));
 }
 function signaturesMatch(a, b) {
   if (a.length !== b.length) return false;
-  return (0, import_utils59.timingSafeEqual)(encoder.encode(a), encoder.encode(b));
+  return (0, import_utils61.timingSafeEqual)(encoder.encode(a), encoder.encode(b));
 }
 function sign(body) {
-  return (0, import_utils59.base64urlEncode)((0, import_utils59.hmacSha256)(getRequestStateKey(), encoder.encode(body)));
+  return (0, import_utils61.base64urlEncode)((0, import_utils61.hmacSha256)(getRequestStateKey(), encoder.encode(body)));
 }
 function encodeRequestState(responses, binding, ttlMs = DEFAULT_REQUEST_STATE_TTL_MS) {
   const payload = {
@@ -30172,7 +30363,7 @@ function decodeRequestState(state, expected) {
   if (!signaturesMatch(signature, sign(body))) return { ok: false, reason: "bad-signature" };
   let payload;
   try {
-    payload = JSON.parse(decoder.decode((0, import_utils59.base64urlDecode)(body)));
+    payload = JSON.parse(decoder.decode((0, import_utils61.base64urlDecode)(body)));
   } catch {
     return { ok: false, reason: "malformed" };
   }
@@ -30184,11 +30375,11 @@ function decodeRequestState(state, expected) {
   if (payload.b !== expected.binding) return { ok: false, reason: "request-mismatch" };
   return { ok: true, responses: payload.r };
 }
-var import_utils59, DEFAULT_REQUEST_STATE_TTL_MS, MAX_REQUEST_STATE_BYTES, cachedKey, encoder, decoder;
+var import_utils61, DEFAULT_REQUEST_STATE_TTL_MS, MAX_REQUEST_STATE_BYTES, cachedKey, encoder, decoder;
 var init_request_state = __esm({
   "libs/sdk/src/transport/mcp-20260728/request-state.ts"() {
     "use strict";
-    import_utils59 = require("@frontmcp/utils");
+    import_utils61 = require("@frontmcp/utils");
     DEFAULT_REQUEST_STATE_TTL_MS = 10 * 60 * 1e3;
     MAX_REQUEST_STATE_BYTES = 256 * 1024;
     encoder = new TextEncoder();
@@ -30722,7 +30913,7 @@ function resolvePrincipal(authInfo) {
   const clientId = authInfo?.["clientId"];
   if (typeof clientId === "string" && clientId.length > 0) return clientId;
   const token = authInfo?.["token"];
-  if (typeof token === "string" && token.length > 0) return `tok:${(0, import_utils60.sha256Hex)(token)}`;
+  if (typeof token === "string" && token.length > 0) return `tok:${(0, import_utils62.sha256Hex)(token)}`;
   return "anonymous";
 }
 function resolveTaskPrincipal(authInfo, isAnonymous = false) {
@@ -30930,12 +31121,12 @@ async function dispatch20260728(options) {
     return { kind: "error", status: mapped.status, error: mapped.error };
   }
 }
-var import_protocol45, import_utils60, MRTR_CAPABLE_METHODS;
+var import_protocol45, import_utils62, MRTR_CAPABLE_METHODS;
 var init_dispatcher = __esm({
   "libs/sdk/src/transport/mcp-20260728/dispatcher.ts"() {
     "use strict";
     import_protocol45 = require("@frontmcp/protocol");
-    import_utils60 = require("@frontmcp/utils");
+    import_utils62 = require("@frontmcp/utils");
     init_errors();
     init_build_scoped_server_options();
     init_mcp_handlers();
@@ -33115,11 +33306,11 @@ var init_remote_mcp = __esm({
 });
 
 // libs/sdk/src/app/instances/app.remote.instance.ts
-var import_utils61, EmptyPluginRegistry, EmptyAdapterRegistry, EmptySkillRegistry, AppRemoteInstance;
+var import_utils63, EmptyPluginRegistry, EmptyAdapterRegistry, EmptySkillRegistry, AppRemoteInstance;
 var init_app_remote_instance = __esm({
   "libs/sdk/src/app/instances/app.remote.instance.ts"() {
     "use strict";
-    import_utils61 = require("@frontmcp/utils");
+    import_utils63 = require("@frontmcp/utils");
     init_common();
     init_errors();
     init_prompt_registry();
@@ -33234,7 +33425,7 @@ var init_app_remote_instance = __esm({
       _unsubscribeCapability;
       constructor(record, scopeProviders) {
         super(record);
-        this.id = this.metadata.id ?? (0, import_utils61.idFromString)(this.metadata.name);
+        this.id = this.metadata.id ?? (0, import_utils63.idFromString)(this.metadata.name);
         this.scopeProviders = scopeProviders;
         this.appOwner = {
           kind: "app",
@@ -33636,11 +33827,11 @@ function getDefaultCacheDir() {
     return "";
   }
 }
-var import_utils62, DEFAULT_CACHE_DIR, DEFAULT_MAX_AGE_MS, DEFAULT_MAX_ENTRIES, EsmCacheManager;
+var import_utils64, DEFAULT_CACHE_DIR, DEFAULT_MAX_AGE_MS, DEFAULT_MAX_ENTRIES, EsmCacheManager;
 var init_esm_cache = __esm({
   "libs/sdk/src/esm-loader/esm-cache.ts"() {
     "use strict";
-    import_utils62 = require("@frontmcp/utils");
+    import_utils64 = require("@frontmcp/utils");
     DEFAULT_CACHE_DIR = getDefaultCacheDir();
     DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
     DEFAULT_MAX_ENTRIES = 100;
@@ -33704,7 +33895,7 @@ var init_esm_cache = __esm({
        * Store an ESM bundle in the cache.
        */
       async put(packageName, version, bundleContent, packageUrl, etag) {
-        if (!(0, import_utils62.isValidMcpUri)(packageUrl)) {
+        if (!(0, import_utils64.isValidMcpUri)(packageUrl)) {
           throw new Error("URI must have a valid scheme (e.g., file://, https://, custom://)");
         }
         const memKey = `${packageName}@${version}`;
@@ -33835,7 +34026,7 @@ var init_esm_cache = __esm({
        */
       getEntryDir(packageName, version) {
         const path3 = require("node:path");
-        const hash = (0, import_utils62.sha256Hex)(`${packageName}@${version}`);
+        const hash = (0, import_utils64.sha256Hex)(`${packageName}@${version}`);
         return path3.join(this.cacheDir, hash);
       }
     };
@@ -33886,7 +34077,7 @@ function normalizeResourceFromEsmExport(raw) {
   const obj = raw;
   if (typeof obj["read"] === "function" && typeof obj["name"] === "string" && typeof obj["uri"] === "string") {
     const uri = obj["uri"];
-    if (!(0, import_utils63.isValidMcpUri)(uri)) return void 0;
+    if (!(0, import_utils65.isValidMcpUri)(uri)) return void 0;
     const description = obj["description"];
     const mimeType = obj["mimeType"];
     return {
@@ -33914,12 +34105,12 @@ function normalizePromptFromEsmExport(raw) {
   }
   return void 0;
 }
-var import_di28, import_utils63;
+var import_di28, import_utils65;
 var init_esm_normalize_utils = __esm({
   "libs/sdk/src/app/instances/esm-normalize.utils.ts"() {
     "use strict";
     import_di28 = require("@frontmcp/di");
-    import_utils63 = require("@frontmcp/utils");
+    import_utils65 = require("@frontmcp/utils");
     init_tokens();
   }
 });
@@ -34360,13 +34551,13 @@ var init_esm_module_loader = __esm({
             URL.revokeObjectURL(url);
           }
         }
-        const { ensureDir, fileExists: fileExists9, sha256Hex: sha256Hex11, writeFile } = await import("@frontmcp/utils");
+        const { ensureDir, fileExists: fileExists9, sha256Hex: sha256Hex12, writeFile } = await import("@frontmcp/utils");
         const nodePath = await import("node:path");
         const nodeOs = await import("node:os");
         const { pathToFileURL } = await import("node:url");
         const dir = nodePath.join(nodeOs.tmpdir(), "frontmcp-esm-modules");
         await ensureDir(dir);
-        const tempPath = nodePath.join(dir, `${sha256Hex11(bundleContent)}.mjs`);
+        const tempPath = nodePath.join(dir, `${sha256Hex12(bundleContent)}.mjs`);
         if (!await fileExists9(tempPath)) {
           await writeFile(tempPath, bundleContent);
         }
@@ -34691,11 +34882,11 @@ var init_esm_loader = __esm({
 });
 
 // libs/sdk/src/app/instances/app.esm.instance.ts
-var import_utils64, EmptyPluginRegistry2, EmptyAdapterRegistry2, EmptySkillRegistry2, AppEsmInstance;
+var import_utils66, EmptyPluginRegistry2, EmptyAdapterRegistry2, EmptySkillRegistry2, AppEsmInstance;
 var init_app_esm_instance = __esm({
   "libs/sdk/src/app/instances/app.esm.instance.ts"() {
     "use strict";
-    import_utils64 = require("@frontmcp/utils");
+    import_utils66 = require("@frontmcp/utils");
     init_common();
     init_errors();
     init_esm_loader();
@@ -34810,7 +35001,7 @@ var init_app_esm_instance = __esm({
       _skills;
       constructor(record, scopeProviders) {
         super(record);
-        this.id = this.metadata.id ?? (0, import_utils64.idFromString)(this.metadata.name);
+        this.id = this.metadata.id ?? (0, import_utils66.idFromString)(this.metadata.name);
         this.scopeProviders = scopeProviders;
         this.appOwner = {
           kind: "app",
@@ -35158,11 +35349,11 @@ function timingSafeEqualStr(a, b) {
   }
   return diff === 0;
 }
-var import_utils65, ALL_SLOTS, PENDING_UI_TTL_MS, AuthUiRegistry;
+var import_utils67, ALL_SLOTS, PENDING_UI_TTL_MS, AuthUiRegistry;
 var init_auth_ui_registry = __esm({
   "libs/sdk/src/auth/auth-ui/auth-ui.registry.ts"() {
     "use strict";
-    import_utils65 = require("@frontmcp/utils");
+    import_utils67 = require("@frontmcp/utils");
     ALL_SLOTS = ["login", "consent", "incremental", "federated", "error"];
     PENDING_UI_TTL_MS = 10 * 60 * 1e3;
     AuthUiRegistry = class {
@@ -35193,7 +35384,7 @@ var init_auth_ui_registry = __esm({
             throw new Error(`auth.ui slot "${slot}" is not one of: ${ALL_SLOTS.join(", ")}.`);
           }
           if (typeof rawPath !== "string" || rawPath.length === 0) continue;
-          const file = (0, import_utils65.isAbsolute)(rawPath) ? rawPath : (0, import_utils65.pathResolve)(sourceDir, rawPath);
+          const file = (0, import_utils67.isAbsolute)(rawPath) ? rawPath : (0, import_utils67.pathResolve)(sourceDir, rawPath);
           this.slots.set(slot, { file });
           this.logger?.verbose(`Registered auth.ui slot "${slot}" \u2192 ${file}`);
         }
@@ -35279,7 +35470,7 @@ var init_auth_ui_registry = __esm({
       mintCsrf(pendingAuthId) {
         const existing = this.pending.get(pendingAuthId);
         if (existing) return existing.csrf;
-        const csrf = (0, import_utils65.sha256Hex)((0, import_utils65.randomBytes)(32)).slice(0, 43);
+        const csrf = (0, import_utils67.sha256Hex)((0, import_utils67.randomBytes)(32)).slice(0, 43);
         this.pending.set(pendingAuthId, { csrf, addedItems: {}, createdAt: Date.now() });
         this.pruneExpired();
         return csrf;
@@ -35332,7 +35523,7 @@ var init_auth_ui_registry = __esm({
       ensurePending(pendingAuthId) {
         let state = this.pending.get(pendingAuthId);
         if (!state) {
-          state = { csrf: (0, import_utils65.sha256Hex)((0, import_utils65.randomBytes)(32)).slice(0, 43), addedItems: {}, createdAt: Date.now() };
+          state = { csrf: (0, import_utils67.sha256Hex)((0, import_utils67.randomBytes)(32)).slice(0, 43), addedItems: {}, createdAt: Date.now() };
           this.pending.set(pendingAuthId, state);
           this.pruneExpired();
         }
@@ -35671,25 +35862,25 @@ var init_auth_utils = __esm({
 });
 
 // libs/sdk/src/auth/authorization/orchestrated.context-extension.ts
-var import_auth18, orchestratedAuthContextExtension;
+var import_auth19, orchestratedAuthContextExtension;
 var init_orchestrated_context_extension = __esm({
   "libs/sdk/src/auth/authorization/orchestrated.context-extension.ts"() {
     "use strict";
-    import_auth18 = require("@frontmcp/auth");
+    import_auth19 = require("@frontmcp/auth");
     orchestratedAuthContextExtension = {
       property: "orchestration",
-      token: import_auth18.ORCHESTRATED_AUTH_ACCESSOR,
+      token: import_auth19.ORCHESTRATED_AUTH_ACCESSOR,
       errorMessage: "Orchestrated authorization not available. Ensure your server is configured with orchestrated mode and the user has completed authentication."
     };
   }
 });
 
 // libs/sdk/src/auth/cimd/index.ts
-var import_auth19;
+var import_auth20;
 var init_cimd = __esm({
   "libs/sdk/src/auth/cimd/index.ts"() {
     "use strict";
-    import_auth19 = require("@frontmcp/auth");
+    import_auth20 = require("@frontmcp/auth");
   }
 });
 
@@ -35711,9 +35902,9 @@ function createCredentialsProviders(opts) {
     name: "SessionCredentialVault"
   };
   const accessorProvider = {
-    provide: import_auth20.CREDENTIALS_ACCESSOR,
+    provide: import_auth21.CREDENTIALS_ACCESSOR,
     inject: () => [FRONTMCP_CONTEXT, FrontMcpLogger],
-    useFactory: (ctx, logger) => new import_auth20.CredentialsAccessorImpl({
+    useFactory: (ctx, logger) => new import_auth21.CredentialsAccessorImpl({
       vault,
       resolveSub: () => resolveRequestSub(ctx),
       signingSecret,
@@ -35726,11 +35917,11 @@ function createCredentialsProviders(opts) {
   };
   return [vaultProvider, accessorProvider];
 }
-var import_auth20, import_di31, SESSION_CREDENTIAL_VAULT;
+var import_auth21, import_di31, SESSION_CREDENTIAL_VAULT;
 var init_credentials_providers = __esm({
   "libs/sdk/src/auth/credentials/credentials.providers.ts"() {
     "use strict";
-    import_auth20 = require("@frontmcp/auth");
+    import_auth21 = require("@frontmcp/auth");
     import_di31 = require("@frontmcp/di");
     init_common();
     init_frontmcp_context_provider();
@@ -35741,14 +35932,14 @@ var init_credentials_providers = __esm({
 });
 
 // libs/sdk/src/auth/credentials/credentials.context-extension.ts
-var import_auth21, credentialsContextExtension;
+var import_auth22, credentialsContextExtension;
 var init_credentials_context_extension = __esm({
   "libs/sdk/src/auth/credentials/credentials.context-extension.ts"() {
     "use strict";
-    import_auth21 = require("@frontmcp/auth");
+    import_auth22 = require("@frontmcp/auth");
     credentialsContextExtension = {
       property: "credentials",
-      token: import_auth21.CREDENTIALS_ACCESSOR,
+      token: import_auth22.CREDENTIALS_ACCESSOR,
       errorMessage: "Per-session credentials are not available. Ensure the server uses auth mode 'local' (or 'remote'); credentials are persisted by a local authenticate() verifier."
     };
   }
@@ -35917,13 +36108,13 @@ function getConfiguredProviders(auth) {
 function getConfiguredProviderIds(auth) {
   return getConfiguredProviders(auth).map((p) => p.id);
 }
-var import_auth22, import_lazy_zod64, import_utils66, pkceChallengeSchema, codeChallengeMethodSchema, responseTypeSchema, safeRedirectUriSchema, oauthAuthorizeRequestSchema, anonymousAuthorizeRequestSchema, inputSchema16, stateSchema15, outputSchema15, plan15, name15, Stage15, OauthAuthorizeFlow;
+var import_auth23, import_lazy_zod64, import_utils68, pkceChallengeSchema, codeChallengeMethodSchema, responseTypeSchema, safeRedirectUriSchema, oauthAuthorizeRequestSchema, anonymousAuthorizeRequestSchema, inputSchema16, stateSchema15, outputSchema15, plan15, name15, Stage15, OauthAuthorizeFlow;
 var init_oauth_authorize_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.authorize.flow.ts"() {
     "use strict";
-    import_auth22 = require("@frontmcp/auth");
+    import_auth23 = require("@frontmcp/auth");
     import_lazy_zod64 = require("@frontmcp/lazy-zod");
-    import_utils66 = require("@frontmcp/utils");
+    import_utils68 = require("@frontmcp/utils");
     init_common();
     init_auth_ui();
     init_cimd();
@@ -35999,7 +36190,7 @@ var init_oauth_authorize_flow = __esm({
       requiresConsent: import_lazy_zod64.z.boolean().default(false).describe("Whether consent flow is enabled"),
       // CIMD (Client ID Metadata Documents)
       isCimdClient: import_lazy_zod64.z.boolean().default(false).describe("Whether client_id is a CIMD URL"),
-      cimdMetadata: import_auth19.clientMetadataDocumentSchema.optional().describe("CIMD metadata document for the client")
+      cimdMetadata: import_auth20.clientMetadataDocumentSchema.optional().describe("CIMD metadata document for the client")
     });
     outputSchema15 = import_lazy_zod64.z.union([
       HttpRedirectSchema,
@@ -36055,14 +36246,14 @@ var init_oauth_authorize_flow = __esm({
         const existingSessionId = request.query["session_id"];
         const isDefaultAuthProvider = !metadata.auth;
         let requiresFederatedLogin = false;
-        if (metadata.auth && (0, import_auth10.isOrchestratedMode)(metadata.auth)) {
+        if (metadata.auth && (0, import_auth11.isOrchestratedMode)(metadata.auth)) {
           const configProviders = getConfiguredProviderIds(metadata.auth);
           const apps = this.scope.apps.getApps();
           const appsWithAuth = apps.filter((app) => app.metadata.auth);
           requiresFederatedLogin = configProviders.length > 0 || appsWithAuth.length > 0;
         }
         let requiresConsent = false;
-        if (metadata.auth && (0, import_auth10.isOrchestratedMode)(metadata.auth)) {
+        if (metadata.auth && (0, import_auth11.isOrchestratedMode)(metadata.auth)) {
           const consentConfig = metadata.auth.consent;
           requiresConsent = consentConfig?.enabled === true;
         }
@@ -36150,7 +36341,7 @@ var init_oauth_authorize_flow = __esm({
           }
         }
         const { client_id, redirect_uri } = result.data;
-        const cimdService = this.get(import_auth19.CimdService);
+        const cimdService = this.get(import_auth20.CimdService);
         const isCimdClientId2 = !!cimdService?.enabled && cimdService.isCimdClientId(client_id);
         const dcrError = this.checkDcrAllowlist(client_id, redirect_uri, isCimdClientId2);
         if (dcrError) {
@@ -36219,7 +36410,7 @@ var init_oauth_authorize_flow = __esm({
         const localAuth = this.scope.auth;
         const secret = localAuth?.signingSecret;
         if (!secret) return void 0;
-        const payload = (0, import_auth22.verifyIncrementalAuthTicket)(token, secret);
+        const payload = (0, import_auth23.verifyIncrementalAuthTicket)(token, secret);
         if (!payload) {
           this.logger.warn("Incremental auth ticket failed verification \u2014 treating as an ordinary login");
           return void 0;
@@ -36252,6 +36443,7 @@ var init_oauth_authorize_flow = __esm({
         const localAuth = auth;
         const store = localAuth.authorizationStore;
         let effectiveIncremental = isIncrementalAuth;
+        let effectivePriorAppIds = priorAuthorizedAppIds;
         if (incrementalTicket) {
           const claimed = await localAuth.claimIncrementalTicket(
             incrementalTicket.jti,
@@ -36260,7 +36452,13 @@ var init_oauth_authorize_flow = __esm({
           if (!claimed) {
             this.logger.warn("Incremental auth ticket already used \u2014 falling back to an ordinary login");
             effectiveIncremental = false;
-            this.state.set({ isIncrementalAuth: false, targetAppId: void 0, targetToolId: void 0 });
+            effectivePriorAppIds = void 0;
+            this.state.set({
+              isIncrementalAuth: false,
+              targetAppId: void 0,
+              targetToolId: void 0,
+              priorAuthorizedAppIds: void 0
+            });
           }
         }
         let federatedLogin;
@@ -36272,7 +36470,7 @@ var init_oauth_authorize_flow = __esm({
               providerIds.push(id);
             }
           }
-          if (providerIds.length === 0 && metadata.auth && (0, import_auth10.isOrchestratedMode)(metadata.auth)) {
+          if (providerIds.length === 0 && metadata.auth && (0, import_auth11.isOrchestratedMode)(metadata.auth)) {
             providerIds.push("__parent__");
           }
           for (const app of apps) {
@@ -36291,7 +36489,7 @@ var init_oauth_authorize_flow = __esm({
         }
         let consent;
         if (requiresConsent) {
-          const consentConfig = metadata.auth && (0, import_auth10.isOrchestratedMode)(metadata.auth) ? metadata.auth.consent : void 0;
+          const consentConfig = metadata.auth && (0, import_auth11.isOrchestratedMode)(metadata.auth) ? metadata.auth.consent : void 0;
           const { availableToolIds } = projectConsentTools(this.scope, consentConfig?.excludedTools);
           consent = {
             enabled: true,
@@ -36319,7 +36517,7 @@ var init_oauth_authorize_flow = __esm({
           targetAppId: effectiveIncremental ? targetAppId : void 0,
           targetToolId: effectiveIncremental ? targetToolId : void 0,
           existingSessionId,
-          priorAuthorizedAppIds,
+          priorAuthorizedAppIds: effectivePriorAppIds,
           // Federated Login State
           federatedLogin,
           // Consent State
@@ -36346,7 +36544,7 @@ var init_oauth_authorize_flow = __esm({
           return;
         }
         const { metadata } = this.scope;
-        if (metadata.auth && (0, import_auth10.isRemoteMode)(metadata.auth) && !isIncrementalAuth) {
+        if (metadata.auth && (0, import_auth11.isRemoteMode)(metadata.auth) && !isIncrementalAuth) {
           await this.startRemoteFederation(pendingAuthId, validatedRequest);
           return;
         }
@@ -36394,7 +36592,7 @@ var init_oauth_authorize_flow = __esm({
               isParentProvider: false
             });
           }
-          if (!hasConfiguredProviders && metadata2.auth && (0, import_auth10.isOrchestratedMode)(metadata2.auth)) {
+          if (!hasConfiguredProviders && metadata2.auth && (0, import_auth11.isOrchestratedMode)(metadata2.auth)) {
             providers.push({
               id: "__parent__",
               mode: metadata2.auth.mode,
@@ -36548,7 +36746,7 @@ var init_oauth_authorize_flow = __esm({
           );
           return;
         }
-        const session = (0, import_auth22.createFederatedAuthSession)({
+        const session = (0, import_auth23.createFederatedAuthSession)({
           pendingAuthId,
           clientId: validatedRequest.client_id,
           redirectUri: validatedRequest.redirect_uri,
@@ -36559,11 +36757,11 @@ var init_oauth_authorize_flow = __esm({
           frontmcpPkce: { challenge: validatedRequest.code_challenge, method: "S256" },
           providerIds: [providerId]
         });
-        const verifier = (0, import_utils66.generateCodeVerifier)();
-        const challenge = (0, import_utils66.sha256Base64url)(verifier);
+        const verifier = (0, import_utils68.generateCodeVerifier)();
+        const challenge = (0, import_utils68.sha256Base64url)(verifier);
         const pkce = { verifier, challenge, method: "S256" };
-        const providerState = `federated:${session.id}:${(0, import_utils66.randomUUID)()}`;
-        (0, import_auth22.startNextProvider)(session, pkce, providerState);
+        const providerState = `federated:${session.id}:${(0, import_utils68.randomUUID)()}`;
+        (0, import_auth23.startNextProvider)(session, pkce, providerState);
         await localAuth.federatedSessionStore.store(session);
         const redirectUrl = await localAuth.buildProviderAuthorizeUrl(providerId, {
           state: providerState,
@@ -36664,7 +36862,7 @@ var init_oauth_authorize_flow = __esm({
           callbackPath,
           fields: login?.fields ?? {}
         };
-        return (0, import_auth22.renderLocalLoginPage)(login, ctx);
+        return (0, import_auth23.renderLocalLoginPage)(login, ctx);
       }
       /**
        * Render incremental authorization page for a single app using HTMX templates
@@ -36677,7 +36875,7 @@ var init_oauth_authorize_flow = __esm({
           appName,
           description: appDescription
         };
-        return (0, import_auth22.buildIncrementalAuthPage)({
+        return (0, import_auth23.buildIncrementalAuthPage)({
           app,
           toolId: toolId || "unknown tool",
           sessionHint: pendingAuthId,
@@ -36698,7 +36896,7 @@ var init_oauth_authorize_flow = __esm({
           appIds: provider.appIds.filter((id) => id !== "__parent__"),
           isPrimary: provider.isParentProvider
         }));
-        return (0, import_auth22.buildFederatedLoginPage)({
+        return (0, import_auth23.buildFederatedLoginPage)({
           providers,
           clientName: clientId,
           pendingAuthId,
@@ -36743,8 +36941,8 @@ var init_oauth_authorize_flow = __esm({
   <div class="error-container">
     <div class="error-icon">\u26A0\uFE0F</div>
     <h1>Authorization Error</h1>
-    <p><span class="error-code">${(0, import_auth22.escapeHtml)(error)}</span></p>
-    <p>${(0, import_auth22.escapeHtml)(description)}</p>
+    <p><span class="error-code">${(0, import_auth23.escapeHtml)(error)}</span></p>
+    <p>${(0, import_auth23.escapeHtml)(description)}</p>
   </div>
 </body>
 </html>`;
@@ -36793,13 +36991,13 @@ function timingSafeEqualStr3(a, b) {
   }
   return diff === 0;
 }
-var import_auth23, import_lazy_zod65, import_utils67, inputSchema17, stateSchema16, outputSchema16, plan16, name16, Stage16, OauthCallbackFlow;
+var import_auth24, import_lazy_zod65, import_utils69, inputSchema17, stateSchema16, outputSchema16, plan16, name16, Stage16, OauthCallbackFlow;
 var init_oauth_callback_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.callback.flow.ts"() {
     "use strict";
-    import_auth23 = require("@frontmcp/auth");
+    import_auth24 = require("@frontmcp/auth");
     import_lazy_zod65 = require("@frontmcp/lazy-zod");
-    import_utils67 = require("@frontmcp/utils");
+    import_utils69 = require("@frontmcp/utils");
     init_common();
     init_auth_ui();
     init_consent_tools_helper();
@@ -37166,7 +37364,7 @@ var init_oauth_callback_flow = __esm({
           return;
         }
         const authOptions = this.scope.auth?.options;
-        if (!authOptions || !(0, import_auth10.isOrchestratedMode)(authOptions)) {
+        if (!authOptions || !(0, import_auth11.isOrchestratedMode)(authOptions)) {
           return;
         }
         const incrementalConfig = authOptions.incrementalAuth;
@@ -37229,8 +37427,8 @@ var init_oauth_callback_flow = __esm({
           this.respond(httpRespond.html(this.renderErrorPage("server_error", "Authorization request incomplete"), 500));
           return;
         }
-        const federatedSession = (0, import_auth23.createFederatedAuthSession)({
-          pendingAuthId: this.state.required.pendingAuthId || (0, import_utils67.randomUUID)(),
+        const federatedSession = (0, import_auth24.createFederatedAuthSession)({
+          pendingAuthId: this.state.required.pendingAuthId || (0, import_utils69.randomUUID)(),
           clientId,
           redirectUri,
           scopes: scopes ?? [],
@@ -37250,15 +37448,15 @@ var init_oauth_callback_flow = __esm({
         await sessionStore.store(federatedSession);
         this.logger.info(`Created federated session: ${federatedSession.id}`);
         const firstProviderId = selectedProviders[0];
-        const verifier = (0, import_utils67.generateCodeVerifier)();
-        const challenge = (0, import_utils67.sha256Base64url)(verifier);
+        const verifier = (0, import_utils69.generateCodeVerifier)();
+        const challenge = (0, import_utils69.sha256Base64url)(verifier);
         const pkce = {
           verifier,
           challenge,
           method: "S256"
         };
-        const providerState = `federated:${federatedSession.id}:${(0, import_utils67.randomUUID)()}`;
-        (0, import_auth23.startNextProvider)(federatedSession, pkce, providerState);
+        const providerState = `federated:${federatedSession.id}:${(0, import_utils69.randomUUID)()}`;
+        (0, import_auth24.startNextProvider)(federatedSession, pkce, providerState);
         await sessionStore.update(federatedSession);
         const providerConfig = localAuth.getProviderConfig(firstProviderId);
         if (!providerConfig) {
@@ -37562,7 +37760,7 @@ var init_oauth_callback_flow = __esm({
           fields: login?.fields ?? {},
           error: failure.message
         };
-        return (0, import_auth23.renderLocalLoginPage)(login, ctx, fields);
+        return (0, import_auth24.renderLocalLoginPage)(login, ctx, fields);
       }
       /**
        * Render a custom `@AuthUi({ slot: 'consent' })` page when one is registered.
@@ -37658,7 +37856,7 @@ var init_oauth_callback_flow = __esm({
         if (pendingAuth.authUiCsrf) {
           hiddenFields.push({ name: "csrf", value: pendingAuth.authUiCsrf });
         }
-        return (0, import_auth23.buildToolConsentPage)({
+        return (0, import_auth24.buildToolConsentPage)({
           tools: toolCards,
           clientName: pendingAuth.clientId,
           pendingAuthId: pendingAuth.id,
@@ -37684,15 +37882,15 @@ var init_oauth_callback_flow = __esm({
        * In production, this would be the user's ID from the database
        */
       generateUserSub(email) {
-        const hash = (0, import_utils67.sha256Hex)(email.toLowerCase());
+        const hash = (0, import_utils69.sha256Hex)(email.toLowerCase());
         return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
       }
       /**
        * Render an error page
        */
       renderErrorPage(error, description) {
-        const safeError = (0, import_auth23.escapeHtml)(error);
-        const safeDescription = (0, import_auth23.escapeHtml)(description);
+        const safeError = (0, import_auth24.escapeHtml)(error);
+        const safeDescription = (0, import_auth24.escapeHtml)(description);
         return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -37803,11 +38001,11 @@ var init_oauth_callback_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.connect.flow.ts
-var import_auth24, import_lazy_zod66, inputSchema18, stateSchema17, outputSchema17, plan17, name17, Stage17, RESERVED_CONNECT_PARAMS, OauthConnectFlow;
+var import_auth25, import_lazy_zod66, inputSchema18, stateSchema17, outputSchema17, plan17, name17, Stage17, RESERVED_CONNECT_PARAMS, OauthConnectFlow;
 var init_oauth_connect_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.connect.flow.ts"() {
     "use strict";
-    import_auth24 = require("@frontmcp/auth");
+    import_auth25 = require("@frontmcp/auth");
     import_lazy_zod66 = require("@frontmcp/lazy-zod");
     init_common();
     inputSchema18 = httpInputSchema;
@@ -37917,7 +38115,7 @@ var init_oauth_connect_flow = __esm({
         }
         this.logger.info(`Connected ${stored} credential(s) mid-session for key "${payload.key}"`);
         this.notifyResourcesUpdated(payload.key);
-        this.respond(httpRespond.html((0, import_auth24.buildConnectSuccessPage)({ key: payload.key })));
+        this.respond(httpRespond.html((0, import_auth25.buildConnectSuccessPage)({ key: payload.key })));
       }
       // ============================================
       // Helpers
@@ -37925,7 +38123,7 @@ var init_oauth_connect_flow = __esm({
       /** Verify the signed resume token against the server secret (constant-time + expiry). */
       verifyToken(token, localAuth) {
         const secret = new TextDecoder().decode(localAuth.secret);
-        return (0, import_auth24.verifyCredentialResumeToken)(token, secret);
+        return (0, import_auth25.verifyCredentialResumeToken)(token, secret);
       }
       /** Resolve the single credential field to render from `login.fields` (first field), or a default. */
       resolveConnectField(login, key) {
@@ -37941,8 +38139,8 @@ var init_oauth_connect_flow = __esm({
       renderConnectPage(payload, login, token, error) {
         const { name: name42, def } = this.resolveConnectField(login, payload.key);
         const action = `${this.scope.fullPath}/oauth/connect`;
-        const [field] = (0, import_auth24.toLoginExtraFields)({ [name42]: def });
-        return (0, import_auth24.buildConnectPage)({
+        const [field] = (0, import_auth25.toLoginExtraFields)({ [name42]: def });
+        return (0, import_auth25.buildConnectPage)({
           token,
           field,
           action,
@@ -38041,8 +38239,8 @@ var init_oauth_connect_flow = __esm({
         return `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><title>Connect Error</title></head>
 <body style="font-family:-apple-system,sans-serif;padding:40px;text-align:center">
 <h1 style="color:#e53e3e">Connect Error</h1>
-<p><code>${(0, import_auth24.escapeHtml)(error)}</code></p>
-<p>${(0, import_auth24.escapeHtml)(description)}</p>
+<p><code>${(0, import_auth25.escapeHtml)(error)}</code></p>
+<p>${(0, import_auth25.escapeHtml)(description)}</p>
 </body></html>`;
       }
     };
@@ -38069,13 +38267,13 @@ var init_oauth_connect_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.provider-callback.flow.ts
-var import_auth25, import_lazy_zod67, import_utils68, inputSchema19, stateSchema18, outputSchema18, plan18, name18, Stage18, OauthProviderCallbackFlow;
+var import_auth26, import_lazy_zod67, import_utils70, inputSchema19, stateSchema18, outputSchema18, plan18, name18, Stage18, OauthProviderCallbackFlow;
 var init_oauth_provider_callback_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.provider-callback.flow.ts"() {
     "use strict";
-    import_auth25 = require("@frontmcp/auth");
+    import_auth26 = require("@frontmcp/auth");
     import_lazy_zod67 = require("@frontmcp/lazy-zod");
-    import_utils68 = require("@frontmcp/utils");
+    import_utils70 = require("@frontmcp/utils");
     init_common();
     init_errors();
     init_consent_tools_helper();
@@ -38176,7 +38374,7 @@ var init_oauth_provider_callback_flow = __esm({
           );
           return;
         }
-        if (!(0, import_auth25.isSessionComplete)(session)) {
+        if (!(0, import_auth26.isSessionComplete)(session)) {
           this.respond(
             httpRespond.html(this.renderErrorPage("invalid_request", "Authentication is still in progress."), 400)
           );
@@ -38375,7 +38573,7 @@ var init_oauth_provider_callback_flow = __esm({
           this.logger.info(`Stored tokens for provider ${providerId} (temp auth: ${tempAuthId})`);
         }
         if (tokens) {
-          (0, import_auth25.completeCurrentProvider)(session, tokens, userInfo);
+          (0, import_auth26.completeCurrentProvider)(session, tokens, userInfo);
           if (userInfo) {
             if (!session.userInfo.sub && userInfo.sub) {
               session.userInfo.sub = userInfo.sub;
@@ -38408,23 +38606,23 @@ var init_oauth_provider_callback_flow = __esm({
           return;
         }
         const localAuth = this.getLocalAuth();
-        if ((0, import_auth25.isSessionComplete)(session)) {
+        if ((0, import_auth26.isSessionComplete)(session)) {
           this.logger.info("All providers authenticated, completing federated auth flow");
           return this.completeFederatedAuth(session);
         }
-        const nextProviderId = (0, import_auth25.getNextProvider)(session);
+        const nextProviderId = (0, import_auth26.getNextProvider)(session);
         if (!nextProviderId) {
           return this.completeFederatedAuth(session);
         }
-        const verifier = (0, import_utils68.generateCodeVerifier)();
-        const challenge = (0, import_utils68.sha256Base64url)(verifier);
+        const verifier = (0, import_utils70.generateCodeVerifier)();
+        const challenge = (0, import_utils70.sha256Base64url)(verifier);
         const pkce = {
           verifier,
           challenge,
           method: "S256"
         };
-        const providerState = `federated:${session.id}:${(0, import_utils68.randomUUID)()}`;
-        (0, import_auth25.startNextProvider)(session, pkce, providerState);
+        const providerState = `federated:${session.id}:${(0, import_utils70.randomUUID)()}`;
+        (0, import_auth26.startNextProvider)(session, pkce, providerState);
         const sessionStore = localAuth.federatedSessionStore;
         if (sessionStore) {
           await sessionStore.update(session);
@@ -38464,7 +38662,7 @@ var init_oauth_provider_callback_flow = __esm({
         const selectedProviderIds = Array.from(session.completedProviders.keys());
         const skippedProviderIds = session.skippedProviders;
         const metadataAuth = this.scope.metadata.auth;
-        const consentConfig = metadataAuth && (0, import_auth10.isOrchestratedMode)(metadataAuth) ? metadataAuth.consent : void 0;
+        const consentConfig = metadataAuth && (0, import_auth11.isOrchestratedMode)(metadataAuth) ? metadataAuth.consent : void 0;
         const consentEnabled = consentConfig?.enabled === true;
         const rememberConsent = consentConfig?.rememberConsent ?? true;
         const consentUserSub = session.userInfo.sub || (session.userInfo.email ? this.generateUserSub(session.userInfo.email) : void 0);
@@ -38587,7 +38785,7 @@ var init_oauth_provider_callback_flow = __esm({
       renderConsentScreen(session, consentConfig, error, preSelectedTools) {
         const callbackPath = `${this.scope.fullPath}/oauth/provider/_consent/callback`;
         const { toolCards } = projectConsentTools(this.scope, consentConfig.excludedTools);
-        return (0, import_auth25.buildToolConsentPage)({
+        return (0, import_auth26.buildToolConsentPage)({
           tools: toolCards,
           clientName: session.clientId,
           // The pending_auth_id input is unused on the federated round-trip (we key
@@ -38615,17 +38813,17 @@ var init_oauth_provider_callback_flow = __esm({
        */
       generateUserSub(email) {
         if (!email) {
-          return `anon:${(0, import_utils68.randomUUID)()}`;
+          return `anon:${(0, import_utils70.randomUUID)()}`;
         }
-        const hash = (0, import_utils68.sha256Base64url)(email.toLowerCase());
+        const hash = (0, import_utils70.sha256Base64url)(email.toLowerCase());
         return `user:${hash.substring(0, 16)}`;
       }
       /**
        * Render an error page
        */
       renderErrorPage(error, description) {
-        const safeError = (0, import_auth25.escapeHtml)(error);
-        const safeDescription = (0, import_auth25.escapeHtml)(description);
+        const safeError = (0, import_auth26.escapeHtml)(error);
+        const safeDescription = (0, import_auth26.escapeHtml)(description);
         return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -38676,7 +38874,7 @@ var init_oauth_provider_callback_flow = __esm({
       }
       getStateValidation() {
         const authOptions = this.scope.auth?.options;
-        if (authOptions && (0, import_auth10.isOrchestratedMode)(authOptions)) {
+        if (authOptions && (0, import_auth11.isOrchestratedMode)(authOptions)) {
           return authOptions.federatedAuth?.stateValidation ?? "strict";
         }
         return "strict";
@@ -38744,12 +38942,12 @@ function isLoopbackRedirectUri(uri) {
   }
   return false;
 }
-var import_lazy_zod68, import_utils69, inputSchema20, outputSchema19, registrationRequestSchema, stateSchema19, plan19, name19, Stage19, OauthRegisterFlow;
+var import_lazy_zod68, import_utils71, inputSchema20, outputSchema19, registrationRequestSchema, stateSchema19, plan19, name19, Stage19, OauthRegisterFlow;
 var init_oauth_register_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.register.flow.ts"() {
     "use strict";
     import_lazy_zod68 = require("@frontmcp/lazy-zod");
-    import_utils69 = require("@frontmcp/utils");
+    import_utils71 = require("@frontmcp/utils");
     init_common();
     inputSchema20 = httpInputSchema;
     outputSchema19 = HttpJsonSchema;
@@ -38913,10 +39111,10 @@ var init_oauth_register_flow = __esm({
       async registerClient() {
         const now = Math.floor(Date.now() / 1e3);
         const { token_endpoint_auth_method, grant_types, response_types, redirect_uris, client_name, scope } = this.state.required.body;
-        const client_id = (0, import_utils69.randomUUID)();
+        const client_id = (0, import_utils71.randomUUID)();
         let client_secret;
         if (token_endpoint_auth_method === "client_secret_post" || token_endpoint_auth_method === "client_secret_basic") {
-          client_secret = (0, import_utils69.base64urlEncode)((0, import_utils69.randomBytes)(24));
+          client_secret = (0, import_utils71.base64urlEncode)((0, import_utils71.randomBytes)(24));
         }
         this.registered = {
           client_id,
@@ -39056,12 +39254,12 @@ function parseRawTokenBody(raw) {
   }
   return {};
 }
-var import_lazy_zod69, import_utils70, inputSchema21, pkceVerifierRegex, authorizationCodeGrant, refreshTokenGrant, anonymousGrant, tokenRequestSchema, stateSchema20, outputSchema20, plan20, name20, Stage20, OauthTokenFlow;
+var import_lazy_zod69, import_utils72, inputSchema21, pkceVerifierRegex, authorizationCodeGrant, refreshTokenGrant, anonymousGrant, tokenRequestSchema, stateSchema20, outputSchema20, plan20, name20, Stage20, OauthTokenFlow;
 var init_oauth_token_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.token.flow.ts"() {
     "use strict";
     import_lazy_zod69 = require("@frontmcp/lazy-zod");
-    import_utils70 = require("@frontmcp/utils");
+    import_utils72 = require("@frontmcp/utils");
     init_common();
     inputSchema21 = httpInputSchema;
     pkceVerifierRegex = /^[A-Za-z0-9_.~-]{43,128}$/;
@@ -39176,14 +39374,14 @@ var init_oauth_token_flow = __esm({
         const { body, isDefaultAuthProvider } = this.state.required;
         if (body?.grant_type !== "authorization_code") return;
         const authOptions = this.scope.auth?.options;
-        if (isDefaultAuthProvider && body.code === "anonymous" && !!authOptions && (0, import_auth10.allowsPublicAccess)(authOptions)) {
+        if (isDefaultAuthProvider && body.code === "anonymous" && !!authOptions && (0, import_auth11.allowsPublicAccess)(authOptions)) {
           const localAuth2 = this.scope.auth;
           const accessToken = await localAuth2.signAnonymousJwt();
           this.state.set("tokenResponse", {
             access_token: accessToken,
             token_type: "Bearer",
             expires_in: 86400,
-            refresh_token: (0, import_utils70.randomUUID)()
+            refresh_token: (0, import_utils72.randomUUID)()
           });
           return;
         }
@@ -39221,7 +39419,7 @@ var init_oauth_token_flow = __esm({
         if (body?.grant_type !== "refresh_token") return;
         if (isDefaultAuthProvider) {
           const authOptions = this.scope.auth?.options;
-          if (!authOptions || !(0, import_auth10.allowsPublicAccess)(authOptions)) {
+          if (!authOptions || !(0, import_auth11.allowsPublicAccess)(authOptions)) {
             this.respond(
               httpRespond.json(
                 { error: "invalid_grant", error_description: "Refresh requires re-authentication on this server" },
@@ -39236,7 +39434,7 @@ var init_oauth_token_flow = __esm({
             access_token: accessToken,
             token_type: "Bearer",
             expires_in: 86400,
-            refresh_token: (0, import_utils70.randomUUID)()
+            refresh_token: (0, import_utils72.randomUUID)()
           });
           return;
         }
@@ -39266,7 +39464,7 @@ var init_oauth_token_flow = __esm({
       async handleAnonymousGrant() {
         const { body } = this.state.required;
         const authOptions = this.scope.auth?.options;
-        if (!authOptions || !(0, import_auth10.allowsPublicAccess)(authOptions)) {
+        if (!authOptions || !(0, import_auth11.allowsPublicAccess)(authOptions)) {
           this.respond(
             httpRespond.json(
               {
@@ -39301,7 +39499,7 @@ var init_oauth_token_flow = __esm({
           access_token: accessToken,
           token_type: "Bearer",
           expires_in: 86400,
-          refresh_token: (0, import_utils70.randomUUID)()
+          refresh_token: (0, import_utils72.randomUUID)()
         });
       }
       async buildTokenResponse() {
@@ -39368,12 +39566,12 @@ var init_oauth_token_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/oauth.userinfo.flow.ts
-var import_reflect_metadata16, import_auth26, import_lazy_zod70, inputSchema22, stateSchema21, outputSchema21, plan21, name21, Stage21, OauthUserInfoFlow;
+var import_reflect_metadata16, import_auth27, import_lazy_zod70, inputSchema22, stateSchema21, outputSchema21, plan21, name21, Stage21, OauthUserInfoFlow;
 var init_oauth_userinfo_flow = __esm({
   "libs/sdk/src/auth/flows/oauth.userinfo.flow.ts"() {
     "use strict";
     import_reflect_metadata16 = require("reflect-metadata");
-    import_auth26 = require("@frontmcp/auth");
+    import_auth27 = require("@frontmcp/auth");
     import_lazy_zod70 = require("@frontmcp/lazy-zod");
     init_common();
     inputSchema22 = httpInputSchema;
@@ -39393,7 +39591,7 @@ var init_oauth_userinfo_flow = __esm({
       async parseInput() {
         const { request } = this.rawInput;
         const authorizationHeader = request.headers?.["authorization"] ?? void 0;
-        const token = (0, import_auth26.extractBearerToken)(authorizationHeader);
+        const token = (0, import_auth27.extractBearerToken)(authorizationHeader);
         const baseUrl = getRequestBaseUrl(request, this.scope.entryPath);
         this.state.set({ token, baseUrl });
       }
@@ -39464,15 +39662,31 @@ var init_oauth_userinfo_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/session.verify.flow.ts
-var import_reflect_metadata17, import_auth27, import_lazy_zod71, import_utils71, inputSchema23, stateSchema22, UnauthorizedSchema, AuthorizedSchema, ForbiddenSchema, sessionVerifyOutputSchema, plan22, name22, Stage22, warnedUnpinnedAudience, SessionVerifyFlow;
+function constantTimeEquals(a, b) {
+  const encoder5 = new TextEncoder();
+  return (0, import_utils73.timingSafeEqual)((0, import_utils73.sha256)(encoder5.encode(a)), (0, import_utils73.sha256)(encoder5.encode(b)));
+}
+function quoteHeaderParam(value) {
+  return value.replace(/[^\x20-\x21\x23-\x7e]/g, "");
+}
+function buildStaticChallenge(options, description) {
+  const scheme = options.scheme.trim();
+  if (!scheme) return "";
+  const parts = [`${quoteHeaderParam(scheme)} realm="${quoteHeaderParam(options.realm)}"`];
+  if (description) {
+    parts.push('error="invalid_token"', `error_description="${quoteHeaderParam(description)}"`);
+  }
+  return parts.join(", ");
+}
+var import_reflect_metadata17, import_auth28, import_lazy_zod71, import_utils73, inputSchema23, stateSchema22, UnauthorizedSchema, AuthorizedSchema, ForbiddenSchema, sessionVerifyOutputSchema, plan22, name22, Stage22, warnedUnpinnedAudience, SessionVerifyFlow;
 var init_session_verify_flow = __esm({
   "libs/sdk/src/auth/flows/session.verify.flow.ts"() {
     "use strict";
     init_common();
     import_reflect_metadata17 = require("reflect-metadata");
-    import_auth27 = require("@frontmcp/auth");
+    import_auth28 = require("@frontmcp/auth");
     import_lazy_zod71 = require("@frontmcp/lazy-zod");
-    import_utils71 = require("@frontmcp/utils");
+    import_utils73 = require("@frontmcp/utils");
     init_notification_service();
     init_session_id_utils();
     inputSchema23 = httpRequestInputSchema;
@@ -39508,7 +39722,14 @@ var init_session_verify_flow = __esm({
     }).describe("403 Forbidden \u2014 token valid but insufficient scope");
     sessionVerifyOutputSchema = import_lazy_zod71.z.union([UnauthorizedSchema, AuthorizedSchema, ForbiddenSchema]);
     plan22 = {
-      pre: ["parseInput", "handlePublicMode", "handleAnonymousFallback", "requireAuthorizationHeader", "verifyIfJwt"],
+      pre: [
+        "parseInput",
+        "handleStaticToken",
+        "handlePublicMode",
+        "handleAnonymousFallback",
+        "requireAuthorizationHeader",
+        "verifyIfJwt"
+      ],
       execute: ["deriveUser", "parseSessionHeader", "buildAuthorizedOutput"]
     };
     name22 = "session:verify";
@@ -39526,14 +39747,20 @@ var init_session_verify_flow = __esm({
        * Encapsulates the shared logic for session creation, payload encryption, and user derivation.
        */
       createAnonymousSession(options) {
-        const { authMode, issuer, scopes = ["anonymous"], sessionIdHeader } = options;
+        const { authMode, issuer, scopes = ["anonymous"], subject, sessionIdHeader } = options;
         this.logger.verbose("createAnonymousSession", { authMode, hasExistingSession: !!sessionIdHeader });
-        const machineId = (0, import_utils71.getMachineId)();
+        const machineId = (0, import_utils73.getMachineId)();
+        const authSignature = subject ? `${authMode}:${subject}` : authMode;
         if (sessionIdHeader) {
-          const existingPayload = decryptPublicSession(sessionIdHeader);
+          const existingPayload = decryptPublicSession(sessionIdHeader, authSignature);
           if (existingPayload && existingPayload.nodeId === machineId) {
             const anonId = existingPayload.uuid ?? `${existingPayload.iat * 1e3}`;
-            const user2 = { sub: `anon:${anonId}`, iss: issuer, name: "Anonymous", scope: scopes.join(" ") };
+            const user2 = {
+              sub: subject ?? `anon:${anonId}`,
+              iss: issuer,
+              name: subject ? "Static token" : "Anonymous",
+              scope: scopes.join(" ")
+            };
             this.respond({
               kind: "authorized",
               authorization: {
@@ -39548,24 +39775,24 @@ var init_session_verify_flow = __esm({
         }
         const now = Date.now();
         const user = {
-          sub: `anon:${(0, import_utils71.randomUUID)()}`,
+          sub: subject ?? `anon:${(0, import_utils73.randomUUID)()}`,
           iss: issuer,
-          name: "Anonymous",
+          name: subject ? "Static token" : "Anonymous",
           scope: scopes.join(" ")
         };
-        const uuid = (0, import_utils71.randomUUID)();
+        const uuid = (0, import_utils73.randomUUID)();
         const platformDetectionConfig = this.scope.metadata.transport?.platformDetection;
         const platformType = detectPlatformFromUserAgent(this.state.userAgent, platformDetectionConfig);
         const payload = {
           uuid,
           nodeId: machineId,
-          authSig: authMode,
+          authSig: authSignature,
           iat: Math.floor(now / 1e3),
           isPublic: authMode === "public",
           authMode,
           ...platformType !== "unknown" && { platformType }
         };
-        const sessionId = (0, import_auth27.encryptJson)(payload);
+        const sessionId = (0, import_auth28.encryptJson)(payload);
         this.respond({
           kind: "authorized",
           authorization: {
@@ -39586,11 +39813,11 @@ var init_session_verify_flow = __esm({
         const sessionIdQuery = request.query["sessionId"];
         const sessionIdHeader = sessionIdRawHeader ?? sessionIdQuery ?? void 0;
         const sessionProtocol = httpTransportHeader ? "http" : sessionIdRawHeader ? "streamable-http" : sessionIdQuery ? "sse" : void 0;
-        const token = (0, import_auth27.extractBearerToken)(authorizationHeader);
+        const token = (0, import_auth28.extractBearerToken)(authorizationHeader);
         const userAgent = request.headers?.["user-agent"] ?? void 0;
         const prmMetadataPath = `/.well-known/oauth-protected-resource${entryPath}${routeBase}`;
         const prmUrl = `${getRequestBaseUrl(request)}${prmMetadataPath}`;
-        const prmMetadataHeader = (0, import_auth27.buildUnauthorizedHeader)(prmUrl);
+        const prmMetadataHeader = (0, import_auth28.buildUnauthorizedHeader)(prmUrl);
         this.logger.verbose("parseInput", {
           hasAuthHeader: !!authorizationHeader,
           hasToken: !!token,
@@ -39609,14 +39836,68 @@ var init_session_verify_flow = __esm({
           prmUrl
         });
       }
+      async handleStaticToken() {
+        const authOptions = this.scope.auth?.options;
+        if (!authOptions || !(0, import_auth11.isStaticMode)(authOptions)) return;
+        const options = authOptions;
+        const presented = this.readStaticCredential(options);
+        if (!presented) {
+          this.logger.warn("handleStaticToken: no credential presented, returning 401");
+          this.respond({
+            kind: "unauthorized",
+            prmMetadataHeader: buildStaticChallenge(options)
+          });
+          return;
+        }
+        const matched = options.tokens.reduce(
+          (found, candidate) => constantTimeEquals(candidate, presented) ? candidate : found,
+          void 0
+        );
+        if (!matched) {
+          this.logger.warn("handleStaticToken: credential did not match, returning 401");
+          this.respond({
+            kind: "unauthorized",
+            prmMetadataHeader: buildStaticChallenge(options, "The access token is invalid")
+          });
+          return;
+        }
+        this.logger.verbose("handleStaticToken: credential accepted");
+        this.createAnonymousSession({
+          authMode: "static",
+          issuer: "static",
+          scopes: options.scopes,
+          subject: `static:${(0, import_utils73.sha256Hex)(matched).slice(0, 12)}`,
+          sessionIdHeader: this.state.sessionIdHeader
+        });
+      }
+      /**
+       * Pull the credential out of the configured header, stripping the scheme
+       * prefix when one is configured (case-insensitively, per RFC 7235).
+       */
+      readStaticCredential(options) {
+        const headers = this.rawInput.request.headers ?? {};
+        const raw = headers[options.header.toLowerCase()];
+        const value = (Array.isArray(raw) ? raw[0] : raw)?.trim();
+        if (!value) return void 0;
+        const { scheme } = options;
+        if (!scheme) return value;
+        if (value.slice(0, scheme.length).toLowerCase() !== scheme.toLowerCase()) return void 0;
+        if (value[scheme.length] !== " ") return void 0;
+        return value.slice(scheme.length + 1).trim() || void 0;
+      }
       async handlePublicMode() {
         const authOptions = this.scope.auth?.options;
-        if (!authOptions || !(0, import_auth10.isPublicMode)(authOptions)) {
+        if (!authOptions || !(0, import_auth11.isPublicMode)(authOptions)) {
           return;
         }
-        if (this.state.token) {
+        if (this.state.token && (0, import_auth28.isJwt)(this.state.token)) {
           return;
         }
+        if (this.state.token) {
+          this.logger.verbose(
+            "handlePublicMode: ignoring non-JWT bearer token (public mode has nothing to verify it against)"
+          );
+        }
         this.logger.info("handlePublicMode: allowing anonymous access (public mode)");
         this.createAnonymousSession({
           authMode: "public",
@@ -39644,7 +39925,7 @@ var init_session_verify_flow = __esm({
         });
       }
       async verifyIfJwt() {
-        const jwks = this.get(import_auth27.JwksService);
+        const jwks = this.get(import_auth28.JwksService);
         const token = this.state.token;
         if (!token) {
           this.logger.warn("verifyIfJwt: missing or empty bearer token, returning 401");
@@ -39654,11 +39935,11 @@ var init_session_verify_flow = __esm({
           });
           return;
         }
-        if (!(0, import_auth27.isJwt)(token)) {
+        if (!(0, import_auth28.isJwt)(token)) {
           this.logger.warn("verifyIfJwt: token is not a JWT, returning 401");
           this.respond({
             kind: "unauthorized",
-            prmMetadataHeader: (0, import_auth27.buildInvalidTokenHeader)(this.state.required.prmUrl, "Token is not a valid JWT")
+            prmMetadataHeader: (0, import_auth28.buildInvalidTokenHeader)(this.state.required.prmUrl, "Token is not a valid JWT")
           });
           return;
         }
@@ -39673,9 +39954,9 @@ var init_session_verify_flow = __esm({
         }
         let verify;
         const authOptions = auth.options;
-        const mode = (0, import_auth10.isTransparentMode)(authOptions) ? "transparent" : "gateway";
+        const mode = (0, import_auth11.isTransparentMode)(authOptions) ? "transparent" : "gateway";
         this.logger.verbose(`verifyIfJwt: verifying using ${mode} mode`);
-        if ((0, import_auth10.isTransparentMode)(authOptions)) {
+        if ((0, import_auth11.isTransparentMode)(authOptions)) {
           const primary = authOptions;
           const issuer = auth.issuer;
           const providerRefs = [
@@ -39695,7 +39976,7 @@ var init_session_verify_flow = __esm({
         const result = await verify;
         if (result.ok) {
           this.state.set({ jwtPayload: result.payload });
-          if ((0, import_auth10.isTransparentMode)(authOptions)) {
+          if ((0, import_auth11.isTransparentMode)(authOptions)) {
             const configuredAudience = authOptions.expectedAudience;
             if (!configuredAudience && !isPublicUrlPinned() && !warnedUnpinnedAudience) {
               warnedUnpinnedAudience = true;
@@ -39703,8 +39984,8 @@ var init_session_verify_flow = __esm({
                 "transparent audience validation is deriving the expected audience from the request Host: set auth.expectedAudience or FRONTMCP_PUBLIC_URL to bind tokens to a fixed resource. X-Forwarded-Host is ignored unless FRONTMCP_TRUST_PROXY is enabled."
               );
             }
-            const expectedAudiences = configuredAudience ? Array.isArray(configuredAudience) ? configuredAudience : [configuredAudience] : (0, import_auth27.deriveExpectedAudience)(this.state.required.baseUrl);
-            const audResult = (0, import_auth27.validateAudience)(result.payload?.["aud"], {
+            const expectedAudiences = configuredAudience ? Array.isArray(configuredAudience) ? configuredAudience : [configuredAudience] : (0, import_auth28.deriveExpectedAudience)(this.state.required.baseUrl);
+            const audResult = (0, import_auth28.validateAudience)(result.payload?.["aud"], {
               expectedAudiences,
               // By default accept tokens with no `aud` claim: many IdPs omit it, and
               // rejecting them here would break existing transparent deployments.
@@ -39718,7 +39999,7 @@ var init_session_verify_flow = __esm({
               this.logger.warn("verifyIfJwt: audience validation failed", { error: audResult.error });
               this.respond({
                 kind: "unauthorized",
-                prmMetadataHeader: (0, import_auth27.buildInvalidTokenHeader)(
+                prmMetadataHeader: (0, import_auth28.buildInvalidTokenHeader)(
                   this.state.required.prmUrl,
                   audResult.error ?? "Token audience is not valid for this resource"
                 )
@@ -39738,7 +40019,7 @@ var init_session_verify_flow = __esm({
               });
               this.respond({
                 kind: "forbidden",
-                prmMetadataHeader: (0, import_auth27.buildInsufficientScopeHeader)(this.state.required.prmUrl, requiredScopes)
+                prmMetadataHeader: (0, import_auth28.buildInsufficientScopeHeader)(this.state.required.prmUrl, requiredScopes)
               });
               return;
             }
@@ -39748,14 +40029,14 @@ var init_session_verify_flow = __esm({
         this.logger.warn("verifyIfJwt: JWT verification failed", { error: result.error });
         this.respond({
           kind: "unauthorized",
-          prmMetadataHeader: (0, import_auth27.buildInvalidTokenHeader)(
+          prmMetadataHeader: (0, import_auth28.buildInvalidTokenHeader)(
             this.state.required.prmUrl,
             result.error ?? "Token verification failed"
           )
         });
       }
       async deriveUser() {
-        this.state.set("user", (0, import_auth27.deriveTypedUser)(this.state.required.jwtPayload ?? {}));
+        this.state.set("user", (0, import_auth28.deriveTypedUser)(this.state.required.jwtPayload ?? {}));
       }
       async parseSessionHeader() {
         const {
@@ -39790,6 +40071,14 @@ var init_session_verify_flow = __esm({
     __decorateClass([
       Stage22("parseInput")
     ], SessionVerifyFlow.prototype, "parseInput", 1);
+    __decorateClass([
+      Stage22("handleStaticToken", {
+        filter: ({ scope }) => {
+          const authOptions = scope.auth?.options;
+          return !!authOptions && (0, import_auth11.isStaticMode)(authOptions);
+        }
+      })
+    ], SessionVerifyFlow.prototype, "handleStaticToken", 1);
     __decorateClass([
       Stage22("handlePublicMode")
     ], SessionVerifyFlow.prototype, "handlePublicMode", 1);
@@ -39798,7 +40087,7 @@ var init_session_verify_flow = __esm({
         filter: ({ state, scope }) => {
           if (state.token) return false;
           const authOptions = scope.auth?.options;
-          if (!authOptions || !(0, import_auth10.isTransparentMode)(authOptions)) return false;
+          if (!authOptions || !(0, import_auth11.isTransparentMode)(authOptions)) return false;
           return authOptions.allowAnonymous === true;
         }
       })
@@ -39808,8 +40097,8 @@ var init_session_verify_flow = __esm({
         filter: ({ state, scope }) => {
           if (state.authorizationHeader) return false;
           const authOptions = scope.auth?.options;
-          if (authOptions && (0, import_auth10.isPublicMode)(authOptions)) return false;
-          if (authOptions && (0, import_auth10.isTransparentMode)(authOptions)) {
+          if (authOptions && (0, import_auth11.isPublicMode)(authOptions)) return false;
+          if (authOptions && (0, import_auth11.isTransparentMode)(authOptions)) {
             if (authOptions.allowAnonymous === true) return false;
           }
           return true;
@@ -39841,13 +40130,13 @@ var init_session_verify_flow = __esm({
 });
 
 // libs/sdk/src/auth/flows/well-known.jwks.flow.ts
-var import_reflect_metadata18, import_auth28, import_lazy_zod72, inputSchema24, stateSchema23, outputSchema22, plan23, name23, Stage23, WellKnownJwksFlow;
+var import_reflect_metadata18, import_auth29, import_lazy_zod72, inputSchema24, stateSchema23, outputSchema22, plan23, name23, Stage23, WellKnownJwksFlow;
 var init_well_known_jwks_flow = __esm({
   "libs/sdk/src/auth/flows/well-known.jwks.flow.ts"() {
     "use strict";
     init_common();
     import_reflect_metadata18 = require("reflect-metadata");
-    import_auth28 = require("@frontmcp/auth");
+    import_auth29 = require("@frontmcp/auth");
     import_lazy_zod72 = require("@frontmcp/lazy-zod");
     init_auth_internal_errors();
     inputSchema24 = httpInputSchema;
@@ -39873,17 +40162,17 @@ var init_well_known_jwks_flow = __esm({
       }
       async collectData() {
         const { isOrchestrated } = this.state.required;
-        const jwksSvc = this.get(import_auth28.JwksService);
+        const jwksSvc = this.get(import_auth29.JwksService);
         if (isOrchestrated) {
           const keysDoc = await jwksSvc.getPublicJwks();
           if (!keysDoc?.keys || !Array.isArray(keysDoc.keys)) {
-            throw new import_auth11.OrchestratorJwksNotAvailableError();
+            throw new import_auth12.OrchestratorJwksNotAvailableError();
           }
           this.respond(httpRespond.json(keysDoc));
           return;
         }
         const options = this.scope.auth.options;
-        if (options && (0, import_auth10.isTransparentMode)(options)) {
+        if (options && (0, import_auth11.isTransparentMode)(options)) {
           if (options.providerConfig?.jwks && options.providerConfig.jwks.keys.length) {
             this.respond(httpRespond.json(options.providerConfig.jwks));
           } else {
@@ -39923,21 +40212,21 @@ var init_well_known_jwks_flow = __esm({
 
 // libs/sdk/src/auth/flows/well-known.oauth-authorization-server.flow.ts
 function resolveDcrEnabled(auth) {
-  if (auth && (0, import_auth10.isLocalMode)(auth)) {
+  if (auth && (0, import_auth11.isLocalMode)(auth)) {
     const dcr = auth.dcr;
     if (dcr && typeof dcr.enabled === "boolean") {
       return dcr.enabled;
     }
   }
-  return !(0, import_utils72.isProduction)();
+  return !(0, import_utils74.isProduction)();
 }
-var import_reflect_metadata19, import_lazy_zod73, import_utils72, inputSchema25, AuthServerMetadataSchema, outputSchema23, wellKnownAsStateSchema, wellKnownAsPlan, name24, Stage24, WellKnownAsFlow;
+var import_reflect_metadata19, import_lazy_zod73, import_utils74, inputSchema25, AuthServerMetadataSchema, outputSchema23, wellKnownAsStateSchema, wellKnownAsPlan, name24, Stage24, WellKnownAsFlow;
 var init_well_known_oauth_authorization_server_flow = __esm({
   "libs/sdk/src/auth/flows/well-known.oauth-authorization-server.flow.ts"() {
     "use strict";
     import_reflect_metadata19 = require("reflect-metadata");
     import_lazy_zod73 = require("@frontmcp/lazy-zod");
-    import_utils72 = require("@frontmcp/utils");
+    import_utils74 = require("@frontmcp/utils");
     init_common();
     init_sdk_errors();
     inputSchema25 = httpInputSchema;
@@ -39997,7 +40286,7 @@ var init_well_known_oauth_authorization_server_flow = __esm({
         const baseUrl = getRequestBaseUrl(request, this.scope.entryPath);
         const oauthBaseUrl = getRequestBaseUrl(request);
         let cimdEnabled = true;
-        if (metadata.auth && (0, import_auth10.isOrchestratedMode)(metadata.auth)) {
+        if (metadata.auth && (0, import_auth11.isOrchestratedMode)(metadata.auth)) {
           cimdEnabled = metadata.auth.cimd?.enabled ?? true;
         }
         this.state.set(
@@ -40009,7 +40298,7 @@ var init_well_known_oauth_authorization_server_flow = __esm({
             // #462 — advertise registration_endpoint only when local-AS DCR is
             // actually active (explicit auth.dcr.enabled, else dev/prod default).
             dcrEnabled: resolveDcrEnabled(metadata.auth),
-            isOrchestrated: metadata.auth ? (0, import_auth10.isOrchestratedMode)(metadata.auth) : false,
+            isOrchestrated: metadata.auth ? (0, import_auth11.isOrchestratedMode)(metadata.auth) : false,
             cimdEnabled
           })
         );
@@ -40203,9 +40492,9 @@ function createSecureStoreProviders(opts) {
     name: "SecureStoreBackend"
   };
   const accessorProvider = {
-    provide: import_auth29.SECURE_STORE_ACCESSOR,
+    provide: import_auth30.SECURE_STORE_ACCESSOR,
     inject: () => [FRONTMCP_CONTEXT, FrontMcpLogger],
-    useFactory: (ctx, logger) => new import_auth29.SecureStoreAccessorImpl({
+    useFactory: (ctx, logger) => new import_auth30.SecureStoreAccessorImpl({
       backend,
       scope,
       resolveSub: () => resolveRequestSub(ctx),
@@ -40218,11 +40507,11 @@ function createSecureStoreProviders(opts) {
   };
   return [backendProvider, accessorProvider];
 }
-var import_auth29, import_di32, SECURE_STORE_BACKEND;
+var import_auth30, import_di32, SECURE_STORE_BACKEND;
 var init_secure_store_providers = __esm({
   "libs/sdk/src/auth/secure-store/secure-store.providers.ts"() {
     "use strict";
-    import_auth29 = require("@frontmcp/auth");
+    import_auth30 = require("@frontmcp/auth");
     import_di32 = require("@frontmcp/di");
     init_common();
     init_frontmcp_context_provider();
@@ -40232,14 +40521,14 @@ var init_secure_store_providers = __esm({
 });
 
 // libs/sdk/src/auth/secure-store/secure-store.context-extension.ts
-var import_auth30, secureStoreContextExtension;
+var import_auth31, secureStoreContextExtension;
 var init_secure_store_context_extension = __esm({
   "libs/sdk/src/auth/secure-store/secure-store.context-extension.ts"() {
     "use strict";
-    import_auth30 = require("@frontmcp/auth");
+    import_auth31 = require("@frontmcp/auth");
     secureStoreContextExtension = {
       property: "secureStore",
-      token: import_auth30.SECURE_STORE_ACCESSOR,
+      token: import_auth31.SECURE_STORE_ACCESSOR,
       errorMessage: "The secure store is not available. Ensure the server uses auth mode 'local' (or 'remote'); the secure store is enabled automatically there."
     };
   }
@@ -40256,7 +40545,7 @@ var init_secure_store = __esm({
 // libs/sdk/src/auth/instances/instance.local-primary-auth.ts
 function getDefaultNoAuthSecret() {
   if (!defaultNoAuthSecret) {
-    defaultNoAuthSecret = (0, import_utils73.randomBytes)(32);
+    defaultNoAuthSecret = (0, import_utils75.randomBytes)(32);
   }
   return defaultNoAuthSecret;
 }
@@ -40275,18 +40564,19 @@ function validateAuthorizationIssuer(received, expected) {
   return { ok: true };
 }
 function isUnsupportedOperation(error) {
-  return error instanceof import_utils73.StorageNotSupportedError;
+  return error instanceof import_utils75.StorageNotSupportedError;
 }
-var import_jose, import_auth31, import_utils73, defaultNoAuthSecret, RESERVED_JWT_CLAIMS, LocalPrimaryAuth;
+var import_jose, import_auth32, import_utils75, MIN_HS256_SECRET_BYTES, defaultNoAuthSecret, RESERVED_JWT_CLAIMS, LocalPrimaryAuth;
 var init_instance_local_primary_auth = __esm({
   "libs/sdk/src/auth/instances/instance.local-primary-auth.ts"() {
     "use strict";
     import_jose = require("jose");
-    import_auth31 = require("@frontmcp/auth");
-    import_utils73 = require("@frontmcp/utils");
+    import_auth32 = require("@frontmcp/auth");
+    import_utils75 = require("@frontmcp/utils");
     init_common();
     init_auth2();
     init_context_extension();
+    init_errors();
     init_cimd();
     init_credentials();
     init_credentials_context_extension();
@@ -40304,6 +40594,7 @@ var init_instance_local_primary_auth = __esm({
     init_well_known_prm_flow();
     init_secure_store();
     init_secure_store_context_extension();
+    MIN_HS256_SECRET_BYTES = 32;
     RESERVED_JWT_CLAIMS = /* @__PURE__ */ new Set([
       "sub",
       "iss",
@@ -40328,27 +40619,39 @@ var init_instance_local_primary_auth = __esm({
         this.providers = providers;
         this.logger = this.providers.getActiveScope().logger.child("LocalPrimaryAuth");
         this.port = this.providers.getActiveScope().metadata.http?.port ?? 3001;
-        this.host = (0, import_utils73.getEnv)("FRONTMCP_PUBLIC_HOST")?.trim() || "localhost";
+        this.host = (0, import_utils75.getEnv)("FRONTMCP_PUBLIC_HOST")?.trim() || "localhost";
         this.issuer = this.deriveIssuer(options);
-        const jwtSecret = (0, import_utils73.getEnv)("JWT_SECRET");
-        if (jwtSecret) {
-          this.secret = new TextEncoder().encode(jwtSecret);
+        const jwtSecret = (0, import_utils75.getEnv)("JWT_SECRET");
+        const hasJwtSecret = !!jwtSecret?.trim();
+        if (hasJwtSecret && jwtSecret) {
+          const encoded = new TextEncoder().encode(jwtSecret);
+          if (encoded.length < MIN_HS256_SECRET_BYTES) {
+            if ((0, import_utils75.isProduction)()) throw new import_auth12.JwtSecretWeakError(encoded.length);
+            this.logger.warn(
+              `JWT_SECRET is ${encoded.length} bytes; HS256 wants at least ${MIN_HS256_SECRET_BYTES} (RFC 7518). This is refused in production \u2014 generate one with \`openssl rand -hex 32\`.`
+            );
+          }
+          this.secret = encoded;
+        } else if ((0, import_utils75.isProduction)() && (0, import_auth11.isOrchestratedMode)(options)) {
+          throw new import_auth12.JwtSecretRequiredError(options.mode);
         } else {
-          this.logger.warn("JWT_SECRET is not set, using default secret");
+          this.logger.warn(
+            "JWT_SECRET is not set; signing with a random per-process secret. Tokens will not survive a restart and will not verify across instances. Set JWT_SECRET for any deployment that mints tokens."
+          );
           this.secret = getDefaultNoAuthSecret();
         }
         this.tokenStorage = this.readTokenStorage(options);
-        this.authorizationStoreImpl = new import_auth31.InMemoryAuthorizationStore();
-        this.federatedSessionStoreImpl = new import_auth31.InMemoryFederatedAuthSessionStore();
-        this.orchestratedTokenStoreImpl = new import_auth31.InMemoryOrchestratedTokenStore({
+        this.authorizationStoreImpl = new import_auth32.InMemoryAuthorizationStore();
+        this.federatedSessionStoreImpl = new import_auth32.InMemoryFederatedAuthSessionStore();
+        this.orchestratedTokenStoreImpl = new import_auth32.InMemoryOrchestratedTokenStore({
           encryptionKey: this.secret
           // Reuse JWT secret for token encryption
         });
-        this.consentStoreImpl = new import_auth31.InMemoryConsentStore();
-        this.dcrClientRegistryImpl = new import_auth31.DcrClientRegistry(this.getDcrConfig() ?? {});
-        if ((0, import_auth10.isOrchestratedMode)(options)) {
+        this.consentStoreImpl = new import_auth32.InMemoryConsentStore();
+        this.dcrClientRegistryImpl = new import_auth32.DcrClientRegistry(this.getDcrConfig() ?? {});
+        if ((0, import_auth11.isOrchestratedMode)(options)) {
           const cimdConfig = options.cimd;
-          this.cimdService = new import_auth19.CimdService(this.logger, cimdConfig);
+          this.cimdService = new import_auth20.CimdService(this.logger, cimdConfig);
         }
         this.ready = this.initialize();
       }
@@ -40360,7 +40663,7 @@ var init_instance_local_primary_auth = __esm({
       keys = [];
       secret;
       logger;
-      jwks = new import_auth31.JwksService();
+      jwks = new import_auth32.JwksService();
       cimdService;
       /**
        * Token storage backend selected from `options.tokenStorage`.
@@ -40455,7 +40758,7 @@ var init_instance_local_primary_auth = __esm({
        * mode returns `undefined`, preserving the historical behavior exactly.
        */
       getDcrConfig() {
-        if ((0, import_auth10.isLocalMode)(this.options)) {
+        if ((0, import_auth11.isLocalMode)(this.options)) {
           return this.options.dcr;
         }
         return void 0;
@@ -40470,7 +40773,7 @@ var init_instance_local_primary_auth = __esm({
         if (dcr && typeof dcr.enabled === "boolean") {
           return dcr.enabled;
         }
-        return !(0, import_utils73.isProduction)();
+        return !(0, import_utils75.isProduction)();
       }
       /** Provider configurations (indexed by provider ID) */
       providerConfigs = /* @__PURE__ */ new Map();
@@ -40506,11 +40809,11 @@ var init_instance_local_primary_auth = __esm({
        */
       deriveIssuer(options) {
         const basePath = `http://${this.host}:${this.port}${this.scope.fullPath}`;
-        if ((0, import_auth10.isPublicMode)(options)) {
+        if ((0, import_auth11.isPublicMode)(options)) {
           return options.issuer ?? basePath;
         }
-        if ((0, import_auth10.isOrchestratedMode)(options)) {
-          if ((0, import_auth10.isOrchestratedLocal)(options)) {
+        if ((0, import_auth11.isOrchestratedMode)(options)) {
+          if ((0, import_auth11.isOrchestratedLocal)(options)) {
             return options.local?.issuer ?? basePath;
           } else {
             return options.local?.issuer ?? basePath;
@@ -40539,19 +40842,19 @@ var init_instance_local_primary_auth = __esm({
        * key, so upstream provider tokens stay encrypted at rest in every backend.
        */
       async initializeStores() {
-        if (!(0, import_auth31.isPersistentTokenStorage)(this.tokenStorage)) {
+        if (!(0, import_auth32.isPersistentTokenStorage)(this.tokenStorage)) {
           return;
         }
         try {
-          const adapter = await (0, import_auth31.createTokenStorageAdapter)(this.tokenStorage);
+          const adapter = await (0, import_auth32.createTokenStorageAdapter)(this.tokenStorage);
           this.storageAdapter = adapter;
-          this.authorizationStoreImpl = new import_auth31.StorageAuthorizationStore(adapter);
-          this.federatedSessionStoreImpl = new import_auth31.StorageFederatedAuthSessionStore(adapter);
-          this.orchestratedTokenStoreImpl = new import_auth31.StorageOrchestratedTokenStore(adapter, {
+          this.authorizationStoreImpl = new import_auth32.StorageAuthorizationStore(adapter);
+          this.federatedSessionStoreImpl = new import_auth32.StorageFederatedAuthSessionStore(adapter);
+          this.orchestratedTokenStoreImpl = new import_auth32.StorageOrchestratedTokenStore(adapter, {
             encryptionKey: this.secret
           });
-          this.consentStoreImpl = new import_auth31.StorageConsentStore(adapter);
-          const backend = (0, import_auth31.isSqliteTokenStorage)(this.tokenStorage) ? "sqlite" : (0, import_auth31.isRedisTokenStorage)(this.tokenStorage) ? "redis" : "unknown";
+          this.consentStoreImpl = new import_auth32.StorageConsentStore(adapter);
+          const backend = (0, import_auth32.isSqliteTokenStorage)(this.tokenStorage) ? "sqlite" : (0, import_auth32.isRedisTokenStorage)(this.tokenStorage) ? "redis" : "unknown";
           this.logger.info(`Token storage initialized with persistent backend: ${backend}`);
         } catch (err) {
           this.logger.error("Failed to initialize persistent token storage", err);
@@ -40593,7 +40896,7 @@ var init_instance_local_primary_auth = __esm({
        */
       async claimIncrementalTicket(jti, ttlMs) {
         const key = `incremental-ticket:${jti}`;
-        const nonce = (0, import_utils73.randomUUID)();
+        const nonce = (0, import_utils75.randomUUID)();
         const ttlSeconds = Math.max(1, Math.ceil(ttlMs / 1e3));
         let storage = await this.getTicketReplayStorage();
         try {
@@ -40637,7 +40940,7 @@ var init_instance_local_primary_auth = __esm({
       /** Replace the replay guard with a fresh in-memory adapter, memoized. */
       useInMemoryTicketReplayStorage() {
         const pending = (async () => {
-          const memory = new import_utils73.MemoryStorageAdapter();
+          const memory = new import_utils75.MemoryStorageAdapter();
           await memory.connect();
           return memory;
         })();
@@ -40645,19 +40948,19 @@ var init_instance_local_primary_auth = __esm({
         return pending;
       }
       async initializeCredentialVault() {
-        if ((0, import_auth10.isPublicMode)(this.options)) {
+        if ((0, import_auth11.isPublicMode)(this.options)) {
           return;
         }
         let storage;
         if (this.storageAdapter) {
           storage = this.storageAdapter;
         } else {
-          const memory = new import_utils73.MemoryStorageAdapter();
+          const memory = new import_utils75.MemoryStorageAdapter();
           await memory.connect();
           storage = memory;
         }
-        const pepper = (0, import_utils73.getEnv)("VAULT_SECRET") ?? (0, import_utils73.getEnv)("JWT_SECRET") ?? void 0;
-        this.credentialVaultImpl = new import_auth31.SessionCredentialVault({
+        const pepper = (0, import_utils75.getEnv)("VAULT_SECRET") ?? (0, import_utils75.getEnv)("JWT_SECRET") ?? void 0;
+        this.credentialVaultImpl = new import_auth32.SessionCredentialVault({
           storage,
           pepper,
           logger: this.logger.child("SessionCredentialVault")
@@ -40702,13 +41005,13 @@ var init_instance_local_primary_auth = __esm({
        * secrets share the same trust root as the access tokens.
        */
       async initializeSecureStore() {
-        if ((0, import_auth10.isPublicMode)(this.options)) {
+        if ((0, import_auth11.isPublicMode)(this.options)) {
           return;
         }
         const config = this.readSecureStoreConfig();
         const reuseAdapter = this.storageAdapter && this.secureStoreSharesTokenStorage(config) ? this.storageAdapter : void 0;
-        const pepper = (0, import_utils73.getEnv)("VAULT_SECRET") ?? (0, import_utils73.getEnv)("JWT_SECRET") ?? new TextDecoder().decode(this.secret);
-        const resolved = await (0, import_auth31.createSecureStore)({
+        const pepper = (0, import_utils75.getEnv)("VAULT_SECRET") ?? (0, import_utils75.getEnv)("JWT_SECRET") ?? new TextDecoder().decode(this.secret);
+        const resolved = await (0, import_auth32.createSecureStore)({
           config,
           pepper,
           storage: reuseAdapter,
@@ -40735,12 +41038,12 @@ var init_instance_local_primary_auth = __esm({
        */
       secureStoreSharesTokenStorage(config) {
         if (typeof config !== "object" || config === null) return false;
-        if ("sqlite" in config && config.sqlite) return (0, import_auth31.isSqliteTokenStorage)(this.tokenStorage);
-        if ("redis" in config && config.redis) return (0, import_auth31.isRedisTokenStorage)(this.tokenStorage);
+        if ("sqlite" in config && config.sqlite) return (0, import_auth32.isSqliteTokenStorage)(this.tokenStorage);
+        if ("redis" in config && config.redis) return (0, import_auth32.isRedisTokenStorage)(this.tokenStorage);
         return false;
       }
       async signAnonymousJwt() {
-        const sub = (0, import_utils73.randomUUID)();
+        const sub = (0, import_utils75.randomUUID)();
         return new import_jose.SignJWT({ sub, role: "user", anonymous: true }).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuedAt().setIssuer(this.issuer).setExpirationTime("1d").sign(this.secret);
       }
       /**
@@ -40813,7 +41116,7 @@ var init_instance_local_primary_auth = __esm({
             }
           }
         }
-        const jwt = new import_jose.SignJWT(claims).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuedAt().setIssuer(this.issuer).setExpirationTime(`${this.accessTokenTtlSeconds}s`).setJti((0, import_utils73.randomUUID)());
+        const jwt = new import_jose.SignJWT(claims).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuedAt().setIssuer(this.issuer).setExpirationTime(`${this.accessTokenTtlSeconds}s`).setJti((0, import_utils75.randomUUID)());
         if (audience) {
           jwt.setAudience(audience);
         }
@@ -40864,7 +41167,7 @@ var init_instance_local_primary_auth = __esm({
             error_description: "Redirect URI does not match"
           };
         }
-        if (!(0, import_auth31.verifyPkce)(codeVerifier, codeRecord.pkce)) {
+        if (!(0, import_auth32.verifyPkce)(codeVerifier, codeRecord.pkce)) {
           this.logger.warn(`PKCE verification failed`);
           return {
             error: "invalid_grant",
@@ -40894,7 +41197,7 @@ var init_instance_local_primary_auth = __esm({
             const pendingAuthId = `pending:${codeRecord.pendingAuthId}`;
             const parts = accessToken.split(".");
             const signature = parts[2] || accessToken;
-            const newAuthId = (0, import_utils73.sha256Hex)(signature).substring(0, 16);
+            const newAuthId = (0, import_utils75.sha256Hex)(signature).substring(0, 16);
             await this.orchestratedTokenStore.migrateTokens(pendingAuthId, newAuthId);
             this.logger.info(`Migrated tokens from ${pendingAuthId} to ${newAuthId}`);
           } catch (err) {
@@ -41035,7 +41338,7 @@ var init_instance_local_primary_auth = __esm({
             scope: import_di4.ProviderScope.GLOBAL,
             name: "auth:jwk-service"
           },
-          provide: import_auth31.JwksService
+          provide: import_auth32.JwksService
         });
         if (this.cimdService) {
           this.providers.injectProvider({
@@ -41044,7 +41347,7 @@ var init_instance_local_primary_auth = __esm({
               scope: import_di4.ProviderScope.GLOBAL,
               name: "auth:cimd-service"
             },
-            provide: import_auth19.CimdService
+            provide: import_auth20.CimdService
           });
           this.logger.debug("CIMD service registered");
         }
@@ -41130,7 +41433,7 @@ var init_instance_local_primary_auth = __esm({
        * kept in the provider config and never logged or exposed to the LLM.
        */
       registerConfiguredProviders() {
-        if (!(0, import_auth10.isLocalMode)(this.options)) {
+        if (!(0, import_auth11.isLocalMode)(this.options)) {
           return;
         }
         const providers = this.options.providers;
@@ -41177,7 +41480,7 @@ var init_instance_local_primary_auth = __esm({
        * kept in the provider config and never logged or exposed to the LLM.
        */
       registerRemoteProvider() {
-        if (!(0, import_auth10.isRemoteMode)(this.options)) {
+        if (!(0, import_auth11.isRemoteMode)(this.options)) {
           return;
         }
         const options = this.options;
@@ -41311,7 +41614,7 @@ var init_instance_local_primary_auth = __esm({
         if (idToken) {
           try {
             const [, payloadB64] = idToken.split(".");
-            const payload = JSON.parse(new TextDecoder().decode((0, import_utils73.base64urlDecode)(payloadB64)));
+            const payload = JSON.parse(new TextDecoder().decode((0, import_utils75.base64urlDecode)(payloadB64)));
             const exp = typeof payload["exp"] === "number" ? payload["exp"] : void 0;
             if (exp !== void 0 && exp * 1e3 < Date.now()) {
               this.logger.warn(`ID token for ${providerId} is expired; falling back to userinfo`);
@@ -41410,11 +41713,11 @@ var init_instance_local_primary_auth = __esm({
 });
 
 // libs/sdk/src/auth/instances/instance.remote-primary-auth.ts
-var import_auth33, RemotePrimaryAuth;
+var import_auth34, RemotePrimaryAuth;
 var init_instance_remote_primary_auth = __esm({
   "libs/sdk/src/auth/instances/instance.remote-primary-auth.ts"() {
     "use strict";
-    import_auth33 = require("@frontmcp/auth");
+    import_auth34 = require("@frontmcp/auth");
     init_common();
     init_session_verify_flow();
     init_well_known_jwks_flow();
@@ -41430,7 +41733,7 @@ var init_instance_remote_primary_auth = __esm({
       scope;
       providers;
       ready;
-      jwks = new import_auth33.JwksService();
+      jwks = new import_auth34.JwksService();
       fetch(input, init) {
         return fetch(input, init);
       }
@@ -41448,7 +41751,7 @@ var init_instance_remote_primary_auth = __esm({
             scope: import_di4.ProviderScope.GLOBAL,
             name: "auth:jwk-service"
           },
-          provide: import_auth33.JwksService
+          provide: import_auth34.JwksService
         });
         await this.registerAuthFlows(scope);
         return Promise.resolve();
@@ -41466,12 +41769,12 @@ var init_instance_remote_primary_auth = __esm({
 });
 
 // libs/sdk/src/auth/auth.registry.ts
-var import_reflect_metadata21, import_auth34, import_di33, DEFAULT_AUTH_OPTIONS, AuthRegistry;
+var import_reflect_metadata21, import_auth35, import_di33, DEFAULT_AUTH_OPTIONS, AuthRegistry;
 var init_auth_registry = __esm({
   "libs/sdk/src/auth/auth.registry.ts"() {
     "use strict";
     import_reflect_metadata21 = require("reflect-metadata");
-    import_auth34 = require("@frontmcp/auth");
+    import_auth35 = require("@frontmcp/auth");
     import_di33 = require("@frontmcp/di");
     init_common();
     init_context_extension();
@@ -41501,14 +41804,14 @@ var init_auth_registry = __esm({
         super("AuthRegistry", providers, metadata, false);
         this.owner = owner;
         this.logger = providers.get(FrontMcpLogger).child("AuthRegistry");
-        this.parsedOptions = (0, import_auth10.parseAuthOptions)(primaryInput ?? DEFAULT_AUTH_OPTIONS);
+        this.parsedOptions = (0, import_auth11.parseAuthOptions)(primaryInput ?? DEFAULT_AUTH_OPTIONS);
         const appAuthInfos = this.extractAppAuthInfo(scope);
-        this.detection = (0, import_auth34.detectAuthProviders)(this.parsedOptions, appAuthInfos);
+        this.detection = (0, import_auth35.detectAuthProviders)(this.parsedOptions, appAuthInfos);
         this.requiresOrchestration = this.detection.requiresOrchestration;
         this.logDetectionResults();
         this.validateConfiguration();
         this.primary = this.createPrimaryAuth(scope, providers, this.parsedOptions);
-        if ((0, import_auth10.isOrchestratedMode)(this.parsedOptions)) {
+        if ((0, import_auth11.isOrchestratedMode)(this.parsedOptions)) {
           installContextExtensions("orchestrated-auth", [orchestratedAuthContextExtension]);
         }
         const primaryRecord = {
@@ -41603,20 +41906,23 @@ var init_auth_registry = __esm({
        * Create the appropriate primary auth provider based on parsed options
        */
       createPrimaryAuth(scope, providers, options) {
-        if ((0, import_auth10.isPublicMode)(options)) {
+        if ((0, import_auth11.isPublicMode)(options)) {
           return new LocalPrimaryAuth(scope, providers, options);
         }
-        if ((0, import_auth10.isTransparentMode)(options)) {
+        if ((0, import_auth11.isStaticMode)(options)) {
+          return new LocalPrimaryAuth(scope, providers, options);
+        }
+        if ((0, import_auth11.isTransparentMode)(options)) {
           return new RemotePrimaryAuth(scope, providers, options);
         }
-        if ((0, import_auth10.isOrchestratedMode)(options)) {
-          if ((0, import_auth10.isOrchestratedLocal)(options)) {
+        if ((0, import_auth11.isOrchestratedMode)(options)) {
+          if ((0, import_auth11.isOrchestratedLocal)(options)) {
             return new LocalPrimaryAuth(scope, providers, options);
           } else {
             return new LocalPrimaryAuth(scope, providers, options);
           }
         }
-        const defaultOptions = (0, import_auth10.parseAuthOptions)({ mode: "public" });
+        const defaultOptions = (0, import_auth11.parseAuthOptions)({ mode: "public" });
         return new LocalPrimaryAuth(scope, providers, defaultOptions);
       }
       buildMap(list) {
@@ -42983,12 +43289,12 @@ var init_complete_flow = __esm({
 });
 
 // libs/sdk/src/elicitation/store/storage-elicitation.store.ts
-var import_utils74, import_utils75, RESOLVED_RESULT_TTL_SECONDS, RESULT_CHANNEL_PREFIX, FALLBACK_RESULT_CHANNEL_PREFIX, StorageElicitationStore;
+var import_utils76, import_utils77, RESOLVED_RESULT_TTL_SECONDS, RESULT_CHANNEL_PREFIX, FALLBACK_RESULT_CHANNEL_PREFIX, StorageElicitationStore;
 var init_storage_elicitation_store = __esm({
   "libs/sdk/src/elicitation/store/storage-elicitation.store.ts"() {
     "use strict";
-    import_utils74 = require("@frontmcp/utils");
-    import_utils75 = require("@frontmcp/utils");
+    import_utils76 = require("@frontmcp/utils");
+    import_utils77 = require("@frontmcp/utils");
     RESOLVED_RESULT_TTL_SECONDS = 300;
     RESULT_CHANNEL_PREFIX = "result:";
     FALLBACK_RESULT_CHANNEL_PREFIX = "fallback-result:";
@@ -43013,9 +43319,9 @@ var init_storage_elicitation_store = __esm({
       constructor(storage, logger) {
         this.storage = storage;
         this.logger = logger;
-        this.pending = new import_utils74.TypedStorage(storage.namespace("pending"));
-        this.fallback = new import_utils74.TypedStorage(storage.namespace("fallback"));
-        this.resolved = new import_utils74.TypedStorage(storage.namespace("resolved"));
+        this.pending = new import_utils76.TypedStorage(storage.namespace("pending"));
+        this.fallback = new import_utils76.TypedStorage(storage.namespace("fallback"));
+        this.resolved = new import_utils76.TypedStorage(storage.namespace("resolved"));
       }
       // ============================================
       // Pending Elicitation Methods
@@ -43025,7 +43331,7 @@ var init_storage_elicitation_store = __esm({
        */
       async setPending(record) {
         const { sessionId, expiresAt } = record;
-        const ttlSeconds = (0, import_utils75.expiresAtToTTL)(expiresAt);
+        const ttlSeconds = (0, import_utils77.expiresAtToTTL)(expiresAt);
         if (ttlSeconds <= 0) {
           this.logger?.warn("[StorageElicitationStore] Record already expired, not storing", {
             sessionId,
@@ -43203,7 +43509,7 @@ var init_storage_elicitation_store = __esm({
        */
       async setPendingFallback(record) {
         const { elicitId, expiresAt } = record;
-        const ttlSeconds = (0, import_utils75.expiresAtToTTL)(expiresAt);
+        const ttlSeconds = (0, import_utils77.expiresAtToTTL)(expiresAt);
         if (ttlSeconds <= 0) {
           this.logger?.warn("[StorageElicitationStore] Fallback record already expired, not storing", { elicitId });
           return;
@@ -43458,7 +43764,7 @@ var init_storage_elicitation_store = __esm({
 
 // libs/sdk/src/elicitation/store/elicitation-encryption.ts
 function getElicitationSecret() {
-  return (0, import_utils76.getEnv)("MCP_ELICITATION_SECRET") || (0, import_utils76.getEnv)("MCP_SESSION_SECRET") || (0, import_utils76.getEnv)("MCP_SERVER_SECRET") || null;
+  return (0, import_utils78.getEnv)("MCP_ELICITATION_SECRET") || (0, import_utils78.getEnv)("MCP_SESSION_SECRET") || (0, import_utils78.getEnv)("MCP_SERVER_SECRET") || null;
 }
 function isElicitationEncryptionAvailable() {
   return getElicitationSecret() !== null;
@@ -43466,32 +43772,32 @@ function isElicitationEncryptionAvailable() {
 async function deriveElicitationKey(sessionId, secret) {
   const serverSecret = secret ?? getElicitationSecret();
   if (!serverSecret) {
-    throw new import_auth11.ElicitationSecretRequiredError();
+    throw new import_auth12.ElicitationSecretRequiredError();
   }
   const ikm = textEncoder.encode(serverSecret + sessionId);
   const salt = textEncoder.encode(ELICITATION_SALT);
   const info = textEncoder.encode(`elicit:${sessionId}`);
-  return (0, import_utils76.hkdfSha256)(ikm, salt, info, 32);
+  return (0, import_utils78.hkdfSha256)(ikm, salt, info, 32);
 }
 async function encryptElicitationData(data, sessionId, secret) {
   const key = await deriveElicitationKey(sessionId, secret);
   const plaintext = textEncoder.encode(JSON.stringify(data));
-  const iv = (0, import_utils76.randomBytes)(12);
-  const { ciphertext, tag } = (0, import_utils76.encryptAesGcm)(key, plaintext, iv);
+  const iv = (0, import_utils78.randomBytes)(12);
+  const { ciphertext, tag } = (0, import_utils78.encryptAesGcm)(key, plaintext, iv);
   return {
     alg: "A256GCM",
-    iv: (0, import_utils76.base64urlEncode)(iv),
-    tag: (0, import_utils76.base64urlEncode)(tag),
-    data: (0, import_utils76.base64urlEncode)(ciphertext)
+    iv: (0, import_utils78.base64urlEncode)(iv),
+    tag: (0, import_utils78.base64urlEncode)(tag),
+    data: (0, import_utils78.base64urlEncode)(ciphertext)
   };
 }
 async function decryptElicitationData(blob, sessionId, secret) {
   try {
     const key = await deriveElicitationKey(sessionId, secret);
-    const iv = (0, import_utils76.base64urlDecode)(blob.iv);
-    const tag = (0, import_utils76.base64urlDecode)(blob.tag);
-    const ciphertext = (0, import_utils76.base64urlDecode)(blob.data);
-    const decrypted = (0, import_utils76.decryptAesGcm)(key, ciphertext, iv, tag);
+    const iv = (0, import_utils78.base64urlDecode)(blob.iv);
+    const tag = (0, import_utils78.base64urlDecode)(blob.tag);
+    const ciphertext = (0, import_utils78.base64urlDecode)(blob.data);
+    const decrypted = (0, import_utils78.decryptAesGcm)(key, ciphertext, iv, tag);
     return JSON.parse(textDecoder.decode(decrypted));
   } catch {
     return null;
@@ -43531,11 +43837,11 @@ async function tryDecryptStoredValue(value, sessionId, secret) {
   }
   return decryptElicitationData(value, sessionId, secret);
 }
-var import_utils76, ELICITATION_SALT, textEncoder, textDecoder;
+var import_utils78, ELICITATION_SALT, textEncoder, textDecoder;
 var init_elicitation_encryption = __esm({
   "libs/sdk/src/elicitation/store/elicitation-encryption.ts"() {
     "use strict";
-    import_utils76 = require("@frontmcp/utils");
+    import_utils78 = require("@frontmcp/utils");
     init_auth_internal_errors();
     ELICITATION_SALT = "elicitation-store-v1";
     textEncoder = new TextEncoder();
@@ -43937,10 +44243,10 @@ var init_encrypted_elicitation_store = __esm({
 
 // libs/sdk/src/elicitation/store/elicitation-store.factory.ts
 function detectStorageType2(storage) {
-  if ((0, import_utils77.getEnv)("UPSTASH_REDIS_REST_URL")) {
+  if ((0, import_utils79.getEnv)("UPSTASH_REDIS_REST_URL")) {
     return "upstash";
   }
-  if ((0, import_utils77.getEnv)("REDIS_URL") || (0, import_utils77.getEnv)("REDIS_HOST")) {
+  if ((0, import_utils79.getEnv)("REDIS_URL") || (0, import_utils79.getEnv)("REDIS_HOST")) {
     return "redis";
   }
   return "memory";
@@ -44026,7 +44332,7 @@ async function createElicitationStore(options = {}) {
       });
     }
   }
-  if (finalStorageConfig?.type === "vercel-kv" || (0, import_utils77.getEnv)("KV_REST_API_URL")) {
+  if (finalStorageConfig?.type === "vercel-kv" || (0, import_utils79.getEnv)("KV_REST_API_URL")) {
     throw new ElicitationNotSupportedError(
       "Vercel KV is not supported for elicitation stores. Elicitation requires pub/sub for cross-node result routing, which Vercel KV does not support. Use Redis or Upstash instead."
     );
@@ -44036,7 +44342,7 @@ async function createElicitationStore(options = {}) {
       "Elicitation requires distributed storage when running on Edge runtime. Edge functions are stateless and cannot use in-memory elicitation. Configure Redis or Upstash storage."
     );
   }
-  const storage = await (0, import_utils77.createStorage)({
+  const storage = await (0, import_utils79.createStorage)({
     ...finalStorageConfig,
     prefix: keyPrefix,
     fallback: isEdgeRuntime2 ? "error" : "memory"
@@ -44074,7 +44380,7 @@ async function createElicitationStore(options = {}) {
 }
 function createMemoryElicitationStore(options = {}) {
   const { keyPrefix = "mcp:elicit:", logger, encryption } = options;
-  const storage = (0, import_utils77.createMemoryStorage)({ prefix: keyPrefix });
+  const storage = (0, import_utils79.createMemoryStorage)({ prefix: keyPrefix });
   let store = new StorageElicitationStore(storage, logger);
   const encryptionEnabled = encryption?.enabled ?? "auto";
   const encryptionSecret = encryption?.secret;
@@ -44130,11 +44436,11 @@ function createSqliteElicitationStore(sqliteConfig, storeOptions = {}) {
     keyPrefix
   });
 }
-var import_utils77;
+var import_utils79;
 var init_elicitation_store_factory = __esm({
   "libs/sdk/src/elicitation/store/elicitation-store.factory.ts"() {
     "use strict";
-    import_utils77 = require("@frontmcp/utils");
+    import_utils79 = require("@frontmcp/utils");
     init_elicitation_error();
     init_elicitation_encryption();
     init_encrypted_elicitation_store();
@@ -44165,12 +44471,12 @@ var init_elicitation2 = __esm({
 });
 
 // libs/sdk/src/elicitation/flows/elicitation-request.flow.ts
-var import_lazy_zod79, import_utils78, inputSchema30, outputSchema28, stateSchema28, plan28, name29, Stage29, ElicitationRequestFlow;
+var import_lazy_zod79, import_utils80, inputSchema30, outputSchema28, stateSchema28, plan28, name29, Stage29, ElicitationRequestFlow;
 var init_elicitation_request_flow = __esm({
   "libs/sdk/src/elicitation/flows/elicitation-request.flow.ts"() {
     "use strict";
     import_lazy_zod79 = require("@frontmcp/lazy-zod");
-    import_utils78 = require("@frontmcp/utils");
+    import_utils80 = require("@frontmcp/utils");
     init_common();
     init_errors();
     init_elicitation_types();
@@ -44253,7 +44559,7 @@ var init_elicitation_request_flow = __esm({
       async generateElicitId() {
         this.logger.verbose("generateElicitId:start");
         const { elicitationId, ttl } = this.state;
-        const elicitId = elicitationId ?? `elicit-${(0, import_utils78.randomUUID)()}`;
+        const elicitId = elicitationId ?? `elicit-${(0, import_utils80.randomUUID)()}`;
         const expiresAt = Date.now() + (ttl ?? DEFAULT_ELICIT_TTL);
         this.state.set({ elicitId, expiresAt });
         this.logger.verbose("generateElicitId:done", { elicitId });
@@ -45709,7 +46015,9 @@ var init_workflow_step_executor = __esm({
   "libs/sdk/src/workflow/engine/workflow-step.executor.ts"() {
     "use strict";
     init_errors();
+    init_job_errors();
     init_workflow_errors();
+    init_job_permission_guard();
     WorkflowStepExecutor = class {
       jobRegistry;
       logger;
@@ -45724,6 +46032,16 @@ var init_workflow_step_executor = __esm({
         if (!job) {
           throw new InvalidEntityError("job", step.jobName, `a registered job (referenced by step "${step.id}")`);
         }
+        const allowed = await JobPermissionGuard.check(
+          job.metadata.permissions,
+          "execute",
+          this.extra.authInfo,
+          this.extra.authoritiesContextBuilder
+        );
+        if (!allowed) {
+          this.logger.warn(`Step "${step.id}" denied: caller does not satisfy the execute permissions of "${job.name}"`);
+          throw new JobNotAuthorizedError(job.name);
+        }
         const retryConfig = step.retry ?? job.metadata.retry ?? {};
         const maxAttempts = retryConfig.maxAttempts ?? 3;
         const backoffMs = retryConfig.backoffMs ?? 1e3;
@@ -45948,11 +46266,11 @@ var init_workflow_engine = __esm({
 });
 
 // libs/sdk/src/job/execution/job-execution.manager.ts
-var import_utils79, JobExecutionManager;
+var import_utils81, JobExecutionManager;
 var init_job_execution_manager = __esm({
   "libs/sdk/src/job/execution/job-execution.manager.ts"() {
     "use strict";
-    import_utils79 = require("@frontmcp/utils");
+    import_utils81 = require("@frontmcp/utils");
     init_principal_utils();
     init_errors();
     init_workflow_engine();
@@ -45971,7 +46289,7 @@ var init_job_execution_manager = __esm({
        */
       async executeJob(job, input, opts = {}) {
         await this.assertMayExecute(job.metadata.permissions, job.name, opts);
-        const runId = (0, import_utils79.randomUUID)();
+        const runId = (0, import_utils81.randomUUID)();
         const retryConfig = job.metadata.retry ?? {};
         const maxAttempts = retryConfig.maxAttempts ?? 1;
         const runRecord = {
@@ -46011,7 +46329,7 @@ var init_job_execution_manager = __esm({
        */
       async executeWorkflow(workflow, jobRegistry, opts = {}) {
         await this.assertMayExecute(workflow.metadata.permissions, workflow.name, opts);
-        const runId = (0, import_utils79.randomUUID)();
+        const runId = (0, import_utils81.randomUUID)();
         const runRecord = {
           runId,
           jobId: workflow.metadata.id ?? workflow.name,
@@ -46137,7 +46455,8 @@ var init_job_execution_manager = __esm({
         try {
           const engine = new WorkflowEngine(workflow.metadata, jobRegistry, this.logger, {
             authInfo: opts.authInfo ?? {},
-            contextProviders: opts.contextProviders
+            contextProviders: opts.contextProviders,
+            authoritiesContextBuilder: opts.authoritiesContextBuilder
           });
           const result = await engine.execute(opts.workflowInput);
           await this.stateStore.updateRun(runId, {
@@ -47914,15 +48233,15 @@ var init_skill_session_types = __esm({
 });
 
 // libs/sdk/src/skill/session/skill-session.manager.ts
-var import_utils80, SkillSessionManager;
+var import_utils82, SkillSessionManager;
 var init_skill_session_manager = __esm({
   "libs/sdk/src/skill/session/skill-session.manager.ts"() {
     "use strict";
-    import_utils80 = require("@frontmcp/utils");
+    import_utils82 = require("@frontmcp/utils");
     init_errors();
     init_skill_session_types();
-    SkillSessionManager = class extends import_utils80.EventEmitter {
-      storage = new import_utils80.AsyncLocalStorage();
+    SkillSessionManager = class extends import_utils82.EventEmitter {
+      storage = new import_utils82.AsyncLocalStorage();
       options;
       logger;
       store;
@@ -49058,11 +49377,11 @@ function createSkillHttpAuthValidator(skillsConfig, logger) {
   }
   return new SkillHttpAuthValidator({ skillsConfig, logger });
 }
-var import_utils81, SkillHttpAuthValidator;
+var import_utils83, SkillHttpAuthValidator;
 var init_skill_http_auth = __esm({
   "libs/sdk/src/skill/auth/skill-http-auth.ts"() {
     "use strict";
-    import_utils81 = require("@frontmcp/utils");
+    import_utils83 = require("@frontmcp/utils");
     SkillHttpAuthValidator = class {
       skillsConfig;
       logger;
@@ -49139,7 +49458,7 @@ var init_skill_http_auth = __esm({
           const keyBytes = encoder5.encode(key);
           if (keyBytes.length === candidateBytes.length) {
             try {
-              if ((0, import_utils81.timingSafeEqual)(keyBytes, candidateBytes)) {
+              if ((0, import_utils83.timingSafeEqual)(keyBytes, candidateBytes)) {
                 found = true;
               }
             } catch {
@@ -52105,105 +52424,6 @@ var init_decide_request_intent_utils = __esm({
   }
 });
 
-// libs/sdk/src/common/utils/path.utils.ts
-function normalizeEntryPrefix(entryPath) {
-  const t = (0, import_utils82.trimSlashes)(entryPath ?? "");
-  return t ? `/${t}` : "";
-}
-function normalizeScopeBase(scopeBase) {
-  const t = (0, import_utils82.trimSlashes)(scopeBase ?? "");
-  return t ? `/${t}` : "";
-}
-function readPublicUrlPin() {
-  try {
-    if (typeof process !== "undefined" && process.env) {
-      const v = process.env["FRONTMCP_PUBLIC_URL"];
-      if (typeof v === "string" && v.trim()) {
-        return v.trim().replace(/\/+$/, "");
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function isPublicUrlPinned() {
-  return readPublicUrlPin() !== void 0;
-}
-function isProxyTrusted() {
-  try {
-    if (typeof process !== "undefined" && process.env) {
-      const v = process.env["FRONTMCP_TRUST_PROXY"];
-      return typeof v === "string" && /^(1|true|yes|on)$/i.test(v.trim());
-    }
-  } catch {
-  }
-  return false;
-}
-function getRequestBaseUrl(req, entryPath) {
-  const pin = readPublicUrlPin();
-  if (pin) {
-    return `${pin}${entryPath ?? ""}`;
-  }
-  const trustProxy = isProxyTrusted();
-  const fwdProto = trustProxy ? req.headers["x-forwarded-proto"] : void 0;
-  const fwdHost = trustProxy ? req.headers["x-forwarded-host"] : void 0;
-  const proto = fwdProto || req.protocol || "http";
-  const host = fwdHost || req.headers["host"];
-  return `${proto}://${host}${entryPath ?? ""}`;
-}
-function computeIssuer(req, entryPath, scopeBase) {
-  const entryPrefix = normalizeEntryPrefix(entryPath);
-  const scope = normalizeScopeBase(scopeBase);
-  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
-}
-function computeResource(req, entryPath, scopeBase) {
-  const entryPrefix = normalizeEntryPrefix(entryPath);
-  const scope = normalizeScopeBase(scopeBase);
-  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
-}
-function normalizeResourceUri(uri) {
-  try {
-    const url = new URL(uri);
-    let normalized = `${url.protocol}//${url.hostname}`;
-    const isDefaultPort = url.protocol === "https:" && url.port === "443" || url.protocol === "http:" && url.port === "80";
-    if (url.port && !isDefaultPort) {
-      normalized += `:${url.port}`;
-    }
-    let path3 = url.pathname;
-    if (path3.length > 1 && path3.endsWith("/")) {
-      path3 = path3.slice(0, -1);
-    }
-    normalized += path3;
-    return normalized;
-  } catch {
-    return uri;
-  }
-}
-function resourceUriMatches(provided, canonical) {
-  return normalizeResourceUri(provided) === normalizeResourceUri(canonical);
-}
-function urlToSafeId(url) {
-  const u = new URL(url);
-  const raw = (u.host + (u.pathname && u.pathname !== "/" ? u.pathname : "")).replace(/\/+$/, "");
-  return (0, import_utils82.trimSlashes)(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
-}
-function makeWellKnownPaths(name42, entryPrefix, scopeBase = "") {
-  const prefix = normalizeEntryPrefix(entryPrefix);
-  const scope = normalizeScopeBase(scopeBase);
-  const reversed = (0, import_utils82.joinPath)(".well-known", name42) + `${prefix}${scope}`;
-  const inPrefixRoot = `${prefix}${(0, import_utils82.joinPath)(".well-known", name42)}${scope}`;
-  const inPrefixScope = `${prefix}${scope}${(0, import_utils82.joinPath)(".well-known", name42)}`;
-  return /* @__PURE__ */ new Set([reversed, inPrefixRoot, inPrefixScope]);
-}
-var import_utils82, import_utils83;
-var init_path_utils = __esm({
-  "libs/sdk/src/common/utils/path.utils.ts"() {
-    "use strict";
-    import_utils82 = require("@frontmcp/utils");
-    import_utils83 = require("@frontmcp/utils");
-  }
-});
-
 // libs/sdk/src/common/utils/global-config.utils.ts
 function getGlobalStoreConfig(pluginName, config) {
   if (!config.redis) {
@@ -52307,14 +52527,14 @@ var init_primary_auth_provider_interface = __esm({
        * to ensure consistent provider IDs across the system.
        */
       deriveId(options) {
-        if ((0, import_auth10.isPublicMode)(options)) {
+        if ((0, import_auth11.isPublicMode)(options)) {
           return options.issuer ?? "public";
         }
-        if ((0, import_auth10.isTransparentMode)(options)) {
+        if ((0, import_auth11.isTransparentMode)(options)) {
           return options.providerConfig?.id ?? urlToSafeId(options.provider);
         }
-        if ((0, import_auth10.isOrchestratedMode)(options)) {
-          if ((0, import_auth10.isOrchestratedRemote)(options)) {
+        if ((0, import_auth11.isOrchestratedMode)(options)) {
+          if ((0, import_auth11.isOrchestratedRemote)(options)) {
             return options.providerConfig?.id ?? urlToSafeId(options.provider);
           }
           return options.local?.issuer ?? "local";
@@ -52537,7 +52757,7 @@ async function tryResolvedSubFile(instance, kind, tail) {
       return parseSkillMdFrontmatter(inline).body;
     }
     const absolutePath = entry.path;
-    const resolvedPath = resolveEntryPath(instance, kind, absolutePath, filename);
+    const resolvedPath = resolveEntryPath2(instance, kind, absolutePath, filename);
     if (!resolvedPath) continue;
     try {
       const buf = await (0, import_utils85.readFileBuffer)(resolvedPath);
@@ -52552,7 +52772,7 @@ async function tryResolvedSubFile(instance, kind, tail) {
   }
   return void 0;
 }
-function resolveEntryPath(instance, kind, absolutePath, filename) {
+function resolveEntryPath2(instance, kind, absolutePath, filename) {
   if (absolutePath && (0, import_utils85.isAbsolute)(absolutePath)) return absolutePath;
   if (!filename) return void 0;
   const baseDir = instance.getBaseDir();
@@ -57407,11 +57627,11 @@ function parseUserScopes(user) {
   const s = user?.scope;
   return typeof s === "string" ? s.split(/\s+/).filter(Boolean) : [];
 }
-var import_auth39, import_lazy_zod106, import_utils96, plan40, httpRequestStateSchema, name41, Stage41, HttpRequestFlow;
+var import_auth40, import_lazy_zod106, import_utils96, plan40, httpRequestStateSchema, name41, Stage41, HttpRequestFlow;
 var init_http_request_flow = __esm({
   "libs/sdk/src/scope/flows/http.request.flow.ts"() {
     "use strict";
-    import_auth39 = require("@frontmcp/auth");
+    import_auth40 = require("@frontmcp/auth");
     import_lazy_zod106 = require("@frontmcp/lazy-zod");
     import_utils96 = require("@frontmcp/utils");
     init_session_verify_flow();
@@ -57516,13 +57736,28 @@ var init_http_request_flow = __esm({
       }
       async acquireQuota() {
         const manager = this.scope.rateLimitManager;
-        if (!manager?.config?.global) return;
+        if (!manager) return;
         const context = this.tryGetContext();
         const partitionCtx = context ? {
           sessionId: context.sessionId,
           clientIp: context.metadata?.clientIp,
           userId: context.authInfo?.clientId
         } : void 0;
+        const ipResult = manager.checkIpFilter(partitionCtx?.clientIp);
+        if (ipResult && !ipResult.allowed) {
+          this.logger.warn(`[${this.requestId}] request rejected by ipFilter`, { reason: ipResult.reason });
+          this.respond(
+            httpRespond.json(
+              {
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "Forbidden: client IP rejected by ipFilter" }
+              },
+              { status: 403 }
+            )
+          );
+          return;
+        }
+        if (!manager.config?.global) return;
         const result = await manager.checkGlobalRateLimit(partitionCtx);
         if (!result.allowed) {
           const retryAfter = Math.ceil((result.retryAfterMs ?? 6e4) / 1e3);
@@ -57605,20 +57840,20 @@ var init_http_request_flow = __esm({
         const tokenStore = auth.orchestratedTokenStore;
         let providers;
         try {
-          const authorizationId = (0, import_auth39.deriveAuthorizationId)(token);
+          const authorizationId = (0, import_auth40.deriveAuthorizationId)(token);
           const providerIds = await tokenStore.getProviderIds(authorizationId);
           providers = Object.fromEntries(providerIds.map((id) => [id, { id }]));
         } catch (err) {
           this.logger.warn(`[${this.requestId}] failed to load orchestrated providers: ${String(err)}`);
         }
-        const authorization = import_auth39.OrchestratedAuthorization.create({
+        const authorization = import_auth40.OrchestratedAuthorization.create({
           token,
           user: { sub: user.sub ?? "unknown", name: user.name, email: user.email, picture: user.picture },
           expiresAt: user.exp ? user.exp * 1e3 : void 0,
           tokenStore,
           providers
         });
-        ctx.setContextToken(import_auth39.ORCHESTRATED_AUTH_ACCESSOR, new import_auth39.OrchestratedAuthAccessorAdapter(authorization));
+        ctx.setContextToken(import_auth40.ORCHESTRATED_AUTH_ACCESSOR, new import_auth40.OrchestratedAuthAccessorAdapter(authorization));
       }
       async router() {
         try {
@@ -58143,6 +58378,7 @@ var init_scope_instance = __esm({
     init_channel_scope_helper();
     init_common();
     init_sqlite();
+    init_path_utils();
     init_complete_flow();
     init_context();
     init_elicitation2();
@@ -58243,7 +58479,7 @@ var init_scope_instance = __esm({
         this.logger = globalProviders.get(FrontMcpLogger).child("FrontMcp.MultiAppScope");
         this.globalProviders = globalProviders;
         this.server = this.globalProviders.get(FrontMcpServer);
-        this.entryPath = rec.metadata.http?.entryPath ?? "";
+        this.entryPath = resolveEntryPath(rec.metadata.http?.entryPath);
         if (rec.kind === "SPLIT_BY_APP") {
           this.routeBase = `/${rec.metadata.id}`;
         } else {
@@ -58347,16 +58583,25 @@ var init_scope_instance = __esm({
         })() : void 0;
         const tasksConfig = this.metadata.tasks;
         const tasksExplicitlyDisabled = tasksConfig?.enabled === false;
+        const tasksExplicitlyEnabled = tasksConfig?.enabled === true;
         const isTaskWorker = !!this.metadata["__taskWorkerMode"];
         const hasPersistentBackend = Boolean(
           tasksConfig?.sqlite || tasksConfig?.redis || this.metadata.redis || this.metadata.sqlite
         );
         const tasksEnabledForCli = this.cliMode && hasPersistentBackend;
-        const shouldInitTasks = !tasksExplicitlyDisabled && (!this.cliMode || tasksEnabledForCli || isTaskWorker);
+        const hasDistributedTaskBackend = Boolean(tasksConfig?.redis ?? this.metadata.redis);
+        const onEdgeRuntime = (0, import_utils97.isEdgeRuntime)();
+        const tasksUnavailableOnEdge = onEdgeRuntime && !hasDistributedTaskBackend && !tasksExplicitlyEnabled;
+        if (tasksUnavailableOnEdge) {
+          this.logger.info(
+            "[tasks] Background tasks are unavailable on this edge/serverless runtime: the in-process runner cannot continue past the HTTP response, and an in-memory store is not shared between isolates. Serving without tasks. Configure `tasks.redis` (Upstash Redis over HTTP works on Workers) to enable them."
+          );
+        }
+        const shouldInitTasks = !tasksExplicitlyDisabled && !tasksUnavailableOnEdge && (!this.cliMode || tasksEnabledForCli || isTaskWorker);
         const tasksPromise = shouldInitTasks ? (async () => {
           const tasksRedis = tasksConfig?.redis ?? this.metadata.redis;
           const tasksSqlite = tasksConfig?.sqlite ?? (tasksRedis ? void 0 : resolvedTopLevelSqlite);
-          const onEdge = (0, import_utils97.isEdgeRuntime)();
+          const onEdge = onEdgeRuntime;
           if (onEdge) {
             const msg = "[tasks] Background tasks are enabled on an edge/serverless runtime. The in-process runner cannot continue past the HTTP response on this platform \u2014 task bodies will not execute. Run on a long-lived Node process, or set `tasks.enabled: false`.";
             if (tasksConfig?.strict) {
@@ -60495,7 +60740,7 @@ function createWebFetchHandler(scope, options = {}) {
     while (end > 1 && withSlash.charCodeAt(end - 1) === 47) end--;
     return withSlash.slice(0, end);
   };
-  const rawEntry = options.entryPath ?? (normalizeEntryPrefix(httpConfig?.entryPath) || "/");
+  const rawEntry = options.entryPath ?? (normalizeEntryPrefix(resolveEntryPath(httpConfig?.entryPath)) || "/");
   const entryPaths = new Set((Array.isArray(rawEntry) ? rawEntry : [rawEntry]).map(normalizePath));
   const cors2 = options.cors ?? mapHttpCors(httpConfig?.cors, scope);
   const corsEnabled = cors2?.origin !== void 0 && cors2.origin !== false;
@@ -60560,7 +60805,7 @@ function createWebFetchHandler(scope, options = {}) {
       );
     }
     if (!entryPaths.has(normalizePath(url.pathname))) {
-      const authResponse = await runMatchingHttpFlowWeb(scope, request);
+      const authResponse = await runMatchingHttpFlowWeb(scope, request, { ctx, env });
       if (authResponse) return withCors(authResponse, request);
       return withCors(Response.json({ error: "Not Found", entryPaths: [...entryPaths] }, { status: 404 }), request);
     }
@@ -60568,13 +60813,13 @@ function createWebFetchHandler(scope, options = {}) {
       const routed = await options.sessionRouter(request, env, ctx);
       if (routed) return withCors(routed, request);
     }
-    const rendered = await runHttpRequestFlowWeb(scope, request, { ctx });
+    const rendered = await runHttpRequestFlowWeb(scope, request, { ctx, env });
     return withCors(rendered ?? Response.json({ error: "Not Found" }, { status: 404 }), request);
   };
 }
 async function runHttpRequestFlowWeb(scope, request, opts = {}) {
   const url = new URL(request.url);
-  const serverRequest = await toServerRequest(request, url, opts.ctx, opts.persistent);
+  const serverRequest = await toServerRequest(request, url, opts.ctx, opts.persistent, opts.env);
   let output;
   try {
     output = await scope.runFlow("http:request", {
@@ -60586,9 +60831,9 @@ async function runHttpRequestFlowWeb(scope, request, opts = {}) {
   }
   return output ? renderHttpOutputToWebResponse(output) : void 0;
 }
-async function runMatchingHttpFlowWeb(scope, request) {
+async function runMatchingHttpFlowWeb(scope, request, opts = {}) {
   const url = new URL(request.url);
-  const serverRequest = await toServerRequest(request, url);
+  const serverRequest = await toServerRequest(request, url, opts.ctx, void 0, opts.env);
   const flowName = await scope.findHttpFlowName(serverRequest);
   if (!flowName) return void 0;
   let output;
@@ -60602,7 +60847,7 @@ async function runMatchingHttpFlowWeb(scope, request) {
   }
   return output ? renderHttpOutputToWebResponse(output) : void 0;
 }
-async function toServerRequest(request, url, ctx, persistent) {
+async function toServerRequest(request, url, ctx, persistent, env) {
   const headers = {};
   request.headers.forEach((v, k) => {
     headers[k] = v;
@@ -60646,10 +60891,39 @@ async function toServerRequest(request, url, ctx, persistent) {
   const tokenized = serverRequest;
   tokenized[ServerRequestTokens.webRequest] = webRequest;
   tokenized[ServerRequestTokens.webCtx] = ctx;
+  tokenized[ServerRequestTokens.webEnv] = env;
   if (persistent) tokenized[ServerRequestTokens.webTransport] = persistent;
   return serverRequest;
 }
+function misconfigurationResponse(error) {
+  const misconfiguration = findMisconfiguration(error);
+  if (!misconfiguration) return void 0;
+  return Response.json(
+    { error: "server_misconfigured", code: misconfiguration.code, message: misconfiguration.remedy },
+    { status: 500 }
+  );
+}
+function findMisconfiguration(error) {
+  let current = error;
+  for (let depth = 0; current instanceof Error && depth < 5; depth++) {
+    const code = current.code;
+    if (typeof code === "string" && MISCONFIGURATION_REMEDIES[code]) {
+      return { code, remedy: MISCONFIGURATION_REMEDIES[code] };
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
 function flowErrorToHttpOutput(error) {
+  const misconfiguration = findMisconfiguration(error);
+  if (misconfiguration) {
+    return {
+      kind: "json",
+      status: 500,
+      contentType: "application/json; charset=utf-8",
+      body: { error: "server_misconfigured", code: misconfiguration.code, message: misconfiguration.remedy }
+    };
+  }
   if (error instanceof FlowControl) {
     switch (error.type) {
       case "respond":
@@ -60673,6 +60947,7 @@ function flowErrorToHttpOutput(error) {
   }
   return { kind: "text", status: 500, body: "Internal Server Error", contentType: "text/plain; charset=utf-8" };
 }
+var MISCONFIGURATION_REMEDIES;
 var init_web_fetch_handler = __esm({
   "libs/sdk/src/transport/web-fetch-handler.ts"() {
     "use strict";
@@ -60682,6 +60957,11 @@ var init_web_fetch_handler = __esm({
     init_errors();
     init_host_validation();
     init_web_response_renderer();
+    MISCONFIGURATION_REMEDIES = {
+      SESSION_SECRET_REQUIRED: "Set MCP_SESSION_SECRET in the deployment environment (e.g. `wrangler secret put MCP_SESSION_SECRET`). Session IDs are encrypted with it, and production refuses the development machine-id fallback.",
+      JWT_SECRET_INVALID: "JWT_SECRET is present but too weak: HS256 requires at least 32 bytes (RFC 7518). Replace it with `openssl rand -hex 32`.",
+      JWT_SECRET_REQUIRED: "Set JWT_SECRET in the deployment environment (e.g. `wrangler secret put JWT_SECRET`). Tokens are signed with it; production refuses the random per-process fallback because tokens would not survive a restart or verify across instances."
+    };
   }
 });
 
@@ -61035,17 +61315,16 @@ var init_express_host_adapter = __esm({
           });
         } else {
           this.deriveHostValidation = (portOrSocketPath, bindAddress) => {
-            const isSocket = typeof portOrSocketPath === "string";
+            if (typeof portOrSocketPath === "string") return void 0;
             const derivation = {
               // `start()` binds `bindAddress ?? '0.0.0.0'`; mirror that exactly.
-              bindAddress: isSocket ? void 0 : bindAddress ?? "0.0.0.0",
-              port: isSocket ? void 0 : portOrSocketPath,
-              socketPath: isSocket ? portOrSocketPath : void 0,
+              bindAddress: bindAddress ?? "0.0.0.0",
+              port: portOrSocketPath,
               issuer: options?.listen?.issuer
             };
             if (!shouldEnforceDerivedHosts(derivation)) {
               console.warn(
-                `[frontmcp] DNS-rebinding protection is not enforcing a Host allow-list: the server binds a routable address (${derivation.bindAddress ?? "unknown"}) and no allowed hosts are configured. Set security.dnsRebindingProtection.allowedHosts (or FRONTMCP_ALLOWED_HOSTS) to your public hostname(s).`
+                `[frontmcp] DNS-rebinding protection is not enforcing a Host allow-list: the server binds a routable address (${derivation.bindAddress}) and no allowed hosts are configured. Set security.dnsRebindingProtection.allowedHosts (or FRONTMCP_ALLOWED_HOSTS) to your public hostname(s).`
               );
               return void 0;
             }
@@ -61101,7 +61380,6 @@ var init_express_host_adapter = __esm({
         return this.app;
       }
       async start(portOrSocketPath, bindAddress) {
-        this.enableDerivedHostValidation(portOrSocketPath, bindAddress);
         this.prepare();
         const server = http.createServer(this.app);
         server.requestTimeout = 0;
@@ -61109,6 +61387,7 @@ var init_express_host_adapter = __esm({
         server.keepAliveTimeout = 75e3;
         if (typeof portOrSocketPath === "string") {
           await this.cleanupStaleSocket(portOrSocketPath);
+          this.enableDerivedHostValidation(portOrSocketPath);
           await new Promise((resolve, reject) => {
             server.on("error", reject);
             server.listen(portOrSocketPath, () => {
@@ -61126,7 +61405,11 @@ var init_express_host_adapter = __esm({
           await new Promise((resolve, reject) => {
             server.on("error", reject);
             server.listen(portOrSocketPath, host, () => {
-              console.log(`MCP HTTP (Express) on ${host}:${portOrSocketPath}`);
+              const bound = server.address();
+              const boundPort = typeof bound === "object" && bound ? bound.port : portOrSocketPath;
+              const boundAddress = typeof bound === "object" && bound ? bound.address : host;
+              this.enableDerivedHostValidation(boundPort, boundAddress);
+              console.log(`MCP HTTP (Express) on ${host}:${boundPort}`);
               resolve();
             });
           });
@@ -61528,7 +61811,7 @@ var init_front_mcp = __esm({
           frontMcp.log?.info("FrontMCP fetch handler created (web-standard transport)");
           return createWebFetchHandler(scope);
         };
-        return async (request) => {
+        return async (request, ctx, env) => {
           if (!inner) {
             if (!building) {
               building = build().catch((err) => {
@@ -61536,9 +61819,15 @@ var init_front_mcp = __esm({
                 throw err;
               });
             }
-            inner = await building;
+            try {
+              inner = await building;
+            } catch (err) {
+              const misconfigured = misconfigurationResponse(err);
+              if (misconfigured) return misconfigured;
+              throw err;
+            }
           }
-          return inner(request);
+          return inner(request, ctx, env);
         };
       }
       /**
@@ -63946,7 +64235,7 @@ __export(index_exports, {
   AuthProviderEntry: () => AuthProviderEntry,
   AuthProviderKind: () => AuthProviderKind,
   AuthProviderScope: () => AuthProviderScope,
-  AuthProvidersNotConfiguredError: () => import_auth11.AuthProvidersNotConfiguredError,
+  AuthProvidersNotConfiguredError: () => import_auth12.AuthProvidersNotConfiguredError,
   AuthorizationRequiredError: () => AuthorizationRequiredError,
   BaseConfig: () => BaseConfig,
   BaseEntry: () => BaseEntry,
@@ -63975,7 +64264,7 @@ __export(index_exports, {
   ConfigValidationError: () => ConfigValidationError,
   Context: () => FrontMcpContext,
   ContextExtensionNotAvailableError: () => ContextExtensionNotAvailableError,
-  CredentialProviderAlreadyRegisteredError: () => import_auth11.CredentialProviderAlreadyRegisteredError,
+  CredentialProviderAlreadyRegisteredError: () => import_auth12.CredentialProviderAlreadyRegisteredError,
   DEFAULT_ELICITATION_OPTIONS: () => DEFAULT_ELICITATION_OPTIONS,
   DEFAULT_ELICIT_TTL: () => DEFAULT_ELICIT_TTL,
   DEFAULT_FALLBACK_WAIT_TTL: () => DEFAULT_FALLBACK_WAIT_TTL,
@@ -64000,14 +64289,14 @@ __export(index_exports, {
   ElicitationEncryptionError: () => ElicitationEncryptionError,
   ElicitationFallbackRequired: () => ElicitationFallbackRequired,
   ElicitationNotSupportedError: () => ElicitationNotSupportedError,
-  ElicitationSecretRequiredError: () => import_auth11.ElicitationSecretRequiredError,
+  ElicitationSecretRequiredError: () => import_auth12.ElicitationSecretRequiredError,
   ElicitationStoreNotInitializedError: () => ElicitationStoreNotInitializedError,
   ElicitationSubscriptionError: () => ElicitationSubscriptionError,
   ElicitationTimeoutError: () => ElicitationTimeoutError,
   EnclaveExecutionError: () => EnclaveExecutionError,
   EncryptedElicitationStore: () => EncryptedElicitationStore,
-  EncryptionContextNotSetError: () => import_auth11.EncryptionContextNotSetError,
-  EncryptionKeyNotConfiguredError: () => import_auth11.EncryptionKeyNotConfiguredError,
+  EncryptionContextNotSetError: () => import_auth12.EncryptionContextNotSetError,
+  EncryptionKeyNotConfiguredError: () => import_auth12.EncryptionKeyNotConfiguredError,
   EntryUnavailableError: () => EntryUnavailableError,
   EntryValidationError: () => EntryValidationError,
   ErrorHandler: () => ErrorHandler,
@@ -64115,8 +64404,8 @@ __export(index_exports, {
   HttpTextSchema: () => HttpTextSchema,
   HttpWebResponseSchema: () => HttpWebResponseSchema,
   ImageOutputSchema: () => ImageOutputSchema,
-  InMemoryOrchestratedTokenStore: () => import_auth41.InMemoryOrchestratedTokenStore,
-  InMemoryStoreRequiredError: () => import_auth11.InMemoryStoreRequiredError,
+  InMemoryOrchestratedTokenStore: () => import_auth42.InMemoryOrchestratedTokenStore,
+  InMemoryStoreRequiredError: () => import_auth12.InMemoryStoreRequiredError,
   InProcessTaskRunner: () => InProcessTaskRunner,
   InputRequiredSignal: () => InputRequiredSignal,
   InternalMcpError: () => InternalMcpError,
@@ -64149,6 +64438,8 @@ __export(index_exports, {
   JobNotAuthorizedError: () => JobNotAuthorizedError,
   JobPermissionGuard: () => JobPermissionGuard,
   JobRegistry: () => JobRegistry,
+  JwtSecretRequiredError: () => import_auth12.JwtSecretRequiredError,
+  JwtSecretWeakError: () => import_auth12.JwtSecretWeakError,
   LLM_ADAPTER: () => LLM_ADAPTER,
   LazyZodSchema: () => import_lazy_zod110.LazyZodSchema,
   ListJobsTool: () => ListJobsTool,
@@ -64178,15 +64469,15 @@ __export(index_exports, {
   NEVER: () => import_lazy_zod110.NEVER,
   NO_BODY_STATUSES: () => NO_BODY_STATUSES,
   NameDisambiguationError: () => NameDisambiguationError,
-  NoProviderIdError: () => import_auth11.NoProviderIdError,
+  NoProviderIdError: () => import_auth12.NoProviderIdError,
   OAuthAuthorizeHook: () => OAuthAuthorizeHook,
   OAuthCallbackHook: () => OAuthCallbackHook,
   OAuthRegisterHook: () => OAuthRegisterHook,
   OAuthTokenHook: () => OAuthTokenHook,
   OUTPUT_SCHEMA_MODES: () => OUTPUT_SCHEMA_MODES,
   OpenAIAdapter: () => OpenAIAdapter,
-  OrchestratedAuthNotAvailableError: () => import_auth11.OrchestratedAuthNotAvailableError,
-  OrchestratorJwksNotAvailableError: () => import_auth11.OrchestratorJwksNotAvailableError,
+  OrchestratedAuthNotAvailableError: () => import_auth12.OrchestratedAuthNotAvailableError,
+  OrchestratorJwksNotAvailableError: () => import_auth12.OrchestratorJwksNotAvailableError,
   PLATFORM_CLIENT_INFO: () => PLATFORM_CLIENT_INFO,
   PRIMITIVE_FILTER_KEYS: () => PRIMITIVE_FILTER_KEYS,
   PROTOCOL_2026_07_28: () => import_protocol57.PROTOCOL_2026_07_28,
@@ -64262,7 +64553,7 @@ __export(index_exports, {
   SCHEMA_DESCRIPTION_FORMATS: () => SCHEMA_DESCRIPTION_FORMATS,
   SamplingNotAvailableError: () => SamplingNotAvailableError,
   ScopeConfigurationError: () => ScopeConfigurationError,
-  ScopeDeniedError: () => import_auth11.ScopeDeniedError,
+  ScopeDeniedError: () => import_auth12.ScopeDeniedError,
   ScopeEntry: () => ScopeEntry,
   ScopeKind: () => ScopeKind,
   ServerNotFoundError: () => ServerNotFoundError,
@@ -64272,9 +64563,9 @@ __export(index_exports, {
   ServerlessHandlerNotInitializedError: () => ServerlessHandlerNotInitializedError,
   SessionClaimConflictError: () => SessionClaimConflictError,
   SessionHookStage: () => SessionHookStage,
-  SessionIdEmptyError: () => import_auth11.SessionIdEmptyError,
+  SessionIdEmptyError: () => import_auth12.SessionIdEmptyError,
   SessionMissingError: () => SessionMissingError,
-  SessionSecretRequiredError: () => import_auth11.SessionSecretRequiredError,
+  SessionSecretRequiredError: () => import_auth12.SessionSecretRequiredError,
   SessionVerificationFailedError: () => SessionVerificationFailedError,
   Skill: () => Skill,
   SkillContext: () => SkillContext,
@@ -64306,9 +64597,9 @@ __export(index_exports, {
   TasksGetFlow: () => TasksGetFlow,
   TasksListFlow: () => TasksListFlow,
   TasksResultFlow: () => TasksResultFlow,
-  TokenLeakDetectedError: () => import_auth11.TokenLeakDetectedError,
-  TokenNotAvailableError: () => import_auth11.TokenNotAvailableError,
-  TokenStoreRequiredError: () => import_auth11.TokenStoreRequiredError,
+  TokenLeakDetectedError: () => import_auth12.TokenLeakDetectedError,
+  TokenNotAvailableError: () => import_auth12.TokenNotAvailableError,
+  TokenStoreRequiredError: () => import_auth12.TokenStoreRequiredError,
   Tool: () => FrontMcpTool,
   ToolContext: () => ToolContext,
   ToolCredentialsRequiredError: () => ToolCredentialsRequiredError,
@@ -64330,8 +64621,8 @@ __export(index_exports, {
   UnsupportedContentTypeError: () => UnsupportedContentTypeError,
   UnsupportedHookOwnerKindError: () => UnsupportedHookOwnerKindError,
   UnsupportedTransportTypeError: () => UnsupportedTransportTypeError,
-  VaultLoadError: () => import_auth11.VaultLoadError,
-  VaultNotFoundError: () => import_auth11.VaultNotFoundError,
+  VaultLoadError: () => import_auth12.VaultLoadError,
+  VaultNotFoundError: () => import_auth12.VaultNotFoundError,
   VercelKvAsyncInitRequiredError: () => VercelKvAsyncInitRequiredError,
   VercelKvNotSupportedError: () => VercelKvNotSupportedError,
   VersionPoller: () => VersionPoller,
@@ -64378,7 +64669,7 @@ __export(index_exports, {
   ZodVoid: () => import_lazy_zod110.ZodVoid,
   agent: () => frontMcpAgent,
   aiPlatformTypeSchema: () => import_auth3.aiPlatformTypeSchema,
-  allowsPublicAccess: () => import_auth10.allowsPublicAccess,
+  allowsPublicAccess: () => import_auth11.allowsPublicAccess,
   annotatedFrontMcpAdaptersSchema: () => annotatedFrontMcpAdaptersSchema,
   annotatedFrontMcpAgentsSchema: () => annotatedFrontMcpAgentsSchema,
   annotatedFrontMcpAppSchema: () => annotatedFrontMcpAppSchema,
@@ -64394,11 +64685,11 @@ __export(index_exports, {
   annotatedFrontMcpToolsSchema: () => annotatedFrontMcpToolsSchema,
   annotatedFrontMcpWorkflowsSchema: () => annotatedFrontMcpWorkflowsSchema,
   app: () => frontMcpApp,
-  appAuthOptionsSchema: () => import_auth9.appAuthOptionsSchema,
+  appAuthOptionsSchema: () => import_auth10.appAuthOptionsSchema,
   appFilterConfigSchema: () => appFilterConfigSchema,
   applyPrimitiveFilter: () => applyPrimitiveFilter,
-  authOptionsSchema: () => import_auth8.authOptionsSchema,
-  authenticateFnSchema: () => import_auth7.authenticateFnSchema,
+  authOptionsSchema: () => import_auth9.authOptionsSchema,
+  authenticateFnSchema: () => import_auth8.authenticateFnSchema,
   authorizationRequiredDataSchema: () => authorizationRequiredDataSchema,
   authorizationRequiredMetaSchema: () => authorizationRequiredMetaSchema,
   authorizationRequiredParamsSchema: () => authorizationRequiredParamsSchema,
@@ -64570,32 +64861,34 @@ __export(index_exports, {
   isFileInstructions: () => isFileInstructions,
   isInlineInstructions: () => isInlineInstructions,
   isLazy: () => import_lazy_zod110.isLazy,
-  isLocalMode: () => import_auth10.isLocalMode,
+  isLocalMode: () => import_auth11.isLocalMode,
   isNewerVersion: () => isNewerVersion,
-  isOrchestratedLocal: () => import_auth10.isOrchestratedLocal,
-  isOrchestratedMode: () => import_auth10.isOrchestratedMode,
-  isOrchestratedRemote: () => import_auth10.isOrchestratedRemote,
+  isOrchestratedLocal: () => import_auth11.isOrchestratedLocal,
+  isOrchestratedMode: () => import_auth11.isOrchestratedMode,
+  isOrchestratedRemote: () => import_auth11.isOrchestratedRemote,
   isPackageSpecifier: () => isPackageSpecifier,
+  isProxyTrusted: () => isProxyTrusted,
   isPublicError: () => isPublicError,
-  isPublicMode: () => import_auth10.isPublicMode,
+  isPublicMode: () => import_auth11.isPublicMode,
   isPublicUrlPinned: () => isPublicUrlPinned,
   isPubsubConfigured: () => isPubsubConfigured,
   isRedisProvider: () => isRedisProvider,
-  isRemoteMode: () => import_auth10.isRemoteMode,
+  isRemoteMode: () => import_auth11.isRemoteMode,
   isSkillDecorated: () => isSkillDecorated,
   isSkillRecord: () => isSkillRecord,
+  isStaticMode: () => import_auth11.isStaticMode,
   isTaskWorkerProcess: () => isTaskWorkerProcess,
   isTerminal: () => isTerminal,
   isToolRefWithClass: () => isToolRefWithClass,
   isToolRefWithName: () => isToolRefWithName,
   isTransientError: () => isTransientError,
-  isTransparentMode: () => import_auth10.isTransparentMode,
+  isTransparentMode: () => import_auth11.isTransparentMode,
   isUrlInstructions: () => isUrlInstructions,
   isValidRange: () => isValidRange,
   isValidVersion: () => isValidVersion,
   isVercelKvProvider: () => isVercelKvProvider,
   job: () => frontMcpJob,
-  joinPath: () => import_utils83.joinPath,
+  joinPath: () => import_utils48.joinPath,
   jsonWebKeySetSchema: () => import_auth.jsonWebKeySetSchema,
   jwkParametersSchema: () => import_auth.jwkParametersSchema,
   jwkSchema: () => import_auth.jwkSchema,
@@ -64603,12 +64896,12 @@ __export(index_exports, {
   loadConfig: () => loadConfig,
   loadEnvFiles: () => loadEnvFiles,
   loadSkillDirectory: () => loadSkillDirectory,
-  localAuthSchema: () => import_auth7.localAuthSchema,
+  localAuthSchema: () => import_auth8.localAuthSchema,
   localDcrClientSchema: () => import_auth4.localDcrClientSchema,
   localDcrConfigSchema: () => import_auth4.localDcrConfigSchema,
   localSigningConfigSchema: () => import_auth4.localSigningConfigSchema,
   loggingOptionsSchema: () => loggingOptionsSchema,
-  loginConfigSchema: () => import_auth7.loginConfigSchema,
+  loginConfigSchema: () => import_auth8.loginConfigSchema,
   makeWellKnownPaths: () => makeWellKnownPaths,
   mapEnvToNestedConfig: () => mapEnvToNestedConfig,
   maxSatisfying: () => maxSatisfying2,
@@ -64628,12 +64921,12 @@ __export(index_exports, {
   normalizeToolAuthProviders: () => normalizeToolAuthProviders,
   normalizeToolRef: () => normalizeToolRef,
   observabilityOptionsSchema: () => observabilityOptionsSchema,
-  orchestratedLocalSchema: () => import_auth7.orchestratedLocalSchema,
-  orchestratedRemoteSchema: () => import_auth7.orchestratedRemoteSchema,
+  orchestratedLocalSchema: () => import_auth8.orchestratedLocalSchema,
+  orchestratedRemoteSchema: () => import_auth8.orchestratedRemoteSchema,
   outputPolicySchema: () => outputPolicySchema,
   packageLoaderSchema: () => packageLoaderSchema,
   paginationOptionsSchema: () => paginationOptionsSchema,
-  parseAuthOptions: () => import_auth10.parseAuthOptions,
+  parseAuthOptions: () => import_auth11.parseAuthOptions,
   parseCallerDir: () => parseCallerDir,
   parseEnvContent: () => parseEnvContent,
   parseEnvContentSync: () => parseEnvContentSync,
@@ -64658,9 +64951,10 @@ __export(index_exports, {
   redisOptionsSchema: () => redisOptionsSchema,
   redisProviderSchema: () => redisProviderSchema,
   registerPendingTC39Hook: () => registerPendingTC39Hook,
-  remoteAuthSchema: () => import_auth7.remoteAuthSchema,
+  remoteAuthSchema: () => import_auth8.remoteAuthSchema,
   remoteProviderConfigSchema: () => import_auth4.remoteProviderConfigSchema,
   resolveDefaultSqlitePath: () => resolveDefaultSqlitePath,
+  resolveEntryPath: () => resolveEntryPath,
   resolveNameConflicts: () => resolveNameConflicts,
   resolveOutputSchemaMode: () => resolveOutputSchemaMode,
   resolvePendingTC39HooksForClass: () => resolvePendingTC39HooksForClass,
@@ -64703,6 +64997,7 @@ __export(index_exports, {
   skillsConfigOptionsSchema: () => skillsConfigOptionsSchema,
   skippedAppBehaviorSchema: () => import_auth4.skippedAppBehaviorSchema,
   sqliteOptionsSchema: () => sqliteOptionsSchema,
+  staticAuthOptionsSchema: () => import_auth6.staticAuthOptionsSchema,
   storageProviderSchema: () => storageProviderSchema,
   supportsStreaming: () => supportsStreaming,
   toJSONSchema: () => import_lazy_zod110.toJSONSchema,
@@ -64714,9 +65009,9 @@ __export(index_exports, {
   tokenStorageSqliteSchema: () => import_auth4.tokenStorageSqliteSchema,
   tool: () => frontMcpTool,
   toolPaginationOptionsSchema: () => toolPaginationOptionsSchema,
-  transparentAuthOptionsSchema: () => import_auth6.transparentAuthOptionsSchema,
+  transparentAuthOptionsSchema: () => import_auth7.transparentAuthOptionsSchema,
   transportOptionsSchema: () => transportOptionsSchema,
-  trimSlashes: () => import_utils83.trimSlashes,
+  trimSlashes: () => import_utils48.trimSlashes,
   tryDecryptStoredValue: () => tryDecryptStoredValue,
   tryGetConfig: () => tryGetConfig,
   upstreamProviderSchema: () => import_auth4.upstreamProviderSchema,
@@ -65053,7 +65348,7 @@ init_mcp_20260728();
 init_mcp_stateless_client_adapter();
 var import_protocol57 = require("@frontmcp/protocol");
 init_ext_apps2();
-var import_auth41 = require("@frontmcp/auth");
+var import_auth42 = require("@frontmcp/auth");
 (function suppressZodExpressWarning() {
   if (typeof process === "undefined" || typeof process.emitWarning !== "function") return;
   const originalEmitWarning = process.emitWarning.bind(process);
@@ -65318,6 +65613,8 @@ var ChannelListHook = FlowHooksOf("channels:list");
   JobNotAuthorizedError,
   JobPermissionGuard,
   JobRegistry,
+  JwtSecretRequiredError,
+  JwtSecretWeakError,
   LLM_ADAPTER,
   LazyZodSchema,
   ListJobsTool,
@@ -65744,6 +66041,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   isOrchestratedMode,
   isOrchestratedRemote,
   isPackageSpecifier,
+  isProxyTrusted,
   isPublicError,
   isPublicMode,
   isPublicUrlPinned,
@@ -65752,6 +66050,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   isRemoteMode,
   isSkillDecorated,
   isSkillRecord,
+  isStaticMode,
   isTaskWorkerProcess,
   isTerminal,
   isToolRefWithClass,
@@ -65829,6 +66128,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   remoteAuthSchema,
   remoteProviderConfigSchema,
   resolveDefaultSqlitePath,
+  resolveEntryPath,
   resolveNameConflicts,
   resolveOutputSchemaMode,
   resolvePendingTC39HooksForClass,
@@ -65871,6 +66171,7 @@ var ChannelListHook = FlowHooksOf("channels:list");
   skillsConfigOptionsSchema,
   skippedAppBehaviorSchema,
   sqliteOptionsSchema,
+  staticAuthOptionsSchema,
   storageProviderSchema,
   supportsStreaming,
   toJSONSchema,