@thinkwell/conductor 0.2.0

package/dist/conductor.js

@@ -0,0 +1,960 @@
+/**
+ * Conductor - orchestrates ACP proxy chains
+ *
+ * The conductor sits between a client and an agent, managing message routing
+ * through a chain of proxy components. It:
+ *
+ * 1. Manages the message event loop
+ * 2. Routes messages left-to-right (client → proxies → agent)
+ * 3. Routes messages right-to-left (agent → proxies → client)
+ * 4. Handles `_proxy/successor/*` message wrapping/unwrapping
+ * 5. Manages proxy capability handshake during initialization
+ * 6. Correlates requests with responses via a pending request map
+ * 7. Bridges MCP-over-ACP for agents without native ACP transport support
+ */
+import { isJsonRpcRequest, isJsonRpcNotification, isJsonRpcResponse, createSuccessResponse, createErrorResponse, createRequest, createNotification, createResponder, PROXY_SUCCESSOR_REQUEST, PROXY_SUCCESSOR_NOTIFICATION, unwrapProxySuccessorRequest, unwrapProxySuccessorNotification, wrapAsProxySuccessorRequest, wrapAsProxySuccessorNotification, } from "@thinkwell/protocol";
+import { MessageQueue } from "./message-queue.js";
+import { McpBridge } from "./mcp-bridge/index.js";
+import { createLogger, createNoopLogger } from "./logger.js";
+/**
+ * The Conductor orchestrates ACP proxy chains.
+ *
+ * It sits between a client and an agent, routing all messages through
+ * a central event loop to preserve message ordering.
+ *
+ * ## Message Flow with Proxies
+ *
+ * ### Left-to-Right (client → agent):
+ * 1. Client sends request to conductor
+ * 2. Conductor forwards to proxy[0] (normal ACP)
+ * 3. Proxy[0] sends `_proxy/successor/request` to conductor
+ * 4. Conductor unwraps and forwards to proxy[1] (normal ACP)
+ * 5. ... until agent receives normal ACP
+ *
+ * ### Right-to-Left (agent → client):
+ * 1. Agent sends notification/request to conductor
+ * 2. Conductor wraps in `_proxy/successor/request` and sends to proxy[n-1]
+ * 3. Proxy[n-1] processes and forwards to conductor
+ * 4. ... until client receives normal ACP
+ */
+export class Conductor {
+    config;
+    messageQueue = new MessageQueue();
+    logger;
+    state = { type: "uninitialized" };
+    // Component connections (populated after initialization)
+    clientConnection = null;
+    proxies = [];
+    agentConnection = null;
+    // Request/response correlation
+    // Maps outgoing request IDs to pending request info
+    pendingRequests = new Map();
+    nextRequestId = 1;
+    // MCP Bridge for agents without native MCP-over-ACP support
+    mcpBridge = null;
+    // Track whether agent supports mcp_acp_transport capability
+    agentSupportsMcpAcpTransport = false;
+    // Pending session/new requests waiting for response (for MCP URL transformation)
+    pendingSessionRequests = new Map();
+    // Maps MCP connection IDs to their responders for _mcp/connect
+    mcpConnectResponders = new Map();
+    constructor(config) {
+        this.config = config;
+        // Initialize logger
+        if (config.logging) {
+            this.logger = createLogger({
+                ...config.logging,
+                name: config.logging.name ?? config.name ?? "conductor",
+                trace: config.trace ?? config.logging.trace,
+            });
+        }
+        else if (config.trace) {
+            this.logger = createLogger({
+                level: "info",
+                name: config.name ?? "conductor",
+                trace: config.trace,
+            });
+        }
+        else {
+            this.logger = createNoopLogger();
+        }
+        // Initialize MCP bridge if enabled
+        if (config.mcpBridgeMode !== "disabled") {
+            this.mcpBridge = new McpBridge({ messageQueue: this.messageQueue });
+        }
+    }
+    /**
+     * Connect to a client and run the conductor's message loop.
+     *
+     * This method blocks until the conductor shuts down.
+     */
+    async connect(clientConnector) {
+        if (this.state.type !== "uninitialized") {
+            throw new Error(`Conductor is already ${this.state.type}`);
+        }
+        this.logger.info("Connecting to client");
+        this.clientConnection = await clientConnector.connect();
+        this.logger.debug("Client connected, starting message pump");
+        // Pump client messages into the queue
+        this.pumpClientMessages(this.clientConnection);
+        // Run the main event loop
+        this.logger.debug("Starting event loop");
+        await this.runEventLoop();
+        this.logger.info("Event loop exited");
+    }
+    /**
+     * Shut down the conductor
+     */
+    async shutdown() {
+        if (this.state.type === "shutdown") {
+            return;
+        }
+        this.logger.info("Shutting down conductor");
+        this.state = { type: "shutdown" };
+        this.messageQueue.close();
+        // Close all connections
+        const closePromises = [];
+        if (this.clientConnection) {
+            closePromises.push(this.clientConnection.close());
+        }
+        for (const proxy of this.proxies) {
+            closePromises.push(proxy.close());
+        }
+        if (this.agentConnection) {
+            closePromises.push(this.agentConnection.close());
+        }
+        // Close MCP bridge
+        if (this.mcpBridge) {
+            closePromises.push(this.mcpBridge.close());
+        }
+        await Promise.all(closePromises);
+        await this.logger.close();
+    }
+    /**
+     * Pump messages from the client into the message queue
+     */
+    pumpClientMessages(client) {
+        (async () => {
+            try {
+                for await (const message of client.messages) {
+                    // Responses from the client (to agent requests) need special handling
+                    if (isJsonRpcResponse(message)) {
+                        const dispatch = this.messageToDispatch(message, { type: "client" });
+                        if (dispatch && dispatch.type === "response") {
+                            // Route the response back via pendingRequests
+                            this.handleResponse(dispatch);
+                        }
+                        continue;
+                    }
+                    const dispatch = this.messageToDispatch(message, { type: "client" });
+                    if (dispatch) {
+                        this.messageQueue.push({
+                            type: "left-to-right",
+                            targetIndex: 0, // First component (proxy[0] or agent if no proxies)
+                            dispatch,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error("Error reading from client", { error: String(error) });
+            }
+            finally {
+                // Client disconnected - shut down
+                this.logger.debug("Client disconnected, shutting down");
+                this.shutdown();
+            }
+        })();
+    }
+    /**
+     * Pump messages from a proxy into the message queue
+     */
+    pumpProxyMessages(connection, proxyIndex) {
+        (async () => {
+            try {
+                for await (const message of connection.messages) {
+                    // Check for `_proxy/successor/*` messages
+                    if (isJsonRpcRequest(message)) {
+                        if (message.method === PROXY_SUCCESSOR_REQUEST) {
+                            // Proxy is forwarding a request to its successor
+                            this.handleProxySuccessorRequest(proxyIndex, message);
+                            continue;
+                        }
+                    }
+                    if (isJsonRpcNotification(message)) {
+                        if (message.method === PROXY_SUCCESSOR_NOTIFICATION) {
+                            // Proxy is forwarding a notification to its successor
+                            this.handleProxySuccessorNotification(proxyIndex, message);
+                            continue;
+                        }
+                    }
+                    // Non-successor messages go right-to-left (toward client)
+                    const dispatch = this.messageToDispatch(message, {
+                        type: "proxy",
+                        index: proxyIndex,
+                    });
+                    if (dispatch) {
+                        this.messageQueue.push({
+                            type: "right-to-left",
+                            sourceIndex: { type: "proxy", index: proxyIndex },
+                            dispatch,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error("Error reading from proxy", { proxyIndex, error: String(error) });
+            }
+            finally {
+                // Component disconnected - shut down the whole chain
+                this.logger.debug("Proxy disconnected, shutting down", { proxyIndex });
+                this.shutdown();
+            }
+        })();
+    }
+    /**
+     * Pump messages from the agent into the message queue
+     */
+    pumpAgentMessages(connection) {
+        (async () => {
+            try {
+                for await (const message of connection.messages) {
+                    const dispatch = this.messageToDispatch(message, {
+                        type: "successor",
+                    });
+                    if (dispatch) {
+                        this.messageQueue.push({
+                            type: "right-to-left",
+                            sourceIndex: { type: "successor" },
+                            dispatch,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error("Error reading from agent", { error: String(error) });
+            }
+            finally {
+                // Component disconnected - shut down the whole chain
+                this.logger.debug("Agent disconnected, shutting down");
+                this.shutdown();
+            }
+        })();
+    }
+    /**
+     * Handle a `_proxy/successor/request` from a proxy
+     *
+     * The proxy is forwarding a request to its successor (next proxy or agent).
+     * We unwrap the inner request and forward it.
+     */
+    handleProxySuccessorRequest(proxyIndex, message) {
+        const params = message.params;
+        const inner = unwrapProxySuccessorRequest(params);
+        // Create a responder that wraps the response back to the proxy
+        const responder = createResponder((result) => {
+            // Send success response back to the proxy for the _proxy/successor/request
+            this.proxies[proxyIndex]?.send(createSuccessResponse(message.id, result));
+        }, (error) => {
+            // Send error response back to the proxy
+            this.proxies[proxyIndex]?.send(createErrorResponse(message.id, error));
+        });
+        const dispatch = {
+            type: "request",
+            id: message.id,
+            method: inner.method,
+            params: inner.params,
+            responder,
+        };
+        // Forward to the next component (proxy[proxyIndex+1] or agent)
+        const targetIndex = proxyIndex + 1;
+        this.messageQueue.push({
+            type: "left-to-right",
+            targetIndex,
+            dispatch,
+        });
+    }
+    /**
+     * Handle a `_proxy/successor/notification` from a proxy
+     *
+     * The proxy is forwarding a notification to its successor.
+     */
+    handleProxySuccessorNotification(proxyIndex, message) {
+        const params = message.params;
+        const inner = unwrapProxySuccessorNotification(params);
+        const dispatch = {
+            type: "notification",
+            method: inner.method,
+            params: inner.params,
+        };
+        // Forward to the next component
+        const targetIndex = proxyIndex + 1;
+        this.messageQueue.push({
+            type: "left-to-right",
+            targetIndex,
+            dispatch,
+        });
+    }
+    /**
+     * Convert a JSON-RPC message to a Dispatch
+     */
+    messageToDispatch(message, source) {
+        if (isJsonRpcRequest(message)) {
+            // For requests, we need to create a responder that routes back
+            const responder = this.createResponderForSource(source, message.id);
+            return {
+                type: "request",
+                id: message.id,
+                method: message.method,
+                params: message.params,
+                responder,
+            };
+        }
+        if (isJsonRpcNotification(message)) {
+            return {
+                type: "notification",
+                method: message.method,
+                params: message.params,
+            };
+        }
+        if (isJsonRpcResponse(message)) {
+            return {
+                type: "response",
+                id: message.id,
+                result: "result" in message ? message.result : undefined,
+                error: "error" in message ? message.error : undefined,
+            };
+        }
+        return null;
+    }
+    /**
+     * Create a responder that routes the response back to the appropriate destination
+     */
+    createResponderForSource(source, requestId) {
+        if (source.type === "client") {
+            // Response goes back to client
+            return createResponder((result) => {
+                this.clientConnection?.send(createSuccessResponse(requestId, result));
+            }, (error) => {
+                this.clientConnection?.send(createErrorResponse(requestId, error));
+            });
+        }
+        else if (source.type === "proxy") {
+            // Response goes back to the proxy (as response to a normal ACP request)
+            const proxyIndex = source.index;
+            return createResponder((result) => {
+                this.proxies[proxyIndex]?.send(createSuccessResponse(requestId, result));
+            }, (error) => {
+                this.proxies[proxyIndex]?.send(createErrorResponse(requestId, error));
+            });
+        }
+        else {
+            // Response goes back to the agent
+            return createResponder((result) => {
+                this.agentConnection?.send(createSuccessResponse(requestId, result));
+            }, (error) => {
+                this.agentConnection?.send(createErrorResponse(requestId, error));
+            });
+        }
+    }
+    /**
+     * Run the main event loop, processing messages from the queue
+     */
+    async runEventLoop() {
+        for await (const message of this.messageQueue) {
+            await this.handleMessage(message);
+        }
+    }
+    /**
+     * Handle a message from the queue
+     */
+    async handleMessage(message) {
+        // Trace message for JSONL output
+        this.logger.traceMessage({
+            direction: message.type === "left-to-right" ? "left-to-right"
+                : message.type === "right-to-left" ? "right-to-left"
+                    : "internal",
+            source: this.getMessageSource(message),
+            target: this.getMessageTarget(message),
+            message,
+        });
+        switch (message.type) {
+            case "left-to-right":
+                this.logger.trace("Routing left-to-right", {
+                    targetIndex: message.targetIndex,
+                    dispatchType: message.dispatch.type,
+                    method: "method" in message.dispatch ? message.dispatch.method : undefined,
+                });
+                await this.handleLeftToRight(message.targetIndex, message.dispatch);
+                break;
+            case "right-to-left":
+                this.logger.trace("Routing right-to-left", {
+                    sourceIndex: message.sourceIndex,
+                    dispatchType: message.dispatch.type,
+                    method: "method" in message.dispatch ? message.dispatch.method : undefined,
+                });
+                await this.handleRightToLeft(message.sourceIndex, message.dispatch);
+                break;
+            case "shutdown":
+                this.logger.debug("Received shutdown message");
+                // Already handled by message queue closing
+                break;
+            // MCP bridge messages
+            case "mcp-connection-received":
+                this.logger.debug("MCP connection received", { acpUrl: message.acpUrl, connectionId: message.connectionId });
+                await this.handleMcpConnectionReceived(message.acpUrl, message.connectionId);
+                break;
+            case "mcp-connection-established":
+                this.logger.debug("MCP connection established", { connectionId: message.connectionId });
+                // Connection established successfully - nothing more to do
+                break;
+            case "mcp-client-to-server":
+                this.logger.trace("MCP client-to-server message", { connectionId: message.connectionId });
+                await this.handleMcpClientToServer(message.connectionId, message.dispatch);
+                break;
+            case "mcp-connection-disconnected":
+                this.logger.debug("MCP connection disconnected", { connectionId: message.connectionId });
+                await this.handleMcpConnectionDisconnected(message.connectionId);
+                break;
+        }
+    }
+    /**
+     * Get the source identifier for a message (for tracing)
+     */
+    getMessageSource(message) {
+        switch (message.type) {
+            case "left-to-right":
+                return message.targetIndex === 0 ? "client" : `proxy[${message.targetIndex - 1}]`;
+            case "right-to-left":
+                return message.sourceIndex.type === "successor" ? "agent" : `proxy[${message.sourceIndex.index}]`;
+            case "mcp-connection-received":
+            case "mcp-client-to-server":
+            case "mcp-connection-disconnected":
+                return "mcp-bridge";
+            default:
+                return "internal";
+        }
+    }
+    /**
+     * Get the target identifier for a message (for tracing)
+     */
+    getMessageTarget(message) {
+        switch (message.type) {
+            case "left-to-right":
+                return message.targetIndex < this.proxies.length
+                    ? `proxy[${message.targetIndex}]`
+                    : "agent";
+            case "right-to-left":
+                if (message.sourceIndex.type === "proxy" && message.sourceIndex.index === 0) {
+                    return "client";
+                }
+                return message.sourceIndex.type === "successor"
+                    ? `proxy[${this.proxies.length - 1}]`
+                    : `proxy[${message.sourceIndex.index - 1}]`;
+            case "mcp-connection-received":
+            case "mcp-client-to-server":
+            case "mcp-connection-disconnected":
+                return "client";
+            default:
+                return "conductor";
+        }
+    }
+    /**
+     * Handle a left-to-right message (client → agent direction)
+     */
+    async handleLeftToRight(targetIndex, dispatch) {
+        // Check if this is an initialize request from the client and we need to set up components
+        if (targetIndex === 0 &&
+            dispatch.type === "request" &&
+            (dispatch.method === "initialize" || dispatch.method === "acp/initialize")) {
+            await this.handleInitialize(dispatch);
+            return;
+        }
+        // Check if this is a session/new request that needs MCP URL transformation
+        if (dispatch.type === "request" &&
+            dispatch.method === "session/new" &&
+            this.mcpBridge &&
+            !this.agentSupportsMcpAcpTransport) {
+            await this.handleSessionNew(targetIndex, dispatch);
+            return;
+        }
+        // Determine target connection
+        const target = this.getTargetConnection(targetIndex);
+        if (!target) {
+            if (dispatch.type === "request") {
+                dispatch.responder.respondWithError({
+                    code: -32603,
+                    message: `No target connection for index ${targetIndex}`,
+                });
+            }
+            return;
+        }
+        // Forward to the target
+        this.forwardToConnection(target, dispatch);
+    }
+    /**
+     * Handle a right-to-left message (agent/proxy → client direction)
+     */
+    async handleRightToLeft(sourceIndex, dispatch) {
+        // Responses need special handling - route via pending request map
+        if (dispatch.type === "response") {
+            this.handleResponse(dispatch);
+            return;
+        }
+        // Determine where to send this message
+        // - If from successor (agent) and we have proxies, wrap and send to last proxy
+        // - If from proxy[n], send to proxy[n-1] or client if n==0
+        // - If no proxies, send directly to client
+        if (this.proxies.length === 0) {
+            // No proxies - send directly to client
+            if (this.clientConnection) {
+                this.forwardToConnection(this.clientConnection, dispatch);
+            }
+            return;
+        }
+        if (sourceIndex.type === "successor") {
+            // Message from agent - wrap and send to last proxy
+            const lastProxyIndex = this.proxies.length - 1;
+            this.forwardWrappedToProxy(lastProxyIndex, dispatch);
+        }
+        else if (sourceIndex.type === "proxy") {
+            const proxyIndex = sourceIndex.index;
+            if (proxyIndex === 0) {
+                // First proxy - send to client (unwrapped)
+                if (this.clientConnection) {
+                    this.forwardToConnection(this.clientConnection, dispatch);
+                }
+            }
+            else {
+                // Send to previous proxy (wrapped)
+                this.forwardWrappedToProxy(proxyIndex - 1, dispatch);
+            }
+        }
+    }
+    /**
+     * Forward a dispatch to a proxy, wrapped in `_proxy/successor/*`
+     *
+     * This is used when routing messages FROM a successor (agent or later proxy)
+     * TO an earlier proxy in the chain.
+     */
+    forwardWrappedToProxy(proxyIndex, dispatch) {
+        const proxy = this.proxies[proxyIndex];
+        if (!proxy)
+            return;
+        switch (dispatch.type) {
+            case "request": {
+                // Wrap as `_proxy/successor/request`
+                const wrappedParams = wrapAsProxySuccessorRequest(dispatch.method, dispatch.params);
+                const outgoingId = this.generateRequestId();
+                this.pendingRequests.set(String(outgoingId), {
+                    originalId: dispatch.id,
+                    responder: dispatch.responder,
+                    source: proxyIndex,
+                });
+                proxy.send(createRequest(outgoingId, PROXY_SUCCESSOR_REQUEST, wrappedParams));
+                break;
+            }
+            case "notification": {
+                // Wrap as `_proxy/successor/notification`
+                const wrappedParams = wrapAsProxySuccessorNotification(dispatch.method, dispatch.params);
+                proxy.send(createNotification(PROXY_SUCCESSOR_NOTIFICATION, wrappedParams));
+                break;
+            }
+            case "response":
+                // Responses are handled via handleResponse, not here
+                break;
+        }
+    }
+    /**
+     * Handle the initialize request - instantiate components and perform initialization sequence
+     *
+     * The initialization follows this sequence:
+     * 1. Instantiate all components (connect to proxies and agent)
+     * 2. Send `initialize` with `_meta.proxy: true` to proxy[0]
+     * 3. Proxy[0] will use `_proxy/successor/request` to forward to proxy[1], etc.
+     * 4. Agent receives `initialize` without proxy capability
+     * 5. Responses flow back up the chain
+     * 6. Conductor verifies each proxy accepted the proxy capability
+     */
+    async handleInitialize(dispatch) {
+        if (this.state.type !== "uninitialized") {
+            dispatch.responder.respondWithError({
+                code: -32600,
+                message: "Conductor already initialized",
+            });
+            return;
+        }
+        this.state = { type: "initializing" };
+        this.logger.info("Starting initialization");
+        try {
+            // Build the initialize request structure
+            const initRequest = {
+                method: dispatch.method,
+                params: dispatch.params,
+            };
+            // Instantiate components
+            this.logger.debug("Instantiating components");
+            const { proxies, agent } = await this.config.instantiator.instantiate(initRequest);
+            this.logger.info("Components instantiated", { proxyCount: proxies.length });
+            // Connect to proxies
+            for (const proxyConnector of proxies) {
+                const proxyConnection = await proxyConnector.connect();
+                this.proxies.push(proxyConnection);
+                this.logger.debug("Proxy connected", { proxyIndex: this.proxies.length - 1 });
+                // Start pumping messages from this proxy
+                this.pumpProxyMessages(proxyConnection, this.proxies.length - 1);
+            }
+            // Connect to agent
+            this.logger.debug("Connecting to agent");
+            this.agentConnection = await agent.connect();
+            this.pumpAgentMessages(this.agentConnection);
+            this.logger.info("Agent connected");
+            this.state = { type: "running" };
+            this.logger.info("Conductor running");
+            if (this.proxies.length === 0) {
+                // No proxies - forward initialize directly to agent
+                const outgoingId = this.generateRequestId();
+                this.pendingRequests.set(String(outgoingId), {
+                    originalId: dispatch.id,
+                    responder: this.createAgentInitializeResponder(dispatch.responder),
+                    source: "client",
+                });
+                this.agentConnection.send(createRequest(outgoingId, dispatch.method, dispatch.params));
+            }
+            else {
+                // With proxies - send initialize with proxy capability to first proxy
+                const paramsWithProxy = this.addProxyCapability(dispatch.params);
+                const outgoingId = this.generateRequestId();
+                this.pendingRequests.set(String(outgoingId), {
+                    originalId: dispatch.id,
+                    responder: this.createProxyInitializeResponder(this.createAgentInitializeResponder(dispatch.responder)),
+                    source: "client",
+                });
+                this.proxies[0].send(createRequest(outgoingId, dispatch.method, paramsWithProxy));
+            }
+        }
+        catch (error) {
+            this.state = { type: "uninitialized" };
+            this.logger.error("Initialization failed", { error: String(error) });
+            dispatch.responder.respondWithError({
+                code: -32603,
+                message: `Failed to initialize: ${error}`,
+            });
+        }
+    }
+    /**
+     * Add proxy capability to initialize params
+     */
+    addProxyCapability(params) {
+        const p = (params ?? {});
+        const meta = (p._meta ?? {});
+        return {
+            ...p,
+            _meta: {
+                ...meta,
+                proxy: true,
+            },
+        };
+    }
+    /**
+     * Remove proxy capability from initialize params (for forwarding to agent)
+     */
+    removeProxyCapability(params) {
+        const p = (params ?? {});
+        const meta = (p._meta ?? {});
+        const { proxy: _, ...restMeta } = meta;
+        return {
+            ...p,
+            _meta: restMeta,
+        };
+    }
+    /**
+     * Create a responder that verifies the proxy accepted the capability
+     */
+    createProxyInitializeResponder(originalResponder) {
+        return createResponder((result) => {
+            // Verify the proxy accepted the proxy capability
+            const response = result;
+            if (!response?._meta?.proxy) {
+                originalResponder.respondWithError({
+                    code: -32600,
+                    message: "Proxy component did not accept proxy capability",
+                });
+                return;
+            }
+            originalResponder.respond(result);
+        }, (error) => {
+            originalResponder.respondWithError(error);
+        });
+    }
+    /**
+     * Create a responder that captures the agent's mcp_acp_transport capability
+     */
+    createAgentInitializeResponder(originalResponder) {
+        return createResponder((result) => {
+            // Capture the mcp_acp_transport capability
+            const response = result;
+            if (response?.capabilities?.mcp_acp_transport) {
+                this.agentSupportsMcpAcpTransport = true;
+            }
+            originalResponder.respond(result);
+        }, (error) => {
+            originalResponder.respondWithError(error);
+        });
+    }
+    /**
+     * Handle a response by routing it back to the original requester
+     */
+    handleResponse(dispatch) {
+        const pending = this.pendingRequests.get(String(dispatch.id));
+        if (!pending) {
+            // No pending request for this ID - might be a duplicate or error
+            this.logger.warn("No pending request for response ID", { id: dispatch.id });
+            return;
+        }
+        this.pendingRequests.delete(String(dispatch.id));
+        if (dispatch.error) {
+            pending.responder.respondWithError(dispatch.error);
+        }
+        else {
+            pending.responder.respond(dispatch.result);
+        }
+    }
+    /**
+     * Forward a dispatch to a connection, handling request ID rewriting
+     */
+    forwardToConnection(connection, dispatch) {
+        switch (dispatch.type) {
+            case "request": {
+                // Rewrite request ID and track for response routing
+                const outgoingId = this.generateRequestId();
+                this.pendingRequests.set(String(outgoingId), {
+                    originalId: dispatch.id,
+                    responder: dispatch.responder,
+                    source: "client", // Default - actual source tracking is in PendingRequest
+                });
+                connection.send(createRequest(outgoingId, dispatch.method, dispatch.params));
+                break;
+            }
+            case "notification":
+                connection.send(createNotification(dispatch.method, dispatch.params));
+                break;
+            case "response":
+                // Responses are handled via handleResponse, not forwarded directly
+                if (dispatch.error) {
+                    connection.send(createErrorResponse(dispatch.id, dispatch.error));
+                }
+                else {
+                    connection.send(createSuccessResponse(dispatch.id, dispatch.result));
+                }
+                break;
+        }
+    }
+    /**
+     * Get the target connection for a given index
+     * Index 0..n-1 are proxies, index n is the agent
+     */
+    getTargetConnection(targetIndex) {
+        if (targetIndex < this.proxies.length) {
+            return this.proxies[targetIndex];
+        }
+        if (targetIndex === this.proxies.length) {
+            return this.agentConnection;
+        }
+        return null;
+    }
+    /**
+     * Handle a session/new request - transform acp: URLs to http: URLs
+     *
+     * If the request contains MCP servers with acp: URLs and the agent doesn't
+     * support mcp_acp_transport, we:
+     * 1. Spawn HTTP listeners for each acp: URL
+     * 2. Transform the URLs to http://localhost:$PORT
+     * 3. Forward the modified request to the agent
+     * 4. When the response comes back with session_id, deliver it to the listeners
+     */
+    async handleSessionNew(targetIndex, dispatch) {
+        const params = dispatch.params;
+        const servers = params?.mcpServers;
+        // Generate a session key to correlate the request with the response
+        const sessionKey = `session-${this.generateRequestId()}`;
+        // Transform MCP servers if needed
+        const { transformedServers, hasAcpServers } = await this.mcpBridge.transformMcpServers(servers, sessionKey);
+        if (!hasAcpServers) {
+            // No acp: servers - forward unchanged
+            const target = this.getTargetConnection(targetIndex);
+            if (target) {
+                this.forwardToConnection(target, dispatch);
+            }
+            return;
+        }
+        // Build the modified params with transformed servers
+        const modifiedParams = {
+            ...params,
+            mcpServers: transformedServers,
+        };
+        // Create a responder that captures the session_id and delivers it to listeners
+        const originalResponder = dispatch.responder;
+        const wrappedResponder = createResponder((result) => {
+            // Extract session_id from the response
+            const response = result;
+            if (response?.sessionId) {
+                this.mcpBridge.completeSession(sessionKey, response.sessionId);
+            }
+            originalResponder.respond(result);
+        }, async (error) => {
+            // Cancel the pending session on error
+            await this.mcpBridge.cancelSession(sessionKey);
+            originalResponder.respondWithError(error);
+        });
+        // Forward the modified request
+        const target = this.getTargetConnection(targetIndex);
+        if (!target) {
+            dispatch.responder.respondWithError({
+                code: -32603,
+                message: `No target connection for index ${targetIndex}`,
+            });
+            return;
+        }
+        const modifiedDispatch = {
+            type: "request",
+            id: dispatch.id,
+            method: dispatch.method,
+            params: modifiedParams,
+            responder: wrappedResponder,
+        };
+        this.forwardToConnection(target, modifiedDispatch);
+    }
+    /**
+     * Handle an MCP connection received from the HTTP bridge
+     *
+     * When an agent connects to our HTTP listener, we need to:
+     * 1. Send _mcp/connect to the proxy that owns this acp: URL
+     * 2. Wait for the connection_id in the response
+     */
+    async handleMcpConnectionReceived(acpUrl, connectionId) {
+        // The connection needs to be routed to the proxy that provides this MCP server
+        // For now, we route to the first proxy (or client if no proxies)
+        // In a more complete implementation, we'd track which proxy registered which URL
+        const mcpConnectParams = {
+            connectionId,
+            url: acpUrl,
+        };
+        // Create a responder for the _mcp/connect request
+        const responder = createResponder((result) => {
+            // Connection established - notify via message queue
+            const response = result;
+            this.messageQueue.push({
+                type: "mcp-connection-established",
+                connectionId: response.connectionId ?? connectionId,
+                serverInfo: response.serverInfo ?? { name: "unknown", version: "0.0.0" },
+            });
+        }, (error) => {
+            this.logger.error("MCP connect failed", { connectionId, acpUrl, error });
+        });
+        this.mcpConnectResponders.set(connectionId, responder);
+        // Route _mcp/connect request toward the client (right-to-left)
+        const dispatch = {
+            type: "request",
+            id: this.generateRequestId(),
+            method: "_mcp/connect",
+            params: mcpConnectParams,
+            responder,
+        };
+        // Send to client (or first proxy in the backward direction)
+        if (this.proxies.length === 0) {
+            // No proxies - send directly to client
+            if (this.clientConnection) {
+                this.forwardToConnection(this.clientConnection, dispatch);
+            }
+        }
+        else {
+            // With proxies - wrap and send to last proxy (backward direction)
+            this.forwardWrappedToProxy(this.proxies.length - 1, dispatch);
+        }
+    }
+    /**
+     * Handle an MCP message from a client (through the HTTP bridge)
+     *
+     * This routes MCP tool calls and other messages through the ACP chain.
+     */
+    async handleMcpClientToServer(connectionId, dispatch) {
+        // Wrap the MCP message in _mcp/message format
+        const mcpMessageParams = {
+            connectionId,
+            method: dispatch.type === "request" || dispatch.type === "notification"
+                ? dispatch.method
+                : undefined,
+            params: dispatch.type === "request" || dispatch.type === "notification"
+                ? dispatch.params
+                : undefined,
+            id: dispatch.type === "request" ? dispatch.id : undefined,
+        };
+        if (dispatch.type === "request") {
+            // Create _mcp/message request
+            const mcpDispatch = {
+                type: "request",
+                id: this.generateRequestId(),
+                method: "_mcp/message",
+                params: mcpMessageParams,
+                responder: dispatch.responder,
+            };
+            // Route toward client (right-to-left direction)
+            if (this.proxies.length === 0) {
+                if (this.clientConnection) {
+                    this.forwardToConnection(this.clientConnection, mcpDispatch);
+                }
+            }
+            else {
+                this.forwardWrappedToProxy(this.proxies.length - 1, mcpDispatch);
+            }
+        }
+        else if (dispatch.type === "notification") {
+            // Create _mcp/message notification
+            const mcpDispatch = {
+                type: "notification",
+                method: "_mcp/message",
+                params: mcpMessageParams,
+            };
+            // Route toward client
+            if (this.proxies.length === 0) {
+                if (this.clientConnection) {
+                    this.forwardToConnection(this.clientConnection, mcpDispatch);
+                }
+            }
+            else {
+                this.forwardWrappedToProxy(this.proxies.length - 1, mcpDispatch);
+            }
+        }
+    }
+    /**
+     * Handle an MCP connection being disconnected
+     */
+    async handleMcpConnectionDisconnected(connectionId) {
+        // Clean up the connect responder if still pending
+        this.mcpConnectResponders.delete(connectionId);
+        // Send _mcp/disconnect notification toward client
+        const dispatch = {
+            type: "notification",
+            method: "_mcp/disconnect",
+            params: { connectionId },
+        };
+        // Route toward client
+        if (this.proxies.length === 0) {
+            if (this.clientConnection) {
+                this.forwardToConnection(this.clientConnection, dispatch);
+            }
+        }
+        else {
+            this.forwardWrappedToProxy(this.proxies.length - 1, dispatch);
+        }
+    }
+    /**
+     * Generate a unique request ID for outgoing requests
+     */
+    generateRequestId() {
+        return this.nextRequestId++;
+    }
+}
+// Re-export instantiator helpers for convenience
+export { fromCommands, fromConnectors, dynamic, staticInstantiator } from "./instantiators.js";
+//# sourceMappingURL=conductor.js.map