@agenthippo-ai/agenthippo 0.1.0

package/out/gateway/bridge.js

@@ -0,0 +1,805 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayBridge = void 0;
+exports.isIdeThreadCompositeRouteKey = isIdeThreadCompositeRouteKey;
+exports.parseIdeThreadIdFromCompositeRouteKey = parseIdeThreadIdFromCompositeRouteKey;
+exports.buildIdeSessionRouteKey = buildIdeSessionRouteKey;
+exports.extractRouteLabelFromGatewaySessionKey = extractRouteLabelFromGatewaySessionKey;
+exports.looksLikeGatewayChannelRouteKey = looksLikeGatewayChannelRouteKey;
+exports.createGatewayBridge = createGatewayBridge;
+/* eslint-disable local/code-no-unexternalized-strings */
+/**
+ * Gateway Bridge - Connects AgentIDE agents to OpenClaw Gateway
+ *
+ * This allows IDE agents to receive messages from messaging channels
+ * (WhatsApp, Telegram, Discord, etc.) via the OpenClaw Gateway.
+ *
+ * The bridge's responsibility is to:
+ * 1. Maintain a WebSocket connection to the Gateway
+ * 2. Forward incoming messages to the existing chat system
+ * 3. Stream responses back to the Gateway
+ *
+ * It does NOT handle API keys or run agents directly - that's the chat system's job.
+ */
+const events_1 = require("events");
+const client_js_1 = require("./client.js");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const outboundHandles_js_1 = require("./outboundHandles.js");
+const outboundPaths_js_1 = require("./outboundPaths.js");
+/**
+ * Key for {@link GatewayService} session map. When the gateway sends the same `sessionKey` for
+ * an agent main session but different `sessionId` values (e.g. CLI `--session-id`), combine them
+ * so each logical thread gets its own VS Code chat.
+ */
+const IDE_THREAD_ROUTE_MARKER = "::sid:";
+/** True when {@link buildIdeSessionRouteKey} combined gateway `sessionKey` + `sessionId` (e.g. CLI `--session-id`). */
+function isIdeThreadCompositeRouteKey(routeKey) {
+    return Boolean(routeKey?.includes(IDE_THREAD_ROUTE_MARKER));
+}
+/** Extract the `sessionId` segment from a composite route key (`...::sid:<id>`). */
+function parseIdeThreadIdFromCompositeRouteKey(routeKey) {
+    if (!routeKey || !isIdeThreadCompositeRouteKey(routeKey)) {
+        return undefined;
+    }
+    const idx = routeKey.lastIndexOf(IDE_THREAD_ROUTE_MARKER);
+    const id = routeKey.slice(idx + IDE_THREAD_ROUTE_MARKER.length).trim();
+    return id.length > 0 ? id : undefined;
+}
+function buildIdeSessionRouteKey(sessionKey, sessionId) {
+    const sk = sessionKey?.trim();
+    const sid = sessionId?.trim();
+    if (sk && sid) {
+        return `${sk}${IDE_THREAD_ROUTE_MARKER}${sid}`;
+    }
+    return sk || sid;
+}
+/**
+ * Tail of `agent:<agentId>:<route-label>` used for channel/dm/thread peer routing.
+ * CLI `openclaw agent --session-id <label>` uses the same shape (see OpenClaw `toAgentStoreSessionKey`).
+ */
+function extractRouteLabelFromGatewaySessionKey(gatewaySessionKey) {
+    const trimmed = gatewaySessionKey.trim();
+    const prefix = "agent:";
+    if (!trimmed.toLowerCase().startsWith(prefix)) {
+        return undefined;
+    }
+    const without = trimmed.slice(prefix.length);
+    const firstColon = without.indexOf(":");
+    if (firstColon < 0) {
+        return undefined;
+    }
+    const rest = without.slice(firstColon + 1).trim();
+    return rest.length > 0 ? rest : undefined;
+}
+/** True when the gateway session key encodes a distinct messaging peer (Slack channel, DM, thread, etc.). */
+function looksLikeGatewayChannelRouteKey(routeKey) {
+    const baseKey = routeKey && routeKey.includes(IDE_THREAD_ROUTE_MARKER)
+        ? routeKey.slice(0, routeKey.lastIndexOf(IDE_THREAD_ROUTE_MARKER))
+        : routeKey;
+    const label = baseKey ? (extractRouteLabelFromGatewaySessionKey(baseKey) ?? baseKey) : undefined;
+    const parts = label?.split(":").filter(Boolean) ?? [];
+    if (parts.length < 2) {
+        return false;
+    }
+    return ["channel", "chat", "dm", "group", "thread", "user"].includes(parts[1].trim().toLowerCase());
+}
+/**
+ * Bridge that connects AgentIDE agents to OpenClaw Gateway.
+ *
+ * Usage:
+ * 1. Create bridge with Gateway URL
+ * 2. Connect to Gateway
+ * 3. Register agents with their HeadlessRunner instances
+ * 4. Gateway will route incoming messages to registered agents
+ */
+class GatewayBridge extends events_1.EventEmitter {
+    options;
+    client;
+    clientInfo;
+    agents = new Map();
+    serverConnId = null;
+    /**
+     * Some OpenClaw builds don't expose remote agent management RPCs.
+     * When absent, keep a local registry and continue in compatibility mode.
+     */
+    supportsAgentRegistration = null;
+    isUnknownMethodError(err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return message.toLowerCase().includes("unknown method");
+    }
+    /**
+     * Ensure the gateway runtime external-agent registry has this agent (CLI `agent` / `chat.send`
+     * use `isExternalAgent`). OpenClaw also registers on `agents.create` / `agents.update`, but
+     * calling `agents.register` here keeps older/partial gateway builds and reconnect races aligned.
+     */
+    async ensureGatewayRuntimeRegistration(agent, workspaceDir) {
+        try {
+            await this.client.request("agents.register", {
+                agent: {
+                    id: agent.id,
+                    name: agent.name ?? agent.id,
+                    workspace: workspaceDir,
+                },
+            });
+        }
+        catch (err) {
+            if (this.isUnknownMethodError(err)) {
+                return;
+            }
+            this.log(`agents.register follow-up failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    constructor(options) {
+        super();
+        this.options = options;
+        // Avoid process crash when socket errors propagate and no consumer listens on the bridge.
+        this.on("error", () => undefined);
+        const { client, clientInfo } = (0, client_js_1.createAgentIDEGatewayClient)(options.gatewayUrl, options.token, options.version);
+        this.client = client;
+        this.clientInfo = clientInfo;
+        this.setupEventHandlers();
+    }
+    setupEventHandlers() {
+        this.client.on("connected", async (hello) => {
+            this.serverConnId = hello.server.connId;
+            this.log(`Connected to Gateway (connId=${this.serverConnId})`);
+            this.emit("connected", hello);
+            // Re-register agents after reconnect
+            if (this.agents.size > 0) {
+                await this.reregisterAllAgents();
+            }
+        });
+        this.client.on("disconnected", () => {
+            this.log("Disconnected from Gateway");
+            this.emit("disconnected");
+        });
+        this.client.on("error", (err) => {
+            this.log(`Gateway error: ${err.message}`);
+            this.emit("error", err);
+        });
+        this.client.on("reconnecting", (attempt) => {
+            this.log(`Reconnecting to Gateway (attempt ${attempt})...`);
+            this.emit("reconnecting", attempt);
+        });
+        // Handle server-initiated requests (e.g., agent.run)
+        this.client.on("request", (frame) => {
+            this.handleServerRequest(frame);
+        });
+        // Handle events from Gateway
+        this.client.on("event:agents.updated", (payload) => {
+            this.emit("agents.updated", payload);
+        });
+    }
+    /**
+     * Connect to the OpenClaw Gateway
+     */
+    async connect() {
+        this.log(`Connecting to Gateway at ${this.options.gatewayUrl}...`);
+        return this.client.connect(this.clientInfo);
+    }
+    /**
+     * Register an agent with the Gateway.
+     * The agent will receive messages routed to its ID.
+     */
+    async registerAgent(agent) {
+        if (this.agents.has(agent.id)) {
+            throw new Error(`Agent ${agent.id} is already registered`);
+        }
+        // `agents.create` / `agents.update` require a filesystem `workspace` directory.
+        // The IDE's VS Code workspace path is not what OpenClaw isolated-agent runners expect.
+        const workspaceDir = (agent.workspace ?? this.resolveOpenClawWorkspaceDir(agent.id)).trim();
+        const syncConfigAgent = agent.syncOpenClawConfigAgent !== false;
+        if (!syncConfigAgent) {
+            await this.ensureGatewayRuntimeRegistration(agent, workspaceDir);
+        }
+        else if (this.supportsAgentRegistration === false) {
+            this.log(`Gateway remote agent management unavailable; using local registration for ${agent.id}`);
+        }
+        else {
+            try {
+                await this.client.request("agents.create", {
+                    name: agent.id,
+                    workspace: workspaceDir,
+                });
+                this.supportsAgentRegistration = true;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (this.isUnknownMethodError(err)) {
+                    this.supportsAgentRegistration = false;
+                    this.log(`Gateway remote agent management rejected (unknown method); using local registration for ${agent.id}`);
+                }
+                else if (message.toLowerCase().includes("already exists")) {
+                    // Make registration idempotent across reconnects.
+                    await this.client.request("agents.update", {
+                        agentId: agent.id,
+                        workspace: workspaceDir,
+                        name: agent.name ?? agent.id,
+                    });
+                    this.supportsAgentRegistration = true;
+                }
+                else {
+                    throw err;
+                }
+            }
+            await this.ensureGatewayRuntimeRegistration(agent, workspaceDir);
+        }
+        this.agents.set(agent.id, agent);
+        this.log(`Registered agent: ${agent.id}`);
+        this.emit("agent.registered", agent.id, { needsBinding: true });
+    }
+    /**
+     * Re-register all agents after reconnection
+     */
+    async reregisterAllAgents() {
+        this.log(`Re-registering ${this.agents.size} agent(s) after reconnect...`);
+        for (const agent of this.agents.values()) {
+            try {
+                if (agent.syncOpenClawConfigAgent === false) {
+                    const workspaceDir = (agent.workspace ?? this.resolveOpenClawWorkspaceDir(agent.id)).trim();
+                    await this.ensureGatewayRuntimeRegistration(agent, workspaceDir);
+                    this.log(`Re-registered runtime agent: ${agent.id}`);
+                    continue;
+                }
+                if (this.supportsAgentRegistration === false) {
+                    this.log(`Skipping remote re-register for ${agent.id} (gateway compatibility mode)`);
+                    continue;
+                }
+                const workspaceDir = (agent.workspace ?? this.resolveOpenClawWorkspaceDir(agent.id)).trim();
+                try {
+                    await this.client.request("agents.create", { name: agent.id, workspace: workspaceDir });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (message.toLowerCase().includes("already exists")) {
+                        await this.client.request("agents.update", {
+                            agentId: agent.id,
+                            workspace: workspaceDir,
+                            name: agent.name ?? agent.id,
+                        });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                await this.ensureGatewayRuntimeRegistration(agent, workspaceDir);
+                this.supportsAgentRegistration = true;
+                this.log(`Re-registered agent: ${agent.id}`);
+            }
+            catch (err) {
+                if (this.isUnknownMethodError(err)) {
+                    this.supportsAgentRegistration = false;
+                    this.log(`Gateway rejected remote agent management during reconnect (unknown method); keeping local registration for ${agent.id}`);
+                    continue;
+                }
+                this.log(`Failed to re-register agent ${agent.id}: ${err}`);
+            }
+        }
+        if (this.supportsAgentRegistration === false) {
+            this.log("Gateway compatibility mode active: inbound routing relies on plugin/session bridge, not agents.register.");
+        }
+    }
+    /**
+     * Unregister an agent from the Gateway
+     */
+    async unregisterAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        try {
+            if (this.supportsAgentRegistration === false) {
+                this.agents.delete(agentId);
+                this.log(`Unregistered local agent: ${agentId} (gateway compatibility mode)`);
+                this.emit("agent.unregistered", agentId);
+                return;
+            }
+            await this.client.request("agents.delete", { agentId, deleteFiles: false }, 30_000);
+            this.agents.delete(agentId);
+            this.log(`Unregistered agent: ${agentId}`);
+            this.emit("agent.unregistered", agentId);
+        }
+        catch (err) {
+            if (this.isUnknownMethodError(err)) {
+                this.supportsAgentRegistration = false;
+                this.agents.delete(agentId);
+                this.log(`Gateway rejected remote agent management delete (unknown method); removed local agent ${agentId} instead`);
+                this.emit("agent.unregistered", agentId);
+                return;
+            }
+            this.log(`Failed to unregister agent ${agentId}: ${err}`);
+        }
+    }
+    isGatewayCompatMode() {
+        return this.supportsAgentRegistration === false;
+    }
+    /**
+     * OpenClaw isolated agent workspace layout:
+     * - `main` uses `~/.openclaw/workspace`
+     * - other agents use `~/.openclaw/workspace-<agentId>`
+     */
+    resolveOpenClawWorkspaceDir(agentId) {
+        const root = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw");
+        return agentId === "main" ? node_path_1.default.join(root, "workspace") : node_path_1.default.join(root, `workspace-${agentId}`);
+    }
+    /**
+     * Handle server-initiated requests
+     */
+    async handleServerRequest(frame) {
+        if (frame.method === "agent.run") {
+            await this.handleAgentRun(frame);
+        }
+        else if (frame.method === "session.new") {
+            await this.handleSessionNew(frame);
+        }
+        else if (frame.method === "agent.cancel") {
+            this.handleAgentCancel(frame);
+        }
+        else {
+            // Unknown method
+            this.client.respond(frame.id, undefined, false, { code: "UNKNOWN_METHOD", message: `Unknown method: ${frame.method}` });
+        }
+    }
+    /**
+     * Handle agent.cancel request from Gateway.
+     * Emits an event for the service to cancel the current generation.
+     */
+    handleAgentCancel(frame) {
+        const params = frame.params;
+        this.log(`Received agent.cancel (agentId=${params?.agentId}, sessionKey=${params?.sessionKey})`);
+        this.emit("agent.cancel", params);
+        // Respond immediately - cancel is best-effort
+        this.client.respond(frame.id, { success: true }, true);
+    }
+    /**
+     * Handle session.new request from Gateway.
+     * Emits an event for the service to handle creating a new chat session.
+     */
+    async handleSessionNew(frame) {
+        const params = frame.params;
+        this.log(`Received session.new request from ${params?.requestedBy ?? "unknown"}`);
+        // Emit event for the service to handle
+        // The service will create a new session and register it
+        this.emit("session.new.request", {
+            requestId: frame.id,
+            params: params ?? {},
+        });
+    }
+    /**
+     * Respond to a session.new request.
+     * Called by the service after it has created (or failed to create) the session.
+     */
+    respondSessionNew(requestId, result) {
+        this.client.respond(requestId, result, result.success, result.success ? undefined : {
+            code: "SESSION_CREATE_ERROR",
+            message: result.error ?? "Failed to create session",
+        });
+    }
+    persistHeadlessGatewayOutbound(agent, agentId, params, runId, routeKey) {
+        const workspaceRoot = agent.workspace?.trim();
+        if (!workspaceRoot) {
+            return;
+        }
+        const gatewaySessionKey = params.sessionKey?.trim() || routeKey;
+        const sessionDirId = (0, outboundPaths_js_1.resolveGatewaySessionDirId)({ gatewaySessionKey });
+        if (!sessionDirId) {
+            return;
+        }
+        const storePath = (0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, sessionDirId);
+        const storeAgentId = agent.agentId?.trim() || agentId;
+        void (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, storeAgentId, params, runId, { gatewayAgentId: agentId })
+            .then((handle) => {
+            if (handle) {
+                this.log(`Gateway outbound routes: ${storePath}`);
+            }
+        })
+            .catch((err) => {
+            this.log(`Failed to persist outbound handle: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    /**
+     * Handle agent.run request from Gateway
+     */
+    async handleAgentRun(frame) {
+        const params = frame.params;
+        if (!params?.message) {
+            this.client.respond(frame.id, undefined, false, { code: "INVALID_PARAMS", message: "message is required" });
+            return;
+        }
+        const agentId = params.agentId || this.getDefaultAgentId();
+        if (!agentId) {
+            this.client.respond(frame.id, undefined, false, { code: "NO_AGENT", message: "No agent available" });
+            return;
+        }
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            this.client.respond(frame.id, undefined, false, { code: "AGENT_NOT_FOUND", message: `Agent ${agentId} not found` });
+            return;
+        }
+        this.log(`Running agent ${agentId} for message: ${params.message.slice(0, 50)}...`);
+        // Emit event so UI can show the incoming message
+        const routeKey = buildIdeSessionRouteKey(params.sessionKey, params.sessionId);
+        const runId = params.idempotencyKey || `${agentId}-${Date.now()}`;
+        this.emit("agent.message", {
+            agentId,
+            message: params.message,
+            channel: params.channel,
+            sessionKey: params.sessionKey,
+            sessionId: params.sessionId,
+            routeKey,
+        });
+        try {
+            // runId assigned above for outbound handle persistence
+            // When useChatUI is true, route to Chat UI handler exclusively.
+            // The gateway is purely a transport layer - it doesn't care about model IDs.
+            const shouldUseChatUI = Boolean(agent.useChatUI && agent.chatUIHandler);
+            if (shouldUseChatUI) {
+                this.log(`Routing gateway message to Chat UI for agent ${agentId} (routeKey=${routeKey ?? "none"})`);
+                await this.handleAgentRunViaChatUI(frame, agent, params, runId, routeKey);
+                return;
+            }
+            // Fallback: use direct message handler (requires engine/model config)
+            const engineId = agent.engineId || "claude";
+            // Check if we have a message handler
+            if (!agent.messageHandler) {
+                throw new Error("No message handler configured for agent");
+            }
+            this.log(`Agent ${agentId} processing message via direct handler, engine=${engineId}`);
+            this.persistHeadlessGatewayOutbound(agent, agentId, params, runId, routeKey);
+            // Capture client for use in emitter callbacks
+            const client = this.client;
+            let fullText = "";
+            let lastSentText = "";
+            let lastStreamTime = 0;
+            let inThinking = false;
+            const STREAM_THROTTLE_MS = 150;
+            const streamSessionKey = routeKey;
+            // Send accumulated text when it changed since the last delta (bypasses throttle).
+            // Called before block boundaries so OpenClaw block/final dedupe sees current text.
+            const flushStreamDelta = () => {
+                if (fullText === lastSentText) {
+                    return;
+                }
+                lastSentText = fullText;
+                lastStreamTime = Date.now();
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey: streamSessionKey,
+                    state: "delta",
+                    text: fullText,
+                });
+            };
+            // Create emitter that streams to Gateway
+            const emitter = {
+                async thinking() {
+                    // Signal thinking start so the gateway can emit accumulated text
+                    // as a block reply (natural break between text and thinking).
+                    // Only send once per text→thinking transition to avoid flooding.
+                    if (!inThinking) {
+                        flushStreamDelta();
+                        inThinking = true;
+                        client.sendEvent("agent.stream", {
+                            runId,
+                            agentId,
+                            sessionKey: streamSessionKey,
+                            state: "thinking",
+                        });
+                    }
+                },
+                async text(delta) {
+                    inThinking = false;
+                    fullText += delta;
+                    // Throttle streaming to Gateway
+                    const now = Date.now();
+                    if (now - lastStreamTime >= STREAM_THROTTLE_MS) {
+                        flushStreamDelta();
+                    }
+                },
+                async toolStart(name) {
+                    flushStreamDelta();
+                    client.sendEvent("agent.stream", {
+                        runId,
+                        agentId,
+                        sessionKey: streamSessionKey,
+                        state: "tool",
+                        toolName: name,
+                        toolState: "start",
+                    });
+                },
+                async toolEnd(name) {
+                    client.sendEvent("agent.stream", {
+                        runId,
+                        agentId,
+                        sessionKey: streamSessionKey,
+                        state: "tool",
+                        toolName: name,
+                        toolState: "end",
+                    });
+                },
+                async progress(msg) {
+                    client.sendEvent("agent.stream", {
+                        runId,
+                        agentId,
+                        sessionKey: streamSessionKey,
+                        state: "progress",
+                        message: msg,
+                    });
+                },
+                async question(payload) {
+                    client.sendEvent("agent.stream", {
+                        runId,
+                        agentId,
+                        sessionKey: streamSessionKey,
+                        state: "progress",
+                        message: `Question: ${payload.prompt}`,
+                    });
+                    return {
+                        selected: [],
+                        freeText: null,
+                        declined: true,
+                    };
+                },
+                async error(msg) {
+                    fullText += `\n[Error: ${msg}]`;
+                    client.sendEvent("agent.stream", {
+                        runId,
+                        agentId,
+                        sessionKey: streamSessionKey,
+                        state: "error",
+                        message: msg,
+                    });
+                },
+                async done() { },
+            };
+            // Call the message handler (goes through the chat system with API keys, sessions, etc.)
+            const result = await agent.messageHandler(params.message, {
+                engineId,
+                sessionId: routeKey,
+                gatewaySessionKey: params.sessionKey,
+                workspaceRoot: agent.workspace,
+                emitter,
+                // Forward the channel sender so serve can map it to a per-user user_id (serve-v3 #4).
+                peerInfo: (params.senderUsername || params.senderName || params.senderId || params.channel)
+                    ? { senderUsername: params.senderUsername, senderName: params.senderName, senderId: params.senderId, channel: params.channel }
+                    : undefined,
+            });
+            if (!result.success && result.error) {
+                throw new Error(result.error);
+            }
+            this.log(`Agent ${agentId} completed: fullText.len=${fullText?.length || 0}`);
+            if (!fullText) {
+                this.log(`WARNING: Agent ${agentId} produced empty response!`);
+            }
+            flushStreamDelta();
+            const response = {
+                text: fullText,
+                runId: params.idempotencyKey,
+            };
+            this.client.respond(frame.id, response, true);
+            this.log(`Agent ${agentId} completed successfully, response length=${fullText.length}`);
+            // Emit event with response for UI
+            this.emit("agent.response", {
+                agentId,
+                message: params.message,
+                response: fullText,
+            });
+        }
+        catch (err) {
+            this.client.respond(frame.id, undefined, false, {
+                code: "AGENT_ERROR",
+                message: err instanceof Error ? err.message : String(err),
+            });
+            this.log(`Agent ${agentId} failed: ${err}`);
+        }
+    }
+    /**
+     * Handle agent.run via Chat UI - routes message to VS Code chat panel
+     * and captures the response to send back to Gateway.
+     *
+     * This is the pure transport mode: gateway doesn't care about model IDs,
+     * the Chat UI handles everything.
+     */
+    async handleAgentRunViaChatUI(frame, agent, params, runId, sessionKey) {
+        const agentId = agent.id;
+        const client = this.client;
+        this.log(`handleAgentRunViaChatUI: agentId=${agentId}, message="${params.message.slice(0, 50)}...", runId=${runId}`);
+        // Create emitter that streams to Gateway - NO THROTTLE for real-time streaming
+        // Accumulate text because Control UI expects accumulated text per chunk (not deltas)
+        let fullText = "";
+        let inThinking = false;
+        const emitter = {
+            async thinking() {
+                // Signal thinking start so the gateway can emit accumulated text
+                // as a block reply. Only send once per text→thinking transition.
+                if (!inThinking) {
+                    inThinking = true;
+                    client.sendEvent("agent.stream", {
+                        runId,
+                        agentId,
+                        sessionKey,
+                        state: "thinking",
+                    });
+                }
+            },
+            async text(delta) {
+                inThinking = false;
+                fullText += delta;
+                // Stream accumulated text - Control UI expects full text per chunk
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "delta",
+                    text: fullText, // Send accumulated, not delta
+                });
+            },
+            async toolStart(name) {
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "tool",
+                    toolName: name,
+                    toolState: "start",
+                });
+            },
+            async toolEnd(name) {
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "tool",
+                    toolName: name,
+                    toolState: "end",
+                });
+            },
+            async progress(msg) {
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "progress",
+                    message: msg,
+                });
+            },
+            async question(payload) {
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "progress",
+                    message: `Question: ${payload.prompt}`,
+                });
+                return {
+                    selected: [],
+                    freeText: null,
+                    declined: true,
+                };
+            },
+            async error(msg) {
+                fullText += `\n[Error: ${msg}]`;
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "error",
+                    message: msg,
+                });
+            },
+            async done() {
+                // Final flush - send completion signal
+                client.sendEvent("agent.stream", {
+                    runId,
+                    agentId,
+                    sessionKey,
+                    state: "done",
+                });
+            },
+        };
+        try {
+            // Build peer info from params
+            const peerInfo = (params.senderUsername || params.senderName || params.senderId || params.channel)
+                ? {
+                    senderUsername: params.senderUsername,
+                    senderName: params.senderName,
+                    senderId: params.senderId,
+                    channel: params.channel,
+                }
+                : undefined;
+            // Route to Chat UI and wait for response
+            const responseText = await agent.chatUIHandler(params.message, sessionKey, peerInfo, emitter, { params, runId, agentId });
+            // Prefer the accumulated streamed text so the final reply is byte-identical
+            // to the text streamed as blocks. The gateway's block/final dedup slices the
+            // final by prefix-matching the last emitted block; using a separately-assembled
+            // responseText (markdown-part join) diverges on whitespace/normalization and
+            // makes that prefix match fail, causing already-streamed text to be re-sent
+            // (duplicate messages on tool-call turns). Fall back to responseText only when
+            // nothing was streamed.
+            const finalText = fullText || responseText;
+            this.log(`Agent ${agentId} (Chat UI) completed: response.len=${finalText.length}`);
+            if (!finalText) {
+                this.log(`WARNING: Agent ${agentId} (Chat UI) produced empty response!`);
+            }
+            const response = {
+                text: finalText,
+                runId: params.idempotencyKey,
+            };
+            this.client.respond(frame.id, response, true);
+            // Emit event with response for UI
+            this.emit("agent.response", {
+                agentId,
+                message: params.message,
+                response: finalText,
+            });
+        }
+        catch (err) {
+            this.client.respond(frame.id, undefined, false, {
+                code: "CHAT_UI_ERROR",
+                message: err instanceof Error ? err.message : String(err),
+            });
+            this.log(`Agent ${agentId} (Chat UI) failed: ${err}`);
+        }
+    }
+    getDefaultAgentId() {
+        if (this.agents.size === 1) {
+            const first = this.agents.keys().next();
+            return first.done ? undefined : first.value;
+        }
+        return undefined;
+    }
+    log(message) {
+        const logLine = `[GatewayBridge] ${message}`;
+        if (this.options.outputChannel) {
+            this.options.outputChannel.appendLine(logLine);
+        }
+        this.emit("log", logLine);
+    }
+    /**
+     * Disconnect from Gateway and cleanup
+     */
+    async disconnect() {
+        // Unregister all agents
+        for (const agentId of this.agents.keys()) {
+            await this.unregisterAgent(agentId);
+        }
+        this.client.close();
+        this.log("Disconnected from Gateway");
+    }
+    get isConnected() {
+        return this.client.isConnected;
+    }
+    get connId() {
+        return this.serverConnId;
+    }
+    get registeredAgents() {
+        return Array.from(this.agents.keys());
+    }
+    /**
+     * Force reconnection to Gateway
+     */
+    async reconnect() {
+        this.log("Force reconnecting to Gateway...");
+        await this.client.reconnect();
+    }
+    /**
+     * Send a request to Gateway (for health checks, etc.)
+     */
+    async request(method, params) {
+        return this.client.request(method, params);
+    }
+}
+exports.GatewayBridge = GatewayBridge;
+/**
+ * Create a GatewayBridge instance
+ */
+function createGatewayBridge(options) {
+    return new GatewayBridge(options);
+}