llm-simple-router 0.8.2 → 0.9.4

package/dist/proxy/transform/response-bridge-responses.js

@@ -0,0 +1,173 @@
+/**
+ * Bridge (lossy) response transformation between OpenAI Responses API
+ * and OpenAI Chat Completions API.
+ *
+ * This is the SECONDARY conversion path used when the upstream provider
+ * only supports the opposite API format. It is lossy because Chat Completions
+ * cannot represent structured reasoning summaries, built-in tool outputs,
+ * or response-level metadata.
+ */
+import { generateChatcmplId, generateRespId, MS_PER_SECOND } from "./id-utils.js";
+// ---------- Responses → Chat Completions ----------
+/**
+ * Convert a Responses API response body to a Chat Completions response body.
+ *
+ * Lossy: structured reasoning summaries are flattened to a single string;
+ * built-in tool output items (web_search_call, etc.) are skipped.
+ */
+export function responsesToChatResponse(bodyStr) {
+    const resp = JSON.parse(bodyStr);
+    const output = resp.output ?? [];
+    const message = { role: "assistant" };
+    const toolCalls = [];
+    const textParts = [];
+    let hasFunctionCall = false;
+    for (const item of output) {
+        const type = item.type;
+        if (type === "message") {
+            // ResponseOutputMessage → extract text content
+            const msgContent = item.content ?? [];
+            for (const part of msgContent) {
+                if (part.type === "output_text" && part.text != null) {
+                    textParts.push(String(part.text));
+                }
+            }
+        }
+        else if (type === "function_call") {
+            // → tool_calls
+            hasFunctionCall = true;
+            toolCalls.push({
+                id: String(item.id ?? ""),
+                type: "function",
+                function: {
+                    name: String(item.name ?? ""),
+                    arguments: String(item.arguments ?? "{}"),
+                },
+            });
+        }
+        else if (type === "reasoning") {
+            // → reasoning_content (joined summary text, LOSSY)
+            const summary = item.summary;
+            if (summary) {
+                const joined = summary.map(s => String(s.text ?? "")).join("");
+                if (joined) {
+                    message.reasoning_content = joined;
+                }
+            }
+        }
+        // Other output types (web_search_call, file_search_call, etc.) → skip
+    }
+    // Text content
+    if (textParts.length > 0) {
+        message.content = textParts.join("");
+    }
+    // Tool calls
+    if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+    }
+    // finish_reason
+    let finishReason;
+    if (hasFunctionCall) {
+        finishReason = "tool_calls";
+    }
+    else {
+        finishReason = mapStatusToFinishReason(String(resp.status ?? "completed"));
+    }
+    // Usage mapping
+    const usage = resp.usage;
+    const promptTokens = usage?.input_tokens ?? 0;
+    const completionTokens = usage?.output_tokens ?? 0;
+    return JSON.stringify({
+        id: generateChatcmplId(),
+        object: "chat.completion",
+        created: Math.floor(Date.now() / MS_PER_SECOND),
+        model: resp.model ?? "",
+        choices: [{
+                index: 0,
+                message,
+                finish_reason: finishReason,
+            }],
+        usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens,
+        },
+    });
+}
+/** Responses API status → Chat Completions finish_reason */
+function mapStatusToFinishReason(status) {
+    if (status === "incomplete")
+        return "length";
+    return "stop";
+}
+// ---------- Chat Completions → Responses ----------
+/**
+ * Convert a Chat Completions response body to a Responses API response body.
+ *
+ * Lossy: Chat Completions has no equivalent for built-in tool output items
+ * or structured reasoning summaries.
+ */
+export function chatToResponsesResponse(bodyStr) {
+    const oai = JSON.parse(bodyStr);
+    const choices = (oai.choices ?? []);
+    const choice = choices[0];
+    const msg = choice?.message;
+    const output = [];
+    // reasoning_content → reasoning output
+    if (msg?.reasoning_content) {
+        output.push({
+            type: "reasoning",
+            id: `rs_${Date.now()}_0`,
+            summary: [{ type: "summary_text", text: String(msg.reasoning_content) }],
+        });
+    }
+    // text content → message output
+    if (msg?.content) {
+        output.push({
+            type: "message",
+            id: `msg_${Date.now()}_1`,
+            role: "assistant",
+            content: [{ type: "output_text", text: String(msg.content) }],
+        });
+    }
+    // tool_calls → function_call output items
+    const toolCalls = msg?.tool_calls;
+    if (toolCalls) {
+        for (let i = 0; i < toolCalls.length; i++) {
+            const tc = toolCalls[i];
+            const fn = tc.function;
+            output.push({
+                type: "function_call",
+                id: String(tc.id ?? `fc_${i}`),
+                call_id: String(tc.id ?? `fc_${i}`),
+                name: String(fn?.name ?? ""),
+                arguments: String(fn?.arguments ?? "{}"),
+            });
+        }
+    }
+    // Status mapping
+    const finishReason = String(choice?.finish_reason ?? "stop");
+    const status = mapFinishReasonToStatus(finishReason);
+    // Usage mapping
+    const oaiUsage = oai.usage;
+    const inputTokens = oaiUsage?.prompt_tokens ?? 0;
+    const outputTokens = oaiUsage?.completion_tokens ?? 0;
+    return JSON.stringify({
+        id: generateRespId(),
+        object: "response",
+        model: oai.model ?? "",
+        status,
+        output,
+        usage: {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            total_tokens: inputTokens + outputTokens,
+        },
+    });
+}
+/** Chat Completions finish_reason → Responses API status */
+function mapFinishReasonToStatus(reason) {
+    if (reason === "length")
+        return "incomplete";
+    return "completed"; // "stop", "tool_calls", and unknown → completed
+}

package/dist/proxy/transform/response-transform-responses.d.ts

@@ -0,0 +1,2 @@
+export declare function responsesToAnthropicResponse(bodyStr: string): string;
+export declare function anthropicToResponsesResponse(bodyStr: string): string;

package/dist/proxy/transform/response-transform-responses.js

@@ -0,0 +1,137 @@
+import { generateMsgId, generateRespId } from "./id-utils.js";
+import { parseToolArguments } from "./sanitize.js";
+// ---------- Status ↔ stop_reason mapping ----------
+const RESP_STATUS_TO_STOP = {
+    completed: "end_turn",
+    incomplete: "max_tokens",
+    failed: "end_turn",
+};
+const ANT_STOP_TO_RESP_STATUS = {
+    end_turn: "completed",
+    stop_sequence: "completed",
+    tool_use: "completed",
+    max_tokens: "incomplete",
+};
+/** Responses API status → Anthropic stop_reason */
+function mapStatusToStopReason(status) {
+    return RESP_STATUS_TO_STOP[status] ?? "end_turn";
+}
+/** Anthropic stop_reason → Responses API status */
+function mapStopReasonToStatus(reason) {
+    return ANT_STOP_TO_RESP_STATUS[reason] ?? "completed";
+}
+// ---------- Responses → Anthropic ----------
+export function responsesToAnthropicResponse(bodyStr) {
+    const resp = JSON.parse(bodyStr);
+    const output = resp.output ?? [];
+    const content = [];
+    for (const item of output) {
+        const type = item.type;
+        if (type === "message") {
+            // ResponseOutputMessage → text blocks
+            const msgContent = item.content ?? [];
+            for (const part of msgContent) {
+                if (part.type === "output_text" && part.text != null) {
+                    content.push({ type: "text", text: String(part.text) });
+                }
+            }
+        }
+        else if (type === "function_call") {
+            // → tool_use block (Anthropic requires "toolu_" prefix)
+            const rawCallId = String(item.call_id ?? "");
+            const antId = rawCallId.startsWith("toolu_") ? rawCallId : `toolu_${rawCallId}`;
+            content.push({
+                type: "tool_use",
+                id: antId,
+                name: String(item.name ?? ""),
+                input: parseToolArguments(item.arguments),
+            });
+        }
+        else if (type === "reasoning") {
+            // → thinking block
+            const summary = item.summary;
+            const thinkingText = summary
+                ? summary.map(s => String(s.text ?? "")).join("")
+                : "";
+            content.push({ type: "thinking", thinking: thinkingText });
+        }
+        // Other output types (web_search_call, etc.) → skip
+    }
+    if (content.length === 0) {
+        content.push({ type: "text", text: "" });
+    }
+    const usage = resp.usage;
+    return JSON.stringify({
+        id: generateMsgId(),
+        type: "message",
+        role: "assistant",
+        content,
+        model: resp.model ?? "",
+        stop_reason: mapStatusToStopReason(String(resp.status ?? "completed")),
+        stop_sequence: null,
+        usage: {
+            input_tokens: usage?.input_tokens ?? 0,
+            output_tokens: usage?.output_tokens ?? 0,
+        },
+    });
+}
+// ---------- Anthropic → Responses ----------
+/** Strip "toolu_" prefix from a tool_use_id to recover the original call_id. */
+function stripTooluPrefix(id) {
+    return id.startsWith("toolu_") ? id.slice(6) : id;
+}
+export function anthropicToResponsesResponse(bodyStr) {
+    const ant = JSON.parse(bodyStr);
+    const blocks = ant.content ?? [];
+    const output = [];
+    for (const block of blocks) {
+        const type = block.type;
+        if (type === "thinking") {
+            // → reasoning output
+            output.push({
+                type: "reasoning",
+                id: `rs_${Date.now()}_${output.length}`,
+                summary: [{ type: "summary_text", text: String(block.thinking ?? "") }],
+            });
+        }
+        else if (type === "text") {
+            // → message output
+            output.push({
+                type: "message",
+                id: generateMsgId(),
+                role: "assistant",
+                content: [{ type: "output_text", text: String(block.text ?? "") }],
+            });
+        }
+        else if (type === "tool_use") {
+            // → function_call output
+            const rawId = String(block.id ?? "");
+            const callId = stripTooluPrefix(rawId);
+            output.push({
+                type: "function_call",
+                id: `fc_${callId}`,
+                call_id: callId,
+                name: String(block.name ?? ""),
+                arguments: JSON.stringify(block.input ?? {}),
+            });
+        }
+    }
+    // Usage mapping: Anthropic → Responses
+    const antUsage = ant.usage;
+    const inputTokens = (antUsage?.input_tokens ?? 0) +
+        (antUsage?.cache_read_input_tokens ?? 0) +
+        (antUsage?.cache_creation_input_tokens ?? 0);
+    const outputTokens = antUsage?.output_tokens ?? 0;
+    return JSON.stringify({
+        id: generateRespId(),
+        object: "response",
+        model: ant.model ?? "",
+        status: mapStopReasonToStatus(String(ant.stop_reason ?? "end_turn")),
+        output,
+        usage: {
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            total_tokens: inputTokens + outputTokens,
+        },
+    });
+}

package/dist/proxy/transform/stream-ant2resp.d.ts

@@ -0,0 +1,26 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+export declare class AnthropicToResponsesTransform extends BaseSSETransform {
+    private state;
+    private responseId;
+    private outputIndex;
+    private sequenceNumber;
+    private hasResponseCreated;
+    private inputTokens;
+    private outputTokens;
+    private pendingStatus;
+    private activeToolCallId;
+    private collectedOutput;
+    private currentItemId;
+    private currentSummaryPartId;
+    private currentContentPartIndex;
+    private createdAt;
+    private nextSeq;
+    private emitResponseCreated;
+    protected processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    private emitCompleted;
+    protected flushPendingData(): void;
+    protected ensureTerminated(): void;
+}

package/dist/proxy/transform/stream-ant2resp.js

@@ -0,0 +1,322 @@
+import { randomBytes } from "crypto";
+import { BaseSSETransform } from "./stream-transform-base.js";
+import { generateRespId } from "./id-utils.js";
+import { RESPONSES_SSE_EVENTS } from "./types-responses.js";
+function randomHex(bytes) {
+    return randomBytes(bytes).toString("hex");
+}
+export class AnthropicToResponsesTransform extends BaseSSETransform {
+    state = "init";
+    responseId = generateRespId();
+    outputIndex = 0;
+    sequenceNumber = 0;
+    hasResponseCreated = false;
+    inputTokens = 0;
+    outputTokens = 0;
+    pendingStatus = null;
+    activeToolCallId = "";
+    collectedOutput = [];
+    currentItemId = "";
+    currentSummaryPartId = "";
+    currentContentPartIndex = 0;
+    createdAt = Math.floor(Date.now() / 1000);
+    nextSeq() {
+        return this.sequenceNumber++;
+    }
+    emitResponseCreated() {
+        if (this.hasResponseCreated)
+            return;
+        this.hasResponseCreated = true;
+        const base = {
+            id: this.responseId,
+            object: "response",
+            model: this.model,
+            status: "in_progress",
+            output: [],
+            created_at: this.createdAt,
+        };
+        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.CREATED, {
+            type: RESPONSES_SSE_EVENTS.CREATED,
+            response: { ...base, status: "queued" },
+            sequence_number: this.nextSeq(),
+        });
+        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.IN_PROGRESS, {
+            type: RESPONSES_SSE_EVENTS.IN_PROGRESS,
+            response: base,
+            sequence_number: this.nextSeq(),
+        });
+    }
+    processEvent(event) {
+        let data;
+        try {
+            data = JSON.parse(event.data);
+        }
+        catch (err) {
+            this.emit("warning", err);
+            return;
+        }
+        switch (data.type) {
+            case "message_start": {
+                const msg = data.message;
+                const usage = msg?.usage;
+                this.inputTokens = usage?.input_tokens ?? 0;
+                this.emitResponseCreated();
+                break;
+            }
+            case "content_block_start": {
+                const block = data.content_block;
+                const blockType = block?.type;
+                if (blockType === "thinking") {
+                    this.state = "thinking";
+                    this.currentItemId = `rs_${randomHex(12)}`;
+                    this.currentSummaryPartId = `sp_${randomHex(8)}`;
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED,
+                        output_index: this.outputIndex,
+                        item: { type: "reasoning", id: this.currentItemId, summary: [] },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.REASONING_SUMMARY_PART_ADDED, {
+                        type: RESPONSES_SSE_EVENTS.REASONING_SUMMARY_PART_ADDED,
+                        output_index: this.outputIndex,
+                        summary_index: 0,
+                        part: { type: "summary_text", text: "" },
+                        sequence_number: this.nextSeq(),
+                    });
+                }
+                else if (blockType === "text") {
+                    this.state = "text";
+                    this.currentItemId = `msg_${randomHex(12)}`;
+                    this.currentContentPartIndex = 0;
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED,
+                        output_index: this.outputIndex,
+                        item: { type: "message", id: this.currentItemId, role: "assistant", content: [], status: "in_progress" },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.CONTENT_PART_ADDED, {
+                        type: RESPONSES_SSE_EVENTS.CONTENT_PART_ADDED,
+                        output_index: this.outputIndex,
+                        content_index: 0,
+                        part: { type: "output_text", text: "", annotations: [] },
+                        sequence_number: this.nextSeq(),
+                    });
+                }
+                else if (blockType === "tool_use") {
+                    this.state = "tool_use";
+                    const toolId = block.id;
+                    // Convert toolu_ prefix to fc_ prefix
+                    this.activeToolCallId = toolId.startsWith("toolu_")
+                        ? `fc_${toolId.slice(6)}`
+                        : `fc_${randomHex(12)}`;
+                    const callId = this.activeToolCallId;
+                    this.currentItemId = callId;
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED,
+                        output_index: this.outputIndex,
+                        item: {
+                            type: "function_call",
+                            id: callId,
+                            call_id: callId,
+                            name: block.name,
+                            arguments: "",
+                            status: "in_progress",
+                        },
+                        sequence_number: this.nextSeq(),
+                    });
+                }
+                break;
+            }
+            case "content_block_delta": {
+                const delta = data.delta;
+                const deltaType = delta?.type;
+                if (deltaType === "thinking_delta") {
+                    const thinking = delta.thinking;
+                    if (thinking) {
+                        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.REASONING_SUMMARY_TEXT_DELTA, {
+                            type: RESPONSES_SSE_EVENTS.REASONING_SUMMARY_TEXT_DELTA,
+                            output_index: this.outputIndex,
+                            summary_index: 0,
+                            delta: thinking,
+                            sequence_number: this.nextSeq(),
+                        });
+                    }
+                }
+                else if (deltaType === "text_delta") {
+                    const text = delta.text;
+                    if (text) {
+                        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DELTA, {
+                            type: RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DELTA,
+                            output_index: this.outputIndex,
+                            content_index: 0,
+                            delta: text,
+                            sequence_number: this.nextSeq(),
+                        });
+                    }
+                }
+                else if (deltaType === "input_json_delta") {
+                    const partialJson = delta.partial_json;
+                    if (partialJson) {
+                        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DELTA, {
+                            type: RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DELTA,
+                            output_index: this.outputIndex,
+                            item_id: this.currentItemId,
+                            call_id: this.activeToolCallId,
+                            delta: partialJson,
+                            sequence_number: this.nextSeq(),
+                        });
+                    }
+                }
+                break;
+            }
+            case "content_block_stop": {
+                if (this.state === "thinking") {
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.REASONING_SUMMARY_TEXT_DONE, {
+                        type: RESPONSES_SSE_EVENTS.REASONING_SUMMARY_TEXT_DONE,
+                        output_index: this.outputIndex,
+                        summary_index: 0,
+                        text: "",
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.REASONING_SUMMARY_PART_DONE, {
+                        type: RESPONSES_SSE_EVENTS.REASONING_SUMMARY_PART_DONE,
+                        output_index: this.outputIndex,
+                        summary_index: 0,
+                        part: { type: "summary_text", text: "" },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE,
+                        output_index: this.outputIndex,
+                        item: { type: "reasoning", id: this.currentItemId, summary: [{ type: "summary_text", text: "" }] },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.collectedOutput.push({ type: "reasoning", id: this.currentItemId, summary: [{ type: "summary_text", text: "" }] });
+                }
+                else if (this.state === "text") {
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DONE, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DONE,
+                        output_index: this.outputIndex,
+                        content_index: 0,
+                        text: "",
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.CONTENT_PART_DONE, {
+                        type: RESPONSES_SSE_EVENTS.CONTENT_PART_DONE,
+                        output_index: this.outputIndex,
+                        content_index: 0,
+                        part: { type: "output_text", text: "", annotations: [] },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE,
+                        output_index: this.outputIndex,
+                        item: { type: "message", id: this.currentItemId, role: "assistant", content: [{ type: "output_text", text: "", annotations: [] }], status: "completed" },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.collectedOutput.push({
+                        type: "message", id: this.currentItemId, role: "assistant",
+                        content: [{ type: "output_text", text: "", annotations: [] }],
+                    });
+                }
+                else if (this.state === "tool_use") {
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DONE, {
+                        type: RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DONE,
+                        output_index: this.outputIndex,
+                        item_id: this.currentItemId,
+                        call_id: this.activeToolCallId,
+                        arguments: "",
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE,
+                        output_index: this.outputIndex,
+                        item: {
+                            type: "function_call", id: this.activeToolCallId,
+                            call_id: this.activeToolCallId,
+                            name: "", arguments: "", status: "completed",
+                        },
+                        sequence_number: this.nextSeq(),
+                    });
+                    this.collectedOutput.push({
+                        type: "function_call", id: this.activeToolCallId,
+                        call_id: this.activeToolCallId, name: "", arguments: "",
+                    });
+                }
+                this.outputIndex++;
+                this.state = "init";
+                break;
+            }
+            case "message_delta": {
+                const msgDelta = data.delta;
+                const usage = data.usage;
+                this.outputTokens = usage?.output_tokens ?? this.outputTokens;
+                const stopReason = msgDelta?.stop_reason;
+                if (stopReason === "tool_use") {
+                    this.pendingStatus = "completed"; // will have function_calls → status remains completed
+                }
+                else if (stopReason === "max_tokens") {
+                    this.pendingStatus = "incomplete";
+                }
+                else {
+                    this.pendingStatus = "completed";
+                }
+                break;
+            }
+            case "message_stop": {
+                this.emitCompleted();
+                break;
+            }
+            case "error": {
+                const error = data.error;
+                this.pushResponsesSSE(RESPONSES_SSE_EVENTS.ERROR, {
+                    type: "error",
+                    message: error?.message ?? "Stream error",
+                    code: error?.type ?? "upstream_error",
+                });
+                this.pushDone();
+                break;
+            }
+            case "ping": {
+                break;
+            }
+            default: {
+                this.emit("warning", { event: "unknown_event", type: data.type });
+                break;
+            }
+        }
+    }
+    emitCompleted() {
+        const status = this.pendingStatus ?? "completed";
+        const completedAt = Math.floor(Date.now() / 1000);
+        const response = {
+            id: this.responseId,
+            object: "response",
+            model: this.model,
+            status: status,
+            output: this.collectedOutput,
+            usage: {
+                input_tokens: this.inputTokens,
+                output_tokens: this.outputTokens,
+                total_tokens: this.inputTokens + this.outputTokens,
+            },
+            created_at: this.createdAt,
+            completed_at: completedAt,
+        };
+        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.COMPLETED, {
+            type: RESPONSES_SSE_EVENTS.COMPLETED,
+            response,
+            sequence_number: this.nextSeq(),
+        });
+        this.pushDone();
+    }
+    flushPendingData() {
+        // No buffered data to flush
+    }
+    ensureTerminated() {
+        if (!this.done) {
+            this.emitResponseCreated();
+            this.emitCompleted();
+        }
+    }
+}