llm-simple-router 0.8.2 → 0.9.4

package/dist/proxy/transform/stream-bridge-chat2resp.d.ts

@@ -0,0 +1,40 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+/**
+ * Bridge transform: Chat Completions SSE → Responses API SSE.
+ *
+ * Used when the client sends a Responses API request but the upstream
+ * provider speaks Chat Completions. This is a lossy conversion —
+ * Responses API has richer event types than Chat delta chunks.
+ */
+export declare class ChatToResponsesBridgeTransform extends BaseSSETransform {
+    private responseId;
+    private hasResponseCreated;
+    private outputIndex;
+    private contentIndex;
+    private sequenceNumber;
+    private hasMessageItemStarted;
+    private hasContentPartStarted;
+    private hasReasoningItemStarted;
+    private inputTokens;
+    private outputTokens;
+    private pendingCompletion;
+    private collectedOutput;
+    private currentMessageItemId;
+    private currentFunctionCallId;
+    private currentFunctionCallName;
+    private currentReasoningItemId;
+    private createdAt;
+    private nextSeq;
+    private ensureResponseCreated;
+    private closeCurrentMessageItem;
+    private closeCurrentReasoningItem;
+    private closeCurrentFunctionCall;
+    private closeAllOpenItems;
+    private emitCompleted;
+    protected processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    protected flushPendingData(): void;
+    protected ensureTerminated(): void;
+}

package/dist/proxy/transform/stream-bridge-chat2resp.js

@@ -0,0 +1,382 @@
+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");
+}
+/**
+ * Bridge transform: Chat Completions SSE → Responses API SSE.
+ *
+ * Used when the client sends a Responses API request but the upstream
+ * provider speaks Chat Completions. This is a lossy conversion —
+ * Responses API has richer event types than Chat delta chunks.
+ */
+export class ChatToResponsesBridgeTransform extends BaseSSETransform {
+    responseId = generateRespId();
+    hasResponseCreated = false;
+    outputIndex = 0;
+    contentIndex = 0;
+    sequenceNumber = 0;
+    hasMessageItemStarted = false;
+    hasContentPartStarted = false;
+    hasReasoningItemStarted = false;
+    inputTokens = 0;
+    outputTokens = 0;
+    pendingCompletion = false;
+    collectedOutput = [];
+    currentMessageItemId = "";
+    currentFunctionCallId = "";
+    currentFunctionCallName = "";
+    currentReasoningItemId = "";
+    createdAt = Math.floor(Date.now() / 1000);
+    nextSeq() {
+        return this.sequenceNumber++;
+    }
+    ensureResponseCreated() {
+        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(),
+        });
+    }
+    closeCurrentMessageItem() {
+        if (this.hasContentPartStarted) {
+            this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DONE, {
+                type: RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DONE,
+                output_index: this.outputIndex,
+                content_index: this.contentIndex,
+                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: this.contentIndex,
+                part: { type: "output_text", text: "", annotations: [] },
+                sequence_number: this.nextSeq(),
+            });
+            this.hasContentPartStarted = false;
+        }
+        if (this.hasMessageItemStarted) {
+            this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE, {
+                type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_DONE,
+                output_index: this.outputIndex,
+                item: {
+                    type: "message",
+                    id: this.currentMessageItemId,
+                    role: "assistant",
+                    content: [{ type: "output_text", text: "", annotations: [] }],
+                    status: "completed",
+                },
+                sequence_number: this.nextSeq(),
+            });
+            this.collectedOutput.push({
+                type: "message",
+                id: this.currentMessageItemId,
+                role: "assistant",
+                content: [{ type: "output_text", text: "", annotations: [] }],
+            });
+            this.hasMessageItemStarted = false;
+            this.outputIndex++;
+        }
+    }
+    closeCurrentReasoningItem() {
+        if (!this.hasReasoningItemStarted)
+            return;
+        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.currentReasoningItemId,
+                summary: [{ type: "summary_text", text: "" }],
+            },
+            sequence_number: this.nextSeq(),
+        });
+        this.collectedOutput.push({
+            type: "reasoning",
+            id: this.currentReasoningItemId,
+            summary: [{ type: "summary_text", text: "" }],
+        });
+        this.hasReasoningItemStarted = false;
+        this.outputIndex++;
+    }
+    closeCurrentFunctionCall() {
+        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DONE, {
+            type: RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DONE,
+            output_index: this.outputIndex,
+            item_id: this.currentFunctionCallId,
+            call_id: this.currentFunctionCallId,
+            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.currentFunctionCallId,
+                call_id: this.currentFunctionCallId,
+                name: this.currentFunctionCallName,
+                arguments: "",
+                status: "completed",
+            },
+            sequence_number: this.nextSeq(),
+        });
+        this.collectedOutput.push({
+            type: "function_call",
+            id: this.currentFunctionCallId,
+            call_id: this.currentFunctionCallId,
+            name: this.currentFunctionCallName,
+            arguments: "",
+        });
+        this.outputIndex++;
+        this.currentFunctionCallId = "";
+        this.currentFunctionCallName = "";
+    }
+    closeAllOpenItems() {
+        this.closeCurrentReasoningItem();
+        this.closeCurrentMessageItem();
+        if (this.currentFunctionCallId) {
+            this.closeCurrentFunctionCall();
+        }
+    }
+    emitCompleted() {
+        const completedAt = Math.floor(Date.now() / 1000);
+        const response = {
+            id: this.responseId,
+            object: "response",
+            model: this.model,
+            status: "completed",
+            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();
+    }
+    processEvent(event) {
+        let chunk;
+        try {
+            chunk = JSON.parse(event.data);
+        }
+        catch (err) {
+            this.emit("warning", err);
+            return;
+        }
+        // Extract usage when present (usage-only chunks or chunks with usage)
+        if (chunk.usage) {
+            const usage = chunk.usage;
+            this.inputTokens = usage.prompt_tokens ?? this.inputTokens;
+            this.outputTokens = usage.completion_tokens ?? this.outputTokens;
+        }
+        // Usage-only chunk (no choices) — may trigger completion
+        if (chunk.usage && !(Array.isArray(chunk.choices) && chunk.choices.length > 0)) {
+            if (this.pendingCompletion) {
+                this.closeAllOpenItems();
+                this.emitCompleted();
+                this.pendingCompletion = false;
+            }
+            return;
+        }
+        const choices = chunk.choices;
+        const choice = choices?.[0];
+        if (!choice)
+            return;
+        const delta = choice.delta;
+        // First chunk with role → emit response.created + response.in_progress
+        if (delta?.role === "assistant") {
+            this.ensureResponseCreated();
+        }
+        // Handle reasoning_content
+        if (delta?.reasoning_content != null && delta.reasoning_content !== "") {
+            this.ensureResponseCreated();
+            // Close message item if open (reasoning comes first, but could be interleaved)
+            this.closeCurrentMessageItem();
+            if (!this.hasReasoningItemStarted) {
+                this.hasReasoningItemStarted = true;
+                this.currentReasoningItemId = `rs_${randomHex(12)}`;
+                this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED, {
+                    type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED,
+                    output_index: this.outputIndex,
+                    item: { type: "reasoning", id: this.currentReasoningItemId, 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(),
+                });
+            }
+            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: delta.reasoning_content,
+                sequence_number: this.nextSeq(),
+            });
+        }
+        // Handle text content
+        if (delta?.content != null && delta.content !== "") {
+            this.ensureResponseCreated();
+            // Close reasoning item if transitioning to text
+            this.closeCurrentReasoningItem();
+            if (!this.hasMessageItemStarted) {
+                this.hasMessageItemStarted = true;
+                this.contentIndex = 0;
+                this.currentMessageItemId = `msg_${randomHex(12)}`;
+                this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED, {
+                    type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED,
+                    output_index: this.outputIndex,
+                    item: {
+                        type: "message",
+                        id: this.currentMessageItemId,
+                        role: "assistant",
+                        content: [],
+                        status: "in_progress",
+                    },
+                    sequence_number: this.nextSeq(),
+                });
+            }
+            if (!this.hasContentPartStarted) {
+                this.hasContentPartStarted = true;
+                this.pushResponsesSSE(RESPONSES_SSE_EVENTS.CONTENT_PART_ADDED, {
+                    type: RESPONSES_SSE_EVENTS.CONTENT_PART_ADDED,
+                    output_index: this.outputIndex,
+                    content_index: this.contentIndex,
+                    part: { type: "output_text", text: "", annotations: [] },
+                    sequence_number: this.nextSeq(),
+                });
+            }
+            this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DELTA, {
+                type: RESPONSES_SSE_EVENTS.OUTPUT_TEXT_DELTA,
+                output_index: this.outputIndex,
+                content_index: this.contentIndex,
+                delta: delta.content,
+                sequence_number: this.nextSeq(),
+            });
+        }
+        // Handle tool_calls
+        const toolCalls = delta?.tool_calls;
+        if (toolCalls) {
+            this.ensureResponseCreated();
+            // Close any open items before starting a tool call
+            this.closeCurrentReasoningItem();
+            this.closeCurrentMessageItem();
+            for (const tc of toolCalls) {
+                const fn = tc.function;
+                const tcId = tc.id;
+                const tcName = fn?.name;
+                // New tool call (has id + name)
+                if (tcId && tcName) {
+                    // Close previous function call if any
+                    if (this.currentFunctionCallId) {
+                        this.closeCurrentFunctionCall();
+                    }
+                    this.currentFunctionCallId = tcId;
+                    this.currentFunctionCallName = tcName;
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED, {
+                        type: RESPONSES_SSE_EVENTS.OUTPUT_ITEM_ADDED,
+                        output_index: this.outputIndex,
+                        item: {
+                            type: "function_call",
+                            id: tcId,
+                            call_id: tcId,
+                            name: tcName,
+                            arguments: "",
+                            status: "in_progress",
+                        },
+                        sequence_number: this.nextSeq(),
+                    });
+                    // Also emit any initial arguments
+                    const args = fn?.arguments;
+                    if (args && args !== "") {
+                        this.pushResponsesSSE(RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DELTA, {
+                            type: RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DELTA,
+                            output_index: this.outputIndex,
+                            item_id: tcId,
+                            call_id: tcId,
+                            delta: args,
+                            sequence_number: this.nextSeq(),
+                        });
+                    }
+                }
+                else if (fn?.arguments) {
+                    // Arguments continuation for current tool call
+                    this.pushResponsesSSE(RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DELTA, {
+                        type: RESPONSES_SSE_EVENTS.FUNCTION_CALL_ARGUMENTS_DELTA,
+                        output_index: this.outputIndex,
+                        item_id: this.currentFunctionCallId,
+                        call_id: this.currentFunctionCallId,
+                        delta: fn.arguments,
+                        sequence_number: this.nextSeq(),
+                    });
+                }
+            }
+        }
+        // Handle finish_reason
+        const finishReason = choice.finish_reason;
+        if (finishReason) {
+            this.closeAllOpenItems();
+            this.pendingCompletion = true;
+            // If there's no usage-only chunk coming, emit completed now
+            // Usage chunk may come in a separate chunk or was already in this chunk
+            if (chunk.usage) {
+                this.emitCompleted();
+                this.pendingCompletion = false;
+            }
+        }
+    }
+    flushPendingData() {
+        // No buffered data to flush
+    }
+    ensureTerminated() {
+        if (!this.done) {
+            this.ensureResponseCreated();
+            this.closeAllOpenItems();
+            this.emitCompleted();
+        }
+    }
+}

package/dist/proxy/transform/stream-bridge-resp2chat.d.ts

@@ -0,0 +1,24 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+/**
+ * Bridge transform: Responses API SSE → Chat Completions SSE.
+ *
+ * Used when the client sends a Chat Completions request but the upstream
+ * provider speaks Responses API. This is a lossy conversion —
+ * Chat Completions has fewer event types than Responses API.
+ */
+export declare class ResponsesToChatBridgeTransform extends BaseSSETransform {
+    private chatcmplId;
+    private hasSentRole;
+    private currentToolCallIndex;
+    private inputTokens;
+    private outputTokens;
+    private finishReasonEmitted;
+    private hasFunctionCall;
+    private ensureRoleSent;
+    protected processEvent(event: {
+        event?: string;
+        data?: string;
+    }): void;
+    protected flushPendingData(): void;
+    protected ensureTerminated(): void;
+}

package/dist/proxy/transform/stream-bridge-resp2chat.js

@@ -0,0 +1,237 @@
+import { BaseSSETransform } from "./stream-transform-base.js";
+import { generateChatcmplId } from "./id-utils.js";
+/**
+ * Bridge transform: Responses API SSE → Chat Completions SSE.
+ *
+ * Used when the client sends a Chat Completions request but the upstream
+ * provider speaks Responses API. This is a lossy conversion —
+ * Chat Completions has fewer event types than Responses API.
+ */
+export class ResponsesToChatBridgeTransform extends BaseSSETransform {
+    chatcmplId = generateChatcmplId();
+    hasSentRole = false;
+    currentToolCallIndex = 0;
+    inputTokens = 0;
+    outputTokens = 0;
+    finishReasonEmitted = false;
+    hasFunctionCall = false;
+    ensureRoleSent() {
+        if (this.hasSentRole)
+            return;
+        this.hasSentRole = true;
+        this.pushOpenAISSE({
+            id: this.chatcmplId,
+            object: "chat.completion.chunk",
+            choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+        });
+    }
+    processEvent(event) {
+        const eventType = event.event;
+        let payload;
+        try {
+            payload = JSON.parse(event.data);
+        }
+        catch (err) {
+            this.emit("warning", err);
+            return;
+        }
+        switch (eventType) {
+            case "response.created":
+            case "response.in_progress":
+            case "response.queued": {
+                // Extract usage from response object if present
+                const resp = payload.response;
+                if (resp?.usage) {
+                    const usage = resp.usage;
+                    this.inputTokens = usage.input_tokens ?? this.inputTokens;
+                    this.outputTokens = usage.output_tokens ?? this.outputTokens;
+                }
+                break;
+            }
+            case "response.output_text.delta": {
+                this.ensureRoleSent();
+                const delta = payload.delta;
+                if (delta) {
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId,
+                        object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: { content: delta }, finish_reason: null }],
+                    });
+                }
+                break;
+            }
+            case "response.output_item.added": {
+                const item = payload.item;
+                const itemType = item?.type;
+                if (itemType === "function_call") {
+                    this.ensureRoleSent();
+                    this.hasFunctionCall = true;
+                    const tcIndex = this.currentToolCallIndex++;
+                    const callId = item.call_id ?? item.id;
+                    const name = item.name ?? "";
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId,
+                        object: "chat.completion.chunk",
+                        choices: [{
+                                index: 0,
+                                delta: {
+                                    tool_calls: [{
+                                            index: tcIndex,
+                                            id: callId,
+                                            type: "function",
+                                            function: { name, arguments: "" },
+                                        }],
+                                },
+                                finish_reason: null,
+                            }],
+                    });
+                }
+                // Other item types (message, reasoning) — skip, content comes via delta events
+                break;
+            }
+            case "response.function_call_arguments.delta": {
+                const delta = payload.delta;
+                if (delta) {
+                    // Use currentToolCallIndex - 1 because the tool call was already registered
+                    const tcIndex = this.currentToolCallIndex - 1;
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId,
+                        object: "chat.completion.chunk",
+                        choices: [{
+                                index: 0,
+                                delta: {
+                                    tool_calls: [{ index: tcIndex, function: { arguments: delta } }],
+                                },
+                                finish_reason: null,
+                            }],
+                    });
+                }
+                break;
+            }
+            case "response.reasoning_summary_text.delta": {
+                this.ensureRoleSent();
+                const delta = payload.delta;
+                if (delta) {
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId,
+                        object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: { reasoning_content: delta }, finish_reason: null }],
+                    });
+                }
+                break;
+            }
+            case "response.completed": {
+                const resp = payload.response;
+                if (resp?.usage) {
+                    const usage = resp.usage;
+                    this.inputTokens = usage.input_tokens ?? this.inputTokens;
+                    this.outputTokens = usage.output_tokens ?? this.outputTokens;
+                }
+                if (!this.finishReasonEmitted) {
+                    this.finishReasonEmitted = true;
+                    const finishReason = this.hasFunctionCall ? "tool_calls" : "stop";
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId,
+                        object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: {}, finish_reason: finishReason }],
+                    });
+                }
+                // Emit usage chunk
+                this.pushOpenAISSE({
+                    id: this.chatcmplId,
+                    object: "chat.completion.chunk",
+                    choices: [],
+                    usage: {
+                        prompt_tokens: this.inputTokens,
+                        completion_tokens: this.outputTokens,
+                        total_tokens: this.inputTokens + this.outputTokens,
+                    },
+                });
+                this.pushDone();
+                break;
+            }
+            case "response.incomplete": {
+                if (!this.finishReasonEmitted) {
+                    this.finishReasonEmitted = true;
+                    this.pushOpenAISSE({
+                        id: this.chatcmplId,
+                        object: "chat.completion.chunk",
+                        choices: [{ index: 0, delta: {}, finish_reason: "length" }],
+                    });
+                }
+                this.pushOpenAISSE({
+                    id: this.chatcmplId,
+                    object: "chat.completion.chunk",
+                    choices: [],
+                    usage: {
+                        prompt_tokens: this.inputTokens,
+                        completion_tokens: this.outputTokens,
+                        total_tokens: this.inputTokens + this.outputTokens,
+                    },
+                });
+                this.pushDone();
+                break;
+            }
+            case "response.failed": {
+                const resp = payload.response;
+                const err = resp?.error;
+                this.pushOpenAISSE({
+                    error: {
+                        message: err?.message ?? "Upstream error",
+                        type: err?.type ?? "api_error",
+                        code: err?.code ?? "upstream_error",
+                    },
+                });
+                this.pushDone();
+                break;
+            }
+            case "response.output_text.done":
+            case "response.content_part.added":
+            case "response.content_part.done":
+            case "response.output_item.done":
+            case "response.function_call_arguments.done":
+            case "response.reasoning_summary_part.added":
+            case "response.reasoning_summary_text.done":
+            case "response.reasoning_summary_part.done":
+            case "response.reasoning_text.delta":
+            case "response.reasoning_text.done":
+            case "response.refusal.delta":
+            case "response.refusal.done": {
+                // These events don't map to Chat SSE — skip
+                break;
+            }
+            case "error": {
+                this.pushOpenAISSE({
+                    error: {
+                        message: payload.message ?? "Stream error",
+                        type: payload.type ?? "api_error",
+                        code: "upstream_error",
+                    },
+                });
+                this.pushDone();
+                break;
+            }
+            default: {
+                this.emit("warning", { event: "unknown_sse_event", eventType });
+                break;
+            }
+        }
+    }
+    flushPendingData() {
+        // No buffered data
+    }
+    ensureTerminated() {
+        if (!this.done) {
+            this.ensureRoleSent();
+            if (!this.finishReasonEmitted) {
+                this.finishReasonEmitted = true;
+                this.pushOpenAISSE({
+                    id: this.chatcmplId,
+                    object: "chat.completion.chunk",
+                    choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+                });
+            }
+            this.pushDone();
+        }
+    }
+}