fix(responses): carry the streamed output items in response.completed (#4307)

open-sse/translator/response/openai-responses.js

@@ -223,15 +223,19 @@ function closeReasoning(state, emit) {
       part: { type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }
     });
 
+    const item = {
+      id: state.reasoningId,
+      type: RESPONSES_ITEM.REASONING,
+      summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }]
+    };
+
     emit("response.output_item.done", {
       type: "response.output_item.done",
       output_index: state.reasoningIndex,
-      item: {
-        id: state.reasoningId,
-        type: RESPONSES_ITEM.REASONING,
-        summary: [{ type: RESPONSES_ITEM.SUMMARY_TEXT, text: state.reasoningBuf }]
-      }
+      item
     });
+
+    recordCompletedOutputItem(state, state.reasoningIndex, item);
   }
 }
 
@@ -295,16 +299,20 @@ function closeMessage(state, emit, idx) {
       part: { type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }
     });
 
+    const item = {
+      id: msgId,
+      type: RESPONSES_ITEM.MESSAGE,
+      content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }],
+      role: ROLE.ASSISTANT
+    };
+
     emit("response.output_item.done", {
       type: "response.output_item.done",
       output_index: parseInt(idx),
-      item: {
-        id: msgId,
-        type: RESPONSES_ITEM.MESSAGE,
-        content: [{ type: RESPONSES_ITEM.OUTPUT_TEXT, annotations: [], logprobs: [], text: fullText }],
-        role: ROLE.ASSISTANT
-      }
+      item
     });
+
+    recordCompletedOutputItem(state, parseInt(idx), item);
   }
 }
 
@@ -398,23 +406,51 @@ function closeToolCall(state, emit, idx) {
       });
     }
 
+    const item = {
+      id: `${custom ? "ctc" : "fc"}_${callId}`,
+      type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
+      ...(custom ? { input: extractCustomToolInput(args) } : { arguments: args }),
+      call_id: callId,
+      name: state.funcNames[idx] || ""
+    };
+
     emit("response.output_item.done", {
       type: "response.output_item.done",
       output_index: parseInt(idx),
-      item: {
-        id: `${custom ? "ctc" : "fc"}_${callId}`,
-        type: custom ? RESPONSES_ITEM.CUSTOM_TOOL_CALL : RESPONSES_ITEM.FUNCTION_CALL,
-        ...(custom ? { input: extractCustomToolInput(args) } : { arguments: args }),
-        call_id: callId,
-        name: state.funcNames[idx] || ""
-      }
+      item
     });
 
+    recordCompletedOutputItem(state, parseInt(idx), item);
+
     state.funcItemDone[idx] = true;
     state.funcArgsDone[idx] = true;
   }
 }
 
+// response.completed carries the finished Response object, so response.output has
+// to repeat the items already delivered in response.output_item.done. Clients that
+// build their final result from the terminal event (GitHub Copilot CLI, the OpenAI
+// SDK "final response" helpers) otherwise treat the turn as empty even though the
+// text was streamed - see issue #4307.
+//
+// Keyed by output_index so a repeated close overwrites rather than duplicating the
+// item, and ordered by output_index so response.output matches the order the items
+// were emitted in. Lazily created because stream.js can hand us a state it built
+// itself rather than one from initState().
+function recordCompletedOutputItem(state, outputIndex, item) {
+  state.completedOutputItems ??= new Map();
+  const index = Number.isInteger(outputIndex) ? outputIndex : Number.parseInt(outputIndex, 10) || 0;
+  state.completedOutputItems.set(index, item);
+}
+
+function collectCompletedOutputItems(state) {
+  const recorded = state.completedOutputItems;
+  if (!(recorded instanceof Map) || recorded.size === 0) return [];
+  return [...recorded.entries()]
+    .sort((left, right) => left[0] - right[0])
+    .map(([, item]) => item);
+}
+
 function sendCompleted(state, emit) {
   if (!state.completedSent) {
     state.completedSent = true;
@@ -427,6 +463,7 @@ function sendCompleted(state, emit) {
         status: "completed",
         background: false,
         error: null,
+        output: collectCompletedOutputItems(state),
         ...(state.responsesUsage ? { usage: state.responsesUsage } : {})
       }
     });

tests/unit/responses-completed-output.test.js

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "vitest";
+
+import { FORMATS } from "../../open-sse/translator/formats.js";
+import { initState } from "../../open-sse/translator/index.js";
+import { openaiToOpenAIResponsesResponse } from "../../open-sse/translator/response/openai-responses.js";
+
+// targetFormat === OPENAI is the direct openai -> openai-responses route, which is
+// the only one where flush() reaches this translator (see the flushReachesUs note
+// above the finish_reason branch).
+function newState() {
+  return { ...initState(FORMATS.OPENAI_RESPONSES), targetFormat: FORMATS.OPENAI };
+}
+
+function textChunk(text, index = 0) {
+  return { id: "chatcmpl-1", choices: [{ index, delta: { content: text } }] };
+}
+
+function reasoningChunk(text, index = 0) {
+  return { id: "chatcmpl-1", choices: [{ index, delta: { reasoning_content: text } }] };
+}
+
+function finishChunk(usage) {
+  return { id: "chatcmpl-1", choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage };
+}
+
+function runChunks(chunks) {
+  const state = newState();
+  const events = [];
+  for (const chunk of chunks) {
+    for (const event of openaiToOpenAIResponsesResponse(chunk, state)) events.push(event);
+  }
+  return { state, events };
+}
+
+function completedResponse(events) {
+  const completed = events.find((event) => event.event === "response.completed");
+  expect(completed, "expected a response.completed event").toBeTruthy();
+  return completed.data.response;
+}
+
+function doneItems(events) {
+  return events
+    .filter((event) => event.event === "response.output_item.done")
+    .map((event) => event.data.item);
+}
+
+describe("response.completed output (issue #4307)", () => {
+  // The regression: sendCompleted() built the response object without an `output`
+  // key at all, so response.completed arrived with no output even though the
+  // message had already been streamed. Clients that build the final result from
+  // the terminal event (GitHub Copilot CLI 1.0.89 with a BYOK provider) printed
+  // the text and then failed with "No response was returned".
+  it("repeats the streamed message in response.completed", () => {
+    const state = newState();
+    openaiToOpenAIResponsesResponse(textChunk("O"), state);
+    openaiToOpenAIResponsesResponse(textChunk("K"), state);
+    const response = completedResponse(openaiToOpenAIResponsesResponse(null, state));
+
+    expect(response.status).toBe("completed");
+    expect(Array.isArray(response.output)).toBe(true);
+    expect(response.output).toHaveLength(1);
+    expect(response.output[0]).toMatchObject({ type: "message", role: "assistant" });
+    expect(response.output[0].content[0]).toMatchObject({ type: "output_text", text: "OK" });
+  });
+
+  it("matches exactly the items already delivered in response.output_item.done", () => {
+    const { events } = runChunks([
+      textChunk("hello"),
+      finishChunk({ prompt_tokens: 7, completion_tokens: 2, total_tokens: 9 }),
+    ]);
+    const response = completedResponse(events);
+    const streamed = doneItems(events);
+
+    expect(streamed).toHaveLength(1);
+    expect(response.output).toEqual(streamed);
+  });
+
+  it("includes a function_call item", () => {
+    const { events } = runChunks([
+      {
+        id: "chatcmpl-1",
+        choices: [
+          {
+            index: 0,
+            delta: {
+              tool_calls: [
+                { index: 0, id: "call_1", function: { name: "get_weather", arguments: '{"city":"Paris"}' } },
+              ],
+            },
+          },
+        ],
+      },
+      finishChunk({ prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }),
+    ]);
+    const response = completedResponse(events);
+
+    expect(response.output).toHaveLength(1);
+    expect(response.output[0]).toMatchObject({
+      type: "function_call",
+      name: "get_weather",
+      arguments: '{"city":"Paris"}',
+      call_id: "call_1",
+    });
+  });
+
+  it("orders output by output_index", () => {
+    const { events } = runChunks([
+      reasoningChunk("thinking", 0),
+      textChunk("answer", 1),
+      finishChunk({ prompt_tokens: 4, completion_tokens: 3, total_tokens: 7 }),
+    ]);
+    const response = completedResponse(events);
+
+    expect(response.output.map((item) => item.type)).toEqual(["reasoning", "message"]);
+    expect(response.output[1].content[0]).toMatchObject({ type: "output_text", text: "answer" });
+  });
+
+  it("reports an empty output array when nothing was produced", () => {
+    const state = newState();
+    const response = completedResponse(openaiToOpenAIResponsesResponse(null, state));
+    expect(response.output).toEqual([]);
+  });
+
+  it("keeps the usage block alongside output", () => {
+    const { events } = runChunks([
+      textChunk("OK"),
+      finishChunk({ prompt_tokens: 3, completion_tokens: 1, total_tokens: 4 }),
+    ]);
+    const response = completedResponse(events);
+
+    expect(response.usage).toMatchObject({ input_tokens: 3, output_tokens: 1, total_tokens: 4 });
+    expect(response.output).toHaveLength(1);
+  });
+
+  it("leaves the in-progress response.created output empty", () => {
+    const { events } = runChunks([textChunk("hi")]);
+    const created = events.find((event) => event.event === "response.created");
+    expect(created.data.response.status).toBe("in_progress");
+    expect(created.data.response.output).toEqual([]);
+  });
+
+  it("does not duplicate items when flush runs more than once", () => {
+    const state = newState();
+    openaiToOpenAIResponsesResponse(textChunk("once"), state);
+    openaiToOpenAIResponsesResponse(null, state);
+    const second = openaiToOpenAIResponsesResponse(null, state);
+
+    expect(second).toEqual([]);
+    expect(state.completedOutputItems.size).toBe(1);
+  });
+});