wehub-resource-sync
2445 lines
76 KiB
TypeScript
2445 lines
76 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
|
|
const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-stream-utils-"));
|
|
process.env.DATA_DIR = TEST_DATA_DIR;
|
|
const core = await import("../../src/lib/db/core.ts");
|
|
|
|
const { createSSEStream, createSSETransformStreamWithLogger, createPassthroughStreamWithLogger } =
|
|
await import("../../open-sse/utils/stream.ts");
|
|
const {
|
|
buildStreamSummaryFromEvents,
|
|
compactStructuredStreamPayload,
|
|
createStructuredSSECollector,
|
|
} = await import("../../open-sse/utils/streamPayloadCollector.ts");
|
|
const { FORMATS } = await import("../../open-sse/translator/formats.ts");
|
|
const { createRequestLogger } = await import("../../open-sse/utils/requestLogger.ts");
|
|
|
|
// Retained stream chunks are prefixed with a fixed-width per-chunk arrival timestamp
|
|
// ("[HH:MM:SS.mmm] ", 15 chars) by the request logger for streaming-latency
|
|
// observability (added in #5834). Strip it before comparing raw chunk payloads.
|
|
const STREAM_CHUNK_TS_PREFIX_LEN = "[HH:MM:SS.mmm] ".length;
|
|
const stripChunkTs = (chunk: string): string => chunk.replace(/^\[\d{2}:\d{2}:\d{2}\.\d{3}\] /, "");
|
|
|
|
const textEncoder = new TextEncoder();
|
|
// PR #3399 intentionally changed the synthetic empty-response text to "" so that
|
|
// proxy internals no longer leak into chat history. Tests assert on the new behavior.
|
|
const SYNTHETIC_CLAUDE_EMPTY_RESPONSE_TEXT = "";
|
|
|
|
async function readTransformed(chunks, options) {
|
|
const source = new ReadableStream({
|
|
start(controller) {
|
|
for (const chunk of chunks) {
|
|
controller.enqueue(textEncoder.encode(chunk));
|
|
}
|
|
controller.close();
|
|
},
|
|
});
|
|
|
|
return new Response(source.pipeThrough(createSSEStream(options))).text();
|
|
}
|
|
|
|
async function readWithTransform(chunks, transformStream) {
|
|
const source = new ReadableStream({
|
|
start(controller) {
|
|
for (const chunk of chunks) {
|
|
controller.enqueue(textEncoder.encode(chunk));
|
|
}
|
|
controller.close();
|
|
},
|
|
});
|
|
|
|
return new Response(source.pipeThrough(transformStream)).text();
|
|
}
|
|
|
|
function multilineDataEvent(payload, splitBeforeKey) {
|
|
const json = JSON.stringify(payload);
|
|
const splitAt = json.indexOf(`"${splitBeforeKey}"`) - 1;
|
|
assert.ok(splitAt > 0, `split key ${splitBeforeKey} must exist in payload`);
|
|
return `data: ${json.slice(0, splitAt)}\ndata: ${json.slice(splitAt)}\n\n`;
|
|
}
|
|
|
|
function parseJsonDataPayloads(text) {
|
|
return text
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: "))
|
|
.map((line) => line.slice(6))
|
|
.filter((data) => data && data !== "[DONE]")
|
|
.map((data) => JSON.parse(data));
|
|
}
|
|
|
|
function parseSillyTavernCustomOpenAIStream(text) {
|
|
const events = [];
|
|
let reasoning = "";
|
|
let content = "";
|
|
|
|
for (const payload of parseJsonDataPayloads(text)) {
|
|
const choices = Array.isArray(payload.choices) ? payload.choices : [];
|
|
const reasoningDelta =
|
|
choices.find((choice) => choice?.delta?.reasoning_content)?.delta?.reasoning_content ??
|
|
choices.find((choice) => choice?.delta?.reasoning)?.delta?.reasoning ??
|
|
"";
|
|
const contentDelta =
|
|
choices[0]?.delta?.content ?? choices[0]?.message?.content ?? choices[0]?.text ?? "";
|
|
|
|
reasoning += reasoningDelta;
|
|
content += contentDelta;
|
|
events.push({ reasoningDelta, contentDelta, reasoning, content });
|
|
}
|
|
|
|
return { reasoning, content, events };
|
|
}
|
|
|
|
test("createSSEStream leaves successful pending requests for onComplete finalization", async () => {
|
|
const usageHistory = await import("../../src/lib/usage/usageHistory.ts");
|
|
usageHistory.clearPendingRequests();
|
|
|
|
const model = "gpt-4";
|
|
const provider = "openai";
|
|
const connectionId = "stream-on-complete-finalize";
|
|
const requestId = usageHistory.trackPendingRequest(model, provider, connectionId, true);
|
|
|
|
let finalizedInOnComplete = false;
|
|
await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_pending_finalize",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model,
|
|
choices: [{ index: 0, delta: { content: "hello" }, finish_reason: null }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_pending_finalize",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model,
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider,
|
|
model,
|
|
connectionId,
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
onComplete(payload) {
|
|
finalizedInOnComplete = usageHistory.finalizePendingRequestById(requestId, {
|
|
providerResponse: payload.providerPayload,
|
|
clientResponse: payload.clientPayload,
|
|
});
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.equal(finalizedInOnComplete, true);
|
|
assert.ok(usageHistory.getCompletedDetails().has(requestId));
|
|
assert.equal(usageHistory.getPendingById().has(requestId), false);
|
|
usageHistory.clearPendingRequests();
|
|
});
|
|
|
|
test.after(() => {
|
|
core.resetDbInstance();
|
|
if (fs.existsSync(TEST_DATA_DIR)) {
|
|
for (const entry of fs.readdirSync(TEST_DATA_DIR)) {
|
|
fs.rmSync(path.join(TEST_DATA_DIR, entry), { recursive: true, force: true });
|
|
}
|
|
}
|
|
});
|
|
|
|
test("createSSEStream passthrough normalizes tool-call finishes and reports the assembled response", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_1",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "Hello " } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_1",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
tool_calls: [
|
|
{
|
|
index: 0,
|
|
id: "call_1",
|
|
type: "function",
|
|
function: {
|
|
name: "read_file",
|
|
arguments: '{"path":"/tmp/a"}',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_1",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"content":"Hello "/);
|
|
assert.match(text, /"name":"read_file"/);
|
|
assert.match(text, /"finish_reason":"tool_calls"/);
|
|
assert.equal(onCompletePayload.status, 200);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].finish_reason, "tool_calls");
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.tool_calls[0].id, "call_1");
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Hello");
|
|
assert.equal(onCompletePayload.clientPayload._streamed, true);
|
|
});
|
|
|
|
test("createSSEStream passthrough converts textual tool-call content into structured call log tool_calls", async () => {
|
|
let onCompletePayload = null;
|
|
const toolArgs = JSON.stringify({
|
|
command: 'sqlite3 /root/.o\u200dmniroute/omniroute.db ".tables"',
|
|
});
|
|
const toolText = `[Tool call: terminal]\nArguments: ${toolArgs}`;
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: toolText } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: {
|
|
messages: [{ role: "user", content: "inspect db" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.equal(onCompletePayload.status, 200);
|
|
assert.match(text, /"tool_calls":\[/);
|
|
assert.match(text, /"name":"terminal"/);
|
|
assert.doesNotMatch(text, /"content":"\[Tool call: terminal/);
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "tool_calls");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls[0].function.name, "terminal");
|
|
assert.deepEqual(JSON.parse(choice.message.tool_calls[0].function.arguments), {
|
|
command: 'sqlite3 /root/.omniroute/omniroute.db ".tables"',
|
|
});
|
|
assert.doesNotMatch(text, /\[Tool call: terminal\]/);
|
|
});
|
|
|
|
test("createSSEStream passthrough converts split textual tool-call content at completion", async () => {
|
|
let onCompletePayload = null;
|
|
const splitToolArgs = JSON.stringify({
|
|
command: 'sqlite3 ~/.o\u200dmniroute/o\u200dmniroute.db ".tables"',
|
|
});
|
|
const chunks = ["[Tool call: terminal]\n", `Arguments: ${splitToolArgs}`];
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: chunks[0] } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { content: chunks[1] } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: { messages: [{ role: "user", content: "inspect db" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"tool_calls":\[/);
|
|
assert.match(text, /"name":"terminal"/);
|
|
assert.doesNotMatch(text, /"content":"\[Tool call: terminal/);
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "tool_calls");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls[0].function.name, "terminal");
|
|
assert.deepEqual(JSON.parse(choice.message.tool_calls[0].function.arguments), {
|
|
command: 'sqlite3 ~/.omniroute/omniroute.db ".tables"',
|
|
});
|
|
assert.doesNotMatch(text, /\[Tool call: terminal\]/);
|
|
});
|
|
|
|
test("createSSEStream passthrough handles textual tool-call content split inside the prefix [Tool call: across chunks", async () => {
|
|
let onCompletePayload = null;
|
|
const splitToolArgs = JSON.stringify({
|
|
command: "whoami",
|
|
});
|
|
const chunks = ["[Tool", " call: terminal]\n", `Arguments: ${splitToolArgs}`];
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_prefix_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: chunks[0] } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_prefix_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { content: chunks[1] } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_prefix_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { content: chunks[2] } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_split_prefix_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: { messages: [{ role: "user", content: "inspect db" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.doesNotMatch(text, /"content":"\[Tool/);
|
|
assert.doesNotMatch(text, /"content":" call:/);
|
|
assert.match(text, /"tool_calls":\[/);
|
|
assert.match(text, /"name":"terminal"/);
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "tool_calls");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls[0].function.name, "terminal");
|
|
assert.deepEqual(JSON.parse(choice.message.tool_calls[0].function.arguments), {
|
|
command: "whoami",
|
|
});
|
|
});
|
|
|
|
test("createSSEStream passthrough buffers fragmented textual tool-call JSON before emitting", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_fragmented_live_shape",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: { role: "assistant", content: '[Tool call: terminal]\nArguments: {"' },
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_fragmented_live_shape",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: { content: 'command":"echo live_shape","timeout":10}' },
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_fragmented_live_shape",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "omniroute",
|
|
model: "MainAgent",
|
|
body: { messages: [{ role: "user", content: "inspect" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.doesNotMatch(text, /\[Tool call:/);
|
|
assert.doesNotMatch(text, /Arguments:/);
|
|
assert.match(text, /"tool_calls":\[/);
|
|
assert.match(text, /"finish_reason":"tool_calls"/);
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "tool_calls");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls[0].function.name, "terminal");
|
|
assert.deepEqual(JSON.parse(choice.message.tool_calls[0].function.arguments), {
|
|
command: "echo live_shape",
|
|
timeout: 10,
|
|
});
|
|
});
|
|
|
|
test("createSSEStream passthrough suppresses trailing prose plus textual tool call", async () => {
|
|
let onCompletePayload = null;
|
|
const toolArgs = JSON.stringify({
|
|
command: "echo should_not_leak",
|
|
timeout: 10,
|
|
});
|
|
const toolText = `Вот оно! Статические файлы Next.js отдают 404. Чанки не найдены.\n\n[Tool call: terminal]\nArguments: ${toolArgs}`;
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_trailing_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: toolText } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_trailing_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "omniroute",
|
|
model: "MainAgent",
|
|
body: { messages: [{ role: "user", content: "inspect static files" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.equal(onCompletePayload.status, 200);
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "tool_calls");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls[0].function.name, "terminal");
|
|
assert.deepEqual(JSON.parse(choice.message.tool_calls[0].function.arguments), {
|
|
command: "echo should_not_leak",
|
|
timeout: 10,
|
|
});
|
|
assert.doesNotMatch(text, /\[Tool call: terminal\]/);
|
|
assert.doesNotMatch(text, /Arguments:/);
|
|
assert.doesNotMatch(JSON.stringify(onCompletePayload.responseBody), /\[Tool call: terminal\]/);
|
|
assert.doesNotMatch(JSON.stringify(onCompletePayload.responseBody), /Arguments:/);
|
|
});
|
|
|
|
test("createSSEStream passthrough suppresses textual tool calls for unknown tools", async () => {
|
|
let onCompletePayload = null;
|
|
const toolText = `[Tool call: search_files_ide]
|
|
Arguments: {"path":"/opt/OmniRoute/src","target":"files"}`;
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_unknown_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: toolText } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_unknown_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: {
|
|
messages: [{ role: "user", content: "inspect files" }],
|
|
tools: [
|
|
{ type: "function", function: { name: "search_files", parameters: { type: "object" } } },
|
|
],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "stop");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls, undefined);
|
|
assert.doesNotMatch(text, /search_files_ide/);
|
|
assert.doesNotMatch(JSON.stringify(onCompletePayload.responseBody), /search_files_ide/);
|
|
});
|
|
|
|
test("createSSEStream passthrough suppresses malformed textual tool-call content", async () => {
|
|
let onCompletePayload = null;
|
|
const malformedToolText = `(empty)[Tool call: terminal]\nArguments: {"command":"sqlite3 /opt/O\u200dmniRoute/data/o\u200dmniroute.`;
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_malformed_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: malformedToolText } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_malformed_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: { messages: [{ role: "user", content: "inspect db" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "stop");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls, undefined);
|
|
// PR #3355 bug-2 fix: flush now always emits the buffer as plain text (not swallowed).
|
|
assert.match(text, /\[Tool call: terminal\]/);
|
|
});
|
|
|
|
test("createSSEStream suppresses malformed compact textual tool-call content", async () => {
|
|
let onCompletePayload = null;
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
candidates: [
|
|
{
|
|
content: {
|
|
parts: [
|
|
{
|
|
text: "[Tool call: search_files_ide{file_glob:*combos*.ts,path:/opt/OmniRoute,target:files}]",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({ candidates: [{ finishReason: "STOP" }] })}\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.ANTIGRAVITY,
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: { messages: [{ role: "user", content: "inspect files" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "stop");
|
|
assert.equal(choice.message.content, null);
|
|
assert.equal(choice.message.tool_calls, undefined);
|
|
assert.doesNotMatch(JSON.stringify(onCompletePayload.responseBody), /\[Tool call:/);
|
|
});
|
|
|
|
test("createSSEStream passthrough flushes a buffered final line without a trailing newline", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_2",
|
|
object: "chat.completion.chunk",
|
|
created: 2,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "tail chunk" } }],
|
|
})}`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /tail chunk/);
|
|
assert.equal(text.includes("data: "), true);
|
|
});
|
|
|
|
test("createSSEStream passthrough merges multi-line SSE data before forwarding", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
multilineDataEvent(
|
|
{
|
|
id: "chatcmpl_multiline",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { content: "hello" }, finish_reason: null }],
|
|
},
|
|
"choices"
|
|
),
|
|
`data: [DONE]\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"content":"hello"/);
|
|
assert.doesNotMatch(text, /\ndata:\s*,/);
|
|
const firstPayload = text
|
|
.split("\n")
|
|
.find((line) => line.startsWith("data: ") && !line.includes("[DONE]"));
|
|
assert.ok(firstPayload, "merged SSE payload should be forwarded as a single JSON data line");
|
|
assert.equal(JSON.parse(firstPayload.slice(6)).choices[0].delta.content, "hello");
|
|
});
|
|
|
|
test("createSSEStream passthrough forwards data only after the complete SSE event boundary", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
[
|
|
`data: ${JSON.stringify({ delta: "hello" })}`,
|
|
"event: response.output_text.delta",
|
|
"",
|
|
"",
|
|
].join("\n"),
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "responses-model",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /^event: response\.output_text\.delta\ndata: /);
|
|
assert.doesNotMatch(text, /^data: .*?\n\nevent:/s);
|
|
});
|
|
|
|
test("createSSEStream passthrough preserves event metadata in a single SSE event", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
[
|
|
": upstream-note",
|
|
"id: 42",
|
|
"trace: upstream-abc",
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_meta",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { content: "metadata content" } }],
|
|
})}`,
|
|
"",
|
|
"",
|
|
].join("\n"),
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /^: upstream-note\nid: 42\ntrace: upstream-abc\ndata: /);
|
|
assert.doesNotMatch(text, /^: upstream-note\n\nid: 42/s);
|
|
assert.doesNotMatch(text, /\ntrace: upstream-abc\n\n/s);
|
|
assert.match(text, /metadata content/);
|
|
});
|
|
|
|
test("createSSEStream translate mode converts Claude SSE into OpenAI chunks and completion payload", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_1",
|
|
model: "claude-sonnet-4",
|
|
role: "assistant",
|
|
usage: { input_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: { type: "text", text: "" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "text_delta", text: "Hello Claude" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn" },
|
|
usage: { output_tokens: 4 },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.CLAUDE,
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "claude",
|
|
model: "claude-sonnet-4",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"content":"Hello Claude"/);
|
|
assert.match(text, /\[DONE\]/);
|
|
assert.equal(onCompletePayload.status, 200);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Hello Claude");
|
|
assert.equal(onCompletePayload.responseBody.usage.prompt_tokens, 3);
|
|
assert.equal(onCompletePayload.responseBody.usage.completion_tokens, 4);
|
|
assert.equal(onCompletePayload.responseBody.usage.total_tokens, 7);
|
|
});
|
|
|
|
test("createSSEStream translate mode preserves Claude text_delta thinking tags as content", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_text_thinking_tag",
|
|
model: "claude-opus-4-6",
|
|
role: "assistant",
|
|
usage: { input_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: { type: "text", text: "" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "text_delta", text: "<thinking>\n[metacognition" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "text_delta", text: "]\n\nVisible answer" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn" },
|
|
usage: { output_tokens: 4 },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.CLAUDE,
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "claude",
|
|
model: "claude-opus-4-6",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const deltas = parseJsonDataPayloads(text)
|
|
.map((payload) => payload.choices?.[0]?.delta)
|
|
.filter(Boolean);
|
|
|
|
assert.deepEqual(
|
|
deltas.filter((delta) => typeof delta.content === "string").map((delta) => delta.content),
|
|
["<thinking>\n[metacognition", "]\n\nVisible answer"]
|
|
);
|
|
assert.equal(
|
|
deltas.some((delta) => delta.reasoning_content !== undefined),
|
|
false
|
|
);
|
|
assert.equal(
|
|
onCompletePayload.responseBody.choices[0].message.content,
|
|
"<thinking>\n[metacognition]\n\nVisible answer"
|
|
);
|
|
});
|
|
|
|
test("createSSEStream translate mode keeps native Claude thinking_delta as reasoning_content", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_native_thinking",
|
|
model: "claude-opus-4-6",
|
|
role: "assistant",
|
|
usage: { input_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: { type: "thinking", thinking: "" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "thinking_delta", thinking: "Native plan" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_stop",
|
|
index: 0,
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 1,
|
|
content_block: { type: "text", text: "" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 1,
|
|
delta: { type: "text_delta", text: "Final answer" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn" },
|
|
usage: { output_tokens: 4 },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.CLAUDE,
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "claude",
|
|
model: "claude-opus-4-6",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
const deltas = parseJsonDataPayloads(text)
|
|
.map((payload) => payload.choices?.[0]?.delta)
|
|
.filter(Boolean);
|
|
|
|
assert.ok(deltas.some((delta) => delta.reasoning_content === "Native plan"));
|
|
assert.ok(deltas.some((delta) => delta.content === "Final answer"));
|
|
});
|
|
|
|
test("createSSEStream translate mode parses multi-line SSE data events", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_multiline",
|
|
model: "claude-sonnet-4",
|
|
role: "assistant",
|
|
usage: { input_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: { type: "text", text: "" },
|
|
})}\n\n`,
|
|
multilineDataEvent(
|
|
{
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "text_delta", text: "Hello from multiline SSE" },
|
|
},
|
|
"delta"
|
|
),
|
|
`data: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn" },
|
|
usage: { output_tokens: 5 },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.CLAUDE,
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "claude",
|
|
model: "claude-sonnet-4",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"content":"Hello from multiline SSE"/);
|
|
assert.equal(
|
|
onCompletePayload.responseBody.choices[0].message.content,
|
|
"Hello from multiline SSE"
|
|
);
|
|
});
|
|
|
|
test("createSSEStream Responses passthrough converts textual tool-call deltas before streaming", async () => {
|
|
let onCompletePayload = null;
|
|
const toolText = `[Tool call: terminal]
|
|
Arguments: {"command":"systemctl status omniroute"}`;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_text.delta",
|
|
delta: toolText,
|
|
})}
|
|
|
|
`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.completed",
|
|
response: {
|
|
id: "resp_textual_tool",
|
|
object: "response",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
status: "completed",
|
|
output: [],
|
|
usage: { input_tokens: 10, output_tokens: 4, total_tokens: 14 },
|
|
},
|
|
})}
|
|
|
|
`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI_RESPONSES,
|
|
clientResponseFormat: FORMATS.OPENAI_RESPONSES,
|
|
provider: "antigravity",
|
|
model: "antigravity/gemini-3.5-flash-low",
|
|
body: {
|
|
input: "check service",
|
|
tools: [{ type: "function", name: "terminal", parameters: { type: "object" } }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.doesNotMatch(text, /\[Tool call: terminal\]/);
|
|
assert.doesNotMatch(text, /Arguments:/);
|
|
assert.match(text, /response.output_item.added/);
|
|
assert.match(text, /response.function_call_arguments.done/);
|
|
assert.match(text, /"name":"terminal"/);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].finish_reason, "tool_calls");
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, null);
|
|
assert.equal(
|
|
onCompletePayload.responseBody.choices[0].message.tool_calls[0].function.name,
|
|
"terminal"
|
|
);
|
|
assert.doesNotMatch(JSON.stringify(onCompletePayload.clientPayload), /\[Tool call: terminal\]/);
|
|
});
|
|
|
|
test("createSSEStream passthrough preserves Responses API events and completion summaries", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_text.delta",
|
|
delta: "Hello ",
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_text.delta",
|
|
delta: "world",
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.completed",
|
|
response: {
|
|
id: "resp_1",
|
|
object: "response",
|
|
model: "gpt-4.1-mini",
|
|
status: "completed",
|
|
usage: { input_tokens: 2, output_tokens: 3, total_tokens: 5 },
|
|
},
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI_RESPONSES,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: { input: "hello" },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /response.output_text.delta/);
|
|
assert.match(text, /response.completed/);
|
|
assert.equal(onCompletePayload.responseBody.usage.total_tokens, 5);
|
|
assert.equal(onCompletePayload.providerPayload.summary.object, "response");
|
|
});
|
|
|
|
test("createSSEStream passthrough drops leaked empty chat bootstrap chunks for Responses clients", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl-dummy",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-5.4",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: { role: "assistant", content: null, refusal: null },
|
|
finish_reason: null,
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`event: response.created\ndata: ${JSON.stringify({
|
|
type: "response.created",
|
|
response: {
|
|
id: "resp_1",
|
|
object: "response",
|
|
model: "gpt-5.4",
|
|
status: "in_progress",
|
|
output: [],
|
|
},
|
|
})}\n\n`,
|
|
`event: response.in_progress\ndata: ${JSON.stringify({
|
|
type: "response.in_progress",
|
|
response: {
|
|
id: "resp_1",
|
|
object: "response",
|
|
model: "gpt-5.4",
|
|
status: "in_progress",
|
|
output: [],
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_text.delta",
|
|
delta: "OK",
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.completed",
|
|
response: {
|
|
id: "resp_1",
|
|
object: "response",
|
|
model: "gpt-5.4",
|
|
status: "completed",
|
|
output: [],
|
|
usage: { input_tokens: 2, output_tokens: 1, total_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
`data: [DONE]\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI_RESPONSES,
|
|
clientResponseFormat: FORMATS.OPENAI_RESPONSES,
|
|
provider: "openai",
|
|
model: "gpt-5.4",
|
|
body: { input: "hello" },
|
|
}
|
|
);
|
|
|
|
assert.doesNotMatch(text, /chatcmpl-dummy/);
|
|
assert.match(text, /response\.created/);
|
|
assert.match(text, /response\.output_text\.delta/);
|
|
assert.match(text, /"delta":"OK"/);
|
|
});
|
|
|
|
test("buildStreamSummaryFromEvents falls back to response.output_text.delta when completed output is empty", () => {
|
|
const summary = buildStreamSummaryFromEvents(
|
|
[
|
|
{
|
|
index: 0,
|
|
data: {
|
|
type: "response.output_text.delta",
|
|
delta: "Hello ",
|
|
},
|
|
},
|
|
{
|
|
index: 1,
|
|
data: {
|
|
type: "response.output_text.delta",
|
|
delta: "world",
|
|
},
|
|
},
|
|
{
|
|
index: 2,
|
|
data: {
|
|
type: "response.completed",
|
|
response: {
|
|
id: "resp_fallback",
|
|
object: "response",
|
|
model: "gpt-5.4",
|
|
status: "completed",
|
|
output: [],
|
|
usage: { output_tokens: 2 },
|
|
},
|
|
},
|
|
},
|
|
],
|
|
FORMATS.OPENAI_RESPONSES,
|
|
"gpt-5.4"
|
|
);
|
|
|
|
assert.equal((summary as any).object, "response");
|
|
assert.equal((summary as any).output[0].type, "message");
|
|
assert.equal((summary as any).output[0].content[0].type, "output_text");
|
|
assert.equal((summary as any).output[0].content[0].text, "Hello world");
|
|
assert.equal((summary as any).usage.output_tokens, 2);
|
|
});
|
|
|
|
test("createSSEStream translate mode aborts on Responses failure with rate limit error", async () => {
|
|
let onCompletePayload = null;
|
|
|
|
await assert.rejects(
|
|
readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.created",
|
|
response: {
|
|
id: "resp_fail",
|
|
object: "response",
|
|
model: "gpt-5.4",
|
|
status: "in_progress",
|
|
output: [],
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.failed",
|
|
response: {
|
|
id: "resp_fail",
|
|
object: "response",
|
|
model: "gpt-5.4",
|
|
status: "failed",
|
|
error: {
|
|
message: "Rate limit reached for gpt-5.4",
|
|
code: "rate_limit_exceeded",
|
|
},
|
|
},
|
|
})}\n\n`,
|
|
`data: [DONE]\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.OPENAI_RESPONSES,
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "codex",
|
|
model: "gpt-5.4",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
),
|
|
/Rate limit reached for gpt-5\.4|Upstream failure/
|
|
);
|
|
|
|
assert.ok(onCompletePayload, "should capture completion payload before aborting");
|
|
assert.equal(onCompletePayload.status, 429);
|
|
assert.equal(onCompletePayload.responseBody.error.type, "rate_limit_error");
|
|
assert.equal(onCompletePayload.responseBody.error.code, "rate_limit_exceeded");
|
|
assert.match(onCompletePayload.responseBody.error.message, /Rate limit reached/);
|
|
});
|
|
|
|
test("createSSEStream passthrough restores Claude tool names from the mapping table", async () => {
|
|
const toolNameMap = new Map([["tool_alias", "read_file"]]);
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: {
|
|
type: "tool_use",
|
|
id: "tool_1",
|
|
name: "tool_alias",
|
|
input: { path: "/tmp/a" },
|
|
},
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.CLAUDE,
|
|
provider: "claude",
|
|
model: "claude-sonnet-4",
|
|
toolNameMap,
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"name":"read_file"/);
|
|
assert.equal(text.includes("tool_alias"), false);
|
|
});
|
|
|
|
test("createSSEStream passthrough fixes generic ids and preserves readable reasoning aliases", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chat",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "kimi-k2.5",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
reasoning: "Let me think first",
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "kimi-k2.5",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"id":"chatcmpl-/);
|
|
assert.match(text, /"reasoning":"Let me think first"/);
|
|
assert.doesNotMatch(text, /"reasoning_content":"Let me think first"/);
|
|
});
|
|
|
|
test("createSSEStream passthrough mirrors unsupported reasoning aliases with valid ids", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning_alias",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "kimi-k2.5",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
reasoning_text: "Alias-only reasoning",
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "kimi-k2.5",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"reasoning_content":"Alias-only reasoning"/);
|
|
});
|
|
|
|
test("createSSEStream passthrough preserves OpenAI content thinking tags as content", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_text_tag",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "openai-compatible-model",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: { role: "assistant", content: "<thinking>\nVisible prompt tag" },
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_text_tag",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "openai-compatible-model",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai-compatible",
|
|
model: "openai-compatible-model",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const deltas = parseJsonDataPayloads(text)
|
|
.map((payload) => payload.choices?.[0]?.delta)
|
|
.filter(Boolean);
|
|
|
|
assert.ok(deltas.some((delta) => delta.content === "<thinking>\nVisible prompt tag"));
|
|
assert.equal(
|
|
deltas.some((delta) => delta.reasoning_content !== undefined),
|
|
false
|
|
);
|
|
assert.equal(
|
|
onCompletePayload.responseBody.choices[0].message.content,
|
|
"<thinking>\nVisible prompt tag"
|
|
);
|
|
});
|
|
|
|
test("createSSEStream passthrough splits mixed reasoning and content deltas and estimates usage", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
reasoning_content: "First think",
|
|
content: "Then answer",
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello world" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const reasoningIndex = text.indexOf('"reasoning_content":"First think"');
|
|
const contentIndex = text.indexOf('"content":"Then answer"');
|
|
|
|
assert.ok(reasoningIndex >= 0);
|
|
assert.ok(contentIndex > reasoningIndex);
|
|
assert.match(text, /"total_tokens":\d+/);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.reasoning_content, "First think");
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Then answer");
|
|
assert.ok(onCompletePayload.responseBody.usage.total_tokens > 0);
|
|
});
|
|
|
|
test("createSSEStream passthrough output is consumable by SillyTavern-style reasoning parser", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning_st",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
reasoning_content: "First think",
|
|
content: "Then answer",
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning_st",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai-compatible",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello world" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
const parsed = parseSillyTavernCustomOpenAIStream(text);
|
|
const reasoningEventIndex = parsed.events.findIndex((event) => event.reasoningDelta);
|
|
const contentEventIndex = parsed.events.findIndex((event) => event.contentDelta);
|
|
|
|
assert.equal(parsed.reasoning, "First think");
|
|
assert.equal(parsed.content, "Then answer");
|
|
assert.ok(reasoningEventIndex >= 0);
|
|
assert.ok(contentEventIndex > reasoningEventIndex);
|
|
});
|
|
|
|
test("createSSEStream passthrough writes complete SSE events per converted chunk", async () => {
|
|
const convertedChunks = [];
|
|
await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
reasoning_content: "First think",
|
|
content: "Then answer",
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_reasoning",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello world" }],
|
|
},
|
|
reqLogger: {
|
|
appendConvertedChunk(value) {
|
|
convertedChunks.push(value);
|
|
},
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.equal(convertedChunks.includes("\n"), false);
|
|
for (const chunk of convertedChunks.filter((value) => value.startsWith("data:"))) {
|
|
assert.equal(chunk.endsWith("\n\n"), true);
|
|
}
|
|
});
|
|
|
|
test("createSSEStream passthrough merges Claude usage chunks and restores mapped tool names", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_passthrough",
|
|
model: "claude-sonnet-4",
|
|
role: "assistant",
|
|
usage: { input_tokens: 6 },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: {
|
|
type: "tool_use",
|
|
id: "tool_1",
|
|
name: "tool_alias",
|
|
input: { path: "/tmp/a" },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 1,
|
|
delta: { text: "Claude says hi" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn" },
|
|
usage: { output_tokens: 4 },
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.CLAUDE,
|
|
provider: "claude",
|
|
model: "claude-sonnet-4",
|
|
toolNameMap: new Map([["tool_alias", "read_file"]]),
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"name":"read_file"/);
|
|
assert.equal(text.includes('"name":"tool_alias"'), false);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Claude says hi");
|
|
assert.equal(onCompletePayload.responseBody.usage.prompt_tokens, 6);
|
|
assert.equal(onCompletePayload.responseBody.usage.completion_tokens, 4);
|
|
assert.equal(onCompletePayload.responseBody.usage.total_tokens, 10);
|
|
});
|
|
|
|
test("#3685 createSSEStream passthrough emits SSE error (not synthetic text) for empty Claude assistant SSE", async () => {
|
|
let failurePayload = null;
|
|
let completePayload = null;
|
|
await assert.rejects(
|
|
readTransformed(
|
|
[
|
|
`event: message_start\ndata: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_empty_passthrough",
|
|
type: "message",
|
|
role: "assistant",
|
|
model: "claude-sonnet-4",
|
|
content: [],
|
|
stop_reason: null,
|
|
stop_sequence: null,
|
|
usage: { input_tokens: 7, output_tokens: 0 },
|
|
},
|
|
})}\n\n`,
|
|
`event: message_stop\ndata: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.CLAUDE,
|
|
provider: "claude",
|
|
model: "claude-sonnet-4",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onFailure(payload) {
|
|
failurePayload = payload;
|
|
},
|
|
onComplete(payload) {
|
|
completePayload = payload;
|
|
},
|
|
}
|
|
),
|
|
/empty response/i
|
|
);
|
|
assert.ok(failurePayload, "onFailure should be called");
|
|
assert.equal(failurePayload.status, 502);
|
|
assert.match(failurePayload.message, /empty response/i);
|
|
assert.equal(failurePayload.code, "empty_response", "code must identify the failure kind");
|
|
assert.equal(typeof failurePayload.code, "string", "code must be a string");
|
|
assert.ok(failurePayload.message.length > 0, "message must be non-empty");
|
|
assert.ok(failurePayload.status >= 500, "status must be a server error (5xx)");
|
|
assert.equal(completePayload, null, "onComplete must not fire when stream is empty");
|
|
});
|
|
|
|
test("createSSEStream passthrough does not emit [DONE] for Claude SSE clients", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`event: message_start\ndata: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_claude_done_gate",
|
|
type: "message",
|
|
role: "assistant",
|
|
model: "claude-sonnet-4",
|
|
content: [],
|
|
stop_reason: null,
|
|
stop_sequence: null,
|
|
usage: { input_tokens: 3, output_tokens: 0 },
|
|
},
|
|
})}\n\n`,
|
|
`event: content_block_start\ndata: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: { type: "text", text: "" },
|
|
})}\n\n`,
|
|
`event: content_block_delta\ndata: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "text_delta", text: "Claude client stream" },
|
|
})}\n\n`,
|
|
`event: content_block_stop\ndata: ${JSON.stringify({
|
|
type: "content_block_stop",
|
|
index: 0,
|
|
})}\n\n`,
|
|
`event: message_delta\ndata: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn", stop_sequence: null },
|
|
usage: { output_tokens: 3 },
|
|
})}\n\n`,
|
|
`event: message_stop\ndata: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.CLAUDE,
|
|
clientResponseFormat: FORMATS.CLAUDE,
|
|
provider: "claude",
|
|
model: "claude-sonnet-4",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /event: message_stop/);
|
|
assert.match(text, /Claude client stream/);
|
|
assert.doesNotMatch(text, /\[DONE\]/);
|
|
});
|
|
|
|
test("#3685 createSSEStream translate mode emits SSE error (not synthetic text) when OpenAI upstream finishes empty for Claude client", async () => {
|
|
let failurePayload = null;
|
|
let completePayload = null;
|
|
await assert.rejects(
|
|
readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_empty_1",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant" } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_empty_1",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
usage: { prompt_tokens: 3, completion_tokens: 0, total_tokens: 3 },
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "translate",
|
|
targetFormat: FORMATS.OPENAI,
|
|
sourceFormat: FORMATS.CLAUDE,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
},
|
|
onFailure(payload) {
|
|
failurePayload = payload;
|
|
},
|
|
onComplete(payload) {
|
|
completePayload = payload;
|
|
},
|
|
}
|
|
),
|
|
/empty response/i
|
|
);
|
|
assert.ok(failurePayload, "onFailure should be called");
|
|
assert.equal(failurePayload.status, 502);
|
|
assert.match(failurePayload.message, /empty response/i);
|
|
assert.equal(failurePayload.code, "empty_response", "code must identify the failure kind");
|
|
assert.ok(failurePayload.message.length > 0, "message must be non-empty");
|
|
assert.ok(failurePayload.status >= 500, "status must be a server error (5xx)");
|
|
assert.equal(completePayload, null, "onComplete must not fire when stream is empty");
|
|
});
|
|
|
|
test("createSSETransformStreamWithLogger flushes a trailing Claude usage event without a newline", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readWithTransform(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: "msg_tail",
|
|
model: "claude-sonnet-4",
|
|
role: "assistant",
|
|
usage: { input_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: { type: "text", text: "" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: { type: "text_delta", text: "Buffered tail" },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_delta",
|
|
delta: { stop_reason: "end_turn" },
|
|
usage: { output_tokens: 5 },
|
|
})}`,
|
|
],
|
|
createSSETransformStreamWithLogger(
|
|
FORMATS.CLAUDE,
|
|
FORMATS.OPENAI,
|
|
"claude",
|
|
null,
|
|
null,
|
|
"claude-sonnet-4",
|
|
null,
|
|
{ messages: [{ role: "user", content: "hello" }] },
|
|
(payload) => {
|
|
onCompletePayload = payload;
|
|
}
|
|
)
|
|
);
|
|
|
|
assert.match(text, /Buffered tail/);
|
|
assert.match(text, /\[DONE\]/);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Buffered tail");
|
|
assert.equal(onCompletePayload.responseBody.usage.prompt_tokens, 3);
|
|
assert.equal(onCompletePayload.responseBody.usage.completion_tokens, 5);
|
|
assert.equal(onCompletePayload.responseBody.usage.total_tokens, 8);
|
|
});
|
|
|
|
test("buildStreamSummaryFromEvents compacts Responses API deltas into a synthetic response", () => {
|
|
const summary = buildStreamSummaryFromEvents(
|
|
[
|
|
{ index: 0, data: { type: "response.output_text.delta", delta: "Hello " } },
|
|
{ index: 1, data: { type: "response.output_text.delta", delta: "world" } },
|
|
{
|
|
index: 2,
|
|
data: {
|
|
type: "response.output_text.done",
|
|
usage: { input_tokens: 2, output_tokens: 3, total_tokens: 5 },
|
|
},
|
|
},
|
|
],
|
|
FORMATS.OPENAI_RESPONSES,
|
|
"gpt-4.1-mini"
|
|
);
|
|
|
|
assert.equal((summary as any).object, "response");
|
|
assert.equal((summary as any).model, "gpt-4.1-mini");
|
|
assert.equal((summary as any).output[0].content[0].text, "Hello world");
|
|
assert.deepEqual((summary as any).usage, { input_tokens: 2, output_tokens: 3, total_tokens: 5 });
|
|
});
|
|
|
|
test("buildStreamSummaryFromEvents preserves Gemini thought parts and function calls", () => {
|
|
const summary = buildStreamSummaryFromEvents(
|
|
[
|
|
{
|
|
index: 0,
|
|
data: {
|
|
modelVersion: "gemini-2.5-pro",
|
|
candidates: [
|
|
{
|
|
content: {
|
|
role: "model",
|
|
parts: [
|
|
{ text: "Thinking", thought: true },
|
|
{ text: " aloud", thought: true },
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
{
|
|
index: 1,
|
|
data: {
|
|
candidates: [
|
|
{
|
|
content: {
|
|
role: "model",
|
|
parts: [
|
|
{ text: "Done." },
|
|
{ functionCall: { name: "read_file", args: { path: "/tmp/a" } } },
|
|
],
|
|
},
|
|
finishReason: "STOP",
|
|
},
|
|
],
|
|
usageMetadata: {
|
|
promptTokenCount: 4,
|
|
candidatesTokenCount: 5,
|
|
totalTokenCount: 9,
|
|
},
|
|
},
|
|
},
|
|
],
|
|
FORMATS.GEMINI,
|
|
"gemini-2.5-pro"
|
|
);
|
|
|
|
assert.equal((summary as any).modelVersion, "gemini-2.5-pro");
|
|
assert.equal((summary as any).candidates[0].content.parts[0].text, "Thinking aloud");
|
|
assert.equal((summary as any).candidates[0].content.parts[0].thought, true);
|
|
assert.deepEqual((summary as any).candidates[0].content.parts[2], {
|
|
functionCall: { name: "read_file", args: { path: "/tmp/a" } },
|
|
});
|
|
assert.deepEqual((summary as any).usageMetadata, {
|
|
promptTokenCount: 4,
|
|
candidatesTokenCount: 5,
|
|
totalTokenCount: 9,
|
|
});
|
|
});
|
|
|
|
test("compactStructuredStreamPayload wraps primitive summaries with Omniroute stream metadata", () => {
|
|
const compact = compactStructuredStreamPayload({
|
|
_streamed: true,
|
|
_format: "sse-json",
|
|
_stage: "client_response",
|
|
_eventCount: 2,
|
|
summary: "done",
|
|
});
|
|
|
|
assert.deepEqual(compact, {
|
|
summary: "done",
|
|
_omniroute_stream: {
|
|
format: "sse-json",
|
|
stage: "client_response",
|
|
eventCount: 2,
|
|
},
|
|
});
|
|
});
|
|
|
|
test("createSSETransformStreamWithLogger flushes Responses API terminal events on stream end", async () => {
|
|
const text = await readWithTransform(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_flush",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "Hello" } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_flush",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
usage: { prompt_tokens: 2, completion_tokens: 3, total_tokens: 5 },
|
|
})}\n\n`,
|
|
],
|
|
createSSETransformStreamWithLogger(
|
|
FORMATS.OPENAI,
|
|
FORMATS.OPENAI_RESPONSES,
|
|
"openai",
|
|
null,
|
|
null,
|
|
"gpt-4.1-mini",
|
|
null,
|
|
{ messages: [{ role: "user", content: "hello" }] }
|
|
)
|
|
);
|
|
|
|
assert.match(text, /response\.created/);
|
|
assert.match(text, /response\.completed/);
|
|
assert.doesNotMatch(text, /\[DONE\]/);
|
|
});
|
|
|
|
test("createPassthroughStreamWithLogger reuses passthrough mode helpers", async () => {
|
|
const text = await readWithTransform(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_passthrough",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "Hello again" } }],
|
|
})}\n\n`,
|
|
"data: [DONE]\n\n",
|
|
],
|
|
createPassthroughStreamWithLogger("openai", null, null, "gpt-4.1-mini", null, {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
})
|
|
);
|
|
|
|
assert.match(text, /Hello again/);
|
|
assert.match(text, /\[DONE\]/);
|
|
});
|
|
|
|
test("createStructuredSSECollector drops excess events and compactStructuredStreamPayload preserves metadata for object summaries", () => {
|
|
const collector = createStructuredSSECollector({
|
|
stage: "client_response",
|
|
maxEvents: 1,
|
|
maxBytes: 512,
|
|
});
|
|
|
|
collector.push({ type: "response.output_text.delta", delta: "one" });
|
|
collector.push({ type: "response.output_text.delta", delta: "two" });
|
|
|
|
const built = collector.build(
|
|
{
|
|
object: "response",
|
|
status: "completed",
|
|
},
|
|
{ includeEvents: false }
|
|
);
|
|
const compact = compactStructuredStreamPayload(built);
|
|
|
|
assert.equal(built._truncated, true);
|
|
assert.equal(built._droppedEvents, 1);
|
|
assert.equal(built._eventCount, 2);
|
|
assert.deepEqual(compact, {
|
|
object: "response",
|
|
status: "completed",
|
|
_omniroute_stream: {
|
|
format: "sse-json",
|
|
stage: "client_response",
|
|
eventCount: 2,
|
|
truncated: true,
|
|
droppedEvents: 1,
|
|
},
|
|
});
|
|
});
|
|
|
|
test("createSSEStream passthrough drops keepalive event blocks without losing Responses deltas", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
"event: keepalive\ndata:\n\n",
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_text.delta",
|
|
delta: "Hello keepalive-safe",
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.completed",
|
|
response: {
|
|
id: "resp_keepalive",
|
|
object: "response",
|
|
model: "gpt-4.1-mini",
|
|
status: "completed",
|
|
usage: { input_tokens: 2, output_tokens: 1, total_tokens: 3 },
|
|
},
|
|
})}\n\n`,
|
|
"data: [DONE]\n\n",
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI_RESPONSES,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: { input: "hello" },
|
|
}
|
|
);
|
|
|
|
assert.equal(text.includes("event: keepalive"), false);
|
|
assert.equal(text.includes("data:\n\n"), false);
|
|
assert.match(text, /response\.output_text\.delta/);
|
|
assert.match(text, /Hello keepalive-safe/);
|
|
assert.match(text, /data: \[DONE\]/);
|
|
});
|
|
|
|
test("createSSEStream passthrough aborts on Responses usage-limit failures and reports 429", async () => {
|
|
let failurePayload = null;
|
|
|
|
await assert.rejects(
|
|
readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.failed",
|
|
response: {
|
|
id: "resp_usage_limit",
|
|
object: "response",
|
|
model: "gpt-5.5",
|
|
status: "failed",
|
|
error: {
|
|
code: "usage_limit_reached",
|
|
message: "Your weekly usage limit has been reached",
|
|
},
|
|
},
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI_RESPONSES,
|
|
provider: "codex",
|
|
model: "gpt-5.5",
|
|
body: { input: "hello" },
|
|
onFailure(payload) {
|
|
failurePayload = payload;
|
|
},
|
|
}
|
|
),
|
|
/weekly usage limit|Upstream failure/
|
|
);
|
|
|
|
assert.ok(failurePayload, "should report the stream failure before aborting");
|
|
assert.equal(failurePayload.status, 429);
|
|
assert.equal(failurePayload.code, "usage_limit_reached");
|
|
});
|
|
|
|
test("createRequestLogger skips disabled logs and caps retained stream chunk bytes", async () => {
|
|
const disabled = await createRequestLogger("openai", "openai", "gpt-test", {
|
|
enabled: false,
|
|
});
|
|
disabled.logClientRawRequest("/v1/chat/completions", { prompt: "hello" });
|
|
disabled.appendProviderChunk("x".repeat(32));
|
|
assert.equal(disabled.getPipelinePayloads(), null);
|
|
|
|
const logger = await createRequestLogger("openai", "openai", "gpt-test", {
|
|
enabled: true,
|
|
captureStreamChunks: true,
|
|
// The byte budget now also counts the 15-char timestamp prefix, so size it as
|
|
// prefix + 5 to keep the original intent: cap the *payload* to 5 bytes ("abcde").
|
|
maxStreamChunkBytes: STREAM_CHUNK_TS_PREFIX_LEN + 5,
|
|
});
|
|
logger.appendProviderChunk("abcdef");
|
|
logger.appendProviderChunk("ghijkl");
|
|
const payloads = logger.getPipelinePayloads();
|
|
|
|
// First chunk retained but its payload truncated to 5 bytes; second replaced by marker.
|
|
assert.equal(stripChunkTs(payloads.streamChunks.provider[0]), "abcde");
|
|
assert.equal(
|
|
payloads.streamChunks.provider[1],
|
|
`[stream chunk log truncated after ${STREAM_CHUNK_TS_PREFIX_LEN + 5} bytes]`
|
|
);
|
|
assert.equal(payloads.streamChunks.provider.length, 2);
|
|
});
|
|
|
|
test("createRequestLogger caps retained stream chunk item count", async () => {
|
|
const logger = await createRequestLogger("openai", "openai", "gpt-test", {
|
|
enabled: true,
|
|
captureStreamChunks: true,
|
|
maxStreamChunkBytes: 1024,
|
|
maxStreamChunkItems: 2,
|
|
});
|
|
|
|
logger.appendProviderChunk("one");
|
|
logger.appendProviderChunk("two");
|
|
logger.appendProviderChunk("three");
|
|
|
|
const payloads = logger.getPipelinePayloads();
|
|
assert.equal(stripChunkTs(payloads.streamChunks.provider[0]), "one");
|
|
assert.equal(payloads.streamChunks.provider[1], "[stream chunk log truncated after 2 chunks]");
|
|
assert.equal(payloads.streamChunks.provider.length, 2);
|
|
});
|
|
|
|
// T-VERIFY: passthrough mode failure decrements pending requests
|
|
// Regression test for missing trackPendingRequest(false) on passthrough failure
|
|
import { getPendingRequests, clearPendingRequests } from "../../src/lib/usage/usageHistory.ts";
|
|
|
|
test("createSSEStream passthrough mode decrements pending requests on failure", async () => {
|
|
// Clear any existing pending requests first
|
|
clearPendingRequests();
|
|
const initial = getPendingRequests();
|
|
assert.equal(Object.keys(initial.byModel).length, 0, "should start with no pending requests");
|
|
|
|
let failurePayload = null;
|
|
const testProvider = "openai-compatible-test-failure";
|
|
const testModel = "gpt-test";
|
|
const testConnectionId = "test-conn-123";
|
|
|
|
await assert.rejects(
|
|
readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.failed",
|
|
response: {
|
|
id: "resp_failed_test",
|
|
object: "response",
|
|
model: testModel,
|
|
status: "failed",
|
|
error: {
|
|
code: "test_failure",
|
|
message: "Test failure for pending request tracking",
|
|
},
|
|
},
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI_RESPONSES,
|
|
provider: testProvider,
|
|
model: testModel,
|
|
connectionId: testConnectionId,
|
|
body: { input: "hello" },
|
|
onFailure(payload) {
|
|
failurePayload = payload;
|
|
},
|
|
}
|
|
),
|
|
/Test failure|Upstream failure/
|
|
);
|
|
|
|
assert.ok(failurePayload, "should report the stream failure");
|
|
|
|
// Verify pending requests are properly decremented after failure
|
|
const pending = getPendingRequests();
|
|
const modelKey = `${testModel} (${testProvider})`;
|
|
const count = pending.byModel[modelKey] || 0;
|
|
assert.equal(
|
|
count,
|
|
0,
|
|
`pending request count for ${modelKey} should be 0 after failure, got ${count}`
|
|
);
|
|
});
|
|
|
|
test("createSSEStream passthrough drops empty choices array chunks", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_empty",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "kimi-k2.6",
|
|
choices: [],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_empty",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "kimi-k2.6",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "Hello" } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_empty",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "kimi-k2.6",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "opencode-go",
|
|
model: "kimi-k2.6",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
// Empty choices WITHOUT usage are DROPPED, never replaced with a synthetic
|
|
// "[OmniRoute] Upstream returned an empty response. Please retry." chunk. That
|
|
// injection (reintroduced by #3422) was fed back by clients as a turn and caused
|
|
// the retry loop #3388/#3502, which #3400 had fixed by dropping the chunk.
|
|
assert.doesNotMatch(text, /\[OmniRoute\] Upstream returned an empty response/);
|
|
// Subsequent valid chunks must still pass through untouched.
|
|
assert.match(text, /"content":"Hello"/);
|
|
assert.match(text, /"finish_reason":"stop"/);
|
|
assert.equal(onCompletePayload.status, 200);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Hello");
|
|
});
|
|
|
|
test("createSSEStream passthrough forwards OpenAI usage-only empty choices chunks", async () => {
|
|
let onCompletePayload = null;
|
|
const usage = { prompt_tokens: 7, completion_tokens: 3, total_tokens: 10 };
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_usage_only",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "Hello" } }],
|
|
usage: null,
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_usage_only",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
usage: null,
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_usage_only",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [],
|
|
usage,
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai-compatible",
|
|
model: "gpt-4.1-mini",
|
|
body: {
|
|
messages: [{ role: "user", content: "hello" }],
|
|
stream_options: { include_usage: true },
|
|
},
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.doesNotMatch(text, /\[OmniRoute\] Upstream returned an empty response/);
|
|
assert.match(text, /"choices":\[\]/);
|
|
assert.match(text, /"usage":\{"prompt_tokens":7,"completion_tokens":3,"total_tokens":10\}/);
|
|
assert.equal(onCompletePayload.status, 200);
|
|
assert.equal(onCompletePayload.usage.prompt_tokens, 7);
|
|
assert.equal(onCompletePayload.usage.completion_tokens, 3);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, "Hello");
|
|
assert.deepEqual(onCompletePayload.responseBody.usage, usage);
|
|
});
|
|
|
|
test("createSSEStream passthrough logs empty response after tool_calls completion", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_tool_then_empty",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-5.5-xhigh",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
tool_calls: [
|
|
{
|
|
index: 0,
|
|
id: "call_tc",
|
|
type: "function",
|
|
function: { name: "task_complete", arguments: "{}" },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_tool_then_empty",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-5.5-xhigh",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "codex",
|
|
model: "gpt-5.5-xhigh",
|
|
body: { messages: [{ role: "user", content: "do task" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.match(text, /"finish_reason":"tool_calls"/);
|
|
assert.equal(onCompletePayload.status, 200);
|
|
assert.equal(onCompletePayload.responseBody.choices[0].finish_reason, "tool_calls");
|
|
assert.equal(
|
|
onCompletePayload.responseBody.choices[0].message.tool_calls[0].function.name,
|
|
"task_complete"
|
|
);
|
|
// Content should be null (empty) since no text was generated
|
|
assert.equal(onCompletePayload.responseBody.choices[0].message.content, null);
|
|
});
|
|
|
|
test("createSSEStream passthrough does not swallow false positive textual tool call", async () => {
|
|
let onCompletePayload = null;
|
|
const sentence = "Checking: [Tool call: terminal] was executed successfully.";
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_false_positive_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: sentence } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_false_positive_textual_tool",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "omniroute",
|
|
model: "MainAgent",
|
|
body: { messages: [{ role: "user", content: "inspect status" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "stop");
|
|
assert.equal(choice.message.content, sentence);
|
|
assert.equal(choice.message.tool_calls, undefined);
|
|
assert.match(text, /\[Tool call: terminal\] was executed successfully/);
|
|
});
|
|
|
|
test("createSSEStream passthrough does not swallow false positive textual tool call starting chunk", async () => {
|
|
let onCompletePayload = null;
|
|
const chunk1 = "[Tool call: terminal]";
|
|
const chunk2 = " was skipped.";
|
|
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_false_positive_textual_tool_start",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: chunk1 } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_false_positive_textual_tool_start",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: { content: chunk2 } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_false_positive_textual_tool_start",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "MainAgent",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "omniroute",
|
|
model: "MainAgent",
|
|
body: { messages: [{ role: "user", content: "inspect status" }] },
|
|
onComplete(payload) {
|
|
onCompletePayload = payload;
|
|
},
|
|
}
|
|
);
|
|
|
|
const choice = onCompletePayload.responseBody.choices[0];
|
|
assert.equal(choice.finish_reason, "stop");
|
|
assert.equal(choice.message.content, chunk1 + chunk2);
|
|
assert.equal(choice.message.tool_calls, undefined);
|
|
assert.match(text, /\[Tool call: terminal\] was skipped/);
|
|
});
|