@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/gateway/bridge.js

@@ -1,843 +0,0 @@
-"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 = exports.MAX_GATEWAY_ID_CHARS = void 0;
-exports.isIdeThreadCompositeRouteKey = isIdeThreadCompositeRouteKey;
-exports.parseIdeThreadIdFromCompositeRouteKey = parseIdeThreadIdFromCompositeRouteKey;
-exports.findOversizedRunField = findOversizedRunField;
-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;
-}
-/** Max length for gateway-supplied identifiers that become filenames or route-index keys. */
-exports.MAX_GATEWAY_ID_CHARS = 512;
-const BOUNDED_RUN_FIELDS = [
-    "agentId", "sessionKey", "sessionId", "channel", "accountId",
-    "target", "threadId", "groupId", "senderUsername", "senderName", "senderId",
-];
-/**
- * Name the first `agent.run` identifier that is present but not a sane bounded string.
- * Returns undefined when every field is absent or valid.
- */
-function findOversizedRunField(params) {
-    const record = params;
-    for (const field of BOUNDED_RUN_FIELDS) {
-        const value = record[field];
-        if (value === undefined || value === null) {
-            continue;
-        }
-        if (typeof value !== "string" || value.length > exports.MAX_GATEWAY_ID_CHARS) {
-            return field;
-        }
-    }
-    return 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 || typeof params.message !== "string") {
-            this.client.respond(frame.id, undefined, false, { code: "INVALID_PARAMS", message: "message is required" });
-            return;
-        }
-        if (params.message.length > client_js_1.MAX_GATEWAY_MESSAGE_CHARS) {
-            this.client.respond(frame.id, undefined, false, {
-                code: "MESSAGE_TOO_LARGE",
-                message: `message exceeds ${client_js_1.MAX_GATEWAY_MESSAGE_CHARS} characters`,
-            });
-            return;
-        }
-        // These land in filenames, route-index keys and JSON stores. An over-long or non-string
-        // value from the gateway is rejected here rather than truncated downstream.
-        const oversizedField = findOversizedRunField(params);
-        if (oversizedField) {
-            this.client.respond(frame.id, undefined, false, { code: "INVALID_PARAMS", message: `${oversizedField} is not a valid string` });
-            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);
-}