@agenthippo-ai/agenthippo 0.1.0

package/out/cli/commands/serve.js

@@ -0,0 +1,583 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveCommand = serveCommand;
+/**
+ * Serve Command - HTTP Server
+ */
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const headless_1 = require("../../headless");
+const pack_loader_1 = require("../pack-loader");
+const utils_1 = require("../utils");
+const runtime_1 = require("../runtime");
+const serve_hardening_1 = require("../serve-hardening");
+const credential_context_1 = require("../credential-context");
+const state_sync_1 = require("../state-sync");
+const cli_agent_id_js_1 = require("../../gateway/cli-agent-id.js");
+const openclaw_channel_routing_js_1 = require("../../gateway/openclaw-channel-routing.js");
+const customRegistry_1 = require("../../engines/customRegistry");
+const BANNER_LINE = '-'.repeat(62);
+async function serveCommand(options) {
+    const apiConfig = (0, pack_loader_1.getApiConfig)();
+    // Load agent pack (required)
+    let pack;
+    const syncLogger = options.verbose ? new headless_1.ConsoleLogger('[Sync]') : new headless_1.NoOpLogger();
+    try {
+        pack = await (0, pack_loader_1.loadAgentPack)(options.agent, options.workspace);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    const packId = pack.manifest.metadata.name;
+    const gatewayAgentId = (0, cli_agent_id_js_1.resolveCliGatewayAgentId)(packId);
+    const defaultEngine = (options.engine || pack.manifest.spec.engine || (0, pack_loader_1.getDefaultConfig)().engine).trim().toLowerCase();
+    const customEngineDefaultModel = !['claude', 'codex'].includes(defaultEngine)
+        ? (0, customRegistry_1.tryResolveCustomEngineManifest)(options.workspace, defaultEngine)?.model?.defaultModel
+        : undefined;
+    // Custom engine manifest defaultModel beats the global AGENTHIPPO_DEFAULT_MODEL
+    // so --engine gemini without --model uses gemini's manifest default, not the
+    // user's global Claude/Codex fallback.
+    const rawModel = options.model || pack.manifest.spec.model || customEngineDefaultModel || (0, pack_loader_1.getEnvDefaultModel)() || (0, pack_loader_1.getDefaultConfig)().model;
+    const defaultModel = (0, headless_1.resolveModelAlias)(rawModel);
+    const rawCheapModel = pack.manifest.spec.cheapModel?.trim();
+    const claudeCheapModel = rawCheapModel ? (0, headless_1.resolveModelAlias)(rawCheapModel) : undefined;
+    if (!apiConfig.apiKey && (defaultEngine === 'claude' || defaultEngine === 'codex')) {
+        console.error('Error: No API key found. Set AGENTHIPPO_LITELLM_API_KEY or ANTHROPIC_API_KEY');
+        for (const line of (0, utils_1.getLiteLLMQuickstartHintLines)()) {
+            console.error(line);
+        }
+        process.exit(1);
+    }
+    // Sync pack content to workspace
+    const bundledPromptsDir = (0, utils_1.findBundledBasePromptsDir)();
+    await (0, headless_1.syncPackToWorkspace)(options.workspace, pack.packPath, packId, defaultEngine, syncLogger, bundledPromptsDir);
+    console.log(`OK: Loaded agent: ${pack.manifest.metadata.name} v${pack.manifest.metadata.version}`);
+    // Resolve persistent session state (serve-v3 §A1: replaces the tmpdir default).
+    const { dir: storagePath, ephemeral } = (0, serve_hardening_1.resolveStateDir)(options.stateDir);
+    const bindHost = (0, serve_hardening_1.resolveBindHost)(options.host);
+    const turnLimiter = new serve_hardening_1.TurnLimiter(options.maxTurnsPerSession ?? 0);
+    // Per-identity request-rate cap (req/min). Keyed on the trusted user id (falling back to
+    // client IP) so rotating session_id can't bypass it. AGENTHIPPO_SERVE_RATE_LIMIT=0 disables.
+    const rateLimitPerMin = Number(process.env.AGENTHIPPO_SERVE_RATE_LIMIT ?? 120);
+    const rateLimiter = new serve_hardening_1.RateLimiter(Number.isFinite(rateLimitPerMin) ? rateLimitPerMin : 120);
+    let landingPageHtml;
+    if (options.wwwDir?.trim()) {
+        const indexPath = path.join(path.resolve(options.wwwDir.trim()), 'index.html');
+        try {
+            landingPageHtml = fs.readFileSync(indexPath, 'utf8');
+        }
+        catch {
+            console.warn(`${utils_1.COLORS.yellow}Warning:${utils_1.COLORS.reset} --www-dir set but unreadable: ${indexPath}`);
+        }
+    }
+    if (ephemeral) {
+        console.warn(`${utils_1.COLORS.yellow}Warning:${utils_1.COLORS.reset} Session state is in a tmpdir (ephemeral). Pass --state-dir or set AGENTHIPPO_HOME to persist sessions across restarts.`);
+    }
+    // Q1: object-store state sync (no-op unless AGENTHIPPO_STATE_S3_URI is set).
+    // Boot-restore so sessions survive a fresh instance with no FS mount (R2/S3/Databricks).
+    const s3State = (0, state_sync_1.resolveS3StateConfig)();
+    if (s3State) {
+        // Preflight: state sync shells out to `aws`. If it's missing, sessions would
+        // silently never persist — fail fast since durable state was explicitly opted into.
+        if (!(await (0, state_sync_1.isAwsCliAvailable)())) {
+            console.error(`${utils_1.COLORS.red}Error: AGENTHIPPO_STATE_S3_URI is set but the \`aws\` CLI was not found.${utils_1.COLORS.reset}`);
+            console.error('   State sync requires the AWS CLI. Install it (https://aws.amazon.com/cli/) or unset AGENTHIPPO_STATE_S3_URI.');
+            process.exit(1);
+        }
+        console.log(`State sync: restoring from ${s3State.uri} …`);
+        await (0, state_sync_1.restoreState)(s3State, storagePath, (m) => console.log(`  ${m}`));
+    }
+    const statePusher = s3State ? (0, state_sync_1.makeStatePusher)(s3State, storagePath, options.verbose ? (m) => console.error(m) : undefined) : null;
+    const logger = options.verbose ? new headless_1.ConsoleLogger('[Server]') : new headless_1.NoOpLogger();
+    // Find SDK CLI paths
+    const claudeCodePath = (0, utils_1.findClaudeCodePath)();
+    const codexPath = (0, utils_1.findCodexPath)();
+    // Validate required CLI is available
+    if (defaultEngine === 'claude' && !claudeCodePath) {
+        console.error(`${utils_1.COLORS.red}Error: Claude Code CLI not found.${utils_1.COLORS.reset}`);
+        console.error('   Install: npm install -g @anthropic-ai/claude-code');
+        console.error('   Or set CLAUDE_CODE_PATH environment variable');
+        process.exit(1);
+    }
+    if (defaultEngine === 'codex' && !codexPath) {
+        console.error(`${utils_1.COLORS.red}Error: Codex CLI not found.${utils_1.COLORS.reset}`);
+        console.error('   Install: npm install -g @openai/codex');
+        console.error('   Or set CODEX_PATH environment variable');
+        process.exit(1);
+    }
+    // V1 permissions are non-interactive in server mode.
+    const permissionHandler = new headless_1.AutoApprovePermissionHandler();
+    const permissions = {
+        fileAccess: (0, pack_loader_1.getFileAccess)(pack),
+    };
+    const runner = (0, headless_1.createHeadlessRunner)({
+        storagePath,
+        packId,
+        packVersion: pack?.manifest.metadata.version,
+        bundledPromptsDir,
+        apiKey: apiConfig.apiKey,
+        baseUrl: apiConfig.baseUrl,
+        useLiteLLM: apiConfig.useLiteLLM,
+        logger,
+        freshState: false,
+        claudeCodeExecutablePath: claudeCodePath,
+        codexExecutablePath: codexPath,
+        permissionHandler,
+        cliEnvPatch: (0, runtime_1.buildCliEnvPatch)({
+            cliPath: process.execPath,
+            workspaceRoot: options.workspace,
+            agentId: packId,
+            baseEnv: process.env,
+        }),
+        ...(claudeCheapModel ? { engineSettings: { claudeCheapModel } } : {}),
+    });
+    /** Set when `--gateway-bridge` is enabled; cleared on shutdown. */
+    let gatewayBridge = null;
+    /** True once the pack is synced and (if bridged) the gateway is connected. Drives GET /ready. */
+    let ready = false;
+    // Create HTTP server
+    const server = http.createServer(async (req, res) => {
+        const cors = (0, serve_hardening_1.corsHeaders)();
+        for (const [k, v] of Object.entries(cors)) {
+            res.setHeader(k, v);
+        }
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        try {
+            // Liveness — always open.
+            if (req.method === 'GET' && req.url === '/health') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'ok' }));
+                return;
+            }
+            // Readiness — pack synced (+ gateway connected when bridged).
+            if (req.method === 'GET' && req.url === '/ready') {
+                res.writeHead(ready ? 200 : 503, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ready }));
+                return;
+            }
+            const urlPath = req.url?.split('?')[0] ?? '';
+            if (req.method === 'GET' && landingPageHtml && (urlPath === '/' || urlPath === '/index.html')) {
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(landingPageHtml);
+                return;
+            }
+            // Chat endpoint
+            if (req.method === 'POST' && urlPath === '/v1/chat') {
+                const body = await parseBody(req);
+                const userId = (0, serve_hardening_1.resolveUserId)(req.headers, body);
+                const dataToken = (0, serve_hardening_1.resolveDataToken)(req.headers);
+                const rlKey = userId ?? (0, serve_hardening_1.clientIp)(req);
+                if (!rateLimiter.tryConsume(rlKey)) {
+                    res.writeHead(429, { 'Content-Type': 'application/json', 'Retry-After': String(rateLimiter.retryAfterSeconds(rlKey)) });
+                    res.end(JSON.stringify({ error: 'Rate limit exceeded' }));
+                    return;
+                }
+                const sessionKey = body.session_id || `anon-${userId ?? 'unknown'}`;
+                if (!turnLimiter.tryConsume(sessionKey)) {
+                    res.writeHead(429, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Per-session turn limit reached' }));
+                    return;
+                }
+                const result = await (0, credential_context_1.runWithCredential)({ userId: userId ?? 'anonymous', dataToken }, () => handleChat(runner, body, defaultEngine, defaultModel, options.workspace, permissions, userId), { dataTokenDir: storagePath });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(result));
+                statePusher?.schedule(); // async-delta push, off the response path
+                return;
+            }
+            // Streaming chat endpoint
+            if (req.method === 'POST' && urlPath === '/v1/chat/stream') {
+                const body = await parseBody(req);
+                const userId = (0, serve_hardening_1.resolveUserId)(req.headers, body);
+                const dataToken = (0, serve_hardening_1.resolveDataToken)(req.headers);
+                const rlKey = userId ?? (0, serve_hardening_1.clientIp)(req);
+                if (!rateLimiter.tryConsume(rlKey)) {
+                    res.writeHead(429, { 'Content-Type': 'application/json', 'Retry-After': String(rateLimiter.retryAfterSeconds(rlKey)) });
+                    res.end(JSON.stringify({ error: 'Rate limit exceeded' }));
+                    return;
+                }
+                const sessionKey = body.session_id || `anon-${userId ?? 'unknown'}`;
+                if (!turnLimiter.tryConsume(sessionKey)) {
+                    res.writeHead(429, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Per-session turn limit reached' }));
+                    return;
+                }
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                });
+                await (0, credential_context_1.runWithCredential)({ userId: userId ?? 'anonymous', dataToken }, () => handleStreamingChat(runner, body, defaultEngine, defaultModel, options.workspace, permissions, res, userId), { dataTokenDir: storagePath });
+                statePusher?.schedule(); // async-delta push, off the response path
+                return;
+            }
+            // 404
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found' }));
+        }
+        catch (err) {
+            const tooLarge = err?.tooLarge === true;
+            if (tooLarge) {
+                if (!res.headersSent) {
+                    // Connection: close — we stopped reading mid-upload; don't reuse this socket.
+                    res.writeHead(413, { 'Content-Type': 'application/json', 'Connection': 'close' });
+                }
+                res.end(JSON.stringify({ error: 'Payload too large' }));
+                return;
+            }
+            console.error('Request error:', err);
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+            }
+            res.end(JSON.stringify({ error: err instanceof Error ? err.message : 'Internal error' }));
+        }
+    });
+    // Start server
+    server.listen(options.port, bindHost, () => {
+        void (async () => {
+            console.log('');
+            console.log(BANNER_LINE);
+            console.log('Agent Hippo Server');
+            console.log(BANNER_LINE);
+            console.log(`Host:      ${bindHost}`);
+            console.log(`Port:      ${options.port}`);
+            console.log(`Engine:    ${defaultEngine}`);
+            console.log(`Model:     ${defaultModel}`);
+            if (claudeCheapModel) {
+                console.log(`Cheap:     ${claudeCheapModel}`);
+            }
+            console.log(`Workspace: ${options.workspace}`);
+            if (pack) {
+                console.log(`Pack:      ${pack.manifest.metadata.name}`);
+                console.log(`Gateway:   ${gatewayAgentId}`);
+            }
+            console.log(BANNER_LINE);
+            console.log('');
+            console.log('Endpoints:');
+            console.log(`  POST http://localhost:${options.port}/v1/chat`);
+            console.log(`  POST http://localhost:${options.port}/v1/chat/stream`);
+            console.log(`  GET  http://localhost:${options.port}/health`);
+            console.log('');
+            console.log('Press Ctrl+C to stop.');
+            console.log('');
+            // Bind channels before bridge connect so config.patch reload does not race registration.
+            const bindSpec = options.bind?.trim();
+            if (bindSpec) {
+                try {
+                    await bindToGatewayChannels(gatewayAgentId, bindSpec);
+                }
+                catch (err) {
+                    console.error(`${utils_1.COLORS.yellow}Warning:${utils_1.COLORS.reset} Failed to bind channels: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            if (options.gatewayBridge) {
+                try {
+                    gatewayBridge = await startServeGatewayBridge({
+                        gatewayAgentId,
+                        packName: pack.manifest.metadata.name,
+                        workspace: options.workspace,
+                        stateDir: storagePath,
+                        engine: defaultEngine,
+                        defaultModel,
+                        runner,
+                        permissions,
+                        onTurnComplete: () => statePusher?.schedule(),
+                    });
+                }
+                catch (err) {
+                    console.error(`${utils_1.COLORS.yellow}Warning:${utils_1.COLORS.reset} Gateway bridge failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Pack is synced (above) and any gateway bridge is connected → ready for traffic.
+            ready = true;
+        })();
+    });
+    // Graceful shutdown — drain in-flight work, stop accepting new connections.
+    let shuttingDown = false;
+    const shutdown = () => {
+        if (shuttingDown) {
+            return;
+        }
+        shuttingDown = true;
+        ready = false; // /ready flips to 503 so a load balancer stops routing here
+        console.log('\nShutting down...');
+        void (async () => {
+            if (statePusher) {
+                try {
+                    await statePusher.flush(); // final durable push before exit
+                }
+                catch {
+                    // best-effort
+                }
+            }
+            if (gatewayBridge) {
+                try {
+                    await gatewayBridge.unregisterAgent(gatewayAgentId);
+                }
+                catch {
+                    // ignore
+                }
+                gatewayBridge = null;
+            }
+            server.close(() => {
+                runner.dispose();
+                process.exit(0);
+            });
+            // Safety net: force exit if connections don't drain promptly.
+            setTimeout(() => {
+                runner.dispose();
+                process.exit(0);
+            }, 10_000).unref();
+        })();
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+async function parseBody(req) {
+    const raw = await (0, serve_hardening_1.readBodyWithCap)(req);
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error('Invalid JSON');
+    }
+}
+async function handleChat(runner, body, defaultEngine, defaultModel, workspace, permissions, userId) {
+    const result = await runner.run({
+        engineId: resolveRequestedEngineId(body.engine, defaultEngine),
+        modelId: body.model || defaultModel,
+        message: body.message,
+        workspaceRoot: workspace,
+        sessionId: body.session_id,
+        analyticsUserId: userId,
+        permissions,
+    });
+    return {
+        success: result.success,
+        text: result.text,
+        thinking: result.thinking || undefined,
+        tool_calls: result.toolCalls,
+        error: result.error,
+    };
+}
+/**
+ * Register this serve process as an OpenClaw external agent (WebSocket `agent.run` → headless runner).
+ * Enables `openclaw agent --agent <packId> --message "…"` against the same gateway.
+ */
+async function startServeGatewayBridge(params) {
+    const { GatewayBridge: Bridge } = await import('../../gateway/bridge.js');
+    const DEFAULT_GATEWAY_PORT = 18789;
+    const gatewayUrl = process.env.OPENCLAW_GATEWAY_URL ?? `ws://127.0.0.1:${DEFAULT_GATEWAY_PORT}`;
+    const token = process.env.OPENCLAW_GATEWAY_TOKEN;
+    const bridge = new Bridge({ gatewayUrl, token });
+    await bridge.connect();
+    await bridge.registerAgent({
+        id: params.gatewayAgentId,
+        agentId: params.packName,
+        name: `${params.packName} (CLI)`,
+        workspace: params.workspace,
+        engineId: params.engine,
+        syncOpenClawConfigAgent: true,
+        messageHandler: async (message, opts) => {
+            const requestedEngine = opts.engineId?.trim().toLowerCase();
+            const effectiveEngine = requestedEngine === 'custom'
+                ? params.engine
+                : (requestedEngine || params.engine);
+            // #4: the channel sender becomes the per-user user_id (analytics + per-user data scoping).
+            const userId = (0, serve_hardening_1.peerToUserId)(opts.peerInfo);
+            const result = await (0, credential_context_1.runWithCredential)({ userId: userId ?? 'gateway' }, () => params.runner.run({
+                engineId: effectiveEngine,
+                modelId: params.defaultModel,
+                message,
+                workspaceRoot: params.workspace,
+                sessionId: opts.sessionId,
+                gatewaySessionKey: opts.gatewaySessionKey,
+                analyticsUserId: userId,
+                emitter: opts.emitter,
+                permissions: params.permissions,
+            }), { dataTokenDir: params.stateDir });
+            params.onTurnComplete?.();
+            return { success: result.success, error: result.error };
+        },
+    });
+    console.log(`${utils_1.COLORS.green}✓${utils_1.COLORS.reset} Gateway bridge: registered "${params.gatewayAgentId}" at ${gatewayUrl}`);
+    console.log(`${utils_1.COLORS.dim}  Gateway outbound routes: ${params.workspace}/.agent-hippo/sessions/<sessionKey>/gateway-outbound.json${utils_1.COLORS.reset}`);
+    console.log(`${utils_1.COLORS.dim}  openclaw agent --agent ${params.gatewayAgentId} --message "…"${utils_1.COLORS.reset}`);
+    return bridge;
+}
+/**
+ * Connect to the gateway and set channel bindings for this agent.
+ * Called when --bind is specified (e.g., --bind "telegram,whatsapp" or --bind "*").
+ */
+async function bindToGatewayChannels(agentId, bindSpec) {
+    const { createAgentIDEGatewayClient } = await import('../../gateway/client.js');
+    const DEFAULT_GATEWAY_PORT = 18789;
+    const gatewayUrl = process.env.OPENCLAW_GATEWAY_URL ?? `ws://127.0.0.1:${DEFAULT_GATEWAY_PORT}`;
+    const token = process.env.OPENCLAW_GATEWAY_TOKEN;
+    const { client, clientInfo } = createAgentIDEGatewayClient(gatewayUrl, token);
+    try {
+        await client.connect(clientInfo);
+    }
+    catch (err) {
+        throw new Error(`Cannot connect to gateway at ${gatewayUrl}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+        let channels;
+        let channelAccountOverrides;
+        let statusPayload;
+        if (bindSpec.trim() === '*') {
+            const ctx = await (0, openclaw_channel_routing_js_1.fetchMeetAgentChannelContext)(client.request.bind(client));
+            channels = ctx.rows.map((ch) => ch.id);
+            statusPayload = ctx.statusPayload;
+        }
+        else {
+            const parsed = (0, openclaw_channel_routing_js_1.parseChannelBindSpecs)(bindSpec);
+            channels = parsed.map((p) => p.channelId);
+            channelAccountOverrides = Object.fromEntries(parsed
+                .filter((p) => p.accountId)
+                .map((p) => [p.channelId, p.accountId]));
+            if (Object.keys(channelAccountOverrides).length === 0) {
+                channelAccountOverrides = undefined;
+            }
+        }
+        if (channels.length === 0) {
+            console.log(`${utils_1.COLORS.yellow}Warning:${utils_1.COLORS.reset} No channels to bind.`);
+            return;
+        }
+        const patched = await (0, openclaw_channel_routing_js_1.applyAgentChannelBindingsViaConfigPatch)(client.request.bind(client), {
+            agentId,
+            selectedChannelIds: channels,
+            channelAccountOverrides,
+            statusPayload,
+        });
+        if (patched) {
+            console.log(`${utils_1.COLORS.green}✓${utils_1.COLORS.reset} Bound ${agentId} to: ${channels.join(', ')}`);
+        }
+        else {
+            console.log(`${utils_1.COLORS.dim}Slack already bound to ${agentId}; skipped config.patch${utils_1.COLORS.reset}`);
+        }
+    }
+    finally {
+        client.close();
+    }
+}
+async function handleStreamingChat(runner, body, defaultEngine, defaultModel, workspace, permissions, res, userId) {
+    let streamEnded = false;
+    const sendEvent = (type, data) => {
+        if (streamEnded || res.writableEnded) {
+            return;
+        }
+        res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+    };
+    const endStream = () => {
+        if (streamEnded) {
+            return;
+        }
+        streamEnded = true;
+        res.end();
+    };
+    const emitter = {
+        async thinking(delta) {
+            sendEvent('thinking', { delta });
+        },
+        async text(delta) {
+            sendEvent('text', { delta });
+        },
+        async toolStart(name, input, toolCallId) {
+            sendEvent('tool_start', { name, input, tool_call_id: toolCallId });
+        },
+        async toolEnd(name, toolCallId, result, isError) {
+            sendEvent('tool_end', { name, tool_call_id: toolCallId, result, is_error: isError });
+        },
+        async progress(message) {
+            sendEvent('progress', { message });
+        },
+        async question(payload) {
+            sendEvent('question', { payload });
+            // No sessionResource in serve path → can't use workbench askQuestions. Emit for visibility; return declined so the run continues (see PLAN/ARCHITECTURE.md § Stream Question).
+            return {
+                selected: [],
+                freeText: null,
+                declined: true,
+            };
+        },
+        async error(message) {
+            sendEvent('error', { message });
+        },
+        async done() {
+            sendEvent('done', {});
+            endStream();
+        },
+    };
+    try {
+        await runner.run({
+            engineId: resolveRequestedEngineId(body.engine, defaultEngine),
+            modelId: body.model || defaultModel,
+            message: body.message,
+            workspaceRoot: workspace,
+            sessionId: body.session_id,
+            analyticsUserId: userId,
+            emitter,
+            permissions,
+        });
+        if (!streamEnded) {
+            sendEvent('done', {});
+            endStream();
+        }
+    }
+    catch (err) {
+        sendEvent('error', { message: err instanceof Error ? err.message : 'Unknown error' });
+        endStream();
+    }
+}
+function resolveRequestedEngineId(requestedEngine, fallbackEngine) {
+    const normalizedRequested = requestedEngine?.trim().toLowerCase();
+    if (!normalizedRequested) {
+        return fallbackEngine;
+    }
+    if (normalizedRequested === 'custom') {
+        return fallbackEngine;
+    }
+    return normalizedRequested;
+}