UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

724 lines (695 loc) • 30.2 kB
import { execFileSync, spawn as nodeSpawn, type ChildProcess, type SpawnOptions } from "node:child_process"; import { mkdtemp, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../../types"; import { isTranslatorBudgetExceededError } from "../../lib/translator-budget"; import { commandInvocation } from "../../lib/win-exec"; import { isStandaloneBinary } from "../../lib/standalone"; import { modelRecordValue } from "../../reasoning-effort"; import type { IncomingMeta } from "../base"; import { buildConversationInput, CodingAgentProtocolError, MAX_TOOL_BLOCK_STARTS, mapStreamMessageToEvents, projectedHistoryCharLimit, readJsonLines, releaseOpenToolBlocks, toolBridgeInitError, type StreamParseState, } from "./protocol"; import { resolveCodingAgentBinary, resolveProfileByBaseUrl, type CodingAgentProviderProfile, type WhichFn } from "./profile"; /** Injectable spawn for tests; production uses node:child_process. */ export type SpawnFn = (command: string, args: readonly string[], options: SpawnOptions) => ChildProcess; /** Injectable Windows process-tree terminator; production uses taskkill /T /F. */ export type KillWindowsProcessTreeFn = (pid: number) => void; /** Per-turn injectables: spawn/which seams for tests plus wall-clock ceilings for timeout, kill grace, and bounded reap. */ export interface CodingAgentDeps { spawn?: SpawnFn; which?: WhichFn; /** Overall wall-clock ceiling for one turn (ms). */ timeoutMs?: number; /** Grace period between SIGTERM and SIGKILL (ms). */ killGraceMs?: number; /** Maximum time to wait for a child that never reports close after termination (ms). */ reapTimeoutMs?: number; /** Test seam for Windows command-shim invocation. */ platform?: NodeJS.Platform; /** Test seam for terminating a Windows CLI and all descendants. */ killWindowsProcessTree?: KillWindowsProcessTreeFn; /** Test seam for a catalog/config write failure after private bridge-directory creation. */ writeToolBridgeFile?: typeof writeFile; } const DEFAULT_TIMEOUT_MS = 300_000; const DEFAULT_KILL_GRACE_MS = 2_000; /** Bound captured stderr so an error message can never carry an unbounded (or secret) payload. */ const MAX_STDERR_BYTES = 8 * 1024; function killWindowsProcessTree(pid: number): void { const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`; execFileSync(taskkill, ["/PID", String(pid), "/T", "/F"], { stdio: "pipe", windowsHide: true, }); } /** Env keys a CLI needs to run; everything else is dropped so the child env is scoped and deterministic. */ const INHERITED_ENV_KEYS = [ "PATH", "HOME", "USERPROFILE", "LANG", "LC_ALL", "LC_CTYPE", "TMPDIR", "TEMP", "TMP", "SHELL", "SYSTEMROOT", "APPDATA", "LOCALAPPDATA", "PROGRAMFILES", "PROGRAMFILES(X86)", "COMSPEC", "PATHEXT", "SYSTEMDRIVE", "USERNAME", "TZ", ] as const; /** * Base scoped child-process environment (§六/§十四). * * Never mutates `process.env` (no cross-provider pollution under concurrency) and never inherits a * parent vendor variable, so a stray region switch in the host shell cannot flip a provider's * region: the profile is the sole authority. Family builders layer the credential + region vars on * top of this. */ export function baseScopedEnv(): Record<string, string> { const env: Record<string, string> = {}; for (const key of INHERITED_ENV_KEYS) { const value = process.env[key]; if (typeof value === "string" && value.length > 0) env[key] = value; } return env; } /** * Redact the profile's credential and common secret shapes before surfacing diagnostics. * * `tokenEnv` is absent for a credentialless profile (the CLI owns its sign-in), which only drops * the `NAME=value` rule; the generic secret shapes are redacted either way. */ export function redactSecrets(text: string, tokenEnv: string | undefined, credential?: string): string { let redacted = text; if (credential) redacted = redacted.split(credential).join("[redacted]"); if (tokenEnv) { const escaped = tokenEnv.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); redacted = redacted.replace(new RegExp(`(${escaped}\\s*[:=]\\s*)\\S+`, "gi"), "$1[redacted]"); } return redacted .replace(/(authorization\s*[:=]\s*)\S+/gi, "$1[redacted]") .replace(/\b(sk-[A-Za-z0-9_-]{6,})\b/g, "[redacted]"); } /** Inputs for one headless CLI turn: region profiles, request context, and family-specific arg/env builders. */ export interface CodingAgentTurnInput { /** Region profiles for this family; the turn fails closed if the base URL matches none. */ profiles: readonly CodingAgentProviderProfile[]; provider: OcxProviderConfig; parsed: OcxParsedRequest; incoming: IncomingMeta; emit: (event: AdapterEvent) => void; /** Family-specific headless argument builder (tools disabled, model, reasoning, system prompt). */ buildArgs: (profile: CodingAgentProviderProfile, parsed: OcxParsedRequest, provider: OcxProviderConfig) => string[]; /** Family-specific scoped env builder (credential + region switch on top of baseScopedEnv). */ buildEnv: (profile: CodingAgentProviderProfile, apiKey: string) => Record<string, string>; /** * Opt-in capture-only tool bridge. When present with a non-empty catalog, the turn writes a * validated catalog plus an MCP config to a private temp dir, passes `--mcp-config` (with exact * `--allowedTools`) alongside the family's tools-disabled args, translates captured tool_use * names back to request wire names, and terminates the process tree at `message_stop` because * the capture-only MCP handler intentionally never answers. Execution stays with the client. */ toolBridge?: CodingAgentToolBridgeInput; deps: CodingAgentDeps; } /** Opt-in capture-only tool bridge for one coding-agent CLI turn. */ export interface CodingAgentToolBridgeInput { /** MCP server name advertised to the CLI; tool_use blocks render it as `mcp__<name>__<tool>`. */ serverName: string; /** Absolute path of the capture-only MCP server module, run with the serving runtime. */ serverModulePath: string; /** Validated tool catalog advertised over ListTools; the server never executes a call. */ tools: ReadonlyArray<{ name: string; description: string; inputSchema: Record<string, unknown> }>; /** CLI-emitted tool name (`mcp__<server>__<tool>`) to the request's wire tool name. */ emittedNameMap: Map<string, string>; /** Captured tool_use blocks accepted in one assistant message. */ maxTurnToolCalls: number; /** * The request's `tool_choice` requires a tool call (`required`, or a named selection). * The nested CLI has no documented force-tool flag, so this is enforced locally: a * terminal text result on a required turn fails closed instead of silently succeeding. */ requireToolCall?: boolean; } export function codeBuddyMcpInvocation(serverModulePath: string, catalogPath: string, standalone = isStandaloneBinary()): string[] { return standalone ? ["__codebuddy-mcp", catalogPath] : [serverModulePath, catalogPath]; } /** * Run one headless coding-agent CLI turn as an OpenCodex `runTurn` (§七/§三十). * * Single transport for every official coding-agent CLI provider: fail closed on a non-canonical * destination, pre-flight the credential and binary, spawn with a scoped env and tools disabled, feed * the replayed conversation over stream-json, map the vendor's Anthropic-aligned frames to * AdapterEvents, and always reap the process. Codex retains tool ownership: the CLI runs with its own * tools disabled, so this turn yields text/reasoning (the control-protocol tool bridge is a * documented fast-follow). */ export async function runCodingAgentTurn(input: CodingAgentTurnInput): Promise<void> { const { profiles, provider, parsed, incoming, emit, buildArgs, buildEnv, deps } = input; const spawnFn = deps.spawn ?? nodeSpawn; const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS; const killGraceMs = deps.killGraceMs ?? DEFAULT_KILL_GRACE_MS; const reapTimeoutMs = deps.reapTimeoutMs ?? (killGraceMs * 2 + 250); const platform = deps.platform ?? process.platform; if (incoming.abortSignal?.aborted) { emit({ type: "error", message: "Coding-agent turn was aborted before start." }); return; } // Fail closed on a non-canonical destination BEFORE any credential is placed in an env (§十六). const profile = resolveProfileByBaseUrl(profiles, provider.baseUrl); if (!profile) { emit({ type: "error", message: "Provider base URL is not a canonical region destination; the credential was not sent.", status: 400, errorType: "invalid_request_error", code: "non_canonical_destination", retryable: false, }); return; } const apiKey = provider.apiKey ?? ""; // A profile WITHOUT a tokenEnv owns no credential to pre-flight: the CLI reads the operator's // own sign-in (Claude Code), so an unauthenticated session is reported by the CLI itself as a // terminal result frame and surfaces through the family's error mapping (§二十六). if (profile.tokenEnv && !apiKey) { emit({ type: "error", message: `${profile.label} credential missing — add an API key for this provider (${profile.tokenEnv}).`, status: 401, errorType: "authentication_error", code: "missing_credential", retryable: false, }); return; } // Pre-flight binary discovery so a missing CLI is a clear error, not a mid-turn ENOENT (§二十六). const binary = resolveCodingAgentBinary(profile, deps.which); if (!binary) { emit({ type: "error", message: `${profile.label} CLI not found on PATH. Install it with: ${profile.installHint}`, status: 500, errorType: "upstream_error", code: "cli_not_found", retryable: false, }); return; } const toolBridge = input.toolBridge; const writeToolBridgeFile = deps.writeToolBridgeFile ?? writeFile; let toolBridgeDir: string | undefined; let toolBridgeMcpConfigPath: string | undefined; if (toolBridge) { if (toolBridge.tools.length === 0 || toolBridge.emittedNameMap.size === 0) { emit({ type: "error", message: "Coding-agent tool bridge was supplied without any isolated tools.", status: 500, errorType: "server_error", code: "tool_bridge_empty", retryable: false, }); return; } try { toolBridgeDir = await mkdtemp(join(tmpdir(), "ocx-coding-agent-tools-")); const catalogPath = join(toolBridgeDir, "catalog.json"); toolBridgeMcpConfigPath = join(toolBridgeDir, "mcp.json"); await writeToolBridgeFile(catalogPath, JSON.stringify(toolBridge.tools), { encoding: "utf8", mode: 0o600, flag: "wx" }); await writeToolBridgeFile( toolBridgeMcpConfigPath, JSON.stringify({ mcpServers: { [toolBridge.serverName]: { type: "stdio", command: process.execPath, args: codeBuddyMcpInvocation(toolBridge.serverModulePath, catalogPath), defer_loading: false, alwaysLoad: true, }, }, }), { encoding: "utf8", mode: 0o600, flag: "wx" }, ); } catch { emit({ type: "error", message: "Coding-agent tool bridge could not be staged securely.", status: 500, errorType: "server_error", code: "tool_bridge_setup_failed", retryable: false, }); if (toolBridgeDir) await rm(toolBridgeDir, { recursive: true, force: true }).catch(() => undefined); return; } } const args = buildArgs(profile, parsed, provider); if (toolBridge && toolBridgeMcpConfigPath) { // Exact names close the wildcard domain; --strict-mcp-config (family args) keeps user // servers out, so the capture server is the only capability this turn can reach. args.push("--allowedTools", [...toolBridge.emittedNameMap.keys()].join(","), "--mcp-config", toolBridgeMcpConfigPath); } const env = buildEnv(profile, apiKey); const invocation = commandInvocation(binary, args, platform, { env }); let child: ChildProcess; try { child = spawnFn(invocation.file, invocation.args, { ...invocation.options, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true, }); } catch (err) { emit({ type: "error", message: redactSecrets(err instanceof Error ? err.message : String(err), profile.tokenEnv, apiKey), status: 500, errorType: "upstream_error", code: "cli_spawn_failed", retryable: false, }); // A synchronous spawn() throw skips the event-loop `finally` below, so the private // bridge dir would leak unless it is removed here as well. if (toolBridgeDir) await rm(toolBridgeDir, { recursive: true, force: true }).catch(() => undefined); return; } // `spawn()` reports launch failures such as ENOENT asynchronously through `error`; they are not // reliably thrown by the call above. Subscribe immediately and create the lifecycle promise now, // before stdout can end, so neither a fast close nor a launch failure can be missed by the reap step. let childProcessError: Error | undefined; const processLifecycle = new Promise<void>(resolve => { let settled = false; const settle = (): void => { if (settled) return; settled = true; resolve(); }; child.once("error", err => { childProcessError = err; // A launch failure has no process to reap and is not guaranteed to emit `close` on every runtime. if (child.pid === undefined) settle(); }); child.once("close", settle); if (child.exitCode !== null) settle(); }); let terminalEmitted = false; const emitOnce = (event: AdapterEvent): void => { if (event.type === "done" || event.type === "error" || event.type === "incomplete") { if (terminalEmitted) return; terminalEmitted = true; } emit(event); }; const stderrChunks: string[] = []; let killed = false; let killTimer: ReturnType<typeof setTimeout> | undefined; const kill = (): void => { if (killed || child.killed) return; killed = true; if (platform === "win32" && child.pid !== undefined) { try { (deps.killWindowsProcessTree ?? killWindowsProcessTree)(child.pid); return; } catch { /* fall back to terminating the direct child */ } } // The capture-only MCP server is the CLI's child. Its stdin closes when the CLI dies, and // mcp-server.ts exits on stdin EOF, so this ladder reaps the whole tree without knowing // the grandchild pid. try { child.kill("SIGTERM"); } catch { /* already gone */ } killTimer = setTimeout(() => { try { child.kill("SIGKILL"); } catch { /* already gone */ } }, killGraceMs); }; const stopStream = (): void => { try { child.stdout?.destroy(); } catch { /* already closed */ } }; const onAbort = (): void => { kill(); stopStream(); }; incoming.abortSignal?.addEventListener("abort", onAbort, { once: true }); const timeoutTimer = setTimeout(() => { kill(); stopStream(); emitOnce({ type: "error", message: `${profile.label} turn timed out.`, status: 504, errorType: "upstream_error", code: "timeout", retryable: true }); }, timeoutMs); child.stderr?.setEncoding("utf8"); child.stderr?.on("data", (chunk: string) => { if (stderrChunks.join("").length < MAX_STDERR_BYTES) stderrChunks.push(chunk); }); const cleanup = (): void => { clearTimeout(timeoutTimer); incoming.abortSignal?.removeEventListener("abort", onAbort); try { child.stdin?.destroy(); } catch { /* ignore */ } // Termination is owned by the reap step below, not here: killing in cleanup would set // `child.killed` and let the wait resolve before the process is actually reaped (§三十). }; let streamProtocolError: string | undefined; let streamProtocolCode: string | undefined; let turnError: string | undefined; // A successful result frame that arrived after every captured tool call completed but // before message_stop. The bridge contract still ends the leg with the synthesized // done(tool_use) at message_stop, so the result-derived done(stop) is deferred and its // usage (authoritative vendor accounting) is folded into the synthesis. Set inside the // stream loop; read by the synthesis and the stream-end error selection below. let deferredResultDone: Extract<AdapterEvent, { type: "done" }> | undefined; const state: StreamParseState = { sawPartialText: false, sawPartialThinking: false, sawTerminalResult: false, openToolBlocks: new Map(), translatorBudget: incoming.translatorBudget, maxToolBlockStarts: toolBridge?.maxTurnToolCalls, strictToolBlockCapture: Boolean(toolBridge), partialToolCallIds: toolBridge ? new Set<string>() : undefined, }; try { // Write the replayed conversation, then close stdin so a single-shot turn can complete. const stdin = child.stdin; if (stdin) { stdin.on("error", () => { /* EPIPE if the CLI exits early; surfaced via close/stderr */ }); // The projected history scales with the model context window on the routed provider row // (catalog and config metadata merged): a 1M-token model keeps 3M characters of replay // where the flat cap cut it near 50k-130k tokens of content. Absent metadata keeps the // flat cap. const historyCharLimit = projectedHistoryCharLimit( modelRecordValue(provider.modelContextWindows, parsed.modelId) ?? provider.contextWindow, ); for (const line of buildConversationInput(parsed, { maxHistoryChars: historyCharLimit })) stdin.write(`${line}\n`); stdin.end(); } const stdout = child.stdout; if (!stdout) throw new CodingAgentProtocolError(`${profile.label} CLI produced no stdout stream`); try { let initValidated = false; let failClosed = false; for await (const message of readJsonLines(stdout)) { if (incoming.abortSignal?.aborted) break; if (toolBridge) { const initError = toolBridgeInitError(message, toolBridge.serverName); if (initError) { emitOnce({ type: "error", message: initError, status: 502, errorType: "upstream_error", code: "tool_bridge_init_mismatch", retryable: false, }); kill(); break; } if (message.type === "system" && message.subtype === "init") initValidated = true; const rawEvent = message.type === "stream_event" && message.event !== null && typeof message.event === "object" ? message.event as Record<string, unknown> : undefined; const rawBlock = rawEvent?.content_block; if ( !initValidated && rawEvent?.type === "content_block_start" && rawBlock !== null && typeof rawBlock === "object" && !Array.isArray(rawBlock) && (rawBlock as Record<string, unknown>).type === "tool_use" ) { emitOnce({ type: "error", message: "Coding-agent CLI called a tool before the tool bridge init handshake completed.", status: 502, errorType: "upstream_error", code: "tool_bridge_init_missing", retryable: false, }); kill(); break; } } const mappedEvents = mapStreamMessageToEvents(message, state); if (state.toolCallLimitExceeded) { emitOnce({ type: "error", message: `Coding-agent CLI returned more than the ${Math.min(MAX_TOOL_BLOCK_STARTS, state.maxToolBlockStarts ?? MAX_TOOL_BLOCK_STARTS)}-tool-call turn limit.`, status: 502, errorType: "upstream_error", code: "tool_call_limit", retryable: false, }); kill(); break; } if (toolBridge && state.uncapturedToolUse) { emitOnce({ type: "error", message: "Coding-agent CLI returned a tool call without a partial tool capture.", status: 502, errorType: "upstream_error", code: "protocol_error", retryable: false, }); kill(); break; } for (const event of mappedEvents) { if (toolBridge && !initValidated && event.type === "done") { emitOnce({ type: "error", message: "Coding-agent CLI ended before the tool bridge init handshake completed.", status: 502, errorType: "upstream_error", code: "tool_bridge_init_missing", retryable: false, }); failClosed = true; kill(); break; } if (toolBridge && event.type === "tool_call_start") { const wireName = toolBridge.emittedNameMap.get(event.name); if (wireName === undefined) { emitOnce({ type: "error", message: "Coding-agent CLI called a tool outside the isolated catalog.", status: 502, errorType: "upstream_error", code: "undeclared_tool_call", retryable: false, }); failClosed = true; kill(); break; } emitOnce({ ...event, name: wireName }); continue; } if ( toolBridge?.requireToolCall === true && !terminalEmitted && event.type === "done" && event.stopReason !== "tool_use" && (state.completedToolCalls ?? 0) === 0 ) { // `tool_choice: required|named` on a bridge turn: a text-only terminal result must not // become a successful completion the client can accept. The capture-only bridge has no // way to force the nested CLI, so fail closed with the same stable error shape the // other bridge contract violations use. emitOnce({ type: "error", message: "CodeBuddy finished without calling the required tool.", status: 502, errorType: "upstream_error", code: "tool_call_required", retryable: false, }); failClosed = true; kill(); break; } if ( toolBridge && !terminalEmitted && event.type === "done" && (state.toolBlockStarts ?? 0) > 0 && (state.completedToolCalls ?? 0) !== (state.toolBlockStarts ?? 0) ) { // A terminal result that arrives while a captured tool call is still open must not // become a successful completion the client can accept. The message_stop check after // the event loop cannot cover this path: the CLI normally parks on the // never-answering capture server, but a stream that delivers the result frame // without (or before) message_stop emits done here, and started-but-unfinished // calls slipped through as successful turns. emitOnce({ type: "error", message: "Coding-agent CLI ended with an incomplete tool call.", status: 502, errorType: "upstream_error", code: "protocol_error", retryable: false, }); failClosed = true; kill(); break; } if ( toolBridge && !terminalEmitted && event.type === "done" && (state.toolBlockStarts ?? 0) > 0 && (state.completedToolCalls ?? 0) === (state.toolBlockStarts ?? 0) ) { // Every captured call completed and the CLI settled with a successful result before // message_stop (instead of parking on the never-answering capture server). Emitting // this done(stop) now would end the turn as a text completion and skip the // synthesized done(tool_use) the client contract expects. Defer it: message_stop // synthesis emits the terminal event with this frame's usage, and a stream that // ends without message_stop fails closed with protocol_error below. deferredResultDone = event; continue; } emitOnce(event.type === "error" ? { ...event, message: redactSecrets(event.message, profile.tokenEnv, apiKey) } : event); } if (failClosed) break; if ( toolBridge && !terminalEmitted && state.sawMessageStop && (state.toolBlockStarts ?? 0) > 0 && (state.completedToolCalls ?? 0) !== (state.toolBlockStarts ?? 0) ) { emitOnce({ type: "error", message: "Coding-agent CLI ended with an incomplete tool call.", status: 502, errorType: "upstream_error", code: "protocol_error", retryable: false, }); kill(); break; } if (toolBridge && !terminalEmitted && state.sawMessageStop && (state.completedToolCalls ?? 0) > 0) { // The raw-start gate above already refused any call opened before the handshake. // The capture-only MCP handler never answers, so the CLI parks after message_stop. // The completed tool_use blocks are this turn's structured output: end the leg here // and terminate the tree; the client executes, and the next request continues. // Pre-result usage snapshots keep this terminated leg accountable: no result frame // ever arrives for a turn parked on the never-answering capture server. const terminalUsage = deferredResultDone?.usage ?? state.partialUsage; emitOnce({ type: "done", stopReason: "tool_use", endTurn: false, ...(terminalUsage ? { usage: terminalUsage } : {}), }); kill(); break; } if (terminalEmitted) break; } } catch (err) { kill(); streamProtocolError = err instanceof Error ? err.message : String(err); if (isTranslatorBudgetExceededError(err)) streamProtocolCode = err.code; } } catch (err) { kill(); turnError = err instanceof Error ? err.message : String(err); } finally { releaseOpenToolBlocks(state); cleanup(); if (toolBridgeDir) { await rm(toolBridgeDir, { recursive: true, force: true }).catch(() => undefined); } } // Reap the process so no zombie is left behind (§三十): wait for the real `close`, and // force-terminate only if it lingers past the grace window after the stream ended. const graceTimer = setTimeout(() => { kill(); }, killGraceMs); let reapTimer: ReturnType<typeof setTimeout> | undefined; await Promise.race([ processLifecycle, new Promise<void>(resolve => { reapTimer = setTimeout(resolve, reapTimeoutMs); }), ]); clearTimeout(graceTimer); if (reapTimer) clearTimeout(reapTimer); if (killTimer) clearTimeout(killTimer); if (!terminalEmitted) { const stderr = redactSecrets(boundedStderr(stderrChunks), profile.tokenEnv, apiKey); if (incoming.abortSignal?.aborted) { emitOnce({ type: "error", message: `${profile.label} turn was aborted.`, retryable: false }); } else if (childProcessError) { emitOnce({ type: "error", message: `${profile.label} CLI failed to start: ${redactSecrets(childProcessError.message, profile.tokenEnv, apiKey)}`, status: 500, errorType: "upstream_error", code: "cli_spawn_failed", retryable: false, }); } else if (turnError) { emitOnce({ type: "error", message: redactSecrets(turnError, profile.tokenEnv, apiKey), status: 502, errorType: "upstream_error", }); } else if (streamProtocolError) { emitOnce({ type: "error", message: redactSecrets(streamProtocolError, profile.tokenEnv, apiKey), status: 502, errorType: "upstream_error", code: streamProtocolCode ?? "protocol_error", retryable: false, }); } else if (child.exitCode !== null && child.exitCode !== 0) { const exitMsg = stderr ? `${profile.label} CLI exited with code ${child.exitCode}: ${stderr}` : `${profile.label} CLI exited with non-zero exit code ${child.exitCode}`; emitOnce({ type: "error", message: exitMsg, status: 502, errorType: "upstream_error", code: "process_exit_error", retryable: false, }); } else if (toolBridge && deferredResultDone !== undefined && !state.sawMessageStop) { emitOnce({ type: "error", message: `${profile.label} CLI delivered a terminal result before message_stop on a tool-bridge turn.`, status: 502, errorType: "upstream_error", code: "protocol_error", retryable: false, }); } else if (!state.sawTerminalResult) { const msg = stderr ? `${profile.label} CLI ended without a terminal result frame: ${stderr}` : `${profile.label} CLI ended without a terminal result frame`; emitOnce({ type: "error", message: msg, status: 502, errorType: "upstream_error", code: "protocol_error", retryable: false, }); } } } function boundedStderr(chunks: string[]): string { let total = 0; const kept: string[] = []; for (const chunk of chunks) { if (total >= MAX_STDERR_BYTES) break; kept.push(chunk); total += chunk.length; } return kept.join("").slice(0, MAX_STDERR_BYTES).trim(); }