chore: import upstream snapshot with attribution

tests/unit/responses-handler.test.ts

@@ -0,0 +1,395 @@
+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";
+import type { ProviderCredentials } from "../../open-sse/executors/base.ts";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-responses-handler-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const { handleResponsesCore } = await import("../../open-sse/handlers/responsesHandler.ts");
+const { COMMAND_CODE_VERSION } = await import("../../open-sse/executors/commandCode.ts");
+
+const originalFetch = globalThis.fetch;
+
+type JsonRecord = Record<string, unknown>;
+type CapturedBody = JsonRecord & {
+  messages?: Array<JsonRecord & { content?: unknown; role?: unknown }>;
+  params?: JsonRecord;
+  tools?: Array<JsonRecord & { function?: JsonRecord }>;
+};
+type CapturedCall = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: CapturedBody;
+};
+type ResponseFactory = (call: CapturedCall, calls: CapturedCall[]) => Response | Promise<Response>;
+type InvokeResponsesCoreOptions = {
+  body?: unknown;
+  provider?: string;
+  model?: string;
+  credentials?: ProviderCredentials;
+  responseFactory?: ResponseFactory;
+  signal?: AbortSignal;
+};
+type ErrorPayload = {
+  error?: {
+    message?: string;
+  };
+};
+
+function noopLog() {
+  return {
+    debug() {},
+    info() {},
+    warn() {},
+    error() {},
+  };
+}
+
+function toPlainHeaders(headers: HeadersInit | undefined): Record<string, string> {
+  if (!headers) return {};
+  if (headers instanceof Headers) return Object.fromEntries(headers.entries());
+  return Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [key, value == null ? "" : String(value)])
+  );
+}
+
+function parseCapturedBody(body: BodyInit | null | undefined): CapturedBody {
+  if (!body) return {};
+  const parsed = JSON.parse(String(body)) as unknown;
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    ? (parsed as CapturedBody)
+    : {};
+}
+
+function buildOpenAISseResponse(text = "hello") {
+  return new Response(
+    [
+      `data: ${JSON.stringify({
+        id: "chatcmpl-responses",
+        object: "chat.completion.chunk",
+        choices: [{ index: 0, delta: { role: "assistant", content: text } }],
+      })}`,
+      "",
+      `data: ${JSON.stringify({
+        id: "chatcmpl-responses",
+        object: "chat.completion.chunk",
+        choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        usage: { prompt_tokens: 4, completion_tokens: 2, total_tokens: 6 },
+      })}`,
+      "",
+      "data: [DONE]",
+      "",
+    ].join("\n"),
+    {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream" },
+    }
+  );
+}
+
+function buildJsonResponse(status: number, payload: unknown) {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+async function resetStorage() {
+  core.resetDbInstance();
+  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+async function invokeResponsesCore({
+  body,
+  provider = "openai",
+  model = "gpt-4o-mini",
+  credentials,
+  responseFactory,
+  signal,
+}: InvokeResponsesCoreOptions = {}) {
+  const calls: CapturedCall[] = [];
+
+  globalThis.fetch = async (url, init = {}) => {
+    const call = {
+      url: String(url),
+      method: init.method || "GET",
+      headers: toPlainHeaders(init.headers),
+      body: parseCapturedBody(init.body),
+    };
+    calls.push(call);
+    return responseFactory ? responseFactory(call, calls) : buildOpenAISseResponse();
+  };
+
+  try {
+    const result = await handleResponsesCore({
+      body: structuredClone(body),
+      modelInfo: { provider, model, extendedContext: false },
+      credentials: credentials || {
+        apiKey: "sk-test",
+        providerSpecificData: {},
+      },
+      log: noopLog(),
+      onCredentialsRefreshed: null,
+      onRequestSuccess: null,
+      onDisconnect: null,
+      connectionId: null,
+      signal,
+    });
+
+    return { result, calls, call: calls.at(-1) };
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+}
+
+test.afterEach(async () => {
+  globalThis.fetch = originalFetch;
+  await resetStorage();
+});
+
+test.after(async () => {
+  globalThis.fetch = originalFetch;
+  await resetStorage();
+  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+});
+
+test("handleResponsesCore converts Responses API input, instructions, tools, metadata, and forces streaming", async () => {
+  const { call, result } = await invokeResponsesCore({
+    body: {
+      model: "gpt-4o-mini",
+      instructions: "You are terse",
+      input: [
+        {
+          type: "message",
+          role: "user",
+          content: [{ type: "input_text", text: "hello" }],
+        },
+      ],
+      tools: [
+        {
+          type: "function",
+          name: "lookup_weather",
+          description: "Find weather",
+          parameters: { type: "object" },
+        },
+      ],
+      metadata: { source: "responses-test" },
+      store: true,
+    },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(call.body.stream, true);
+  assert.equal(call.body.messages[0].role, "system");
+  assert.equal(call.body.messages[0].content, "You are terse");
+  assert.equal(call.body.messages[1].role, "user");
+  assert.equal(call.body.messages[1].content[0].text, "hello");
+  assert.equal(call.body.tools[0].function.name, "lookup_weather");
+  assert.equal(call.body.metadata, undefined);
+  assert.equal("store" in call.body, false);
+});
+
+test("handleResponsesCore strips previous_response_id by default and handles empty input arrays", async () => {
+  const { call, result } = await invokeResponsesCore({
+    body: {
+      model: "gpt-4o-mini",
+      input: [],
+      previous_response_id: "resp_prev_123",
+      metadata: { session: "abc" },
+    },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(call.body.previous_response_id, undefined);
+  assert.equal(call.body.metadata, undefined);
+  // Empty input[] now injects a placeholder user message to avoid upstream
+  // "400: at least one message is required" rejections (9router#419).
+  assert.equal(Array.isArray(call.body.messages), true);
+  assert.equal(call.body.messages.length, 1);
+  assert.equal(call.body.messages[0].role, "user");
+  assert.equal(call.body.stream, true);
+});
+
+test("handleResponsesCore preserves store for Codex responses when connection opt-in is enabled", async () => {
+  const { call, result } = await invokeResponsesCore({
+    body: {
+      model: "gpt-5.3-codex",
+      input: [],
+      previous_response_id: "resp_prev_store",
+      store: true,
+    },
+    provider: "codex",
+    model: "gpt-5.3-codex",
+    credentials: {
+      accessToken: "codex-token",
+      providerSpecificData: {
+        openaiStoreEnabled: true,
+      },
+    },
+  });
+
+  assert.equal(result.success, true);
+  // When openaiStoreEnabled=true, the request keeps previous_response_id and
+  // store=true so the upstream Codex Responses session continues from prior turn.
+  assert.equal(call.body.previous_response_id, "resp_prev_store");
+  assert.equal(call.body.store, true);
+  assert.equal(call.body.stream, true);
+});
+
+test("handleResponsesCore transforms upstream OpenAI SSE into Responses API SSE", async () => {
+  const { result } = await invokeResponsesCore({
+    body: {
+      model: "gpt-4o-mini",
+      input: "hello",
+    },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(result.response.headers.get("Content-Type"), "text/event-stream");
+
+  const sse = await result.response.text();
+  assert.match(sse, /event: response\.created/);
+  assert.match(sse, /event: response\.output_text\.delta/);
+  assert.match(sse, /event: response\.completed/);
+  assert.match(sse, /data: \[DONE\]/);
+});
+
+test("handleResponsesCore transforms Command Code executor SSE through Responses shim", async () => {
+  const { call, result } = await invokeResponsesCore({
+    provider: "command-code",
+    model: "gpt-5.4-mini",
+    credentials: { apiKey: "cc_test_key", providerSpecificData: {} },
+    body: {
+      model: "gpt-5.4-mini",
+      input: "hello command code",
+    },
+    responseFactory() {
+      return new Response(
+        [
+          `data: ${JSON.stringify({ type: "text-delta", text: "command" })}`,
+          "",
+          `data: ${JSON.stringify({ type: "reasoning-delta", text: "thinking" })}`,
+          "",
+          `data: ${JSON.stringify({ type: "finish", finishReason: "stop" })}`,
+          "",
+        ].join("\n"),
+        { status: 200, headers: { "Content-Type": "application/x-ndjson" } }
+      );
+    },
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(call.url, "https://api.commandcode.ai/alpha/generate");
+  assert.equal(call.headers.Authorization, "Bearer cc_test_key");
+  assert.equal(call.headers["x-command-code-version"], COMMAND_CODE_VERSION);
+  assert.equal(call.body.params.model, "gpt-5.4-mini");
+  assert.equal(call.body.params.stream, true);
+
+  const sse = await result.response.text();
+  assert.match(sse, /event: response\.created/);
+  assert.match(sse, /event: response\.output_text\.delta/);
+  assert.match(sse, /command/);
+  assert.match(sse, /event: response\.completed/);
+  assert.match(sse, /data: \[DONE\]/);
+});
+
+test("handleResponsesCore propagates upstream failures from chatCore unchanged", async () => {
+  const { result } = await invokeResponsesCore({
+    body: {
+      model: "gpt-4o-mini",
+      input: "hello",
+    },
+    responseFactory() {
+      return buildJsonResponse(401, {
+        error: { message: "unauthorized" },
+      });
+    },
+  });
+
+  assert.equal(result.success, false);
+  assert.equal(result.status, 401);
+
+  const payload = (await result.response.json()) as ErrorPayload;
+  assert.equal(payload.error.message, "[401]: unauthorized");
+});
+
+test("handleResponsesCore rejects invalid Responses API input that cannot be translated", async () => {
+  // After #2695 the web_search family is allowed; use file_search to keep this
+  // assertion exercising the "untranslatable tool type" path.
+  await assert.rejects(
+    () =>
+      handleResponsesCore({
+        body: {
+          model: "gpt-4o-mini",
+          input: "hello",
+          tools: [{ type: "file_search" }],
+        },
+        modelInfo: { provider: "openai", model: "gpt-4o-mini", extendedContext: false },
+        credentials: { apiKey: "sk-test", providerSpecificData: {} },
+        log: noopLog(),
+        onCredentialsRefreshed: null,
+        onRequestSuccess: null,
+        onDisconnect: null,
+        connectionId: null,
+      }),
+    (error) =>
+      error instanceof Error && error.message.includes("file_search tool type is not supported")
+  );
+});
+
+test("handleResponsesCore injects SSE keepalive frames for Responses streams", async (t) => {
+  // PR #2233 changed the Responses-API heartbeat shape from a SSE comment
+  // (`: keepalive ...`) to a `data: {"type":"response.in_progress"}` frame,
+  // because strict proxies only count `data:` lines as activity.
+  t.mock.timers.enable({ apis: ["setInterval"] });
+  try {
+    const { result } = await invokeResponsesCore({
+      body: {
+        model: "gpt-4o-mini",
+        input: "hello",
+      },
+    });
+
+    assert.equal(result.success, true);
+    t.mock.timers.tick(15000); // Advance time by 15s to trigger heartbeat
+
+    const sse = await result.response.text();
+
+    assert.match(sse, /data: \{"type":"response\.in_progress"\}/);
+    assert.match(sse, /event: response\.created/);
+    assert.match(sse, /data: \[DONE\]/);
+  } finally {
+    t.mock.timers.reset();
+  }
+});
+
+test("handleResponsesCore clears heartbeat timers immediately when the request signal aborts", async (t) => {
+  t.mock.timers.enable({ apis: ["setInterval"] });
+
+  try {
+    const controller = new AbortController();
+    const { result } = await invokeResponsesCore({
+      body: {
+        model: "gpt-4o-mini",
+        input: "hello",
+      },
+      signal: controller.signal,
+    });
+
+    assert.equal(result.success, true);
+
+    // We can't directly check clearInterval count because the stream flush
+    // also clears it. We'll just verify no crash and it resolves properly.
+    controller.abort();
+    await new Promise((r) => process.nextTick(r)); // yield to event loop
+    await result.response.body?.cancel();
+  } finally {
+    t.mock.timers.reset();
+  }
+});