@mcp-web/bridge 0.1.0

package/dist/core.js

@@ -0,0 +1,1508 @@
+/**
+ * @fileoverview MCPWebBridge - Runtime-agnostic core for the MCP Web Bridge.
+ *
+ * This module provides the core bridge functionality that connects web frontends
+ * to AI agents via the Model Context Protocol (MCP). The bridge acts as an
+ * intermediary, handling WebSocket connections from frontends and HTTP requests
+ * from MCP clients.
+ * @module @mcp-web/bridge
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MCPWebBridge_instances, _a, _MCPWebBridge_sessions, _MCPWebBridge_queries, _MCPWebBridge_config, _MCPWebBridge_scheduler, _MCPWebBridge_tokenSessionIds, _MCPWebBridge_tokenQueryCounts, _MCPWebBridge_sessionTimeoutIntervalId, _MCPWebBridge_toolResponseHandlers, _MCPWebBridge_resourceResponseHandlers, _MCPWebBridge_mcpSessions, _MCPWebBridge_mcpSessionTimeoutIntervalId, _MCPWebBridge_resolvedIcon, _MCPWebBridge_iconReady, _MCPWebBridge_handleWebSocketConnect, _MCPWebBridge_handleWebSocketMessage, _MCPWebBridge_handleWebSocketClose, _MCPWebBridge_handleFrontendMessage, _MCPWebBridge_handleAuthentication, _MCPWebBridge_handleToolRegistration, _MCPWebBridge_handleResourceRegistration, _MCPWebBridge_handleActivity, _MCPWebBridge_handleQueryCancel, _MCPWebBridge_handleQuery, _MCPWebBridge_handleHttpRequest, _MCPWebBridge_handleQueryProgressEndpoint, _MCPWebBridge_handleQueryCompleteEndpoint, _MCPWebBridge_handleQueryFailEndpoint, _MCPWebBridge_handleQueryCancelEndpoint, _MCPWebBridge_handleMCPRequest, _MCPWebBridge_mcpSuccessResponse, _MCPWebBridge_mcpSuccessResponseWithHeaders, _MCPWebBridge_mcpErrorResponse, _MCPWebBridge_wrapToolCallResult, _MCPWebBridge_getVersion, _MCPWebBridge_resolveIcon, _MCPWebBridge_getIcon, _MCPWebBridge_handleInitialize, _MCPWebBridge_getSessionAndSessionId, _MCPWebBridge_getSessionFromMetaParams, _MCPWebBridge_createSessionNotFoundError, _MCPWebBridge_handleToolsList, _MCPWebBridge_handleToolCall, _MCPWebBridge_handleResourcesList, _MCPWebBridge_handleResourceRead, _MCPWebBridge_listSessions, _MCPWebBridge_handlePromptsList, _MCPWebBridge_forwardToolCallToSession, _MCPWebBridge_forwardResourceReadToSession, _MCPWebBridge_decrementQueryCount, _MCPWebBridge_decrementQueryCountForQuery, _MCPWebBridge_closeOldestSessionForToken, _MCPWebBridge_cleanupSession, _MCPWebBridge_startSessionTimeoutChecker, _MCPWebBridge_startMcpSessionTimeoutChecker, _MCPWebBridge_notifyToolsChanged, _MCPWebBridge_handleSSEStream, _MCPWebBridge_handleMcpSessionDelete;
+import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, URL } from 'node:url';
+import { InternalErrorCode, InvalidSessionErrorCode, McpWebConfigSchema, MissingAuthenticationErrorCode, NoSessionsFoundErrorCode, QueryAcceptedMessageSchema, QueryCancelMessageSchema, QueryCompleteBridgeMessageSchema, QueryCompleteClientMessageSchema, QueryFailureMessageSchema, QueryLimitExceededErrorCode, QueryMessageSchema, QueryNotActiveErrorCode, QueryNotFoundErrorCode, QueryProgressMessageSchema, SessionExpiredErrorCode, SessionLimitExceededErrorCode, SessionNameAlreadyInUseErrorCode, SessionNotFoundErrorCode, SessionNotSpecifiedErrorCode, ToolNameRequiredErrorCode, ToolNotAllowedErrorCode, ToolNotFoundErrorCode, ToolSchemaConflictErrorCode, UnknownMethodErrorCode, } from '@mcp-web/types';
+import { NoopScheduler } from './runtime/scheduler.js';
+import { jsonResponse, sseResponse } from './runtime/types.js';
+const SessionNotSpecifiedErrorDetails = 'Multiple sessions available. See `available_sessions` or call the `list_sessions` tool to discover available sessions and specify the session using `_meta.sessionId`.';
+// ============================================
+// Helper Functions
+// ============================================
+/**
+ * Builds the query URL by appending the UUID to the agent URL.
+ * If no protocol is specified, defaults to http://.
+ */
+const buildQueryUrl = (agentUrl, uuid) => {
+    // Add http:// if no protocol specified
+    const urlWithProtocol = agentUrl.includes('://') ? agentUrl : `http://${agentUrl}`;
+    const url = new URL(urlWithProtocol);
+    if (url.pathname === '/' || url.pathname === '') {
+        url.pathname = '/query';
+    }
+    if (url.pathname.endsWith('/')) {
+        url.pathname = url.pathname.slice(0, -1);
+    }
+    url.pathname = `${url.pathname}/${uuid}`;
+    return url.toString();
+};
+// ============================================
+// MCPWebBridge Core Class
+// ============================================
+/**
+ * Core bridge server that connects web frontends to AI agents via MCP.
+ *
+ * MCPWebBridge manages WebSocket connections from frontends, routes tool calls,
+ * handles queries, and exposes an HTTP API for MCP clients. It is runtime-agnostic
+ * and delegates I/O operations to adapters.
+ *
+ * @example Using with Node.js adapter (recommended)
+ * ```typescript
+ * import { MCPWebBridgeNode } from '@mcp-web/bridge';
+ *
+ * const bridge = new MCPWebBridgeNode({
+ *   name: 'My App Bridge',
+ *   description: 'Bridge for my web application',
+ * });
+ * ```
+ *
+ * @example Using core class with custom adapter
+ * ```typescript
+ * import { MCPWebBridge } from '@mcp-web/bridge';
+ *
+ * const bridge = new MCPWebBridge(config);
+ * const handlers = bridge.getHandlers();
+ * // Wire handlers to your runtime's WebSocket/HTTP servers
+ * ```
+ */
+export class MCPWebBridge {
+    /**
+     * Creates a new MCPWebBridge instance.
+     *
+     * @param config - Bridge configuration options
+     * @param scheduler - Optional scheduler for timing operations (used for testing)
+     * @throws {Error} If configuration validation fails
+     */
+    constructor(config, scheduler) {
+        _MCPWebBridge_instances.add(this);
+        _MCPWebBridge_sessions.set(this, new Map());
+        _MCPWebBridge_queries.set(this, new Map());
+        _MCPWebBridge_config.set(this, void 0);
+        _MCPWebBridge_scheduler.set(this, void 0);
+        // Session & Query limit tracking
+        _MCPWebBridge_tokenSessionIds.set(this, new Map());
+        _MCPWebBridge_tokenQueryCounts.set(this, new Map());
+        _MCPWebBridge_sessionTimeoutIntervalId.set(this, void 0);
+        // Message handlers for tool responses (keyed by requestId)
+        _MCPWebBridge_toolResponseHandlers.set(this, new Map());
+        // Message handlers for resource responses (keyed by requestId)
+        _MCPWebBridge_resourceResponseHandlers.set(this, new Map());
+        // MCP protocol sessions (Remote MCP / Streamable HTTP)
+        _MCPWebBridge_mcpSessions.set(this, new Map());
+        _MCPWebBridge_mcpSessionTimeoutIntervalId.set(this, void 0);
+        // Resolved icon (data URI), populated asynchronously if icon is a URL
+        _MCPWebBridge_resolvedIcon.set(this, void 0);
+        _MCPWebBridge_iconReady.set(this, void 0);
+        const parsedConfig = McpWebConfigSchema.safeParse(config);
+        if (!parsedConfig.success) {
+            throw new Error(`Invalid bridge server configuration: ${parsedConfig.error.message}`);
+        }
+        __classPrivateFieldSet(this, _MCPWebBridge_config, parsedConfig.data, "f");
+        __classPrivateFieldSet(this, _MCPWebBridge_scheduler, scheduler ?? new NoopScheduler(), "f");
+        // Resolve icon: if it's a URL, fetch and convert to base64 data URI
+        __classPrivateFieldSet(this, _MCPWebBridge_iconReady, __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_resolveIcon).call(this), "f");
+        // Start session timeout checker if configured
+        if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").sessionMaxDurationMs) {
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_startSessionTimeoutChecker).call(this);
+        }
+        // Start MCP session idle timeout checker
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_startMcpSessionTimeoutChecker).call(this);
+    }
+    /**
+     * The validated bridge configuration.
+     * @returns The complete configuration object with defaults applied
+     */
+    get config() {
+        return __classPrivateFieldGet(this, _MCPWebBridge_config, "f");
+    }
+    /**
+     * Returns handlers for wiring to runtime-specific I/O.
+     *
+     * Use these handlers to connect the bridge to your runtime's WebSocket
+     * and HTTP servers. Pre-built adapters (Node, Bun, Deno, PartyKit) handle
+     * this automatically.
+     *
+     * @returns Object containing WebSocket and HTTP handlers
+     */
+    getHandlers() {
+        return {
+            onWebSocketConnect: (sessionId, ws, url) => __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleWebSocketConnect).call(this, sessionId, ws, url),
+            onWebSocketMessage: (sessionId, ws, data) => __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleWebSocketMessage).call(this, sessionId, ws, data),
+            onWebSocketClose: (sessionId) => __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleWebSocketClose).call(this, sessionId),
+            onHttpRequest: (req) => __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleHttpRequest).call(this, req),
+        };
+    }
+    /**
+     * Gracefully shuts down the bridge.
+     *
+     * Closes all WebSocket connections, cancels scheduled tasks, and clears
+     * all internal state. Call this when shutting down your server.
+     *
+     * @returns Promise that resolves when shutdown is complete
+     */
+    async close() {
+        // Stop session timeout checker
+        if (__classPrivateFieldGet(this, _MCPWebBridge_sessionTimeoutIntervalId, "f")) {
+            __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").cancelInterval(__classPrivateFieldGet(this, _MCPWebBridge_sessionTimeoutIntervalId, "f"));
+            __classPrivateFieldSet(this, _MCPWebBridge_sessionTimeoutIntervalId, undefined, "f");
+        }
+        // Stop MCP session timeout checker
+        if (__classPrivateFieldGet(this, _MCPWebBridge_mcpSessionTimeoutIntervalId, "f")) {
+            __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").cancelInterval(__classPrivateFieldGet(this, _MCPWebBridge_mcpSessionTimeoutIntervalId, "f"));
+            __classPrivateFieldSet(this, _MCPWebBridge_mcpSessionTimeoutIntervalId, undefined, "f");
+        }
+        // Close all WebSocket connections
+        for (const session of __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").values()) {
+            if (session.ws.readyState === 'OPEN') {
+                session.ws.close(1000, 'Server shutting down');
+            }
+        }
+        __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").clear();
+        // Clean up MCP sessions (close SSE streams)
+        for (const mcpSession of __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").values()) {
+            if (mcpSession.sseCleanup) {
+                mcpSession.sseCleanup();
+            }
+        }
+        __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").clear();
+        // Clear queries and tracking maps
+        __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").clear();
+        __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").clear();
+        __classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").clear();
+        __classPrivateFieldGet(this, _MCPWebBridge_toolResponseHandlers, "f").clear();
+        // Dispose scheduler
+        __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").dispose();
+    }
+}
+_a = MCPWebBridge, _MCPWebBridge_sessions = new WeakMap(), _MCPWebBridge_queries = new WeakMap(), _MCPWebBridge_config = new WeakMap(), _MCPWebBridge_scheduler = new WeakMap(), _MCPWebBridge_tokenSessionIds = new WeakMap(), _MCPWebBridge_tokenQueryCounts = new WeakMap(), _MCPWebBridge_sessionTimeoutIntervalId = new WeakMap(), _MCPWebBridge_toolResponseHandlers = new WeakMap(), _MCPWebBridge_resourceResponseHandlers = new WeakMap(), _MCPWebBridge_mcpSessions = new WeakMap(), _MCPWebBridge_mcpSessionTimeoutIntervalId = new WeakMap(), _MCPWebBridge_resolvedIcon = new WeakMap(), _MCPWebBridge_iconReady = new WeakMap(), _MCPWebBridge_instances = new WeakSet(), _MCPWebBridge_handleWebSocketConnect = function _MCPWebBridge_handleWebSocketConnect(_sessionId, _ws, url) {
+    const session = url.searchParams.get('session');
+    if (!session) {
+        return false;
+    }
+    return true;
+}, _MCPWebBridge_handleWebSocketMessage = function _MCPWebBridge_handleWebSocketMessage(sessionId, ws, data) {
+    try {
+        const message = JSON.parse(data);
+        // Check if this is a tool response
+        if (message.type === 'tool-response') {
+            const handler = __classPrivateFieldGet(this, _MCPWebBridge_toolResponseHandlers, "f").get(message.requestId);
+            if (handler) {
+                handler(data);
+                return;
+            }
+        }
+        // Check if this is a resource response
+        if (message.type === 'resource-response') {
+            const handler = __classPrivateFieldGet(this, _MCPWebBridge_resourceResponseHandlers, "f").get(message.requestId);
+            if (handler) {
+                handler(data);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleFrontendMessage).call(this, sessionId, message, ws);
+    }
+    catch (error) {
+        console.error('Invalid JSON message:', error);
+        ws.close(1003, 'Invalid JSON');
+    }
+}, _MCPWebBridge_handleWebSocketClose = function _MCPWebBridge_handleWebSocketClose(sessionId) {
+    __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_cleanupSession).call(this, sessionId);
+}, _MCPWebBridge_handleFrontendMessage = function _MCPWebBridge_handleFrontendMessage(sessionId, message, ws) {
+    switch (message.type) {
+        case 'authenticate':
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleAuthentication).call(this, sessionId, message, ws);
+            break;
+        case 'register-tool':
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleToolRegistration).call(this, sessionId, message);
+            break;
+        case 'register-resource':
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleResourceRegistration).call(this, sessionId, message);
+            break;
+        case 'activity':
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleActivity).call(this, sessionId, message);
+            break;
+        case 'tool-response':
+            // Handled by per-request listeners
+            break;
+        case 'resource-response':
+            // Handled by per-request listeners
+            break;
+        case 'query':
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleQuery).call(this, sessionId, message, ws);
+            break;
+        case 'query_cancel':
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleQueryCancel).call(this, message);
+            break;
+        default:
+            console.warn(`Unknown message type: ${message.type}`);
+    }
+}, _MCPWebBridge_handleAuthentication = function _MCPWebBridge_handleAuthentication(sessionId, message, ws) {
+    const { authToken } = message;
+    // Check session limit
+    if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").maxSessionsPerToken) {
+        const existingSessions = __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").get(authToken);
+        const currentCount = existingSessions?.size ?? 0;
+        if (currentCount >= __classPrivateFieldGet(this, _MCPWebBridge_config, "f").maxSessionsPerToken) {
+            if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").onSessionLimitExceeded === 'close_oldest') {
+                __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_closeOldestSessionForToken).call(this, authToken);
+            }
+            else {
+                ws.send(JSON.stringify({
+                    type: 'authentication-failed',
+                    error: 'Session limit exceeded',
+                    code: SessionLimitExceededErrorCode,
+                }));
+                ws.close(1008, 'Session limit exceeded');
+                return;
+            }
+        }
+    }
+    // Check for duplicate session name
+    if (message.sessionName) {
+        const existingSessionIds = __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").get(authToken);
+        if (existingSessionIds) {
+            for (const existingId of existingSessionIds) {
+                const existingSession = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(existingId);
+                if (existingSession?.sessionName === message.sessionName) {
+                    ws.send(JSON.stringify({
+                        type: 'authentication-failed',
+                        error: `Session name "${message.sessionName}" is already in use`,
+                        code: SessionNameAlreadyInUseErrorCode,
+                    }));
+                    ws.close(1008, 'Session name already in use');
+                    return;
+                }
+            }
+        }
+    }
+    const sessionData = {
+        ws,
+        authToken: message.authToken,
+        origin: message.origin,
+        pageTitle: message.pageTitle,
+        sessionName: message.sessionName,
+        userAgent: message.userAgent,
+        connectedAt: Date.now(),
+        lastActivity: Date.now(),
+        tools: new Map(),
+        resources: new Map(),
+    };
+    __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").set(sessionId, sessionData);
+    // Track session for this token
+    const sessionIds = __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").get(authToken) ?? new Set();
+    sessionIds.add(sessionId);
+    __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").set(authToken, sessionIds);
+    ws.send(JSON.stringify({
+        type: 'authenticated',
+        sessionId,
+        success: true,
+    }));
+}, _MCPWebBridge_handleToolRegistration = function _MCPWebBridge_handleToolRegistration(sessionId, message) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (!session) {
+        console.warn(`Tool registration for unknown session: ${sessionId}`);
+        return;
+    }
+    const toolName = message.tool.name;
+    const newSchema = JSON.stringify(message.tool.inputSchema ?? {});
+    // Check sibling sessions (same auth token) for schema conflicts
+    const siblingSessionIds = __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").get(session.authToken);
+    if (siblingSessionIds) {
+        for (const siblingId of siblingSessionIds) {
+            if (siblingId === sessionId)
+                continue;
+            const sibling = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(siblingId);
+            if (!sibling)
+                continue;
+            const existingTool = sibling.tools.get(toolName);
+            if (existingTool) {
+                const existingSchema = JSON.stringify(existingTool.inputSchema ?? {});
+                if (existingSchema !== newSchema) {
+                    console.warn(`Tool schema conflict: '${toolName}' registered by session ${siblingId} has a different schema. Rejecting registration from session ${sessionId}.`);
+                    session.ws.send(JSON.stringify({
+                        type: 'tool-registration-error',
+                        toolName,
+                        error: ToolSchemaConflictErrorCode,
+                        message: `Tool '${toolName}' is already registered by another session with a different schema. Tools with the same name must have identical schemas across sessions.`,
+                    }));
+                    return;
+                }
+            }
+        }
+    }
+    console.log('registering tool for session', sessionId, message);
+    session.tools.set(message.tool.name, message.tool);
+    // Notify connected MCP clients (Claude Desktop) about tool changes
+    __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_notifyToolsChanged).call(this, session.authToken);
+}, _MCPWebBridge_handleResourceRegistration = function _MCPWebBridge_handleResourceRegistration(sessionId, message) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (!session) {
+        console.warn(`Resource registration for unknown session: ${sessionId}`);
+        return;
+    }
+    console.log('registering resource for session', sessionId, message);
+    session.resources.set(message.resource.uri, message.resource);
+}, _MCPWebBridge_handleActivity = function _MCPWebBridge_handleActivity(sessionId, message) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (session) {
+        session.lastActivity = message.timestamp;
+    }
+}, _MCPWebBridge_handleQueryCancel = async function _MCPWebBridge_handleQueryCancel(message) {
+    const cancelMessage = QueryCancelMessageSchema.parse(message);
+    const { uuid } = cancelMessage;
+    const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(uuid);
+    if (!query) {
+        console.warn(`Cancel requested for unknown query: ${uuid}`);
+        return;
+    }
+    query.state = 'cancelled';
+    if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").agentUrl) {
+        try {
+            await fetch(buildQueryUrl(__classPrivateFieldGet(this, _MCPWebBridge_config, "f").agentUrl, uuid), {
+                method: 'DELETE',
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        catch (error) {
+            console.debug(`Failed to notify agent of query deletion (optional): ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCountForQuery).call(this, query);
+    __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(uuid);
+}, _MCPWebBridge_handleQuery = async function _MCPWebBridge_handleQuery(sessionId, message, ws) {
+    const { uuid, responseTool, tools, restrictTools } = message;
+    if (!__classPrivateFieldGet(this, _MCPWebBridge_config, "f").agentUrl) {
+        ws.send(JSON.stringify(QueryFailureMessageSchema.parse({
+            uuid,
+            error: 'Missing Agent URL',
+        })));
+        return;
+    }
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (!session) {
+        ws.send(JSON.stringify(QueryFailureMessageSchema.parse({
+            uuid,
+            error: 'Session not found',
+        })));
+        return;
+    }
+    // Check query limit
+    if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").maxInFlightQueriesPerToken) {
+        const currentQueries = __classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").get(session.authToken) ?? 0;
+        if (currentQueries >= __classPrivateFieldGet(this, _MCPWebBridge_config, "f").maxInFlightQueriesPerToken) {
+            ws.send(JSON.stringify(QueryFailureMessageSchema.parse({
+                uuid,
+                error: 'Query limit exceeded. Wait for existing queries to complete.',
+                code: QueryLimitExceededErrorCode,
+            })));
+            return;
+        }
+    }
+    // Increment query count
+    __classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").set(session.authToken, (__classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").get(session.authToken) ?? 0) + 1);
+    try {
+        __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").set(uuid, {
+            sessionId,
+            responseTool: responseTool?.name,
+            toolCalls: [],
+            ws,
+            state: 'active',
+            tools,
+            restrictTools,
+        });
+        const response = await fetch(buildQueryUrl(__classPrivateFieldGet(this, _MCPWebBridge_config, "f").agentUrl, uuid), {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(__classPrivateFieldGet(this, _MCPWebBridge_config, "f").authToken && {
+                    Authorization: `Bearer ${__classPrivateFieldGet(this, _MCPWebBridge_config, "f").authToken}`,
+                }),
+            },
+            body: JSON.stringify(QueryMessageSchema.parse(message)),
+        });
+        if (!response.ok) {
+            throw new Error(`Agent responded with ${response.status}: ${response.statusText}`);
+        }
+        ws.send(JSON.stringify(QueryAcceptedMessageSchema.parse({ uuid })));
+    }
+    catch (error) {
+        console.error(`Error forwarding query ${uuid}:`, error);
+        __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(uuid);
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCount).call(this, session.authToken);
+        ws.send(JSON.stringify(QueryFailureMessageSchema.parse({
+            uuid,
+            error: `${error instanceof Error ? error.message : String(error)}`,
+        })));
+    }
+}, _MCPWebBridge_handleHttpRequest = 
+// ============================================
+// HTTP Request Handling
+// ============================================
+async function _MCPWebBridge_handleHttpRequest(req) {
+    const startTime = Date.now();
+    // Debug logging helper
+    const debug = (message, data) => {
+        if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+            if (data !== undefined) {
+                console.log(`[MCP Debug] ${message}`, data);
+            }
+            else {
+                console.log(`[MCP Debug] ${message}`);
+            }
+        }
+    };
+    debug(`→ ${req.method} ${req.url}`);
+    debug(`  Headers:`, {
+        accept: req.headers.get('accept'),
+        contentType: req.headers.get('content-type'),
+        authorization: req.headers.get('authorization') ? '[PRESENT]' : '[ABSENT]',
+        mcpSessionId: req.headers.get('mcp-session-id'),
+    });
+    // Handle CORS preflight
+    if (req.method === 'OPTIONS') {
+        debug(`← 200 (CORS preflight)`);
+        return jsonResponse(200, '');
+    }
+    const url = new URL(req.url, 'http://localhost');
+    const pathname = url.pathname;
+    // Route query endpoints
+    const queryProgressMatch = pathname.match(/^\/query\/([^/]+)\/progress$/);
+    const queryCompleteMatch = pathname.match(/^\/query\/([^/]+)\/complete$/);
+    const queryFailMatch = pathname.match(/^\/query\/([^/]+)\/fail$/);
+    const queryCancelMatch = pathname.match(/^\/query\/([^/]+)\/cancel$/);
+    if (req.method === 'POST' && queryProgressMatch) {
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleQueryProgressEndpoint).call(this, queryProgressMatch[1], req);
+    }
+    if (req.method === 'PUT' && queryCompleteMatch) {
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleQueryCompleteEndpoint).call(this, queryCompleteMatch[1], req);
+    }
+    if (req.method === 'PUT' && queryFailMatch) {
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleQueryFailEndpoint).call(this, queryFailMatch[1], req);
+    }
+    if (req.method === 'PUT' && queryCancelMatch) {
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleQueryCancelEndpoint).call(this, queryCancelMatch[1], req);
+    }
+    // Handle MCP session deletion (client closing session)
+    if (req.method === 'DELETE') {
+        const mcpSessionId = req.headers.get('mcp-session-id');
+        if (mcpSessionId) {
+            debug(`  Processing DELETE for session ${mcpSessionId}`);
+            const response = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleMcpSessionDelete).call(this, mcpSessionId);
+            debug(`← ${response.status} (session delete) [${Date.now() - startTime}ms]`);
+            return response;
+        }
+        debug(`← 400 (missing Mcp-Session-Id) [${Date.now() - startTime}ms]`);
+        return jsonResponse(400, { error: 'Mcp-Session-Id header required' });
+    }
+    // Handle GET requests for SSE stream (Remote MCP server-initiated messages)
+    if (req.method === 'GET') {
+        const acceptsSSE = req.headers.get('accept')?.includes('text/event-stream');
+        if (acceptsSSE) {
+            debug(`  Opening SSE stream`);
+            return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleSSEStream).call(this, req);
+        }
+        // Plain GET returns server info (no auth required)
+        debug(`← 200 (server info) [${Date.now() - startTime}ms]`);
+        const icon = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getIcon).call(this);
+        return jsonResponse(200, {
+            name: __classPrivateFieldGet(this, _MCPWebBridge_config, "f").name,
+            description: __classPrivateFieldGet(this, _MCPWebBridge_config, "f").description,
+            version: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getVersion).call(this),
+            ...(icon && { icon }),
+        });
+    }
+    // Handle MCP JSON-RPC requests
+    if (req.method === 'POST') {
+        debug(`  Processing MCP request`);
+        const response = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleMCPRequest).call(this, req);
+        debug(`← ${response.status} [${Date.now() - startTime}ms]`);
+        return response;
+    }
+    debug(`← 404 (not found) [${Date.now() - startTime}ms]`);
+    return jsonResponse(404, { error: 'Not Found' });
+}, _MCPWebBridge_handleQueryProgressEndpoint = async function _MCPWebBridge_handleQueryProgressEndpoint(uuid, req) {
+    try {
+        const body = await req.text();
+        const message = JSON.parse(body);
+        const progressMessage = QueryProgressMessageSchema.parse({
+            uuid,
+            ...message,
+        });
+        const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(uuid);
+        if (!query) {
+            return jsonResponse(404, { error: QueryNotFoundErrorCode });
+        }
+        if (query.ws.readyState === 'OPEN') {
+            query.ws.send(JSON.stringify(progressMessage));
+        }
+        return jsonResponse(200, { success: true });
+    }
+    catch (error) {
+        console.error('Error handling query progress:', error);
+        return jsonResponse(400, { error: 'Invalid request body' });
+    }
+}, _MCPWebBridge_handleQueryCompleteEndpoint = async function _MCPWebBridge_handleQueryCompleteEndpoint(uuid, req) {
+    try {
+        const body = await req.text();
+        const message = JSON.parse(body);
+        const completeMessage = QueryCompleteClientMessageSchema.parse({
+            uuid,
+            ...message,
+        });
+        const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(uuid);
+        if (!query) {
+            return jsonResponse(404, { error: QueryNotFoundErrorCode });
+        }
+        if (query.responseTool) {
+            const errorMessage = QueryFailureMessageSchema.parse({
+                uuid,
+                error: `Query specified responseTool '${query.responseTool}' but agent called queryComplete() instead`,
+            });
+            if (query.ws.readyState === 'OPEN') {
+                query.ws.send(JSON.stringify(errorMessage));
+            }
+            __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCountForQuery).call(this, query);
+            __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(uuid);
+            return jsonResponse(400, { error: errorMessage.error });
+        }
+        query.state = 'completed';
+        const bridgeMessage = QueryCompleteBridgeMessageSchema.parse({
+            uuid,
+            message: completeMessage.message,
+            toolCalls: query.toolCalls,
+        });
+        if (query.ws.readyState === 'OPEN') {
+            query.ws.send(JSON.stringify(bridgeMessage));
+        }
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCountForQuery).call(this, query);
+        __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(uuid);
+        return jsonResponse(200, { success: true });
+    }
+    catch (error) {
+        console.error('Error handling query complete:', error);
+        return jsonResponse(400, { error: 'Invalid request body' });
+    }
+}, _MCPWebBridge_handleQueryFailEndpoint = async function _MCPWebBridge_handleQueryFailEndpoint(uuid, req) {
+    try {
+        const body = await req.text();
+        const message = JSON.parse(body);
+        const failureMessage = QueryFailureMessageSchema.parse({
+            uuid,
+            ...message,
+        });
+        const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(uuid);
+        if (!query) {
+            return jsonResponse(404, { error: QueryNotFoundErrorCode });
+        }
+        query.state = 'failed';
+        if (query.ws.readyState === 'OPEN') {
+            query.ws.send(JSON.stringify(failureMessage));
+        }
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCountForQuery).call(this, query);
+        __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(uuid);
+        return jsonResponse(200, { success: true });
+    }
+    catch (error) {
+        console.error('Error handling query fail:', error);
+        return jsonResponse(400, { error: 'Invalid request body' });
+    }
+}, _MCPWebBridge_handleQueryCancelEndpoint = async function _MCPWebBridge_handleQueryCancelEndpoint(uuid, req) {
+    try {
+        const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(uuid);
+        if (!query) {
+            return jsonResponse(404, { error: QueryNotFoundErrorCode });
+        }
+        query.state = 'cancelled';
+        const body = await req.text();
+        const cancellationMessage = QueryCancelMessageSchema.parse({
+            uuid,
+            reason: body ? JSON.parse(body).reason : undefined,
+        });
+        if (query.ws.readyState === 'OPEN') {
+            query.ws.send(JSON.stringify(cancellationMessage));
+        }
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCountForQuery).call(this, query);
+        __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(uuid);
+        return jsonResponse(200, { success: true });
+    }
+    catch (error) {
+        console.error('Error handling query cancel:', error);
+        return jsonResponse(400, { error: 'Invalid request body' });
+    }
+}, _MCPWebBridge_handleMCPRequest = 
+// ============================================
+// MCP JSON-RPC Handling
+// ============================================
+async function _MCPWebBridge_handleMCPRequest(req) {
+    try {
+        const body = await req.text();
+        const mcpRequest = JSON.parse(body);
+        // Debug logging
+        if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+            console.log(`[MCP Debug]   Method: ${mcpRequest.method}, ID: ${mcpRequest.id}`);
+            if (mcpRequest.params && Object.keys(mcpRequest.params).length > 0) {
+                console.log(`[MCP Debug]   Params:`, JSON.stringify(mcpRequest.params).substring(0, 200));
+            }
+        }
+        // Extract auth token from header OR URL query param (for Remote MCP compatibility)
+        const authHeader = req.headers.get('authorization');
+        const url = new URL(req.url, 'http://localhost');
+        const authToken = authHeader?.replace('Bearer ', '') ?? url.searchParams.get('token') ?? undefined;
+        const mcpSessionId = req.headers.get('mcp-session-id');
+        const queryId = mcpRequest.params?._meta?.queryId;
+        // Handle initialize separately - it creates an MCP session
+        if (mcpRequest.method === 'initialize') {
+            if (!authToken) {
+                if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+                    console.log(`[MCP Debug]   Error: Missing authentication token`);
+                }
+                return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32600, MissingAuthenticationErrorCode);
+            }
+            const { result, sessionId } = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleInitialize).call(this, authToken);
+            if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+                console.log(`[MCP Debug]   Created MCP session: ${sessionId}`);
+            }
+            return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpSuccessResponseWithHeaders).call(this, mcpRequest.id, result, {
+                'Mcp-Session-Id': sessionId,
+            });
+        }
+        // Handle initialized notification (no response needed per spec, but we accept it)
+        if (mcpRequest.method === 'notifications/initialized') {
+            // Update MCP session activity
+            if (mcpSessionId) {
+                const mcpSession = __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").get(mcpSessionId);
+                if (mcpSession) {
+                    mcpSession.lastActivity = Date.now();
+                }
+            }
+            return jsonResponse(202, '');
+        }
+        // For all other requests, validate MCP session if provided
+        if (mcpSessionId) {
+            const mcpSession = __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").get(mcpSessionId);
+            if (!mcpSession) {
+                return jsonResponse(404, { error: 'MCP session not found' });
+            }
+            mcpSession.lastActivity = Date.now();
+        }
+        const sessions = new Map();
+        if (queryId) {
+            const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(queryId);
+            if (!query) {
+                return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32600, QueryNotFoundErrorCode);
+            }
+            if (query.state !== 'active') {
+                return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32600, QueryNotActiveErrorCode);
+            }
+            const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(query.sessionId);
+            if (!session) {
+                return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32600, InvalidSessionErrorCode);
+            }
+            sessions.set(query.sessionId, session);
+        }
+        else if (authToken) {
+            for (const [sessionId, session] of __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").entries()) {
+                if (session.authToken === authToken) {
+                    sessions.set(sessionId, session);
+                }
+            }
+        }
+        else {
+            return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32600, MissingAuthenticationErrorCode);
+        }
+        if (sessions.size === 0) {
+            return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32600, NoSessionsFoundErrorCode);
+        }
+        let result;
+        switch (mcpRequest.method) {
+            case 'tools/list':
+                result = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleToolsList).call(this, sessions, mcpRequest.params);
+                break;
+            case 'tools/call':
+                result = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleToolCall).call(this, sessions, mcpRequest.params);
+                result = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_wrapToolCallResult).call(this, result);
+                break;
+            case 'resources/list':
+                result = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleResourcesList).call(this, sessions, mcpRequest.params);
+                break;
+            case 'resources/read':
+                result = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handleResourceRead).call(this, sessions, mcpRequest.params);
+                break;
+            case 'prompts/list':
+                result = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_handlePromptsList).call(this, sessions, mcpRequest.params);
+                break;
+            default:
+                return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32601, UnknownMethodErrorCode);
+        }
+        // Check for fatal errors
+        if (result &&
+            typeof result === 'object' &&
+            'error_is_fatal' in result &&
+            result.error_is_fatal === true) {
+            const fatalError = result;
+            return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, mcpRequest.id, -32602, fatalError.error_message, fatalError);
+        }
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpSuccessResponse).call(this, mcpRequest.id, result);
+    }
+    catch (error) {
+        console.error('MCP request error:', error);
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_mcpErrorResponse).call(this, 0, -32603, InternalErrorCode);
+    }
+}, _MCPWebBridge_mcpSuccessResponse = function _MCPWebBridge_mcpSuccessResponse(id, result) {
+    const response = {
+        jsonrpc: '2.0',
+        id,
+        result,
+    };
+    return jsonResponse(200, response);
+}, _MCPWebBridge_mcpSuccessResponseWithHeaders = function _MCPWebBridge_mcpSuccessResponseWithHeaders(id, result, headers) {
+    const response = {
+        jsonrpc: '2.0',
+        id,
+        result,
+    };
+    return {
+        status: 200,
+        headers: {
+            'content-type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(response),
+    };
+}, _MCPWebBridge_mcpErrorResponse = function _MCPWebBridge_mcpErrorResponse(id, code, message, data) {
+    const response = {
+        jsonrpc: '2.0',
+        id,
+        error: { code, message, data },
+    };
+    return jsonResponse(200, response);
+}, _MCPWebBridge_wrapToolCallResult = function _MCPWebBridge_wrapToolCallResult(result) {
+    // Check if this is an error response
+    if (result && typeof result === 'object' && 'error' in result) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+    // Handle different result types
+    if (typeof result === 'string') {
+        // Check if it's a data URL (image)
+        if (result.startsWith('data:image/')) {
+            const mimeType = result.split(';')[0].split(':')[1];
+            // Extract base64 data after the comma
+            const base64Data = result.split(',')[1];
+            return {
+                content: [
+                    {
+                        type: 'image',
+                        data: base64Data,
+                        mimeType,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    }
+    if (result !== null && result !== undefined) {
+        // Check if it's an object containing a data URL (e.g., { dataUrl: "data:image/png;base64,..." })
+        // This handles tools that return image data wrapped in an object rather than as a raw string.
+        if (typeof result === 'object' && 'dataUrl' in result) {
+            const dataUrl = result.dataUrl;
+            if (typeof dataUrl === 'string' && dataUrl.startsWith('data:image/')) {
+                const mimeType = dataUrl.split(';')[0].split(':')[1];
+                const base64Data = dataUrl.split(',')[1];
+                return {
+                    content: [
+                        {
+                            type: 'image',
+                            data: base64Data,
+                            mimeType,
+                        },
+                    ],
+                };
+            }
+        }
+        // Extract _meta from the result object to place at the top level of CallToolResult.
+        // The MCP protocol expects _meta as a top-level field on the result object,
+        // not embedded inside the JSON text content (where the host can't find it).
+        let topLevelMeta;
+        let resultToSerialize = result;
+        if (typeof result === 'object' && '_meta' in result) {
+            const { _meta, ...rest } = result;
+            if (_meta && typeof _meta === 'object') {
+                topLevelMeta = _meta;
+            }
+            resultToSerialize = rest;
+        }
+        const wrapped = {
+            content: [
+                {
+                    type: 'text',
+                    text: typeof resultToSerialize === 'object' ? JSON.stringify(resultToSerialize, null, 2) : String(resultToSerialize),
+                },
+            ],
+        };
+        if (topLevelMeta) {
+            wrapped._meta = topLevelMeta;
+        }
+        return wrapped;
+    }
+    // null or undefined result
+    return {
+        content: [
+            {
+                type: 'text',
+                text: '',
+            },
+        ],
+    };
+}, _MCPWebBridge_getVersion = function _MCPWebBridge_getVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const packageJsonPath = join(__dirname, '..', 'package.json');
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson.version || '1.0.0';
+    }
+    catch {
+        return '1.0.0';
+    }
+}, _MCPWebBridge_resolveIcon = 
+/**
+ * Resolves the icon config value to a data URI.
+ * If icon is already a data URI, uses it directly.
+ * If icon is an HTTP(S) URL, fetches it and converts to a base64 data URI.
+ * Fails gracefully — icon is simply omitted if resolution fails.
+ */
+async function _MCPWebBridge_resolveIcon() {
+    const icon = __classPrivateFieldGet(this, _MCPWebBridge_config, "f").icon;
+    if (!icon)
+        return;
+    // Already a data URI — use as-is
+    if (icon.startsWith('data:')) {
+        __classPrivateFieldSet(this, _MCPWebBridge_resolvedIcon, icon, "f");
+        return;
+    }
+    // HTTP(S) URL — fetch and convert
+    if (icon.startsWith('http://') || icon.startsWith('https://')) {
+        try {
+            const response = await fetch(icon);
+            if (!response.ok) {
+                console.warn(`[MCPWebBridge] Failed to fetch icon from ${icon}: HTTP ${response.status}`);
+                return;
+            }
+            const contentType = response.headers.get('content-type') || 'image/png';
+            const buffer = await response.arrayBuffer();
+            const base64 = Buffer.from(buffer).toString('base64');
+            __classPrivateFieldSet(this, _MCPWebBridge_resolvedIcon, `data:${contentType};base64,${base64}`, "f");
+        }
+        catch (error) {
+            console.warn(`[MCPWebBridge] Failed to fetch icon from ${icon}:`, error instanceof Error ? error.message : error);
+        }
+        return;
+    }
+    // Unrecognized format — use as-is (could be a relative URL)
+    __classPrivateFieldSet(this, _MCPWebBridge_resolvedIcon, icon, "f");
+}, _MCPWebBridge_getIcon = 
+/**
+ * Returns the resolved icon data URI, waiting for resolution if needed.
+ */
+async function _MCPWebBridge_getIcon() {
+    await __classPrivateFieldGet(this, _MCPWebBridge_iconReady, "f");
+    return __classPrivateFieldGet(this, _MCPWebBridge_resolvedIcon, "f");
+}, _MCPWebBridge_handleInitialize = 
+/**
+ * Handles MCP initialize request and creates a new MCP session.
+ * Returns the initialize result along with a session ID for the Mcp-Session-Id header.
+ */
+async function _MCPWebBridge_handleInitialize(authToken) {
+    // Create a new MCP session
+    const sessionId = crypto.randomUUID();
+    const mcpSession = {
+        id: sessionId,
+        authToken,
+        createdAt: Date.now(),
+        lastActivity: Date.now(),
+    };
+    __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").set(sessionId, mcpSession);
+    const icon = await __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getIcon).call(this);
+    const result = {
+        protocolVersion: '2024-11-05',
+        capabilities: {
+            tools: { listChanged: true },
+            resources: {},
+            prompts: {},
+        },
+        serverInfo: {
+            name: __classPrivateFieldGet(this, _MCPWebBridge_config, "f").name,
+            description: __classPrivateFieldGet(this, _MCPWebBridge_config, "f").description,
+            version: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getVersion).call(this),
+            ...(icon && { icon }),
+        },
+    };
+    return { result, sessionId };
+}, _MCPWebBridge_getSessionAndSessionId = function _MCPWebBridge_getSessionAndSessionId(sessions, sessionId) {
+    if (!sessionId) {
+        if (sessions.size === 1) {
+            sessionId = sessions.keys().next().value;
+            if (!sessionId) {
+                return undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    const session = sessions.get(sessionId);
+    if (!session) {
+        return undefined;
+    }
+    return [sessionId, session];
+}, _MCPWebBridge_getSessionFromMetaParams = function _MCPWebBridge_getSessionFromMetaParams(sessions, params) {
+    const sessionId = params?._meta?.sessionId;
+    return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getSessionAndSessionId).call(this, sessions, sessionId)?.[1];
+}, _MCPWebBridge_createSessionNotFoundError = function _MCPWebBridge_createSessionNotFoundError(sessions) {
+    if (sessions.size > 1) {
+        return {
+            error: SessionNotSpecifiedErrorCode,
+            error_message: SessionNotSpecifiedErrorDetails,
+            available_sessions: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_listSessions).call(this, sessions),
+        };
+    }
+    return { error: SessionNotFoundErrorCode };
+}, _MCPWebBridge_handleToolsList = async function _MCPWebBridge_handleToolsList(sessions, params) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getSessionFromMetaParams).call(this, sessions, params);
+    const listSessionsTool = {
+        name: 'list_sessions',
+        description: 'List all browser sessions with their available tools',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    };
+    if (!session && sessions.size > 1) {
+        // Multiple sessions: expose all tools (deduplicated) with session_id required
+        const tools = [listSessionsTool];
+        const seen = new Set();
+        for (const s of sessions.values()) {
+            for (const tool of s.tools.values()) {
+                if (seen.has(tool.name))
+                    continue;
+                seen.add(tool.name);
+                tools.push({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            session_id: {
+                                type: 'string',
+                                description: 'Session ID (required) — use list_sessions to see available sessions',
+                            },
+                            ...(tool.inputSchema?.properties || {}),
+                        },
+                        required: [
+                            'session_id',
+                            ...(tool.inputSchema?.required || []),
+                        ],
+                    },
+                    // Forward _meta (e.g., _meta.ui.resourceUri for MCP Apps)
+                    ...(tool._meta ? { _meta: tool._meta } : {}),
+                });
+            }
+        }
+        return {
+            tools,
+            _meta: { available_sessions: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_listSessions).call(this, sessions) },
+        };
+    }
+    if (!session) {
+        return {
+            error: SessionNotFoundErrorCode,
+            error_message: 'No session found for the provided authentication',
+            error_is_fatal: true,
+        };
+    }
+    const tools = [listSessionsTool];
+    for (const tool of session.tools.values()) {
+        const sessionAwareTool = {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    session_id: {
+                        type: 'string',
+                        description: 'Session ID (optional - will auto-select if only one session active)',
+                    },
+                    ...(tool.inputSchema?.properties || {}),
+                },
+                required: tool.inputSchema?.required || [],
+            },
+            // Forward _meta (e.g., _meta.ui.resourceUri for MCP Apps)
+            ...(tool._meta ? { _meta: tool._meta } : {}),
+        };
+        tools.push(sessionAwareTool);
+    }
+    return { tools };
+}, _MCPWebBridge_handleToolCall = async function _MCPWebBridge_handleToolCall(sessions, params) {
+    const { name: toolName, arguments: toolInput, _meta } = params || {};
+    if (!toolName) {
+        return { error: ToolNameRequiredErrorCode };
+    }
+    const queryId = _meta?.queryId;
+    if (queryId) {
+        const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(queryId);
+        if (!query) {
+            return { error: QueryNotFoundErrorCode };
+        }
+        if (query.state !== 'active') {
+            return { error: QueryNotActiveErrorCode };
+        }
+        if (query.restrictTools && query.tools) {
+            const allowed = query.tools.some((t) => t.name === toolName);
+            if (!allowed) {
+                return {
+                    error: ToolNotAllowedErrorCode,
+                    details: 'The query restricts the allowed tool calls. Use one of `allowed_tools`.',
+                    allowed_tools: query.tools.map((t) => t.name),
+                };
+            }
+        }
+    }
+    if (toolName === 'list_sessions') {
+        return { sessions: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_listSessions).call(this, sessions) };
+    }
+    const [sessionId, session] = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getSessionAndSessionId).call(this, sessions, toolInput?.session_id || _meta?.sessionId) || [];
+    if (!sessionId || !session) {
+        return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_createSessionNotFoundError).call(this, sessions);
+    }
+    if (!session.tools.has(toolName)) {
+        return {
+            error: ToolNotFoundErrorCode,
+            available_tools: Array.from(session.tools.keys()),
+        };
+    }
+    // Strip session_id from tool input before forwarding — it's a routing
+    // parameter injected by the bridge, not an actual tool argument.
+    const { session_id: _, ...forwardedInput } = toolInput || {};
+    return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_forwardToolCallToSession).call(this, sessionId, toolName, forwardedInput, queryId);
+}, _MCPWebBridge_handleResourcesList = async function _MCPWebBridge_handleResourcesList(sessions, params) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getSessionFromMetaParams).call(this, sessions, params);
+    const sessionListResource = {
+        uri: 'sessions://list',
+        name: 'sessions',
+        description: 'List of all active browser sessions for this authentication context',
+        mimeType: 'application/json',
+    };
+    if (!session && sessions.size > 1) {
+        return {
+            resources: [sessionListResource],
+            isError: true,
+            error: SessionNotSpecifiedErrorCode,
+            error_message: SessionNotSpecifiedErrorDetails,
+            error_is_fatal: false,
+            available_sessions: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_listSessions).call(this, sessions),
+        };
+    }
+    if (!session) {
+        return {
+            error: SessionNotFoundErrorCode,
+            error_message: 'No session found for the provided authentication',
+            error_is_fatal: true,
+        };
+    }
+    const resources = [sessionListResource];
+    // Add frontend-registered resources
+    for (const resource of session.resources.values()) {
+        resources.push({
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType ?? 'text/html',
+        });
+    }
+    return { resources };
+}, _MCPWebBridge_handleResourceRead = async function _MCPWebBridge_handleResourceRead(sessions, params) {
+    const { uri, _meta } = params || {};
+    if (!uri) {
+        return { error: 'Resource URI is required' };
+    }
+    if (uri === 'sessions://list') {
+        const sessionData = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_listSessions).call(this, sessions);
+        return {
+            contents: [
+                {
+                    uri: 'sessions://list',
+                    mimeType: 'application/json',
+                    text: JSON.stringify(sessionData, null, 2),
+                },
+            ],
+        };
+    }
+    // Look for frontend-registered resource
+    const [sessionId, session] = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getSessionAndSessionId).call(this, sessions, _meta?.sessionId) || [];
+    if (!sessionId || !session) {
+        // If no session specified and multiple sessions, check all sessions for the resource
+        for (const [sid, sess] of sessions.entries()) {
+            if (sess.resources.has(uri)) {
+                return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_forwardResourceReadToSession).call(this, sid, uri);
+            }
+        }
+        return { error: 'Resource not found' };
+    }
+    if (!session.resources.has(uri)) {
+        return { error: 'Resource not found' };
+    }
+    return __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_forwardResourceReadToSession).call(this, sessionId, uri);
+}, _MCPWebBridge_listSessions = function _MCPWebBridge_listSessions(sessions) {
+    return Array.from(sessions.entries()).map(([key, session]) => ({
+        session_id: key,
+        session_name: session.sessionName,
+        origin: session.origin,
+        page_title: session.pageTitle,
+        connected_at: new Date(session.connectedAt).toISOString(),
+        last_activity: new Date(session.lastActivity).toISOString(),
+        available_tools: Array.from(session.tools.keys()),
+    }));
+}, _MCPWebBridge_handlePromptsList = async function _MCPWebBridge_handlePromptsList(sessions, params) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_getSessionFromMetaParams).call(this, sessions, params);
+    if (!session && sessions.size > 1) {
+        return {
+            prompts: [],
+            isError: true,
+            error: SessionNotSpecifiedErrorCode,
+            error_message: SessionNotSpecifiedErrorDetails,
+            error_is_fatal: false,
+            available_sessions: __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_listSessions).call(this, sessions),
+        };
+    }
+    if (!session) {
+        return {
+            error: SessionNotFoundErrorCode,
+            error_message: 'No session found for the provided authentication',
+            error_is_fatal: true,
+        };
+    }
+    return { prompts: [] };
+}, _MCPWebBridge_forwardToolCallToSession = async function _MCPWebBridge_forwardToolCallToSession(sessionId, toolName, toolInput, queryId) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (!session || session.ws.readyState !== 'OPEN') {
+        return { error: 'Session not available' };
+    }
+    const requestId = crypto.randomUUID();
+    const toolCall = {
+        type: 'tool-call',
+        requestId,
+        toolName,
+        toolInput,
+        ...(queryId && { queryId }),
+    };
+    return new Promise((resolve) => {
+        let timeoutId;
+        const handleResponse = (data) => {
+            try {
+                const message = JSON.parse(data);
+                if (message.type === 'tool-response' &&
+                    message.requestId === requestId) {
+                    if (timeoutId) {
+                        __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").cancel(timeoutId);
+                    }
+                    __classPrivateFieldGet(this, _MCPWebBridge_toolResponseHandlers, "f").delete(requestId);
+                    session.ws.offMessage(handleResponse);
+                    const toolResult = message.result;
+                    if (queryId) {
+                        const query = __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").get(queryId);
+                        if (query) {
+                            query.toolCalls.push({
+                                tool: toolName,
+                                arguments: toolInput,
+                                result: toolResult,
+                            });
+                            if (query.responseTool === toolName) {
+                                if (!(toolResult &&
+                                    typeof toolResult === 'object' &&
+                                    'error' in toolResult)) {
+                                    const bridgeMessage = QueryCompleteBridgeMessageSchema.parse({
+                                        uuid: queryId,
+                                        message: undefined,
+                                        toolCalls: query.toolCalls,
+                                    });
+                                    if (query.ws.readyState === 'OPEN') {
+                                        query.ws.send(JSON.stringify(bridgeMessage));
+                                    }
+                                    __classPrivateFieldGet(this, _MCPWebBridge_queries, "f").delete(queryId);
+                                }
+                            }
+                        }
+                    }
+                    resolve(toolResult);
+                }
+            }
+            catch {
+                // Ignore invalid JSON
+            }
+        };
+        // Set up timeout
+        timeoutId = __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").schedule(() => {
+            __classPrivateFieldGet(this, _MCPWebBridge_toolResponseHandlers, "f").delete(requestId);
+            session.ws.offMessage(handleResponse);
+            resolve({ error: 'Tool call timeout' });
+        }, 30000);
+        __classPrivateFieldGet(this, _MCPWebBridge_toolResponseHandlers, "f").set(requestId, handleResponse);
+        session.ws.onMessage(handleResponse);
+        session.ws.send(JSON.stringify(toolCall));
+    });
+}, _MCPWebBridge_forwardResourceReadToSession = async function _MCPWebBridge_forwardResourceReadToSession(sessionId, uri) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (!session || session.ws.readyState !== 'OPEN') {
+        return { error: 'Session not available' };
+    }
+    const requestId = crypto.randomUUID();
+    const resourceRead = {
+        type: 'resource-read',
+        requestId,
+        uri,
+    };
+    return new Promise((resolve) => {
+        let timeoutId;
+        const handleResponse = (data) => {
+            try {
+                const message = JSON.parse(data);
+                if (message.type === 'resource-response' &&
+                    message.requestId === requestId) {
+                    if (timeoutId) {
+                        __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").cancel(timeoutId);
+                    }
+                    __classPrivateFieldGet(this, _MCPWebBridge_resourceResponseHandlers, "f").delete(requestId);
+                    session.ws.offMessage(handleResponse);
+                    if (message.error) {
+                        resolve({ error: message.error });
+                        return;
+                    }
+                    // Build MCP resource read response
+                    if (message.blob) {
+                        // Binary content (base64 encoded)
+                        resolve({
+                            contents: [
+                                {
+                                    uri,
+                                    mimeType: message.mimeType,
+                                    blob: message.blob,
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        // Text content
+                        resolve({
+                            contents: [
+                                {
+                                    uri,
+                                    mimeType: message.mimeType,
+                                    text: message.content,
+                                },
+                            ],
+                        });
+                    }
+                }
+            }
+            catch {
+                // Ignore invalid JSON
+            }
+        };
+        // Set up timeout
+        timeoutId = __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").schedule(() => {
+            __classPrivateFieldGet(this, _MCPWebBridge_resourceResponseHandlers, "f").delete(requestId);
+            session.ws.offMessage(handleResponse);
+            resolve({ error: 'Resource read timeout' });
+        }, 30000);
+        __classPrivateFieldGet(this, _MCPWebBridge_resourceResponseHandlers, "f").set(requestId, handleResponse);
+        session.ws.onMessage(handleResponse);
+        session.ws.send(JSON.stringify(resourceRead));
+    });
+}, _MCPWebBridge_decrementQueryCount = function _MCPWebBridge_decrementQueryCount(authToken) {
+    const count = __classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").get(authToken) ?? 0;
+    if (count <= 1) {
+        __classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").delete(authToken);
+    }
+    else {
+        __classPrivateFieldGet(this, _MCPWebBridge_tokenQueryCounts, "f").set(authToken, count - 1);
+    }
+}, _MCPWebBridge_decrementQueryCountForQuery = function _MCPWebBridge_decrementQueryCountForQuery(query) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(query.sessionId);
+    if (session) {
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_decrementQueryCount).call(this, session.authToken);
+    }
+}, _MCPWebBridge_closeOldestSessionForToken = function _MCPWebBridge_closeOldestSessionForToken(authToken) {
+    const sessionIds = __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").get(authToken);
+    if (!sessionIds || sessionIds.size === 0)
+        return;
+    let oldest = null;
+    for (const sessionId of sessionIds) {
+        const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+        if (session && (!oldest || session.connectedAt < oldest.connectedAt)) {
+            oldest = { sessionId, connectedAt: session.connectedAt };
+        }
+    }
+    if (oldest) {
+        const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(oldest.sessionId);
+        if (session) {
+            session.ws.send(JSON.stringify({
+                type: 'session-closed',
+                reason: 'Session limit exceeded, closing oldest session',
+                code: SessionLimitExceededErrorCode,
+            }));
+            session.ws.close(1008, 'Session limit exceeded');
+        }
+    }
+}, _MCPWebBridge_cleanupSession = function _MCPWebBridge_cleanupSession(sessionId) {
+    const session = __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").get(sessionId);
+    if (session) {
+        const sessionIds = __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").get(session.authToken);
+        if (sessionIds) {
+            sessionIds.delete(sessionId);
+            if (sessionIds.size === 0) {
+                __classPrivateFieldGet(this, _MCPWebBridge_tokenSessionIds, "f").delete(session.authToken);
+            }
+        }
+        // Notify connected MCP clients about tool changes (tools removed)
+        __classPrivateFieldGet(this, _MCPWebBridge_instances, "m", _MCPWebBridge_notifyToolsChanged).call(this, session.authToken);
+    }
+    __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f").delete(sessionId);
+}, _MCPWebBridge_startSessionTimeoutChecker = function _MCPWebBridge_startSessionTimeoutChecker() {
+    const maxDuration = __classPrivateFieldGet(this, _MCPWebBridge_config, "f").sessionMaxDurationMs;
+    if (!maxDuration)
+        return;
+    __classPrivateFieldSet(this, _MCPWebBridge_sessionTimeoutIntervalId, __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").scheduleInterval(() => {
+        const now = Date.now();
+        for (const [_sessionId, session] of __classPrivateFieldGet(this, _MCPWebBridge_sessions, "f")) {
+            if (now - session.connectedAt > maxDuration) {
+                session.ws.send(JSON.stringify({
+                    type: 'session-expired',
+                    code: SessionExpiredErrorCode,
+                }));
+                session.ws.close(1008, 'Session expired');
+            }
+        }
+    }, 60000), "f");
+}, _MCPWebBridge_startMcpSessionTimeoutChecker = function _MCPWebBridge_startMcpSessionTimeoutChecker() {
+    // Check every minute
+    __classPrivateFieldSet(this, _MCPWebBridge_mcpSessionTimeoutIntervalId, __classPrivateFieldGet(this, _MCPWebBridge_scheduler, "f").scheduleInterval(() => {
+        const now = Date.now();
+        for (const [sessionId, mcpSession] of __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f")) {
+            const idleTime = now - mcpSession.lastActivity;
+            if (idleTime > _a.MCP_SESSION_IDLE_TIMEOUT_MS) {
+                // Clean up SSE stream if open
+                if (mcpSession.sseCleanup) {
+                    mcpSession.sseCleanup();
+                }
+                __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").delete(sessionId);
+                console.log(`MCP session ${sessionId} expired after ${idleTime}ms of inactivity`);
+            }
+        }
+    }, 60000), "f");
+}, _MCPWebBridge_notifyToolsChanged = function _MCPWebBridge_notifyToolsChanged(authToken) {
+    for (const mcpSession of __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").values()) {
+        // Only notify sessions with matching auth token
+        if (mcpSession.authToken === authToken && mcpSession.sseWriter) {
+            const notification = {
+                jsonrpc: '2.0',
+                method: 'notifications/tools/list_changed',
+            };
+            mcpSession.sseWriter(JSON.stringify(notification));
+        }
+    }
+}, _MCPWebBridge_handleSSEStream = function _MCPWebBridge_handleSSEStream(req) {
+    const mcpSessionId = req.headers.get('mcp-session-id');
+    if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+        console.log(`[MCP Debug]   SSE stream request, session: ${mcpSessionId || '[NONE]'}`);
+    }
+    if (!mcpSessionId) {
+        if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+            console.log(`[MCP Debug]   SSE Error: Missing Mcp-Session-Id header`);
+        }
+        // Return a regular response indicating error - we need Mcp-Session-Id
+        return sseResponse((writer, _onClose) => {
+            writer(JSON.stringify({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32600,
+                    message: 'Mcp-Session-Id header required for SSE stream',
+                },
+            }));
+        });
+    }
+    const mcpSession = __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").get(mcpSessionId);
+    if (!mcpSession) {
+        if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+            console.log(`[MCP Debug]   SSE Error: MCP session not found`);
+        }
+        return sseResponse((writer, _onClose) => {
+            writer(JSON.stringify({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32600,
+                    message: 'MCP session not found',
+                },
+            }));
+        });
+    }
+    if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+        console.log(`[MCP Debug]   SSE stream opened successfully`);
+    }
+    return sseResponse((writer, onClose) => {
+        // Store the writer so we can push notifications later
+        mcpSession.sseWriter = writer;
+        mcpSession.lastActivity = Date.now();
+        // Set up cleanup for when client disconnects
+        const cleanup = () => {
+            if (__classPrivateFieldGet(this, _MCPWebBridge_config, "f").debug) {
+                console.log(`[MCP Debug]   SSE stream closed for session ${mcpSessionId}`);
+            }
+            mcpSession.sseWriter = undefined;
+            mcpSession.sseCleanup = undefined;
+        };
+        mcpSession.sseCleanup = cleanup;
+        // Register the onClose callback
+        // Note: The adapter will call onClose when the client disconnects
+        // We store our cleanup function so we can also call it manually
+    });
+}, _MCPWebBridge_handleMcpSessionDelete = function _MCPWebBridge_handleMcpSessionDelete(sessionId) {
+    const mcpSession = __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").get(sessionId);
+    if (!mcpSession) {
+        return jsonResponse(404, { error: 'MCP session not found' });
+    }
+    // Clean up SSE stream if open
+    if (mcpSession.sseCleanup) {
+        mcpSession.sseCleanup();
+    }
+    __classPrivateFieldGet(this, _MCPWebBridge_mcpSessions, "f").delete(sessionId);
+    return jsonResponse(200, { success: true });
+};
+MCPWebBridge.MCP_SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+//# sourceMappingURL=core.js.map