harness-dispatch 0.4.0 → 0.5.0

package/dist/http/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/http/server.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAO1B,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AA4ND,wBAAsB,eAAe,CAAC,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAyX5F;AAED,eAAO,MAAM,kBAAkB,wBAAkB,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/http/server.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAU1B,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAiDD;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,KAAK;CAAG;AA0gB7C,wBAAsB,eAAe,CAAC,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAgN5F;AAED,eAAO,MAAM,kBAAkB,wBAAkB,CAAC"}

package/dist/http/server.js

@@ -6,7 +6,8 @@ import { buildMcpServer, buildMcpServerInstance, } from "../mcp/server.js";
 import { buildStatus, buildUsage } from "../status.js";
 import { evaluateRoutePolicy } from "../route-policy.js";
 import { isIsolatedWorkspacePolicy } from "../workspaces.js";
-import { resolveWorkingDir, workingDirWarning } from "../working-dir.js";
+import { resolveWorkingDir, validateWorkingDir, workingDirWarning } from "../working-dir.js";
+import { getAsyncJob, startAsyncJobTracked } from "../jobs.js";
 function sendJson(res, statusCode, body) {
     const text = JSON.stringify(body, null, 2);
     res.writeHead(statusCode, {
@@ -31,6 +32,19 @@ function isLoopbackHost(host) {
 // any authorized (or, if --host is opened beyond loopback, network-adjacent)
 // caller exhaust process memory with one oversized POST.
 const MAX_REQUEST_BODY_BYTES = 10 * 1024 * 1024;
+/**
+ * A request the CALLER can fix — malformed JSON, a missing required field, a
+ * working directory that does not exist.
+ *
+ * Everything except the 413 was returned as 500. PRODUCT.md names CI and cron
+ * as consumers of this surface, and retry-on-5xx will happily retry a request
+ * that can never succeed. A 4xx says "stop and fix the request", which is the
+ * true statement.
+ */
+export class BadRequestError extends Error {
+}
+/** Mirrors MAX_CONTEXT_FILES in mcp/tools.ts — the two surfaces must agree. */
+const MAX_CONTEXT_FILES_HTTP = 64;
 class PayloadTooLargeError extends Error {
 }
 async function readJson(req, maxBytes = MAX_REQUEST_BODY_BYTES) {
@@ -49,7 +63,14 @@ async function readJson(req, maxBytes = MAX_REQUEST_BODY_BYTES) {
         chunks.push(buf);
     }
     const text = Buffer.concat(chunks).toString("utf-8");
-    return text.trim() ? JSON.parse(text) : {};
+    if (!text.trim())
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new BadRequestError(`request body is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 function contentToText(content) {
     if (typeof content === "string")
@@ -115,6 +136,37 @@ function parseHints(body) {
             raw.workspacePolicy === "git_worktree") {
             hints.workspacePolicy = raw.workspacePolicy;
         }
+        // routePolicy was never read here at all. evaluateRoutePolicy implements
+        // local_only, approval_required and blocked in full, and on this surface
+        // they were wired to nothing: POST {"hints":{"routePolicy":"blocked"}}
+        // returned 200 and dispatched. PRODUCT.md names CI and cron as this
+        // surface's consumers, and calls a guarantee that reads correctly and does
+        // nothing at runtime its own counter-signal.
+        if (raw.routePolicy === "local_only" ||
+            raw.routePolicy === "approval_required" ||
+            raw.routePolicy === "blocked") {
+            hints.routePolicy = raw.routePolicy;
+        }
+        if (typeof raw.timeoutMs === "number" && Number.isFinite(raw.timeoutMs)) {
+            hints.timeoutMs = raw.timeoutMs;
+        }
+        // Unknown keys are REJECTED, matching the MCP surface. The whole point of
+        // making hints strict there was that `safety_profile` (the config
+        // spelling) silently disabled a safety limit; accepting it here left the
+        // identical typo failing open on the other surface.
+        const known = new Set([
+            "model",
+            "taskType",
+            "preferLargeContext",
+            "safetyProfile",
+            "workspacePolicy",
+            "routePolicy",
+            "timeoutMs",
+        ]);
+        const unknown = Object.keys(raw).filter((k) => !known.has(k));
+        if (unknown.length > 0) {
+            throw new BadRequestError(`unknown hints key(s): ${unknown.join(", ")}. Valid: ${[...known].join(", ")}.`);
+        }
     }
     if (body.workspacePolicy === "shared" ||
         body.workspacePolicy === "shared_locked" ||
@@ -125,15 +177,33 @@ function parseHints(body) {
     return hints;
 }
 function parseChatRequest(raw) {
-    if (!raw || typeof raw !== "object") {
-        throw new Error("request body must be a JSON object");
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        // Was a plain Error, so `null`, `"hello"` and `42` all returned 500. The
+        // BadRequestError mapping was added for JSON PARSE failures only — same
+        // fix, one of two paths, which is the pattern this file keeps repeating.
+        throw new BadRequestError("request body must be a JSON object");
     }
     const body = raw;
     const prompt = typeof body.prompt === "string" && body.prompt.trim()
         ? body.prompt
         : messagesToPrompt(body.messages);
     if (!prompt.trim())
-        throw new Error("messages or prompt is required");
+        throw new BadRequestError("messages or prompt is required");
+    // MCP validates this; HTTP did not, so `workingDir: "Z:/nope"` surfaced as
+    // `spawn node.EXE ENOENT` — verbatim the wrong-cause error working-dir.ts
+    // exists to prevent, on the surface CI uses.
+    const workingDirError = validateWorkingDir(typeof body.workingDir === "string"
+        ? body.workingDir
+        : undefined);
+    if (workingDirError !== undefined)
+        throw new BadRequestError(workingDirError);
+    // Same cap as the MCP surface, and for the same reason: each file's parent
+    // directory becomes an --add-dir grant on CLI routes, so an unbounded list
+    // is an unbounded set of directories handed to a coding agent. The cap was
+    // added at the MCP boundary only; this surface accepted 500.
+    if (Array.isArray(body.files) && body.files.length > MAX_CONTEXT_FILES_HTTP) {
+        throw new BadRequestError(`files: ${body.files.length} entries exceeds the maximum of ${MAX_CONTEXT_FILES_HTTP}.`);
+    }
     const files = Array.isArray(body.files)
         ? body.files.filter((v) => typeof v === "string")
         : [];
@@ -153,6 +223,235 @@ function parseChatRequest(raw) {
         hints: parseHints(body),
     };
 }
+/**
+ * Run fanout arms to completion INDEPENDENTLY of one another.
+ *
+ * Promise.all rejected the whole batch when one arm threw (workspace lock
+ * timeout, worktree setup failure), discarding every other arm's completed —
+ * and possibly billed — work behind a single 500. Each arm now settles on its
+ * own; a thrown arm becomes a failed row naming its route. One row shape for
+ * the streaming and non-streaming branches on purpose: they used to differ
+ * (streaming omitted success/error), the one-sibling-guarded pattern again.
+ */
+async function runFanoutArms(router, routes, parsed) {
+    const settled = await Promise.allSettled(routes.map((route) => router.routeTo(route, parsed.prompt, parsed.files, parsed.workingDir, {
+        ...(parsed.hints.safetyProfile !== undefined
+            ? { safetyProfile: parsed.hints.safetyProfile }
+            : {}),
+        ...(parsed.hints.workspacePolicy !== undefined
+            ? { workspacePolicy: parsed.hints.workspacePolicy }
+            : {}),
+        ...(parsed.hints.taskType !== undefined ? { taskType: parsed.hints.taskType } : {}),
+    })));
+    return settled.map((s, i) => {
+        if (s.status === "fulfilled") {
+            const r = s.value.result;
+            return {
+                route: r.service,
+                success: r.success,
+                output: r.output,
+                ...(r.error !== undefined ? { error: r.error } : {}),
+                ...(r.workspace !== undefined ? { workspace: r.workspace } : {}),
+            };
+        }
+        return {
+            route: routes[i],
+            success: false,
+            output: "",
+            error: s.reason instanceof Error ? s.reason.message : String(s.reason),
+        };
+    });
+}
+/**
+ * POST /v1/chat/completions — extracted from the request callback, where
+ * this logic sat eleven brace-levels deep (the smell checker's worst
+ * finding for the whole repo). Behaviour is unchanged; only the nesting
+ * moved.
+ */
+async function handleChatCompletions(holder, parsed, res, sse) {
+    const state = holder.state;
+    if (parsed.mode === "fanout") {
+        const fanoutSafetyProfile = parsed.hints.safetyProfile ?? "read_only";
+        if (fanoutSafetyProfile !== "read_only" &&
+            (parsed.hints.workspacePolicy === undefined ||
+                !isIsolatedWorkspacePolicy(parsed.hints.workspacePolicy))) {
+            sendJson(res, 400, {
+                error: {
+                    message: "write-capable fanout requires workspacePolicy=copy or workspacePolicy=git_worktree; use read_only fanout or run single-route workspace_edit",
+                    code: "workspace_isolation_required",
+                },
+            });
+            return;
+        }
+        parsed.hints.safetyProfile = fanoutSafetyProfile;
+    }
+    const eligibleRoutes = (requestedRoutes) => {
+        const routes = [];
+        const skippedRoutes = [];
+        for (const route of requestedRoutes) {
+            const svc = state.config.services[route];
+            if (!svc) {
+                // The MCP tool rejects unknown fanout targets by name; this
+                // surface silently skipped them, returning 200 with fewer arms
+                // and an empty skippedRoutes. Same input, two answers.
+                throw new BadRequestError(`Unknown fanout target: ${route}. Valid route ids: ` +
+                    `${Object.keys(state.config.services).join(", ")}.`);
+            }
+            const dispatcher = state.dispatchers[route];
+            const breaker = state.router.getBreaker(route);
+            const policy = evaluateRoutePolicy(route, svc, {
+                ...(dispatcher !== undefined ? { dispatcher } : {}),
+                circuitBroken: Boolean(breaker?.isTripped),
+                ...(parsed.hints.safetyProfile !== undefined
+                    ? { requestedSafetyProfile: parsed.hints.safetyProfile }
+                    : {}),
+            });
+            if (policy.skipped)
+                skippedRoutes.push(policy.skipped);
+            if (!policy.blocked)
+                routes.push(route);
+        }
+        return { routes, skippedRoutes };
+    };
+    if (parsed.stream) {
+        // Resolve fanout targets BEFORE writing SSE headers.
+        //
+        // eligibleRoutes throws BadRequestError for an unknown route, but it
+        // was called after writeHead — so headersSent was true, the error
+        // handler could only res.end(), and the caller got HTTP 200 with a
+        // zero-byte body. The non-streaming path returns a proper 400 with
+        // the valid ids. Same input, two answers, again.
+        // Default to every dispatchable route when `models` is omitted,
+        // exactly as the non-streaming branch does. Streaming passed
+        // parsed.models straight through, so {"mode":"fanout","stream":true}
+        // with no models fanned out to ZERO routes and reported success —
+        // content "[]", empty skippedRoutes, HTTP 200.
+        const preSelected = parsed.mode === "fanout"
+            ? eligibleRoutes(parsed.models.length > 0
+                ? parsed.models
+                : Object.keys(state.config.services).filter((route) => route in state.dispatchers))
+            : undefined;
+        res.writeHead(200, {
+            "content-type": "text/event-stream; charset=utf-8",
+            "cache-control": "no-cache",
+            connection: "keep-alive",
+        });
+        sse.started = true;
+        if (parsed.mode === "fanout") {
+            const selected = preSelected;
+            const rows = await runFanoutArms(state.router, selected.routes, parsed);
+            writeSse(res, {
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            content: JSON.stringify(rows),
+                        },
+                        finish_reason: null,
+                    },
+                ],
+                harness_dispatch: {
+                    mode: "fanout",
+                    skippedRoutes: selected.skippedRoutes,
+                    ...(parsed.workingDirWarning !== undefined
+                        ? { warning: parsed.workingDirWarning }
+                        : {}),
+                },
+            });
+        }
+        else {
+            for await (const { event, decision } of state.router.stream(parsed.prompt, parsed.files, parsed.workingDir, { hints: parsed.hints, maxFallbacks: 2 })) {
+                if (event.type === "stdout") {
+                    writeSse(res, {
+                        choices: [
+                            {
+                                index: 0,
+                                delta: { content: event.chunk },
+                                finish_reason: null,
+                            },
+                        ],
+                        harness_dispatch: decision ? { route: decision.service } : undefined,
+                    });
+                }
+                else if (event.type === "completion" && !event.result.success) {
+                    writeSse(res, {
+                        error: {
+                            message: event.result.error ?? "routing failed",
+                            route: event.result.service,
+                        },
+                    });
+                }
+            }
+        }
+        writeSse(res, {
+            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        });
+        res.write("data: [DONE]\n\n");
+        res.end();
+        return;
+    }
+    if (parsed.mode === "fanout") {
+        const routes = parsed.models.length > 0
+            ? parsed.models
+            : Object.keys(state.config.services).filter((route) => route in state.dispatchers);
+        const selected = eligibleRoutes(routes);
+        const rows = await runFanoutArms(state.router, selected.routes, parsed);
+        sendJson(res, 200, completionEnvelope(JSON.stringify(rows, null, 2), typeof parsed.hints.model === "string" ? parsed.hints.model : "harness-dispatch", {
+            harness_dispatch: {
+                mode: "fanout",
+                skippedRoutes: selected.skippedRoutes,
+                ...(parsed.workingDirWarning !== undefined
+                    ? { warning: parsed.workingDirWarning }
+                    : {}),
+            },
+        }));
+        return;
+    }
+    // Backed by a persisted job, not a bare in-process await. This
+    // surface's users are curl/CI/cron — exactly the clients that enforce
+    // their own request timeouts — and a direct await meant a client that
+    // gave up mid-run lost the finished result with no way to retrieve
+    // it. The job survives (it runs detached and lands on disk); the
+    // jobId is exposed in the response AND in a header so even a caller
+    // that only captured headers before timing out can recover the
+    // result via `job_status`.
+    const { status: jobStatus, completion } = await startAsyncJobTracked({ holder }, {
+        prompt: parsed.prompt,
+        files: parsed.files,
+        workingDir: parsed.workingDir,
+        hints: parsed.hints,
+    });
+    res.setHeader("x-harness-dispatch-job-id", jobStatus.jobId);
+    await completion;
+    const job = await getAsyncJob(jobStatus.jobId);
+    const result = job.result?.result;
+    const decision = job.result?.decision ?? undefined;
+    if (result === undefined) {
+        // Terminal without a result payload: the runner died or was
+        // orphaned. The job dir still names what happened.
+        sendJson(res, 500, {
+            error: `job ${jobStatus.jobId} ended without a result (status: ${job.status.status}); ` +
+                `check job_status for details`,
+            jobId: jobStatus.jobId,
+        });
+        return;
+    }
+    sendJson(res, 200, completionEnvelope(result.output, decision?.model ?? parsed.hints.model ?? "harness-dispatch", {
+        harness_dispatch: {
+            jobId: jobStatus.jobId,
+            route: result.service,
+            success: result.success,
+            error: result.error,
+            workspace: result.workspace,
+            routing: decision,
+            skippedRoutes: decision?.skippedRoutes ?? result.skippedRoutes,
+            ...(parsed.workingDirWarning !== undefined
+                ? { warning: parsed.workingDirWarning }
+                : {}),
+        },
+    }));
+    return;
+}
 function completionEnvelope(content, model, extra) {
     return {
         id: `chatcmpl-${randomUUID()}`,
@@ -190,9 +489,16 @@ export async function startHttpServer(opts = {}) {
         sendJson(res, 401, { error: "unauthorized" });
         return false;
     };
+    // A bare IPv6 host must be bracketed to be legal inside a URL:
+    // new URL("/mcp", "http://::1") throws "Invalid URL", which turned EVERY
+    // request to a server bound on ::1 into a 500 — the bind succeeded and the
+    // loopback check blessed the address, so nothing else ever caught it.
+    const urlBase = `http://${host.includes(":") && !host.startsWith("[") ? `[${host}]` : host}`;
     const http = createServer(async (req, res) => {
+        // Shared with handleChatCompletions, read by the catch below.
+        const sse = { started: false };
         try {
-            const url = new URL(req.url ?? "/", `http://${host}`);
+            const url = new URL(req.url ?? "/", urlBase);
             if (url.pathname === "/v1/models" && req.method === "GET") {
                 if (!requireAuth(req, res))
                     return;
@@ -244,161 +550,7 @@ export async function startHttpServer(opts = {}) {
                     return;
                 await reloader.maybeReload();
                 const parsed = parseChatRequest(await readJson(req));
-                const state = holder.state;
-                if (parsed.mode === "fanout") {
-                    const fanoutSafetyProfile = parsed.hints.safetyProfile ?? "read_only";
-                    if (fanoutSafetyProfile !== "read_only" &&
-                        (parsed.hints.workspacePolicy === undefined ||
-                            !isIsolatedWorkspacePolicy(parsed.hints.workspacePolicy))) {
-                        sendJson(res, 400, {
-                            error: {
-                                message: "write-capable fanout requires workspacePolicy=copy or workspacePolicy=git_worktree; use read_only fanout or run single-route workspace_edit",
-                                code: "workspace_isolation_required",
-                            },
-                        });
-                        return;
-                    }
-                    parsed.hints.safetyProfile = fanoutSafetyProfile;
-                }
-                const eligibleRoutes = (requestedRoutes) => {
-                    const routes = [];
-                    const skippedRoutes = [];
-                    for (const route of requestedRoutes) {
-                        const svc = state.config.services[route];
-                        if (!svc)
-                            continue;
-                        const dispatcher = state.dispatchers[route];
-                        const breaker = state.router.getBreaker(route);
-                        const policy = evaluateRoutePolicy(route, svc, {
-                            ...(dispatcher !== undefined ? { dispatcher } : {}),
-                            circuitBroken: Boolean(breaker?.isTripped),
-                            ...(parsed.hints.safetyProfile !== undefined
-                                ? { requestedSafetyProfile: parsed.hints.safetyProfile }
-                                : {}),
-                        });
-                        if (policy.skipped)
-                            skippedRoutes.push(policy.skipped);
-                        if (!policy.blocked)
-                            routes.push(route);
-                    }
-                    return { routes, skippedRoutes };
-                };
-                if (parsed.stream) {
-                    res.writeHead(200, {
-                        "content-type": "text/event-stream; charset=utf-8",
-                        "cache-control": "no-cache",
-                        connection: "keep-alive",
-                    });
-                    if (parsed.mode === "fanout") {
-                        const selected = eligibleRoutes(parsed.models);
-                        const results = await Promise.all(selected.routes.map((route) => state.router.routeTo(route, parsed.prompt, parsed.files, parsed.workingDir, {
-                            ...(parsed.hints.safetyProfile !== undefined
-                                ? { safetyProfile: parsed.hints.safetyProfile }
-                                : {}),
-                            ...(parsed.hints.workspacePolicy !== undefined
-                                ? { workspacePolicy: parsed.hints.workspacePolicy }
-                                : {}),
-                            ...(parsed.hints.taskType !== undefined ? { taskType: parsed.hints.taskType } : {}),
-                        })));
-                        writeSse(res, {
-                            choices: [
-                                {
-                                    index: 0,
-                                    delta: {
-                                        content: JSON.stringify(results.map((r) => ({
-                                            route: r.result.service,
-                                            output: r.result.output,
-                                            workspace: r.result.workspace,
-                                        }))),
-                                    },
-                                    finish_reason: null,
-                                },
-                            ],
-                            harness_dispatch: {
-                                mode: "fanout",
-                                skippedRoutes: selected.skippedRoutes,
-                                ...(parsed.workingDirWarning !== undefined
-                                    ? { warning: parsed.workingDirWarning }
-                                    : {}),
-                            },
-                        });
-                    }
-                    else {
-                        for await (const { event, decision } of state.router.stream(parsed.prompt, parsed.files, parsed.workingDir, { hints: parsed.hints, maxFallbacks: 2 })) {
-                            if (event.type === "stdout") {
-                                writeSse(res, {
-                                    choices: [
-                                        {
-                                            index: 0,
-                                            delta: { content: event.chunk },
-                                            finish_reason: null,
-                                        },
-                                    ],
-                                    harness_dispatch: decision ? { route: decision.service } : undefined,
-                                });
-                            }
-                            else if (event.type === "completion" && !event.result.success) {
-                                writeSse(res, {
-                                    error: {
-                                        message: event.result.error ?? "routing failed",
-                                        route: event.result.service,
-                                    },
-                                });
-                            }
-                        }
-                    }
-                    writeSse(res, {
-                        choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-                    });
-                    res.write("data: [DONE]\n\n");
-                    res.end();
-                    return;
-                }
-                if (parsed.mode === "fanout") {
-                    const routes = parsed.models.length > 0
-                        ? parsed.models
-                        : Object.keys(state.config.services).filter((route) => route in state.dispatchers);
-                    const selected = eligibleRoutes(routes);
-                    const results = await Promise.all(selected.routes.map((route) => state.router.routeTo(route, parsed.prompt, parsed.files, parsed.workingDir, {
-                        ...(parsed.hints.safetyProfile !== undefined
-                            ? { safetyProfile: parsed.hints.safetyProfile }
-                            : {}),
-                        ...(parsed.hints.workspacePolicy !== undefined
-                            ? { workspacePolicy: parsed.hints.workspacePolicy }
-                            : {}),
-                        ...(parsed.hints.taskType !== undefined ? { taskType: parsed.hints.taskType } : {}),
-                    })));
-                    sendJson(res, 200, completionEnvelope(JSON.stringify(results.map((r) => ({
-                        route: r.result.service,
-                        success: r.result.success,
-                        output: r.result.output,
-                        error: r.result.error,
-                        workspace: r.result.workspace,
-                    })), null, 2), typeof parsed.hints.model === "string" ? parsed.hints.model : "harness-dispatch", {
-                        harness_dispatch: {
-                            mode: "fanout",
-                            skippedRoutes: selected.skippedRoutes,
-                            ...(parsed.workingDirWarning !== undefined
-                                ? { warning: parsed.workingDirWarning }
-                                : {}),
-                        },
-                    }));
-                    return;
-                }
-                const { result, decision } = await state.router.route(parsed.prompt, parsed.files, parsed.workingDir, { hints: parsed.hints, maxFallbacks: 2 });
-                sendJson(res, 200, completionEnvelope(result.output, decision?.model ?? parsed.hints.model ?? "harness-dispatch", {
-                    harness_dispatch: {
-                        route: result.service,
-                        success: result.success,
-                        error: result.error,
-                        workspace: result.workspace,
-                        routing: decision,
-                        skippedRoutes: decision?.skippedRoutes ?? result.skippedRoutes,
-                        ...(parsed.workingDirWarning !== undefined
-                            ? { warning: parsed.workingDirWarning }
-                            : {}),
-                    },
-                }));
+                await handleChatCompletions(holder, parsed, res, sse);
                 return;
             }
             if (url.pathname === mcpRoute) {
@@ -439,10 +591,27 @@ export async function startHttpServer(opts = {}) {
             sendText(res, 404, "not found");
         }
         catch (err) {
-            if (!res.headersSent) {
+            if (sse.started) {
+                // Mid-stream failure: the client already holds a 200 and possibly
+                // partial frames, and a bare end() made a truncated stream
+                // indistinguishable from a complete one. Emit an error frame and the
+                // stream terminator so the caller can tell.
+                try {
+                    writeSse(res, { error: { message: err instanceof Error ? err.message : String(err) } });
+                    res.write("data: [DONE]\n\n");
+                }
+                catch {
+                    // Socket already gone; nothing left to tell it.
+                }
+                res.end();
+            }
+            else if (!res.headersSent) {
                 if (err instanceof PayloadTooLargeError) {
                     sendJson(res, 413, { error: err.message });
                 }
+                else if (err instanceof BadRequestError) {
+                    sendJson(res, 400, { error: err.message });
+                }
                 else {
                     sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
                 }