diff --git a/open-sse/translator/response/openai-responses.js b/open-sse/translator/response/openai-responses.js index 80f8a785..6a865d1a 100644 --- a/open-sse/translator/response/openai-responses.js +++ b/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 } : {}) } }); diff --git a/tests/unit/responses-completed-output.test.js b/tests/unit/responses-completed-output.test.js new file mode 100644 index 00000000..f72c4603 --- /dev/null +++ b/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); + }); +}); \ No newline at end of file