@frontmcp/sdk 1.0.0-beta.7 → 1.0.0-beta.9

package/index.js

@@ -4085,7 +4085,7 @@ var init_provider_errors = __esm({
 });
 
 // libs/sdk/src/errors/transport.errors.ts
-var MethodNotImplementedError, UnsupportedTransportTypeError, TransportBusRequiredError, InvalidTransportSessionError, TransportNotConnectedError, TransportAlreadyStartedError, UnsupportedContentTypeError;
+var MethodNotImplementedError, UnsupportedTransportTypeError, TransportBusRequiredError, InvalidTransportSessionError, TransportNotConnectedError, TransportAlreadyStartedError, UnsupportedContentTypeError, TransportServiceNotAvailableError;
 var init_transport_errors = __esm({
   "libs/sdk/src/errors/transport.errors.ts"() {
     "use strict";
@@ -4128,6 +4128,11 @@ var init_transport_errors = __esm({
         this.contentType = contentType2;
       }
     };
+    TransportServiceNotAvailableError = class extends InternalMcpError {
+      constructor() {
+        super("Transport service not available", "TRANSPORT_SERVICE_NOT_AVAILABLE");
+      }
+    };
   }
 });
 
@@ -4533,6 +4538,7 @@ __export(errors_exports, {
   TransportAlreadyStartedError: () => TransportAlreadyStartedError,
   TransportBusRequiredError: () => TransportBusRequiredError,
   TransportNotConnectedError: () => TransportNotConnectedError,
+  TransportServiceNotAvailableError: () => TransportServiceNotAvailableError,
   UnauthorizedError: () => UnauthorizedError,
   UnsupportedClientVersionError: () => UnsupportedClientVersionError,
   UnsupportedContentTypeError: () => UnsupportedContentTypeError,
@@ -7688,8 +7694,9 @@ var init_notification_service = __esm({
       emergency: 7
     };
     NotificationService = class _NotificationService {
-      constructor(scope) {
+      constructor(scope, options = {}) {
         this.scope = scope;
+        this.options = options;
         this.logger = scope.logger.child("NotificationService");
       }
       logger;
@@ -7706,6 +7713,9 @@ var init_notification_service = __esm({
       terminatedSessions = /* @__PURE__ */ new Set();
       /** Maximum number of terminated sessions to track before eviction */
       static MAX_TERMINATED_SESSIONS = 1e4;
+      get maxTerminatedSessions() {
+        return this.options.maxTerminatedSessions ?? _NotificationService.MAX_TERMINATED_SESSIONS;
+      }
       /**
        * Initialize the notification service and subscribe to registry changes.
        * Called after all registries are ready.
@@ -7787,7 +7797,7 @@ var init_notification_service = __esm({
         const wasRegistered = this.unregisterServer(sessionId);
         this.scope.providers.cleanupSession(sessionId);
         this.logger.verbose(`Cleaned up provider cache for terminated session: ${sessionId.slice(0, 20)}...`);
-        if (this.terminatedSessions.size >= _NotificationService.MAX_TERMINATED_SESSIONS) {
+        if (this.terminatedSessions.size >= this.maxTerminatedSessions) {
           const oldest = this.terminatedSessions.values().next().value;
           if (oldest) {
             this.terminatedSessions.delete(oldest);
@@ -8471,7 +8481,14 @@ async function handleWaitingFallback(deps, error) {
         );
       }
     }, ttl);
-    scope.elicitationStore.subscribeFallbackResult(
+    const store = scope.elicitationStore;
+    if (!store) {
+      resolved = true;
+      clearTimeout(timeoutHandle);
+      reject(new ElicitationStoreNotInitializedError());
+      return;
+    }
+    store.subscribeFallbackResult(
       error.elicitId,
       (result) => {
         if (!resolved) {
@@ -8552,7 +8569,7 @@ var init_tool_instance = __esm({
         this.name = record.metadata.id || record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         const meta = record.metadata;
         this.rawInputSchema = meta["rawInputSchema"];
@@ -9167,8 +9184,7 @@ var init_tools_list_flow = __esm({
           );
         }
         const sessionId = authInfo.sessionId;
-        const scope = this.scope;
-        const platformType = authInfo.sessionIdPayload?.platformType ?? (sessionId ? scope.notifications?.getPlatformType(sessionId) : void 0) ?? "unknown";
+        const platformType = authInfo.sessionIdPayload?.platformType ?? (sessionId ? this.scope.notifications?.getPlatformType(sessionId) : void 0) ?? "unknown";
         this.logger.verbose(`parseInput: detected platform=${platformType}`);
         const cursor = params?.cursor;
         if (cursor) this.logger.verbose(`parseInput: cursor=${cursor}`);
@@ -9275,8 +9291,7 @@ var init_tools_list_flow = __esm({
         try {
           const allResolved = this.state.required.resolvedTools;
           const platformType = this.state.platformType ?? "unknown";
-          const scope = this.scope;
-          const paginationConfig = scope.pagination?.tools;
+          const paginationConfig = this.scope.metadata.pagination?.tools;
           const usePagination = this.shouldPaginate(allResolved.length, paginationConfig);
           const sortedResolved = [...allResolved].sort((a, b) => a.finalName.localeCompare(b.finalName));
           let resolved = sortedResolved;
@@ -9336,12 +9351,12 @@ var init_tools_list_flow = __esm({
                 this.logger.warn(`parseTools: toolUI not available in scope for ${finalName}`);
                 return item;
               }
-              const scope2 = this.scope;
+              const scope = this.scope;
               let manifest;
               let detectedType;
               try {
-                manifest = scope2.toolUI.getManifest(finalName);
-                detectedType = scope2.toolUI.detectUIType(uiConfig.template);
+                manifest = scope.toolUI.getManifest(finalName);
+                detectedType = scope.toolUI.detectUIType(uiConfig.template);
               } catch (error) {
                 this.logger.warn(`parseTools: failed to access toolUI for ${finalName}`, error);
                 return item;
@@ -9858,8 +9873,11 @@ var init_call_tool_flow = __esm({
             const authInfo = this.state.authInfo;
             const authInfoWithTransport = authInfo;
             const sessionId = authInfo?.sessionId ?? "anonymous";
-            const scope = this.scope;
-            await scope.elicitationStore.setPendingFallback({
+            const store = this.scope.elicitationStore;
+            if (!store) {
+              throw new InternalMcpError("Elicitation store not initialized");
+            }
+            await store.setPendingFallback({
               elicitId: error.elicitId,
               sessionId,
               toolName: error.toolName,
@@ -9870,11 +9888,11 @@ var init_call_tool_flow = __esm({
               expiresAt: Date.now() + error.ttl
             });
             const transportType = authInfoWithTransport?.transport?.type;
-            if (transportType === "streamable-http" && canDeliverNotifications(scope, sessionId)) {
+            if (transportType === "streamable-http" && canDeliverNotifications(this.scope, sessionId)) {
               this.logger.info("execute: using waiting fallback for streamable-http", {
                 elicitId: error.elicitId
               });
-              const deps = { scope, sessionId, logger: this.logger };
+              const deps = { scope: this.scope, sessionId, logger: this.logger };
               const result = await handleWaitingFallback(deps, error);
               toolContext.output = result;
               this.logger.verbose("execute:done (elicitation waiting fallback)");
@@ -9984,6 +10002,10 @@ ${JSON.stringify(error.schema, null, 2)}
           const useStructuredContent = resolvedMode.useStructuredContent;
           let htmlContent;
           let uiMeta = {};
+          if (!scope.toolUI) {
+            this.logger.verbose("applyUI: toolUI not available, skipping UI rendering");
+            return;
+          }
           if (servingMode === "static") {
             this.logger.verbose("applyUI: UI using static mode (structured data only)", {
               tool: tool.metadata.name,
@@ -10201,8 +10223,8 @@ var init_send_elicitation_result_tool = __esm({
       async execute(input) {
         const { elicitId, action, content } = input;
         this.logger.info("sendElicitationResult: processing", { elicitId, action });
-        const scope = this.scope;
-        if (!scope?.elicitationStore) {
+        const store = this.scope.elicitationStore;
+        if (!store) {
           this.logger.error("sendElicitationResult: scope or elicitationStore not available");
           return {
             content: [
@@ -10214,7 +10236,7 @@ var init_send_elicitation_result_tool = __esm({
             isError: true
           };
         }
-        const pending = await scope.elicitationStore.getPendingFallback(elicitId);
+        const pending = await store.getPendingFallback(elicitId);
         if (!pending) {
           this.logger.warn("sendElicitationResult: no pending elicitation found", { elicitId });
           return {
@@ -10228,7 +10250,7 @@ var init_send_elicitation_result_tool = __esm({
           };
         }
         if (Date.now() > pending.expiresAt) {
-          await scope.elicitationStore.deletePendingFallback(elicitId);
+          await store.deletePendingFallback(elicitId);
           this.logger.warn("sendElicitationResult: elicitation expired", { elicitId });
           return {
             content: [
@@ -10244,8 +10266,8 @@ var init_send_elicitation_result_tool = __esm({
           status: action,
           ...action === "accept" && content !== void 0 && { content }
         };
-        await scope.elicitationStore.setResolvedResult(elicitId, elicitResult, pending.sessionId);
-        await scope.elicitationStore.deletePendingFallback(elicitId);
+        await store.setResolvedResult(elicitId, elicitResult, pending.sessionId);
+        await store.deletePendingFallback(elicitId);
         this.logger.info("sendElicitationResult: re-invoking original tool", {
           elicitId,
           toolName: pending.toolName
@@ -10255,7 +10277,7 @@ var init_send_elicitation_result_tool = __esm({
           ctx.setPreResolvedElicitResult(elicitResult);
         }
         try {
-          const toolResult = await scope.runFlowForOutput("tools:call-tool", {
+          const toolResult = await this.scope.runFlowForOutput("tools:call-tool", {
             request: {
               method: "tools/call",
               params: {
@@ -10270,19 +10292,19 @@ var init_send_elicitation_result_tool = __esm({
             elicitId,
             toolName: pending.toolName
           });
-          await scope.elicitationStore.publishFallbackResult(elicitId, pending.sessionId, {
+          await store.publishFallbackResult(elicitId, pending.sessionId, {
             success: true,
             result: toolResult
           });
-          await scope.elicitationStore.deleteResolvedResult(elicitId);
+          await store.deleteResolvedResult(elicitId);
           return toolResult;
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          await scope.elicitationStore.publishFallbackResult(elicitId, pending.sessionId, {
+          await store.publishFallbackResult(elicitId, pending.sessionId, {
             success: false,
             error: errorMessage
           });
-          await scope.elicitationStore.deleteResolvedResult(elicitId);
+          await store.deleteResolvedResult(elicitId);
           this.logger.error("sendElicitationResult: original tool failed", {
             elicitId,
             toolName: pending.toolName,
@@ -10984,7 +11006,7 @@ var init_resource_instance = __esm({
         this.name = record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this.providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.isTemplate = "uriTemplate" in record.metadata;
         if (this.isTemplate) {
           const templateMetadata = record.metadata;
@@ -11239,11 +11261,14 @@ var init_read_resource_flow = __esm({
         this.logger.info(`findResource: looking for resource with URI "${uri}"`);
         if (isUIResourceUri(uri)) {
           this.logger.info(`findResource: detected UI resource URI "${uri}"`);
-          const scope = this.scope;
           const { sessionId, authInfo } = this.state;
-          const platformType = authInfo?.sessionIdPayload?.platformType ?? (sessionId ? scope.notifications.getPlatformType(sessionId) : void 0);
+          const platformType = authInfo?.sessionIdPayload?.platformType ?? (sessionId ? this.scope.notifications.getPlatformType(sessionId) : void 0);
           this.logger.verbose(`findResource: platform type for session: ${platformType ?? "unknown"}`);
-          const uiResult = handleUIResourceRead(uri, scope.toolUI, platformType);
+          if (!this.scope.toolUI) {
+            this.logger.verbose("findResource: toolUI not available, skipping UI resource handling");
+            throw new ResourceNotFoundError(uri);
+          }
+          const uiResult = handleUIResourceRead(uri, this.scope.toolUI, platformType);
           if (uiResult.handled) {
             if (uiResult.error) {
               this.logger.warn(`findResource: UI resource error - ${uiResult.error}`);
@@ -12719,7 +12744,7 @@ var init_prompt_instance = __esm({
         this.name = record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.ready = this.initialize();
       }
       async initialize() {
@@ -18311,7 +18336,7 @@ var init_flow_instance = __esm({
         this.FlowClass = this.record.provide;
         this.ready = this.initialize();
         this.plan = this.record.metadata.plan;
-        this.hooks = scope.providers.getHooksRegistry();
+        this.hooks = scope.hooks;
         this.logger = scope.logger.child("FlowInstance");
       }
       async initialize() {
@@ -18679,8 +18704,8 @@ var init_flow_registry = __esm({
           const rec = this.defs.get(token);
           const deps = rec.metadata.dependsOn ?? [];
           for (const d of deps) {
-            if (d == ScopeEntry2) {
-              this.graph.get(token).add(ScopeEntry2);
+            if (d == ScopeEntry3) {
+              this.graph.get(token).add(ScopeEntry3);
             } else {
               if (!this.providers.get(d)) {
                 throw new RegistryDependencyNotRegisteredError("Flow", (0, import_di22.tokenName)(token), (0, import_di22.tokenName)(d));
@@ -19001,7 +19026,7 @@ var init_agent_scope = __esm({
             {
               scope: import_di23.ProviderScope.GLOBAL,
               name: "ScopeEntry",
-              provide: ScopeEntry2,
+              provide: ScopeEntry3,
               useValue: agentScopeEntry
             },
             // Also register as Scope so getActiveScope() returns the agent's scope
@@ -19112,6 +19137,12 @@ var init_agent_scope = __esm({
       get toolUI() {
         return this.parentScope.toolUI;
       }
+      get skills() {
+        return this.parentScope.skills;
+      }
+      get scopeMetadata() {
+        return this.parentScope.metadata;
+      }
       // ============================================================================
       // Flow Execution
       // ============================================================================
@@ -19170,18 +19201,42 @@ var init_agent_scope = __esm({
       get agents() {
         return this.agentScope.agents;
       }
+      get skills() {
+        return this.agentScope.skills;
+      }
       get notifications() {
         return this.agentScope.notifications;
       }
       get toolUI() {
         return this.agentScope.toolUI;
       }
+      get transportService() {
+        return void 0;
+      }
+      get rateLimitManager() {
+        return void 0;
+      }
+      get elicitationStore() {
+        return void 0;
+      }
+      get metadata() {
+        return this.agentScope.scopeMetadata;
+      }
+      get record() {
+        return void 0;
+      }
+      get ready() {
+        return this.agentScope.ready;
+      }
       registryFlows(...flows) {
         return this.agentScope.registryFlows(...flows);
       }
       runFlow(name33, input, deps) {
         return this.agentScope.runFlow(name33, input, deps);
       }
+      runFlowForOutput(name33, input, deps) {
+        return this.agentScope.runFlowForOutput(name33, input, deps);
+      }
     };
   }
 });
@@ -19229,7 +19284,7 @@ var init_agent_instance = __esm({
         this.id = record.metadata.id ?? record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this.providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         this.outputSchema = record.metadata.outputSchema;
         this.systemInstructions = record.metadata.systemInstructions;
@@ -27845,6 +27900,18 @@ var init_http_request_flow = __esm({
             this.respond(httpRespond.notFound("Session not found"));
             return;
           }
+          const authorization = request[ServerRequestTokens.auth];
+          if (authorization?.token) {
+            const transportService = this.scope.transportService;
+            if (transportService) {
+              for (const protocol of ["streamable-http", "sse"]) {
+                try {
+                  await transportService.destroyTransporter(protocol, authorization.token, sessionId);
+                } catch {
+                }
+              }
+            }
+          }
           this.logger.info(`[${this.requestId}] Session terminated: ${sessionId}`);
           this.respond(httpRespond.noContent());
         } catch (error) {
@@ -28022,8 +28089,13 @@ var init_transport_remote = __esm({
       async destroy(_reason) {
         throw new MethodNotImplementedError("RemoteTransporter", "destroy");
       }
+      get isInitialized() {
+        return false;
+      }
       markAsInitialized() {
       }
+      resetForReinitialization() {
+      }
     };
   }
 });
@@ -29379,12 +29451,25 @@ var init_transport_local_adapter = __esm({
       #requestId = 1;
       ready;
       server;
+      /**
+       * Whether this transport has already been initialized via the MCP initialize handshake.
+       * Override in subclasses that track initialization state.
+       */
+      get isInitialized() {
+        return false;
+      }
       /**
        * Marks this transport as pre-initialized for session recreation.
        * Override in subclasses that need to set the MCP SDK's _initialized flag.
        */
       markAsInitialized() {
       }
+      /**
+       * Resets initialization state to allow re-initialization.
+       * Override in subclasses that support session re-initialization.
+       */
+      resetForReinitialization() {
+      }
       connectServer() {
         const { info, apps } = this.scope.metadata;
         const hasRemoteApps = apps?.some((app) => this.isRemoteApp(app)) ?? false;
@@ -29473,8 +29558,13 @@ var init_transport_local_adapter = __esm({
       }
       ensureAuthInfo(req, transport) {
         const { token, user, session } = req[ServerRequestTokens.auth];
-        const sessionId = session?.id ?? `fallback:${Date.now()}`;
-        const sessionPayload = session?.payload ?? { protocol: "streamable-http" };
+        if (!session?.id) {
+          throw new Error(
+            "Session ID is required in ensureAuthInfo. This indicates a bug in session propagation \u2014 the session should have been set by the flow."
+          );
+        }
+        const sessionId = session.id;
+        const sessionPayload = session.payload ?? { protocol: "streamable-http" };
         if (this.initSessionPayload) {
           const init = this.initSessionPayload;
           if (init.supportsElicitation !== void 0 && sessionPayload.supportsElicitation === void 0) {
@@ -29509,6 +29599,17 @@ var init_transport_local_adapter = __esm({
       get elicitStore() {
         return this.scope.elicitationStore;
       }
+      /**
+       * Get the elicitation store, throwing if not initialized.
+       * Use in contexts where elicitation is required (sendElicitRequest, cancelPendingElicit).
+       */
+      requireElicitStore() {
+        const store = this.elicitStore;
+        if (!store) {
+          throw new Error("Elicitation store not initialized");
+        }
+        return store;
+      }
       /**
        * Cancel any pending elicitation request.
        * Called before sending a new elicit to enforce single-elicit-per-session.
@@ -29526,9 +29627,12 @@ var init_transport_local_adapter = __esm({
           clearTimeout(this.pendingElicit.timeoutHandle);
           this.pendingElicit.resolve({ status: "cancel" });
           const sessionId = this.key.sessionId;
-          const pending = await this.elicitStore.getPending(sessionId);
-          if (pending) {
-            await this.elicitStore.publishResult(pending.elicitId, sessionId, { status: "cancel" });
+          const store = this.elicitStore;
+          if (store) {
+            const pending = await store.getPending(sessionId);
+            if (pending) {
+              await store.publishResult(pending.elicitId, sessionId, { status: "cancel" });
+            }
           }
           this.pendingElicit = void 0;
           this.logger.info("Cancelled previous pending elicit");
@@ -30878,7 +30982,8 @@ var init_transport_sse_adapter = __esm({
         const elicitId = elicitationId ?? `elicit-${this.newRequestId}`;
         const sessionId = this.key.sessionId;
         const expiresAt = Date.now() + ttl;
-        await this.elicitStore.setPending({
+        const store = this.requireElicitStore();
+        await store.setPending({
           elicitId,
           sessionId,
           createdAt: Date.now(),
@@ -30921,10 +31026,10 @@ var init_transport_sse_adapter = __esm({
             settled = true;
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(new ElicitationTimeoutError(elicitId, ttl));
           }, ttl);
-          this.elicitStore.subscribeResult(
+          store.subscribeResult(
             elicitId,
             (result) => {
               safeResolve(result);
@@ -30938,7 +31043,7 @@ var init_transport_sse_adapter = __esm({
             clearTimeout(timeoutHandle);
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(err);
           });
           this.pendingElicit = {
@@ -31021,6 +31126,31 @@ var init_streamable_http_transport = __esm({
         }
         this._applyInitState(webTransport, sessionId);
       }
+      /**
+       * Resets the transport's initialization state to allow re-initialization.
+       *
+       * This is needed when a client reconnects after terminating its session:
+       * the cached transport is still marked as initialized, but the client
+       * needs to re-initialize. Resetting _initialized and sessionId allows
+       * the MCP SDK to process a fresh initialize request.
+       *
+       * This is the inverse of setInitializationState().
+       */
+      resetForReinitialization() {
+        const webTransport = this._webStandardTransport;
+        if (!webTransport) {
+          this._pendingInitState = void 0;
+          return;
+        }
+        if (!("_initialized" in webTransport)) {
+          throw new InvalidTransportSessionError(
+            "[RecreateableStreamableHTTPServerTransport] Expected _initialized field not found on internal transport. This may indicate an incompatible MCP SDK version."
+          );
+        }
+        webTransport._initialized = false;
+        webTransport.sessionId = void 0;
+        this._pendingInitState = void 0;
+      }
       /**
        * Applies initialization state to the internal transport.
        * @param webTransport - The internal _webStandardTransport object
@@ -31180,6 +31310,7 @@ var init_transport_streamable_http_adapter = __esm({
        */
       async sendElicitRequest(relatedRequestId, message, requestedSchema, options) {
         await this.cancelPendingElicit();
+        const store = this.requireElicitStore();
         const sessionId = this.key.sessionId;
         const flowOutput = await this.scope.runFlowForOutput("elicitation:request", {
           relatedRequestId,
@@ -31204,7 +31335,7 @@ var init_transport_streamable_http_adapter = __esm({
         } catch (error) {
           this.logger.error("[StreamableHttpAdapter] sendElicitRequest: transport.send() failed", error);
           try {
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             this.logger.verbose("[StreamableHttpAdapter] sendElicitRequest: cleaned up pending record after send failure");
           } catch (cleanupError) {
             this.logger.warn("[StreamableHttpAdapter] sendElicitRequest: failed to clean up pending record", cleanupError);
@@ -31236,10 +31367,10 @@ var init_transport_streamable_http_adapter = __esm({
             settled = true;
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(new ElicitationTimeoutError(elicitId, ttl));
           }, ttl);
-          this.elicitStore.subscribeResult(
+          store.subscribeResult(
             elicitId,
             (result) => {
               safeResolve(result);
@@ -31253,7 +31384,7 @@ var init_transport_streamable_http_adapter = __esm({
             clearTimeout(timeoutHandle);
             this.pendingElicit = void 0;
             await unsubscribe?.();
-            await this.elicitStore.deletePending(sessionId);
+            await store.deletePending(sessionId);
             reject(err);
           });
           this.pendingElicit = {
@@ -31264,6 +31395,20 @@ var init_transport_streamable_http_adapter = __esm({
           };
         });
       }
+      get isInitialized() {
+        return this.transport.isInitialized || this.transport.hasPendingInitState;
+      }
+      /**
+       * Resets the transport's initialization state to allow re-initialization.
+       * Used when a client retries initialize on an already-initialized session
+       * (e.g., after reconnect following session termination).
+       */
+      resetForReinitialization() {
+        this.transport.resetForReinitialization();
+        this.logger.info("[StreamableHttpAdapter] Reset transport for re-initialization", {
+          sessionId: this.key.sessionId?.slice(0, 20)
+        });
+      }
       /**
        * Marks this transport as pre-initialized for session recreation.
        * This is needed when recreating a transport from Redis because the
@@ -31338,6 +31483,9 @@ var init_transport_local = __esm({
           res.status(500).json(rpcError("Internal error"));
         }
       }
+      get isInitialized() {
+        return this.adapter.isInitialized;
+      }
       /**
        * Marks this transport as pre-initialized for session recreation.
        * This is needed when recreating a transport from Redis because the
@@ -31346,6 +31494,9 @@ var init_transport_local = __esm({
       markAsInitialized() {
         this.adapter.markAsInitialized();
       }
+      resetForReinitialization() {
+        this.adapter.resetForReinitialization();
+      }
       async destroy(reason) {
         try {
           await this.adapter.destroy(reason);
@@ -31730,6 +31881,79 @@ var init_ext_apps2 = __esm({
 });
 
 // libs/sdk/src/transport/flows/handle.streamable-http.flow.ts
+function resolveStreamableHttpSession(params) {
+  const { rawHeader, authorizationSession, createSession } = params;
+  const rawMcpSessionHeader = typeof rawHeader === "string" ? rawHeader : void 0;
+  const mcpSessionHeader = validateMcpSessionHeader(rawMcpSessionHeader);
+  if (rawHeader !== void 0 && !mcpSessionHeader) {
+    return { responded404: true, createdNew: false };
+  }
+  if (mcpSessionHeader) {
+    if (authorizationSession?.id === mcpSessionHeader) {
+      return { session: authorizationSession, createdNew: false, responded404: false };
+    }
+    return { session: { id: mcpSessionHeader }, createdNew: false, responded404: false };
+  }
+  if (authorizationSession) {
+    return { session: authorizationSession, createdNew: false, responded404: false };
+  }
+  return { session: createSession(), createdNew: true, responded404: false };
+}
+function classifyStreamableHttpRequest(params) {
+  const { method, body } = params;
+  if (method.toUpperCase() === "GET") {
+    return { requestType: "sseListener" };
+  }
+  const jsonRpcMethod = body?.method;
+  if (jsonRpcMethod === "initialize") {
+    return { requestType: "initialize" };
+  }
+  if (typeof jsonRpcMethod === "string" && jsonRpcMethod.startsWith("ui/")) {
+    return { requestType: "extApps" };
+  }
+  if (import_protocol38.ElicitResultSchema.safeParse(body?.result).success) {
+    return { requestType: "elicitResult" };
+  }
+  if (jsonRpcMethod && import_protocol38.RequestSchema.safeParse(body).success) {
+    return { requestType: "message" };
+  }
+  return { error: "Invalid Request" };
+}
+function syncStreamableHttpAuthorizationSession(authorization, session) {
+  if (!authorization.session) {
+    authorization.session = session;
+  }
+}
+async function lookupStreamableHttpTransport(params) {
+  const { transportService, token, sessionId, response } = params;
+  const inMemoryTransport = await transportService.getTransporter("streamable-http", token, sessionId);
+  if (inMemoryTransport) {
+    return { kind: "transport", source: "memory", transport: inMemoryTransport };
+  }
+  let recreationError;
+  try {
+    const storedSession = await transportService.getStoredSession("streamable-http", token, sessionId);
+    if (storedSession) {
+      const recreatedTransport = await transportService.recreateTransporter(
+        "streamable-http",
+        token,
+        sessionId,
+        storedSession,
+        response
+      );
+      if (recreatedTransport) {
+        return { kind: "transport", source: "redis", transport: recreatedTransport };
+      }
+    }
+  } catch (error) {
+    recreationError = error;
+  }
+  const wasCreated = await transportService.wasSessionCreatedAsync("streamable-http", token, sessionId);
+  if (wasCreated) {
+    return { kind: "session-expired", recreationError };
+  }
+  return { kind: "session-not-initialized", recreationError };
+}
 var import_zod62, import_protocol38, plan19, stateSessionSchema, stateSchema18, name20, Stage20, HandleStreamableHttpFlow;
 var init_handle_streamable_http_flow = __esm({
   "libs/sdk/src/transport/flows/handle.streamable-http.flow.ts"() {
@@ -31773,64 +31997,60 @@ var init_handle_streamable_http_flow = __esm({
         const authorization = request[ServerRequestTokens.auth];
         const { token } = authorization;
         const logger = this.scopeLogger.child("handle:streamable-http:parseInput");
-        const raw = request.headers?.["mcp-session-id"];
-        const rawMcpSessionHeader = typeof raw === "string" ? raw : void 0;
-        const mcpSessionHeader = validateMcpSessionHeader(rawMcpSessionHeader);
-        if (raw !== void 0 && !mcpSessionHeader) {
+        const sessionResolution = resolveStreamableHttpSession({
+          rawHeader: request.headers?.["mcp-session-id"],
+          authorizationSession: authorization.session,
+          createSession: () => {
+            const query = request.query;
+            const skillsOnlyMode = detectSkillsOnlyMode(query);
+            return createSessionId("streamable-http", token, {
+              userAgent: request.headers?.["user-agent"],
+              platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
+              skillsOnlyMode
+            });
+          }
+        });
+        if (sessionResolution.responded404 || !sessionResolution.session) {
           logger.warn("parseInput: invalid mcp-session-id header");
           this.respond(httpRespond.sessionNotFound("invalid session id"));
           return;
         }
-        let session;
-        if (mcpSessionHeader) {
-          if (authorization.session?.id === mcpSessionHeader) {
-            session = authorization.session;
-          } else {
-            session = { id: mcpSessionHeader };
-          }
-        } else if (authorization.session) {
-          session = authorization.session;
-        } else {
-          const query = request.query;
-          const skillsOnlyMode = detectSkillsOnlyMode(query);
-          session = createSessionId("streamable-http", token, {
-            userAgent: request.headers?.["user-agent"],
-            platformDetectionConfig: this.scope.metadata.transport?.platformDetection,
-            skillsOnlyMode
-          });
-        }
+        const session = sessionResolution.session;
         this.state.set(stateSchema18.parse({ token, session }));
         logger.info("parseInput: session resolved", { sessionId: session.id?.slice(0, 20) });
       }
       async router() {
         const { request } = this.rawInput;
         const logger = this.scopeLogger.child("handle:streamable-http:router");
-        if (request.method.toUpperCase() === "GET") {
-          this.state.set("requestType", "sseListener");
-          logger.info("router: requestType=sseListener, method=GET");
+        const classification = classifyStreamableHttpRequest({
+          method: request.method,
+          body: request.body
+        });
+        if ("error" in classification) {
+          logger.warn("router: invalid request, no valid method");
+          this.respond(httpRespond.rpcError("Invalid Request"));
           return;
         }
-        const body = request.body;
-        const method = body?.method;
-        if (method === "initialize") {
-          this.state.set("requestType", "initialize");
+        this.state.set("requestType", classification.requestType);
+        if (classification.requestType === "sseListener") {
+          logger.info("router: requestType=sseListener, method=GET");
+        } else if (classification.requestType === "initialize") {
           logger.info("router: requestType=initialize, method=POST");
-        } else if (typeof method === "string" && method.startsWith("ui/")) {
-          this.state.set("requestType", "extApps");
+        } else if (classification.requestType === "extApps") {
+          const method = request.body?.method;
           logger.info(`router: requestType=extApps, method=${method}`);
-        } else if (import_protocol38.ElicitResultSchema.safeParse(request.body?.result).success) {
-          this.state.set("requestType", "elicitResult");
+        } else if (classification.requestType === "elicitResult") {
           logger.info("router: requestType=elicitResult, method=POST");
-        } else if (method && import_protocol38.RequestSchema.safeParse(request.body).success) {
-          this.state.set("requestType", "message");
-          logger.info(`router: requestType=message, method=${method}`);
         } else {
-          logger.warn("router: invalid request, no valid method");
-          this.respond(httpRespond.rpcError("Invalid Request"));
+          const method = request.body?.method;
+          logger.info(`router: requestType=message, method=${method}`);
         }
       }
       async onInitialize() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scope.logger.child("handle:streamable-http:onInitialize");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -31840,7 +32060,15 @@ var init_handle_streamable_http_flow = __esm({
           tokenPrefix: token?.slice(0, 10)
         });
         try {
+          const authorization = request[ServerRequestTokens.auth];
+          syncStreamableHttpAuthorizationSession(authorization, session);
           const transport = await transportService.createTransporter("streamable-http", token, session.id, response);
+          if (transport.isInitialized) {
+            logger.info("onInitialize: transport already initialized, resetting for re-initialization", {
+              sessionId: session.id?.slice(0, 20)
+            });
+            transport.resetForReinitialization();
+          }
           logger.info("onInitialize: transport created, calling initialize");
           await transport.initialize(request, response);
           logger.info("onInitialize: completed successfully");
@@ -31858,6 +32086,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onElicitResult() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onElicitResult");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -31908,6 +32139,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onMessage() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onMessage");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -31915,44 +32149,21 @@ var init_handle_streamable_http_flow = __esm({
           sessionId: session.id?.slice(0, 20),
           hasToken: !!token
         });
-        let transport = await transportService.getTransporter("streamable-http", token, session.id);
-        logger.verbose("onMessage: getTransporter result", { found: !!transport });
-        if (!transport) {
-          try {
-            logger.verbose("onMessage: transport not in memory, checking Redis", {
-              sessionId: session.id?.slice(0, 20)
-            });
-            const storedSession = await transportService.getStoredSession("streamable-http", token, session.id);
-            logger.verbose("onMessage: getStoredSession result", {
-              found: !!storedSession,
-              initialized: storedSession?.initialized
-            });
-            if (storedSession) {
-              logger.verbose("onMessage: recreating transport from stored session", {
-                sessionId: session.id?.slice(0, 20),
-                createdAt: storedSession.createdAt,
-                initialized: storedSession.initialized
-              });
-              transport = await transportService.recreateTransporter(
-                "streamable-http",
-                token,
-                session.id,
-                storedSession,
-                response
-              );
-              logger.verbose("onMessage: transport recreated successfully");
-            }
-          } catch (error) {
+        const transportLookup = await lookupStreamableHttpTransport({
+          transportService,
+          token,
+          sessionId: session.id,
+          response
+        });
+        if (transportLookup.kind !== "transport") {
+          const body = request.body;
+          if (transportLookup.recreationError) {
             logger.warn("Failed to recreate transport from stored session", {
               sessionId: session.id?.slice(0, 20),
-              error: error instanceof Error ? error.message : String(error)
+              error: transportLookup.recreationError instanceof Error ? transportLookup.recreationError.message : String(transportLookup.recreationError)
             });
           }
-        }
-        if (!transport) {
-          const wasCreated = await transportService.wasSessionCreatedAsync("streamable-http", token, session.id);
-          const body = request.body;
-          if (wasCreated) {
+          if (transportLookup.kind === "session-expired") {
             logger.info("Session expired - client should re-initialize", {
               sessionId: session.id?.slice(0, 20),
               tokenHash: token.slice(0, 8),
@@ -31974,6 +32185,8 @@ var init_handle_streamable_http_flow = __esm({
           }
           return;
         }
+        const transport = transportLookup.transport;
+        logger.verbose("onMessage: transport resolved", { source: transportLookup.source });
         try {
           await transport.handleRequest(request, response);
           this.handled();
@@ -31992,6 +32205,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onSseListener() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onSseListener");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -32029,6 +32245,9 @@ var init_handle_streamable_http_flow = __esm({
       }
       async onExtApps() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:streamable-http:onExtApps");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -32079,8 +32298,7 @@ var init_handle_streamable_http_flow = __esm({
           }
           return;
         }
-        const scope = this.scope;
-        const configuredCapabilities = scope.metadata.extApps?.hostCapabilities;
+        const configuredCapabilities = this.scope.metadata.extApps?.hostCapabilities;
         const hostCapabilities = {
           serverToolProxy: configuredCapabilities?.serverToolProxy ?? true,
           logging: configuredCapabilities?.logging ?? true,
@@ -32089,9 +32307,9 @@ var init_handle_streamable_http_flow = __esm({
         const handler = createExtAppsMessageHandler({
           context: {
             sessionId: session.id,
-            logger: scope.logger,
+            logger: this.scope.logger,
             callTool: async (name33, args) => {
-              const result = await scope.runFlow("tools:call-tool", {
+              const result = await this.scope.runFlow("tools:call-tool", {
                 request: { method: "tools/call", params: { name: name33, arguments: args } },
                 ctx: {
                   authInfo: {
@@ -32177,6 +32395,7 @@ var init_handle_sse_flow = __esm({
     "use strict";
     init_common();
     import_zod63 = require("zod");
+    init_errors();
     init_session_id_utils();
     init_skill_mode_utils();
     plan20 = {
@@ -32246,10 +32465,9 @@ var init_handle_sse_flow = __esm({
       }
       async router() {
         const { request } = this.rawInput;
-        const scope = this.scope;
         const requestPath = normalizeEntryPrefix(request.path);
-        const prefix = normalizeEntryPrefix(scope.entryPath);
-        const scopePath = normalizeScopeBase(scope.routeBase);
+        const prefix = normalizeEntryPrefix(this.scope.entryPath);
+        const scopePath = normalizeScopeBase(this.scope.routeBase);
         const basePath = `${prefix}${scopePath}`;
         if (requestPath === `${basePath}/sse`) {
           this.state.set("requestType", "initialize");
@@ -32259,6 +32477,9 @@ var init_handle_sse_flow = __esm({
       }
       async onInitialize() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
         const transport = await transportService.createTransporter("sse", token, session.id, response);
@@ -32270,6 +32491,9 @@ var init_handle_sse_flow = __esm({
       }
       async onMessage() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scopeLogger.child("handle:legacy-sse:onMessage");
         const { request, response } = this.rawInput;
         const { token, session } = this.state.required;
@@ -32342,6 +32566,7 @@ var init_handle_stateless_http_flow = __esm({
     init_common();
     import_zod64 = require("zod");
     import_protocol39 = require("@frontmcp/protocol");
+    init_errors();
     plan21 = {
       pre: ["parseInput", "router"],
       execute: ["handleRequest"],
@@ -32389,6 +32614,9 @@ var init_handle_stateless_http_flow = __esm({
       }
       async handleRequest() {
         const transportService = this.scope.transportService;
+        if (!transportService) {
+          throw new TransportServiceNotAvailableError();
+        }
         const logger = this.scope.logger.child("HandleStatelessHttpFlow");
         const { request, response } = this.rawInput;
         const { token, isAuthenticated, requestType } = this.state;
@@ -36079,11 +36307,10 @@ var init_call_agent_flow = __esm({
           throw new InvalidMethodError(method, "tools/call");
         }
         const { name: toolName } = params;
-        const scope = this.scope;
         const agentId = toolName;
         let agent;
-        if (scope.agents) {
-          agent = scope.agents.findById(agentId) ?? scope.agents.findByName(agentId);
+        if (this.scope.agents) {
+          agent = this.scope.agents.findById(agentId) ?? this.scope.agents.findByName(agentId);
         }
         const agentOwnerId = agent?.owner?.id;
         const progressToken = params._meta?.progressToken;
@@ -36099,8 +36326,7 @@ var init_call_agent_flow = __esm({
       }
       async findAgent() {
         this.logger.verbose("findAgent:start");
-        const scope = this.scope;
-        const agents = scope.agents;
+        const agents = this.scope.agents;
         if (!agents) {
           this.logger.warn("findAgent: no agent registry available");
           throw new AgentNotFoundError(this.state.required.input.name);
@@ -36521,7 +36747,10 @@ var init_elicitation_request_flow = __esm({
       async storePendingRecord() {
         this.logger.verbose("storePendingRecord:start");
         const { elicitId, sessionId, message, mode, expiresAt, requestedSchema } = this.state.required;
-        const scope = this.scope;
+        const store = this.scope.elicitationStore;
+        if (!store) {
+          throw new ElicitationStoreNotInitializedError();
+        }
         const pendingRecord = {
           elicitId,
           sessionId,
@@ -36531,7 +36760,7 @@ var init_elicitation_request_flow = __esm({
           mode,
           requestedSchema
         };
-        await scope.elicitationStore.setPending(pendingRecord);
+        await store.setPending(pendingRecord);
         this.state.set("pendingRecord", pendingRecord);
         this.logger.verbose("storePendingRecord:done", { elicitId, sessionId });
       }
@@ -36658,8 +36887,11 @@ var init_elicitation_result_flow = __esm({
       async lookupPending() {
         this.logger.verbose("lookupPending:start");
         const { sessionId } = this.state.required;
-        const scope = this.scope;
-        const pendingRecord = await scope.elicitationStore.getPending(sessionId);
+        const store = this.scope.elicitationStore;
+        if (!store) {
+          throw new ElicitationStoreNotInitializedError();
+        }
+        const pendingRecord = await store.getPending(sessionId);
         this.state.set("pendingRecord", pendingRecord ?? void 0);
         if (!pendingRecord) {
           this.logger.verbose("lookupPending:notFound", { sessionId });
@@ -36711,14 +36943,14 @@ var init_elicitation_result_flow = __esm({
         this.logger.verbose("publishResult:start");
         const { pendingRecord, elicitResult } = this.state;
         const { sessionId } = this.state.required;
-        const scope = this.scope;
-        if (!pendingRecord || !elicitResult) {
+        const store = this.scope.elicitationStore;
+        if (!pendingRecord || !elicitResult || !store) {
           this.state.set("handled", false);
           this.logger.verbose("publishResult:skip (no pending or no result)");
           return;
         }
         try {
-          await scope.elicitationStore.publishResult(pendingRecord.elicitId, sessionId, elicitResult);
+          await store.publishResult(pendingRecord.elicitId, sessionId, elicitResult);
           this.state.set("handled", true);
           this.logger.verbose("publishResult:done", {
             elicitId: pendingRecord.elicitId,
@@ -38112,7 +38344,7 @@ var init_job_instance = __esm({
         this.name = record.metadata.id || record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.inputSchema = record.metadata.inputSchema ?? {};
         this.outputSchema = record.metadata.outputSchema ?? {};
         this.ready = this.initialize();
@@ -38499,7 +38731,7 @@ var init_workflow_instance = __esm({
         this.name = record.metadata.id || record.metadata.name;
         this.fullName = this.owner.id + ":" + this.name;
         this.scope = this._providers.getActiveScope();
-        this.hooks = this.scope.providers.getHooksRegistry();
+        this.hooks = this.scope.hooks;
         this.ready = this.initialize();
       }
       async initialize() {
@@ -40156,14 +40388,13 @@ var init_scope_instance = __esm({
     init_plugin_registry();
     init_elicitation2();
     init_flows2();
-    init_elicitation_error();
     init_send_elicitation_result_tool();
     init_tool_utils();
     init_tool_instance();
     init_event_stores();
     init_job_scope_helper();
     import_guard6 = require("@frontmcp/guard");
-    Scope = class _Scope extends ScopeEntry2 {
+    Scope = class _Scope extends ScopeEntry3 {
       id;
       globalProviders;
       logger;
@@ -40572,7 +40803,7 @@ var init_scope_instance = __esm({
           {
             scope: import_di4.ProviderScope.GLOBAL,
             name: "ScopeEntry",
-            provide: ScopeEntry2,
+            provide: ScopeEntry3,
             useValue: this
           },
           {
@@ -40669,9 +40900,6 @@ var init_scope_instance = __esm({
        * @see createElicitationStore for factory implementation details
        */
       get elicitationStore() {
-        if (!this._elicitationStore) {
-          throw new ElicitationStoreNotInitializedError();
-        }
         return this._elicitationStore;
       }
       /**
@@ -42532,7 +42760,13 @@ var init_front_mcp = __esm({
         return this.scopes.getScopes();
       }
       static async bootstrap(options) {
-        const frontMcp = new _FrontMcpInstance2(options);
+        const parsedConfig = frontMcpMetadataSchema.parse(options);
+        const daemonSocket = process.env["FRONTMCP_DAEMON_SOCKET"];
+        if (daemonSocket) {
+          await _FrontMcpInstance2.runUnixSocket({ ...parsedConfig, socketPath: daemonSocket });
+          return;
+        }
+        const frontMcp = new _FrontMcpInstance2(parsedConfig);
         await frontMcp.ready;
         await frontMcp.start();
         frontMcp.log?.info("FrontMCP bootstrap complete");
@@ -43606,7 +43840,7 @@ var init_front_mcp_interface = __esm({
 });
 
 // libs/sdk/src/common/interfaces/server.interface.ts
-var import_protocol44, ServerRequest11, ServerResponse3, FrontMcpServer;
+var import_protocol44, ServerRequest11, ServerResponse4, FrontMcpServer;
 var init_server_interface = __esm({
   "libs/sdk/src/common/interfaces/server.interface.ts"() {
     "use strict";
@@ -43617,7 +43851,7 @@ var init_server_interface = __esm({
       body;
       authSession;
     };
-    ServerResponse3 = class extends import_protocol44.HttpServerResponse {
+    ServerResponse4 = class extends import_protocol44.HttpServerResponse {
     };
     FrontMcpServer = class {
     };
@@ -45563,13 +45797,13 @@ var init_dynamic = __esm({
 });
 
 // libs/sdk/src/common/entries/scope.entry.ts
-var ScopeEntry2;
+var ScopeEntry3;
 var init_scope_entry = __esm({
   "libs/sdk/src/common/entries/scope.entry.ts"() {
     "use strict";
     init_base_entry();
     init_utils2();
-    ScopeEntry2 = class extends BaseEntry {
+    ScopeEntry3 = class extends BaseEntry {
       get fullPath() {
         const prefix = normalizeEntryPrefix(this.entryPath ?? "");
         const scope = normalizeScopeBase(this.routeBase ?? "");
@@ -46609,12 +46843,12 @@ __export(index_exports, {
   ResourceTemplateKind: () => ResourceTemplateKind,
   ScopeConfigurationError: () => ScopeConfigurationError,
   ScopeDeniedError: () => import_auth11.ScopeDeniedError,
-  ScopeEntry: () => ScopeEntry2,
+  ScopeEntry: () => ScopeEntry3,
   ScopeKind: () => ScopeKind,
   ServerNotFoundError: () => ServerNotFoundError,
   ServerRequest: () => ServerRequest11,
   ServerRequestTokens: () => ServerRequestTokens,
-  ServerResponse: () => ServerResponse3,
+  ServerResponse: () => ServerResponse4,
   ServerlessHandlerNotInitializedError: () => ServerlessHandlerNotInitializedError,
   SessionHookStage: () => SessionHookStage,
   SessionIdEmptyError: () => import_auth11.SessionIdEmptyError,
@@ -46647,6 +46881,7 @@ __export(index_exports, {
   TransportAlreadyStartedError: () => TransportAlreadyStartedError,
   TransportBusRequiredError: () => TransportBusRequiredError,
   TransportNotConnectedError: () => TransportNotConnectedError,
+  TransportServiceNotAvailableError: () => TransportServiceNotAvailableError,
   UnauthorizedError: () => UnauthorizedError,
   UnsupportedClientVersionError: () => UnsupportedClientVersionError,
   UnsupportedContentTypeError: () => UnsupportedContentTypeError,
@@ -47498,6 +47733,7 @@ var AgentCallHook = FlowHooksOf("agents:call-agent");
   TransportAlreadyStartedError,
   TransportBusRequiredError,
   TransportNotConnectedError,
+  TransportServiceNotAvailableError,
   UnauthorizedError,
   UnsupportedClientVersionError,
   UnsupportedContentTypeError,