xonecas.io
64875
Mc

mini-coder / commit ccb7c49

fix: handle incomplete assistant streams

xonecas2026-04-09 ccb7c49ebee97deb4f27318a8509ffb779427513 parent f8e150e

5 files changed

TODO.md+4−3
@@ -7,16 +7,17 @@ The spec.md and code are the sources of truth, not this file, don't assume anyth
77
88 ## In progress
99
10-- None right now.
10+- [ ] **Terminal bench with harbor** in `terminal-bench`.
1111
1212 ## Open items
1313
14-- None right now.
14+- [ ] **If git is not installed the app breaks** we should check before we use git, and ensure robustness.
15+- [ ] **Emit a terminal `aborted` event for tool-phase interrupts** (`agent.ts`, `headless.ts`) — interrupting during tool execution currently returns `stopReason: "aborted"` without emitting the terminal `aborted` event required by the headless NDJSON spec.
1516
1617 ## Low priority (deffered until further notice)
1718
1819 - [ ] **Prevent `/session` from switching sessions mid-run** (`ui/commands.ts`, `ui/agent.ts`) — selecting a session while a turn is active can desync UI state from the session the loop is still writing to.
19-- [ ] **XML-escape generated skill catalog fields** (`skills.ts`) — skill names, descriptions, and paths containing XML metacharacters can break the `<available_skills>` prompt block.
20+- [ ] **Replace custom XML parsing and frontmatter parsing with dedicated dependencies** (`skills.ts`, `prompt.ts`)
2021
2122 ## Plugin related (documented only, no plugin related work is planned right now)
2223
src/agent.test.ts+177−0
@@ -991,6 +991,183 @@ describe("agent loop", () => {
991991 ]);
992992 });
993993
994+ test("uses an explicit stream end result when no terminal event was emitted", async () => {
995+ const api = "agent-stream-end-result-test";
996+ const sourceId = "agent-stream-end-result-test-source";
997+ const model: Model<string> = {
998+ id: "agent-stream-end-result-model",
999+ name: "Agent Stream End Result Model",
1000+ api,
1001+ provider: "test",
1002+ baseUrl: "http://localhost:0",
1003+ reasoning: false,
1004+ input: ["text"],
1005+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
1006+ contextWindow: 128000,
1007+ maxTokens: 4096,
1008+ };
1009+
1010+ const finalMessage: AssistantMessage = {
1011+ role: "assistant",
1012+ content: [{ type: "text", text: "done without terminal event" }],
1013+ api,
1014+ provider: model.provider,
1015+ model: model.id,
1016+ usage: ZERO_USAGE,
1017+ stopReason: "stop",
1018+ timestamp: Date.now(),
1019+ };
1020+
1021+ registerApiProvider(
1022+ {
1023+ api,
1024+ stream: () => {
1025+ const stream = createAssistantMessageEventStream();
1026+ queueMicrotask(() => {
1027+ stream.end(finalMessage);
1028+ });
1029+ return stream;
1030+ },
1031+ streamSimple: () => {
1032+ const stream = createAssistantMessageEventStream();
1033+ queueMicrotask(() => {
1034+ stream.end(finalMessage);
1035+ });
1036+ return stream;
1037+ },
1038+ },
1039+ sourceId,
1040+ );
1041+
1042+ const session = createSession(db, { cwd: tmp });
1043+ const userMsg = makeUser("hello");
1044+ const turn = appendMessage(db, session.id, userMsg);
1045+
1046+ try {
1047+ const result = await runAgentLoop({
1048+ db,
1049+ sessionId: session.id,
1050+ turn,
1051+ model,
1052+ systemPrompt: "Test",
1053+ tools: [],
1054+ toolHandlers: new Map(),
1055+ messages: [userMsg],
1056+ cwd: tmp,
1057+ });
1058+
1059+ expect(result.stopReason).toBe("stop");
1060+ const lastMessage = result.messages.at(-1);
1061+ expect(lastMessage?.role).toBe("assistant");
1062+ if (!lastMessage || lastMessage.role !== "assistant") {
1063+ throw new Error("Expected assistant message");
1064+ }
1065+ expect(lastMessage.stopReason).toBe("stop");
1066+ expect(lastMessage.content).toEqual(finalMessage.content);
1067+ } finally {
1068+ unregisterApiProviders(sourceId);
1069+ }
1070+ });
1071+
1072+ test("treats a stream that ends without a terminal event as an error instead of hanging", async () => {
1073+ const api = "agent-incomplete-stream-test";
1074+ const sourceId = "agent-incomplete-stream-test-source";
1075+ const model: Model<string> = {
1076+ id: "agent-incomplete-stream-model",
1077+ name: "Agent Incomplete Stream Model",
1078+ api,
1079+ provider: "test",
1080+ baseUrl: "http://localhost:0",
1081+ reasoning: false,
1082+ input: ["text"],
1083+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
1084+ contextWindow: 128000,
1085+ maxTokens: 4096,
1086+ };
1087+
1088+ const buildPartialMessage = (): AssistantMessage => ({
1089+ role: "assistant",
1090+ content: [{ type: "text", text: "partial" }],
1091+ api,
1092+ provider: model.provider,
1093+ model: model.id,
1094+ usage: ZERO_USAGE,
1095+ stopReason: "stop",
1096+ timestamp: Date.now(),
1097+ });
1098+
1099+ registerApiProvider(
1100+ {
1101+ api,
1102+ stream: () => {
1103+ const stream = createAssistantMessageEventStream();
1104+ queueMicrotask(() => {
1105+ stream.push({
1106+ type: "start",
1107+ partial: buildPartialMessage(),
1108+ });
1109+ stream.end();
1110+ });
1111+ return stream;
1112+ },
1113+ streamSimple: () => {
1114+ const stream = createAssistantMessageEventStream();
1115+ queueMicrotask(() => {
1116+ stream.push({
1117+ type: "start",
1118+ partial: buildPartialMessage(),
1119+ });
1120+ stream.end();
1121+ });
1122+ return stream;
1123+ },
1124+ },
1125+ sourceId,
1126+ );
1127+
1128+ const session = createSession(db, { cwd: tmp });
1129+ const userMsg = makeUser("hello");
1130+ const turn = appendMessage(db, session.id, userMsg);
1131+ const timeout = Symbol("timeout");
1132+
1133+ try {
1134+ const raced = await Promise.race([
1135+ runAgentLoop({
1136+ db,
1137+ sessionId: session.id,
1138+ turn,
1139+ model,
1140+ systemPrompt: "Test",
1141+ tools: [],
1142+ toolHandlers: new Map(),
1143+ messages: [userMsg],
1144+ cwd: tmp,
1145+ }),
1146+ new Promise<typeof timeout>((resolve) => {
1147+ setTimeout(() => resolve(timeout), 100);
1148+ }),
1149+ ]);
1150+
1151+ expect(raced).not.toBe(timeout);
1152+ if (raced === timeout) {
1153+ throw new Error("Expected runAgentLoop to settle");
1154+ }
1155+
1156+ expect(raced.stopReason).toBe("error");
1157+ const lastMessage = raced.messages.at(-1);
1158+ expect(lastMessage?.role).toBe("assistant");
1159+ if (!lastMessage || lastMessage.role !== "assistant") {
1160+ throw new Error("Expected assistant error message");
1161+ }
1162+ expect(lastMessage.stopReason).toBe("error");
1163+ expect(lastMessage.errorMessage).toContain(
1164+ "Stream ended without a final assistant message",
1165+ );
1166+ } finally {
1167+ unregisterApiProviders(sourceId);
1168+ }
1169+ });
1170+
9941171 test("preserves thinking content on assistant messages", async () => {
9951172 faux.setResponses([
9961173 fauxAssistantMessage([
src/agent.ts+49−1
@@ -376,6 +376,44 @@ function handleAssistantStreamEvent(
376376 }
377377 }
378378
379+function buildIncompleteAssistantMessage(
380+ opts: Pick<RunAgentOpts, "model" | "signal">,
381+ partialAssistantMessage?: AssistantMessage,
382+): AssistantMessage {
383+ const stopReason = opts.signal?.aborted ? "aborted" : "error";
384+ const errorMessage =
385+ stopReason === "aborted"
386+ ? "Request was aborted"
387+ : "Stream ended without a final assistant message";
388+
389+ return {
390+ role: "assistant",
391+ content: partialAssistantMessage
392+ ? cloneAssistantContent(partialAssistantMessage.content)
393+ : [],
394+ api: partialAssistantMessage?.api ?? opts.model.api,
395+ provider: partialAssistantMessage?.provider ?? opts.model.provider,
396+ model: partialAssistantMessage?.model ?? opts.model.id,
397+ usage: partialAssistantMessage?.usage ?? {
398+ input: 0,
399+ output: 0,
400+ cacheRead: 0,
401+ cacheWrite: 0,
402+ totalTokens: 0,
403+ cost: {
404+ input: 0,
405+ output: 0,
406+ cacheRead: 0,
407+ cacheWrite: 0,
408+ total: 0,
409+ },
410+ },
411+ stopReason,
412+ errorMessage,
413+ timestamp: Date.now(),
414+ };
415+}
416+
379417 async function streamAssistantMessage(
380418 opts: Pick<
381419 RunAgentOpts,
@@ -394,6 +432,12 @@ async function streamAssistantMessage(
394432 buildAgentContext(opts.systemPrompt, opts.messages, opts.tools),
395433 buildStreamOptions(opts.apiKey, opts.effort, opts.signal),
396434 );
435+ const streamResult = eventStream.result();
436+ let settledStreamResult: AssistantMessage | undefined;
437+ void streamResult.then((message) => {
438+ settledStreamResult = message;
439+ });
440+
397441 let assistantMessage: AssistantMessage | undefined;
398442 let partialAssistantMessage: AssistantMessage | undefined;
399443
@@ -406,8 +450,12 @@ async function streamAssistantMessage(
406450 handleAssistantStreamEvent(event, opts.onEvent) ?? assistantMessage;
407451 }
408452
453+ // `end(result)` resolves the final result without emitting a terminal event.
454+ await Promise.resolve();
409455 const finalAssistantMessage =
410- assistantMessage ?? (await eventStream.result());
456+ assistantMessage ??
457+ settledStreamResult ??
458+ buildIncompleteAssistantMessage(opts, partialAssistantMessage);
411459 if (!partialAssistantMessage) {
412460 return finalAssistantMessage;
413461 }
src/ui.test.ts+43−0
@@ -1484,6 +1484,49 @@ describe("ui rendering", () => {
14841484 }
14851485 });
14861486
1487+ test("blurring the input while idle unfocuses it", () => {
1488+ const state = createTestState();
1489+
1490+ try {
1491+ const controller = createInputController(state);
1492+
1493+ controller.onBlur();
1494+
1495+ const input = expectTextInput(renderInputArea(state.theme, controller));
1496+ expect(input.props.focused).toBe(false);
1497+ } finally {
1498+ state.db.close();
1499+ }
1500+ });
1501+
1502+ test("opening input history during a running turn blurs the input without aborting", () => {
1503+ const state = createTestState();
1504+ state.running = true;
1505+ state.abortController = new AbortController();
1506+
1507+ try {
1508+ appendPromptHistory(state.db, {
1509+ text: "saved prompt",
1510+ cwd: state.cwd,
1511+ });
1512+
1513+ const controller = createInputController(state);
1514+ const base = expectVStack(renderBaseLayout(state, 80, controller));
1515+
1516+ base.props.onKeyPress?.("ctrl+r");
1517+ expect(renderActiveOverlay(state)).not.toBeNull();
1518+
1519+ controller.onBlur();
1520+
1521+ expect(state.abortController.signal.aborted).toBe(false);
1522+ const input = expectTextInput(renderInputArea(state.theme, controller));
1523+ expect(input.props.focused).toBe(false);
1524+ expect(renderActiveOverlay(state)).not.toBeNull();
1525+ } finally {
1526+ state.db.close();
1527+ }
1528+ });
1529+
14871530 test("Tab autocompletes the last file path in normal input mode", () => {
14881531 const state = createTestState();
14891532 const cwd = createTempDir();
src/ui.ts+3−1
@@ -324,7 +324,9 @@ export function createInputController(state: AppState): InputController {
324324 cel.render();
325325 },
326326 onBlur: () => {
327- inputFocused = false;
327+ if (!state.running) {
328+ inputFocused = false;
329+ }
328330 cel.render();
329331 },
330332 onKeyPress: (key) => {