wehub-resource-sync
505 lines
15 KiB
TypeScript
505 lines
15 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-numeric-ids-"));
|
|
process.env.DATA_DIR = TEST_DATA_DIR;
|
|
const core = await import("../../src/lib/db/core.ts");
|
|
|
|
const { createSSEStream } = await import("../../open-sse/utils/stream.ts");
|
|
const { FORMATS } = await import("../../open-sse/translator/formats.ts");
|
|
|
|
const textEncoder = new TextEncoder();
|
|
|
|
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();
|
|
}
|
|
|
|
test.after(() => {
|
|
core.resetDbInstance();
|
|
if (fs.existsSync(TEST_DATA_DIR)) {
|
|
fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("createSSEStream passthrough coerces numeric tool_call id to string", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_num",
|
|
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_num",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
tool_calls: [
|
|
{
|
|
index: 0,
|
|
id: 12345,
|
|
type: "function",
|
|
function: { name: "read_file", arguments: '{"path":"/tmp/a"}' },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "chatcmpl_num",
|
|
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;
|
|
},
|
|
}
|
|
);
|
|
|
|
const lines = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"));
|
|
let sawStreamedToolCall = false;
|
|
for (const line of lines) {
|
|
const payload = JSON.parse(line.slice(6));
|
|
const tc = payload?.choices?.[0]?.delta?.tool_calls?.[0];
|
|
if (tc?.id) {
|
|
assert.equal(typeof tc.id, "string", "tool_call.id should be a string");
|
|
assert.equal(tc.id, "12345");
|
|
sawStreamedToolCall = true;
|
|
}
|
|
}
|
|
assert.equal(sawStreamedToolCall, true, "expected streamed tool_call.id to be present");
|
|
|
|
const finalId = onCompletePayload?.responseBody?.choices?.[0]?.message?.tool_calls?.[0]?.id;
|
|
assert.equal(typeof finalId, "string", "tool_call.id in final message should be a string");
|
|
assert.equal(finalId, "12345");
|
|
});
|
|
|
|
test("createSSEStream passthrough preserves numeric top-level id as string", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: 123,
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { content: "Hello" } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: 123,
|
|
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" }] },
|
|
}
|
|
);
|
|
|
|
const lines = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"));
|
|
|
|
assert.ok(lines.length > 0, "expected streamed chunks");
|
|
for (const line of lines) {
|
|
const payload = JSON.parse(line.slice(6));
|
|
assert.equal(typeof payload.id, "string", "top-level chunk id should be a string");
|
|
assert.equal(payload.id, "123");
|
|
assert.notEqual(payload.id.startsWith("chatcmpl-"), true);
|
|
}
|
|
});
|
|
|
|
test("createSSEStream responses passthrough coerces numeric ids to strings", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.created",
|
|
response: {
|
|
id: 987,
|
|
model: "gpt-4.1-mini",
|
|
status: "in_progress",
|
|
output: [],
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_item.added",
|
|
response_id: 987,
|
|
output_index: 0,
|
|
item: {
|
|
id: 456,
|
|
call_id: 654,
|
|
type: "function_call",
|
|
status: "in_progress",
|
|
name: "lookup",
|
|
arguments: "",
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.function_call_arguments.delta",
|
|
response_id: 987,
|
|
item_id: 456,
|
|
output_index: 0,
|
|
delta: '{"q":',
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.function_call_arguments.done",
|
|
response_id: 987,
|
|
item_id: 456,
|
|
output_index: 0,
|
|
arguments: '{"q":1}',
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.completed",
|
|
response: {
|
|
id: 987,
|
|
model: "gpt-4.1-mini",
|
|
status: "completed",
|
|
output: [
|
|
{
|
|
id: 456,
|
|
call_id: 654,
|
|
type: "function_call",
|
|
status: "completed",
|
|
name: "lookup",
|
|
arguments: '{"q":1}',
|
|
},
|
|
],
|
|
},
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: { input: "hello" },
|
|
}
|
|
);
|
|
|
|
const payloads = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"))
|
|
.map((line) => JSON.parse(line.slice(6)));
|
|
|
|
const created = payloads.find((payload) => payload.type === "response.created");
|
|
assert.equal(typeof created.response.id, "string");
|
|
assert.equal(created.response.id, "987");
|
|
|
|
const added = payloads.find((payload) => payload.type === "response.output_item.added");
|
|
assert.equal(typeof added.response_id, "string");
|
|
assert.equal(added.response_id, "987");
|
|
assert.equal(typeof added.item.id, "string");
|
|
assert.equal(added.item.id, "456");
|
|
assert.equal(typeof added.item.call_id, "string");
|
|
assert.equal(added.item.call_id, "654");
|
|
|
|
const delta = payloads.find((payload) => payload.type === "response.function_call_arguments.delta");
|
|
assert.equal(typeof delta.response_id, "string");
|
|
assert.equal(delta.response_id, "987");
|
|
assert.equal(typeof delta.item_id, "string");
|
|
assert.equal(delta.item_id, "456");
|
|
|
|
const completed = payloads.find((payload) => payload.type === "response.completed");
|
|
assert.equal(typeof completed.response.id, "string");
|
|
assert.equal(completed.response.id, "987");
|
|
assert.equal(typeof completed.response.output[0].id, "string");
|
|
assert.equal(completed.response.output[0].id, "456");
|
|
assert.equal(typeof completed.response.output[0].call_id, "string");
|
|
assert.equal(completed.response.output[0].call_id, "654");
|
|
});
|
|
|
|
test("createSSEStream responses passthrough does not normalize unrelated top-level id", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.output_text.delta",
|
|
id: 1,
|
|
response_id: 987,
|
|
item_id: 456,
|
|
delta: "x",
|
|
})}\n\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: { input: "hello" },
|
|
}
|
|
);
|
|
|
|
const payloads = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"))
|
|
.map((line) => JSON.parse(line.slice(6)));
|
|
|
|
const delta = payloads.find((p) => p.type === "response.output_text.delta");
|
|
assert.equal(typeof delta.id, "number", "unrelated top-level id should stay numeric");
|
|
assert.equal(delta.id, 1);
|
|
assert.equal(typeof delta.response_id, "string");
|
|
assert.equal(delta.response_id, "987");
|
|
assert.equal(typeof delta.item_id, "string");
|
|
assert.equal(delta.item_id, "456");
|
|
});
|
|
|
|
test("createSSEStream passthrough normalizes numeric id in final chunk without trailing newline", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: 123,
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { content: "Hello" } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: 123,
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
|
|
})}`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
}
|
|
);
|
|
|
|
const lines = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"));
|
|
|
|
for (const line of lines) {
|
|
const payload = JSON.parse(line.slice(6));
|
|
if (payload.id) {
|
|
assert.equal(typeof payload.id, "string", "top-level chunk id should be a string");
|
|
assert.equal(payload.id, "123");
|
|
}
|
|
}
|
|
});
|
|
|
|
test("createSSEStream responses passthrough normalizes numeric ids in final chunk without trailing newline", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "response.created",
|
|
response: { id: 987, model: "gpt-4.1-mini", status: "in_progress", output: [] },
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "response.completed",
|
|
response: {
|
|
id: 987,
|
|
model: "gpt-4.1-mini",
|
|
status: "completed",
|
|
output: [
|
|
{
|
|
id: 456,
|
|
call_id: 654,
|
|
type: "function_call",
|
|
status: "completed",
|
|
name: "lookup",
|
|
arguments: "{}",
|
|
},
|
|
],
|
|
},
|
|
})}`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.OPENAI,
|
|
provider: "openai",
|
|
model: "gpt-4.1-mini",
|
|
body: { input: "hello" },
|
|
}
|
|
);
|
|
|
|
const payloads = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"))
|
|
.map((line) => JSON.parse(line.slice(6)));
|
|
|
|
const completed = payloads.find((p) => p.type === "response.completed");
|
|
assert.equal(typeof completed.response.id, "string");
|
|
assert.equal(completed.response.id, "987");
|
|
assert.equal(typeof completed.response.output[0].id, "string");
|
|
assert.equal(completed.response.output[0].id, "456");
|
|
assert.equal(typeof completed.response.output[0].call_id, "string");
|
|
assert.equal(completed.response.output[0].call_id, "654");
|
|
});
|
|
|
|
test("createSSEStream passthrough coerces tool_call id 0 without index", async () => {
|
|
let onCompletePayload = null;
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
id: "cmpl_0",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [{ index: 0, delta: { role: "assistant", content: "" } }],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "cmpl_0",
|
|
object: "chat.completion.chunk",
|
|
created: 1,
|
|
model: "gpt-4.1-mini",
|
|
choices: [
|
|
{
|
|
index: 0,
|
|
delta: {
|
|
tool_calls: [
|
|
{
|
|
id: 0,
|
|
type: "function",
|
|
function: { name: "zero", arguments: '{"path":"/tmp"}' },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
id: "cmpl_0",
|
|
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;
|
|
},
|
|
}
|
|
);
|
|
|
|
const lines = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"));
|
|
let sawStreamedToolCall = false;
|
|
for (const line of lines) {
|
|
const payload = JSON.parse(line.slice(6));
|
|
const tc = payload?.choices?.[0]?.delta?.tool_calls?.[0];
|
|
if (tc?.id != null) {
|
|
assert.equal(typeof tc.id, "string", "tool_call.id should be a string");
|
|
assert.equal(tc.id, "0");
|
|
sawStreamedToolCall = true;
|
|
}
|
|
}
|
|
assert.equal(sawStreamedToolCall, true, "expected streamed tool_call.id to be present");
|
|
|
|
const finalId = onCompletePayload?.responseBody?.choices?.[0]?.message?.tool_calls?.[0]?.id;
|
|
assert.equal(typeof finalId, "string", "tool_call.id in final message should be a string");
|
|
assert.equal(finalId, "0");
|
|
});
|
|
|
|
test("createSSEStream Claude passthrough does not normalize numeric ids", async () => {
|
|
const text = await readTransformed(
|
|
[
|
|
`data: ${JSON.stringify({
|
|
type: "message_start",
|
|
message: {
|
|
id: 987,
|
|
type: "message",
|
|
role: "assistant",
|
|
content: [],
|
|
model: "claude-3-5-sonnet",
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_start",
|
|
index: 0,
|
|
content_block: {
|
|
id: 456,
|
|
type: "text",
|
|
text: "",
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "content_block_delta",
|
|
index: 0,
|
|
delta: {
|
|
type: "text_delta",
|
|
text: "Hello",
|
|
},
|
|
})}\n\n`,
|
|
`data: ${JSON.stringify({
|
|
type: "message_stop",
|
|
})}\n`,
|
|
],
|
|
{
|
|
mode: "passthrough",
|
|
sourceFormat: FORMATS.ANTHROPIC,
|
|
provider: "anthropic",
|
|
model: "claude-3-5-sonnet-20241022",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
}
|
|
);
|
|
|
|
const payloads = text
|
|
.trim()
|
|
.split("\n")
|
|
.filter((line) => line.startsWith("data: ") && !line.includes("[DONE]"))
|
|
.map((line) => JSON.parse(line.slice(6)));
|
|
|
|
const start = payloads.find((p) => p.type === "message_start");
|
|
assert.equal(start.message.id, 987, "Claude message id should remain numeric");
|
|
assert.equal(typeof start.message.id, "number");
|
|
|
|
const contentStart = payloads.find((p) => p.type === "content_block_start");
|
|
assert.equal(contentStart.content_block.id, 456, "Claude content block id should remain numeric");
|
|
assert.equal(typeof contentStart.content_block.id, "number");
|
|
});
|