@rerouter/helper 0.0.0-stage → 0.1.0

package/src/responses-bridge.test.js

@@ -0,0 +1,580 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import {
+  ResponsesBridgeError,
+  chatJsonToResponse,
+  responsesToChatRequest,
+  wrapResponsesStream,
+} from "./lib/responses-bridge.js";
+import { startBridge } from "./lib/bridge-server.js";
+
+// ------------------------------------------------------- helpers
+function sseStream(frames) {
+  const encoder = new TextEncoder();
+  const payload = frames.map((f) => (f === "[DONE]" ? "data: [DONE]\n\n" : `data: ${JSON.stringify(f)}\n\n`)).join("");
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(payload));
+      controller.close();
+    },
+  });
+}
+
+async function readSseEvents(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const events = [];
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    let sep;
+    while ((sep = buffer.indexOf("\n\n")) >= 0) {
+      const raw = buffer.slice(0, sep);
+      buffer = buffer.slice(sep + 2);
+      const eventLine = raw.split("\n").find((l) => l.startsWith("event:"));
+      const dataLine = raw
+        .split("\n")
+        .filter((l) => l.startsWith("data:"))
+        .map((l) => l.slice(5).trimStart())
+        .join("\n");
+      events.push({ event: eventLine?.slice(6).trim(), data: dataLine ? JSON.parse(dataLine) : null });
+    }
+  }
+  return events;
+}
+
+// ------------------------------------------------------- responsesToChatRequest
+describe("responsesToChatRequest", () => {
+  it("translates a simple string input", () => {
+    const { request } = responsesToChatRequest({ model: "acme/pro-1", input: "hello" });
+    assert.equal(request.model, "acme/pro-1");
+    assert.deepEqual(request.messages, [{ role: "user", content: "hello" }]);
+  });
+
+  it("instructions → system message first", () => {
+    const { request } = responsesToChatRequest({
+      model: "m",
+      instructions: "You are an assistant.",
+      input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }],
+    });
+    assert.equal(request.messages[0].role, "system");
+    assert.equal(request.messages[0].content, "You are an assistant.");
+    assert.equal(request.messages[1].role, "user");
+  });
+
+  it("role developer → system", () => {
+    const { request } = responsesToChatRequest({
+      model: "m",
+      input: [{ type: "message", role: "developer", content: [{ type: "input_text", text: "rules" }] }],
+    });
+    assert.equal(request.messages[0].role, "system");
+  });
+
+  it("input_image → image_url, input_file → 400", () => {
+    const { request } = responsesToChatRequest({
+      model: "m",
+      input: [
+        {
+          type: "message",
+          role: "user",
+          content: [
+            { type: "input_text", text: "look" },
+            { type: "input_image", image_url: "https://x/img.png" },
+          ],
+        },
+      ],
+    });
+    const content = request.messages[0].content;
+    assert.equal(content[0].type, "text");
+    assert.deepEqual(content[1], { type: "image_url", image_url: { url: "https://x/img.png" } });
+
+    assert.throws(
+      () =>
+        responsesToChatRequest({
+          model: "m",
+          input: [{ type: "message", role: "user", content: [{ type: "input_file", file_id: "f1" }] }],
+        }),
+      (err) => err instanceof ResponsesBridgeError && err.status === 400,
+    );
+  });
+
+  it("function_call → assistant tool_calls; function_call_output → role tool", () => {
+    const { request } = responsesToChatRequest({
+      model: "m",
+      input: [
+        { type: "message", role: "user", content: [{ type: "input_text", text: "call" }] },
+        { type: "function_call", call_id: "call_1", name: "get_weather", arguments: '{"city":"JKT"}' },
+        { type: "function_call_output", call_id: "call_1", output: "sunny" },
+      ],
+    });
+    const assistant = request.messages[1];
+    assert.equal(assistant.role, "assistant");
+    assert.deepEqual(assistant.tool_calls, [
+      { id: "call_1", type: "function", function: { name: "get_weather", arguments: '{"city":"JKT"}' } },
+    ]);
+    const tool = request.messages[2];
+    assert.equal(tool.role, "tool");
+    assert.equal(tool.tool_call_id, "call_1");
+    assert.equal(tool.content, "sunny");
+  });
+
+  it("custom tool wrapped as function {input:string} and tracked", () => {
+    const { request, customToolNames } = responsesToChatRequest({
+      model: "m",
+      input: "x",
+      tools: [
+        { type: "function", name: "f1", parameters: { type: "object", properties: { a: { type: "string" } } } },
+        { type: "custom", name: "c1", description: "freeform" },
+      ],
+    });
+    assert.equal(request.tools.length, 2);
+    assert.equal(request.tools[0].function.name, "f1");
+    const c1 = request.tools[1].function;
+    assert.equal(c1.name, "c1");
+    assert.deepEqual(c1.parameters.required, ["input"]);
+    assert.equal(c1.parameters.properties.input.type, "string");
+    assert.ok(customToolNames.has("c1"));
+    assert.ok(!customToolNames.has("f1"));
+  });
+
+  it("custom_tool_call input → arguments JSON {input}", () => {
+    const { request, customToolNames } = responsesToChatRequest({
+      model: "m",
+      input: [{ type: "custom_tool_call", call_id: "k1", name: "paint", input: "cat painting" }],
+    });
+    assert.ok(customToolNames.has("paint"));
+    assert.equal(request.messages[0].tool_calls[0].function.arguments, '{"input":"cat painting"}');
+  });
+
+  it("reasoning item dropped, reasoning.effort → reasoning_effort", () => {
+    const { request } = responsesToChatRequest({
+      model: "m",
+      input: [
+        { type: "reasoning", summary: [] },
+        { type: "message", role: "user", content: [{ type: "input_text", text: "x" }] },
+      ],
+      reasoning: { effort: "high" },
+    });
+    assert.equal(request.messages.length, 1);
+    assert.equal(request.reasoning_effort, "high");
+  });
+
+  it("max_output_tokens → max_tokens, stream, tool_choice object", () => {
+    const { request } = responsesToChatRequest({
+      model: "m",
+      input: "x",
+      stream: true,
+      max_output_tokens: 512.9,
+      tool_choice: { type: "function", name: "f1" },
+    });
+    assert.equal(request.max_tokens, 512);
+    assert.equal(request.stream, true);
+    assert.deepEqual(request.tool_choice, { type: "function", function: { name: "f1" } });
+  });
+
+  it("rejects empty input and missing model", () => {
+    assert.throws(() => responsesToChatRequest({ input: "x" }), /model/);
+    assert.throws(() => responsesToChatRequest({ model: "m", input: [] }), /empty/);
+    assert.throws(() => responsesToChatRequest("not an object"), /object/);
+  });
+});
+
+// ------------------------------------------------------- chatJsonToResponse
+describe("chatJsonToResponse", () => {
+  const baseChat = {
+    id: "chatcmpl-1",
+    created: 1700000000,
+    model: "acme/pro-1",
+    choices: [{ message: { role: "assistant", content: "answer" }, finish_reason: "stop" }],
+    usage: {
+      prompt_tokens: 10,
+      completion_tokens: 5,
+      total_tokens: 15,
+      prompt_tokens_details: { cached_tokens: 2 },
+      completion_tokens_details: { reasoning_tokens: 1 },
+    },
+  };
+
+  it("text → output message + usage mapping", () => {
+    const resp = chatJsonToResponse(baseChat, { requestedModel: "acme/pro-1" });
+    assert.match(resp.id, /^resp_/);
+    assert.equal(resp.object, "response");
+    assert.equal(resp.status, "completed");
+    assert.equal(resp.model, "acme/pro-1");
+    assert.equal(resp.output.length, 1);
+    assert.equal(resp.output[0].type, "message");
+    assert.equal(resp.output[0].content[0].type, "output_text");
+    assert.equal(resp.output[0].content[0].text, "answer");
+    assert.deepEqual(resp.usage, {
+      input_tokens: 10,
+      input_tokens_details: { cached_tokens: 2 },
+      output_tokens: 5,
+      output_tokens_details: { reasoning_tokens: 1 },
+      total_tokens: 15,
+    });
+  });
+
+  it("finish length → status incomplete + incomplete_details", () => {
+    const resp = chatJsonToResponse(
+      { ...baseChat, choices: [{ message: { content: "x" }, finish_reason: "length" }] },
+      { requestedModel: "m" },
+    );
+    assert.equal(resp.status, "incomplete");
+    assert.deepEqual(resp.incomplete_details, { reason: "max_output_tokens" });
+  });
+
+  it("tool_calls → function_call / custom_tool_call output items", () => {
+    const chat = {
+      ...baseChat,
+      choices: [
+        {
+          message: {
+            content: null,
+            tool_calls: [
+              { id: "call_a", type: "function", function: { name: "f1", arguments: '{"a":1}' } },
+              { id: "call_b", type: "function", function: { name: "c1", arguments: '{"input":"freeform"}' } },
+            ],
+          },
+          finish_reason: "tool_calls",
+        },
+      ],
+    };
+    const resp = chatJsonToResponse(chat, {
+      requestedModel: "m",
+      customToolNames: new Set(["c1"]),
+    });
+    assert.equal(resp.output.length, 2);
+    const fn = resp.output[0];
+    assert.equal(fn.type, "function_call");
+    assert.equal(fn.call_id, "call_a");
+    assert.equal(fn.arguments, '{"a":1}');
+    const custom = resp.output[1];
+    assert.equal(custom.type, "custom_tool_call");
+    assert.equal(custom.call_id, "call_b");
+    assert.equal(custom.input, "freeform");
+  });
+});
+
+// ------------------------------------------------------- wrapResponsesStream
+describe("wrapResponsesStream", () => {
+  it("wraps a text stream into complete Responses events", async () => {
+    const upstream = sseStream([
+      { choices: [{ delta: { role: "assistant" }, finish_reason: null }] },
+      { choices: [{ delta: { content: "Hello " }, finish_reason: null }] },
+      { choices: [{ delta: { content: "world" }, finish_reason: null }] },
+      { choices: [{ delta: {}, finish_reason: "stop" }], usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 } },
+      "[DONE]",
+    ]);
+    const events = await readSseEvents(wrapResponsesStream(upstream, { requestedModel: "acme/pro-1" }));
+    const names = events.map((e) => e.event);
+
+    assert.equal(names[0], "response.created");
+    assert.equal(names[1], "response.in_progress");
+    assert.ok(names.includes("response.output_item.added"));
+    assert.ok(names.includes("response.content_part.added"));
+    assert.equal(names.filter((n) => n === "response.output_text.delta").length, 2);
+    assert.ok(names.includes("response.output_text.done"));
+    assert.ok(names.includes("response.content_part.done"));
+    assert.ok(names.includes("response.output_item.done"));
+    assert.equal(names.at(-1), "response.completed");
+
+    // sequence_number increases monotonically
+    const seqs = events.map((e) => e.data.sequence_number);
+    assert.deepEqual(seqs, [...seqs].sort((a, b) => a - b));
+
+    const deltas = events.filter((e) => e.event === "response.output_text.delta").map((e) => e.data.delta);
+    assert.equal(deltas.join(""), "Hello world");
+
+    const done = events.find((e) => e.event === "response.output_text.done");
+    assert.equal(done.data.text, "Hello world");
+
+    const completed = events.at(-1).data.response;
+    assert.equal(completed.status, "completed");
+    assert.equal(completed.model, "acme/pro-1");
+    assert.equal(completed.output[0].type, "message");
+    assert.equal(completed.output[0].content[0].text, "Hello world");
+    assert.equal(completed.usage.total_tokens, 5);
+  });
+
+  it("wraps tool_calls stream → function_call events", async () => {
+    const upstream = sseStream([
+      {
+        choices: [
+          {
+            delta: { tool_calls: [{ index: 0, id: "call_1", function: { name: "get_weather", arguments: "" } }] },
+            finish_reason: null,
+          },
+        ],
+      },
+      { choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '{"city":' } }] }, finish_reason: null }] },
+      { choices: [{ delta: { tool_calls: [{ index: 0, function: { arguments: '"JKT"}' } }] }, finish_reason: null }] },
+      { choices: [{ delta: {}, finish_reason: "tool_calls" }] },
+      "[DONE]",
+    ]);
+    const events = await readSseEvents(wrapResponsesStream(upstream, { requestedModel: "m" }));
+    const names = events.map((e) => e.event);
+    assert.ok(names.includes("response.function_call_arguments.delta"));
+    assert.ok(names.includes("response.function_call_arguments.done"));
+
+    const completed = events.at(-1).data.response;
+    const fnItem = completed.output.find((o) => o.type === "function_call");
+    assert.equal(fnItem.call_id, "call_1");
+    assert.equal(fnItem.name, "get_weather");
+    assert.equal(fnItem.arguments, '{"city":"JKT"}');
+  });
+
+  it("custom tool stream → custom_tool_call events with parsed input", async () => {
+    const upstream = sseStream([
+      {
+        choices: [
+          { delta: { tool_calls: [{ index: 0, id: "c9", function: { name: "paint", arguments: '{"input":"cat"}' } }] }, finish_reason: null },
+        ],
+      },
+      { choices: [{ delta: {}, finish_reason: "tool_calls" }] },
+      "[DONE]",
+    ]);
+    const events = await readSseEvents(
+      wrapResponsesStream(upstream, { requestedModel: "m", customToolNames: new Set(["paint"]) }),
+    );
+    const names = events.map((e) => e.event);
+    assert.ok(names.includes("response.custom_tool_call_input.delta"));
+    assert.ok(names.includes("response.custom_tool_call_input.done"));
+    const completed = events.at(-1).data.response;
+    const item = completed.output.find((o) => o.type === "custom_tool_call");
+    assert.equal(item.input, "cat");
+  });
+
+  it("upstream error chunk → response.failed without completed", async () => {
+    const upstream = sseStream([
+      { choices: [{ delta: { content: "partial" }, finish_reason: null }] },
+      { error: { message: "upstream exploded" } },
+    ]);
+    const events = await readSseEvents(wrapResponsesStream(upstream, { requestedModel: "m" }));
+    const names = events.map((e) => e.event);
+    assert.ok(names.includes("response.failed"));
+    assert.ok(!names.includes("response.completed"));
+    const failed = events.find((e) => e.event === "response.failed");
+    assert.equal(failed.data.response.status, "failed");
+    assert.match(failed.data.response.error.message, /upstream exploded/);
+  });
+
+  it("finish length → response.completed status incomplete", async () => {
+    const upstream = sseStream([
+      { choices: [{ delta: { content: "x" }, finish_reason: null }] },
+      { choices: [{ delta: {}, finish_reason: "length" }] },
+      "[DONE]",
+    ]);
+    const events = await readSseEvents(wrapResponsesStream(upstream, { requestedModel: "m" }));
+    const completed = events.at(-1).data.response;
+    assert.equal(completed.status, "incomplete");
+    assert.deepEqual(completed.incomplete_details, { reason: "max_output_tokens" });
+  });
+});
+
+// ------------------------------------------------------- startBridge (server)
+describe("startBridge", () => {
+  function fakeFetchChat(chatJson) {
+    return async (url, init) => {
+      assert.ok(url.endsWith("/v1/chat/completions"));
+      return new Response(JSON.stringify(chatJson), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    };
+  }
+
+  async function withBridge(fetchImpl, fn) {
+    const bridge = await startBridge({ port: 0, baseUrl: "https://gw.test", apiKey: "sk-rr-test", fetchImpl });
+    try {
+      await fn(bridge);
+    } finally {
+      await bridge.close();
+    }
+  }
+
+  it("GET /health answers ok without auth", async () => {
+    await withBridge(fetch, async (bridge) => {
+      const res = await fetch(`${bridge.url.replace(/\/v1$/, "")}/health`);
+      assert.equal(res.status, 200);
+      const body = await res.json();
+      assert.equal(body.ok, true);
+      assert.equal(body.upstream, "https://gw.test");
+    });
+  });
+
+  it("POST /v1/responses non-stream translates both ways + forwards auth", async () => {
+    let seenAuth;
+    let seenBody;
+    const fetchImpl = async (url, init) => {
+      seenAuth = init.headers.authorization;
+      seenBody = JSON.parse(init.body);
+      return new Response(
+        JSON.stringify({
+          created: 1700000000,
+          model: "acme/pro-1",
+          choices: [{ message: { role: "assistant", content: "hello" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    };
+    await withBridge(fetchImpl, async (bridge) => {
+      const res = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: "Bearer sk-rr-client" },
+        body: JSON.stringify({ model: "acme/pro-1", input: "hi" }),
+      });
+      assert.equal(res.status, 200);
+      const body = await res.json();
+      assert.equal(body.object, "response");
+      assert.equal(body.output[0].content[0].text, "hello");
+      assert.equal(seenAuth, "Bearer sk-rr-client", "client auth forwarded as-is");
+      assert.deepEqual(seenBody.messages, [{ role: "user", content: "hi" }]);
+    });
+  });
+
+  it("falls back to local apiKey when client sends no Authorization", async () => {
+    let seenAuth;
+    const fetchImpl = async (url, init) => {
+      seenAuth = init.headers.authorization;
+      return new Response(
+        JSON.stringify({ choices: [{ message: { content: "x" }, finish_reason: "stop" }] }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    };
+    await withBridge(fetchImpl, async (bridge) => {
+      const res = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model: "m", input: "x" }),
+      });
+      assert.equal(res.status, 200);
+      assert.equal(seenAuth, "Bearer sk-rr-test");
+    });
+  });
+
+  it("no auth at all → 401", async () => {
+    const bridge = await startBridge({ port: 0, baseUrl: "https://gw.test", fetchImpl: fakeFetchChat({}) });
+    try {
+      const res = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model: "m", input: "x" }),
+      });
+      assert.equal(res.status, 401);
+      const body = await res.json();
+      assert.equal(body.error.type, "authentication_error");
+    } finally {
+      await bridge.close();
+    }
+  });
+
+  it("upstream error forwarded with status + gateway message", async () => {
+    const fetchImpl = async () =>
+      new Response(JSON.stringify({ error: { message: "insufficient balance" } }), {
+        status: 402,
+        headers: { "content-type": "application/json" },
+      });
+    await withBridge(fetchImpl, async (bridge) => {
+      const res = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: "Bearer k" },
+        body: JSON.stringify({ model: "m", input: "x" }),
+      });
+      assert.equal(res.status, 402);
+      const body = await res.json();
+      assert.match(body.error.message, /insufficient balance/);
+      assert.equal(body.error.code, "upstream_error");
+    });
+  });
+
+  it("gateway unreachable → 502 upstream_unreachable", async () => {
+    const fetchImpl = async () => {
+      throw new Error("ECONNREFUSED");
+    };
+    await withBridge(fetchImpl, async (bridge) => {
+      const res = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: "Bearer k" },
+        body: JSON.stringify({ model: "m", input: "x" }),
+      });
+      assert.equal(res.status, 502);
+      const body = await res.json();
+      assert.equal(body.error.code, "upstream_unreachable");
+    });
+  });
+
+  it("stream: SSE from the gateway wrapped into Responses events", async () => {
+    const sse = [
+      'data: {"choices":[{"delta":{"content":"hi "},"finish_reason":null}]}',
+      'data: {"choices":[{"delta":{"content":"you"},"finish_reason":null}]}',
+      'data: {"choices":[{"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":2,"total_tokens":3}}',
+      "data: [DONE]",
+    ].join("\n\n") + "\n\n";
+    const fetchImpl = async () =>
+      new Response(sse, { status: 200, headers: { "content-type": "text/event-stream" } });
+    await withBridge(fetchImpl, async (bridge) => {
+      const res = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: "Bearer k" },
+        body: JSON.stringify({ model: "m", input: "x", stream: true }),
+      });
+      assert.equal(res.status, 200);
+      assert.match(res.headers.get("content-type"), /text\/event-stream/);
+      const text = await res.text();
+      assert.match(text, /event: response\.created/);
+      assert.match(text, /event: response\.output_text\.delta/);
+      assert.match(text, /event: response\.completed/);
+      const completedLine = text
+        .split("\n")
+        .filter((l) => l.startsWith("data:"))
+        .map((l) => JSON.parse(l.slice(5).trim()))
+        .find((d) => d.type === "response.completed");
+      assert.equal(completedLine.response.status, "completed");
+      assert.equal(completedLine.response.usage.total_tokens, 3);
+    });
+  });
+
+  it("GET /v1/models passthrough to the gateway", async () => {
+    let seenAuth;
+    const fetchImpl = async (url, init) => {
+      seenAuth = init.headers.authorization;
+      assert.ok(url.endsWith("/v1/models"));
+      return new Response(JSON.stringify({ object: "list", data: [{ id: "m1" }] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    };
+    await withBridge(fetchImpl, async (bridge) => {
+      const res = await fetch(`${bridge.url}/models`, {
+        headers: { authorization: "Bearer sk-rr-client" },
+      });
+      assert.equal(res.status, 200);
+      const body = await res.json();
+      assert.equal(body.data[0].id, "m1");
+      assert.equal(seenAuth, "Bearer sk-rr-client");
+    });
+  });
+
+  it("invalid request (not JSON / unknown input) → 400", async () => {
+    await withBridge(fakeFetchChat({}), async (bridge) => {
+      const bad = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: "Bearer k" },
+        body: "not json",
+      });
+      assert.equal(bad.status, 400);
+
+      const unknown = await fetch(`${bridge.url}/responses`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: "Bearer k" },
+        body: JSON.stringify({ model: "m", input: [{ type: "alien_item" }] }),
+      });
+      assert.equal(unknown.status, 400);
+      const body = await unknown.json();
+      assert.match(body.error.message, /Unknown/);
+    });
+  });
+});