offrouter-core 0.2.1 → 0.2.2

package/src/proxy/responses-server.test.ts

@@ -1,322 +0,0 @@
-import http from "node:http";
-import { afterEach, describe, expect, it } from "vitest";
-import { InMemoryAuditStore } from "../audit.js";
-import { ProviderError } from "../providers/adapter.js";
-import { createFakeProvider } from "../providers/fake.js";
-import {
-  createResponsesProxyContext,
-  type ResponsesProxyContext,
-} from "./responses-mapper.js";
-import {
-  startResponsesProxy,
-  type ResponsesProxyHandle,
-} from "./responses-server.js";
-import type { PolicyConfig, ProviderCandidate } from "../types.js";
-
-const POLICY: PolicyConfig = {
-  allowlistedProfiles: ["proxy"],
-  deniedProfilePatterns: ["*-work"],
-};
-
-function fakeCandidate(): ProviderCandidate {
-  return {
-    providerId: "fake",
-    modelId: "fake-coder",
-    authTier: "api-key",
-    authScope: "third-party",
-    health: "healthy",
-    supportsTools: true,
-    supportsStreaming: true,
-    supportsJson: true,
-    supportsImages: false,
-    estimatedCostUsd: 0.01,
-  };
-}
-
-function makeContext(
-  adapter = createFakeProvider({ id: "fake" }),
-): ResponsesProxyContext {
-  return createResponsesProxyContext({
-    policy: POLICY,
-    candidates: [fakeCandidate()],
-    adapters: { fake: adapter },
-    delegation: { audit: new InMemoryAuditStore() },
-  });
-}
-
-interface PostResult {
-  status: number;
-  headers: http.IncomingHttpHeaders;
-  text: string;
-}
-
-function post(
-  handle: ResponsesProxyHandle,
-  path: string,
-  body: unknown,
-  options: { token?: string } = {},
-): Promise<PostResult> {
-  return new Promise((resolve, reject) => {
-    const req = http.request(
-      {
-        host: "127.0.0.1",
-        port: handle.port,
-        path,
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          ...(options.token
-            ? { authorization: `Bearer ${options.token}` }
-            : {}),
-        },
-      },
-      (res) => {
-        const chunks: Buffer[] = [];
-        res.on("data", (c: Buffer) => chunks.push(c));
-        res.on("end", () =>
-          resolve({
-            status: res.statusCode ?? 0,
-            headers: res.headers,
-            text: Buffer.concat(chunks).toString("utf8"),
-          }),
-        );
-      },
-    );
-    req.on("error", reject);
-    req.end(JSON.stringify(body));
-  });
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-const handles: ResponsesProxyHandle[] = [];
-afterEach(async () => {
-  while (handles.length > 0) {
-    const h = handles.pop();
-    if (h) await h.close();
-  }
-});
-
-async function start(
-  context: ResponsesProxyContext,
-  options: Parameters<typeof startResponsesProxy>[1] = {},
-): Promise<ResponsesProxyHandle> {
-  const handle = await startResponsesProxy(context, {
-    port: 0,
-    harness: { kind: "other", profile: "proxy" },
-    workspace: { cwd: "/tmp/project", trusted: true },
-    ...options,
-  });
-  handles.push(handle);
-  return handle;
-}
-
-describe("responses proxy", () => {
-  it("streams a successful Responses SSE sequence", async () => {
-    const adapter = createFakeProvider({
-      id: "fake",
-      streamChunks: ["hello ", "world"],
-    });
-    const handle = await start(makeContext(adapter));
-
-    const res = await post(handle, "/v1/responses", {
-      input: "hi",
-      stream: true,
-    });
-    expect(res.status).toBe(200);
-    expect(res.headers["content-type"]).toContain("text/event-stream");
-    expect(res.text).toContain("response.created");
-    expect(res.text).toContain("response.output_text.delta");
-    expect(res.text).toContain("response.completed");
-    expect(res.text).toContain("hello ");
-    expect(res.text).toContain('"output_text":"hello world"');
-  });
-
-  it("returns 403 for a denied work profile", async () => {
-    const handle = await start(makeContext(), {
-      harness: { kind: "other", profile: "claude-work" },
-    });
-    const res = await post(handle, "/v1/responses", { input: "hi" });
-    expect(res.status).toBe(403);
-    const json = JSON.parse(res.text) as { error: { message: string } };
-    expect(json.error.message).toMatch(/denied/i);
-  });
-
-  it("returns 503 when no provider is configured", async () => {
-    const context = createResponsesProxyContext({
-      policy: POLICY,
-      candidates: [],
-      adapters: {},
-      delegation: { audit: new InMemoryAuditStore() },
-    });
-    const handle = await start(context);
-    const res = await post(handle, "/v1/responses", { input: "hi" });
-    expect(res.status).toBe(503);
-    const json = JSON.parse(res.text) as { error: { message: string } };
-    expect(json.error).toBeDefined();
-  });
-
-  it("maps a provider error to an HTTP status before streaming starts", async () => {
-    const adapter = createFakeProvider({
-      id: "fake",
-      error: new ProviderError({
-        code: "rate_limited",
-        message: "slow down",
-        retryable: true,
-        httpStatus: 429,
-      }),
-    });
-    const handle = await start(makeContext(adapter));
-    const res = await post(handle, "/v1/responses", { input: "hi" });
-    expect(res.status).toBe(429);
-    const json = JSON.parse(res.text) as {
-      error: { message: string; type: string };
-    };
-    expect(json.error.message).toContain("slow down");
-    expect(json.error.type).toBe("rate_limit_error");
-  });
-
-  it("cancels the provider call when the client disconnects", async () => {
-    const adapter = createFakeProvider({
-      id: "fake",
-      hangUntilCancel: true,
-    });
-    const context = makeContext(adapter);
-    const handle = await start(context);
-
-    const req = http.request({
-      host: "127.0.0.1",
-      port: handle.port,
-      path: "/v1/responses",
-      method: "POST",
-      headers: { "content-type": "application/json" },
-    });
-    req.on("error", () => undefined);
-    req.end(JSON.stringify({ input: "hang please" }));
-    await sleep(60);
-    req.destroy();
-
-    let cancelled = false;
-    for (let i = 0; i < 150; i++) {
-      await sleep(20);
-      if (context.runtime.listTasks().some((t) => t.status === "cancelled")) {
-        cancelled = true;
-        break;
-      }
-    }
-    expect(cancelled).toBe(true);
-  });
-
-  it("enforces a bearer auth token", async () => {
-    const handle = await start(makeContext(), { token: "sekret" });
-
-    const noToken = await post(handle, "/v1/responses", { input: "hi" });
-    expect(noToken.status).toBe(401);
-
-    const wrong = await post(
-      handle,
-      "/v1/responses",
-      { input: "hi" },
-      { token: "nope" },
-    );
-    expect(wrong.status).toBe(401);
-
-    const ok = await post(
-      handle,
-      "/v1/responses",
-      { input: "hi" },
-      { token: "sekret" },
-    );
-    expect(ok.status).toBe(200);
-    expect(ok.text).toContain("response.completed");
-  });
-
-  it("rejects unknown paths with 404", async () => {
-    const handle = await start(makeContext());
-    const res = await post(handle, "/v1/unknown", { input: "hi" });
-    expect(res.status).toBe(404);
-  });
-
-  it("accepts the chat/completions alias and streams delta chunks", async () => {
-    const adapter = createFakeProvider({
-      id: "fake",
-      streamChunks: ["alpha", "beta"],
-    });
-    const handle = await start(makeContext(adapter));
-    const res = await post(handle, "/v1/chat/completions", {
-      messages: [{ role: "user", content: "hi" }],
-      stream: true,
-    });
-    expect(res.status).toBe(200);
-    expect(res.text).toContain("chat.completion.chunk");
-    expect(res.text).toContain("alpha");
-    expect(res.text).toContain('"finish_reason":"stop"');
-    expect(res.text).toContain("[DONE]");
-  });
-
-  it("returns a single JSON response object when stream is false", async () => {
-    const adapter = createFakeProvider({
-      id: "fake",
-      streamChunks: ["hello ", "world"],
-    });
-    const handle = await start(makeContext(adapter));
-    const res = await post(handle, "/v1/responses", {
-      input: "hi",
-      stream: false,
-    });
-    expect(res.status).toBe(200);
-    expect(res.headers["content-type"]).toContain("application/json");
-    expect(res.headers["content-type"]).not.toContain("text/event-stream");
-    // No SSE framing.
-    expect(res.text).not.toContain("data: ");
-    expect(res.text).not.toContain("response.created");
-    const json = JSON.parse(res.text);
-    expect(json.object).toBe("response");
-    expect(json.status).toBe("completed");
-    expect(json.output_text).toBe("hello world");
-    const msg = json.output[0];
-    expect(msg?.content[0]?.text).toBe("hello world");
-  });
-
-  it("returns a single chat completion JSON object when stream is false", async () => {
-    const adapter = createFakeProvider({
-      id: "fake",
-      streamChunks: ["alpha", "beta"],
-    });
-    const handle = await start(makeContext(adapter));
-    const res = await post(handle, "/v1/chat/completions", {
-      messages: [{ role: "user", content: "hi" }],
-      stream: false,
-    });
-    expect(res.status).toBe(200);
-    expect(res.headers["content-type"]).toContain("application/json");
-    expect(res.text).not.toContain("[DONE]");
-    const json = JSON.parse(res.text);
-    expect(json.object).toBe("chat.completion");
-    expect(json.choices[0].message.role).toBe("assistant");
-    expect(json.choices[0].message.content).toBe("alphabeta");
-    expect(json.choices[0].finish_reason).toBe("stop");
-  });
-
-  it("returns a 400 OpenAI-style error for an invalid request body", async () => {
-    const handle = await start(makeContext());
-    // Unknown top-level keys are stripped (OpenAI-compat interop), not rejected.
-    const unknownKey = await post(handle, "/v1/responses", {
-      input: "hi",
-      bogus: true,
-      tools: [],
-      store: false,
-    });
-    expect(unknownKey.status).toBe(200);
-
-    const badType = await post(handle, "/v1/responses", {
-      input: "hi",
-      max_output_tokens: "lots",
-    });
-    expect(badType.status).toBe(400);
-    const json2 = JSON.parse(badType.text);
-    expect(json2.error.type).toBe("invalid_request_error");
-  });
-});