offrouter-core 0.2.0 → 0.2.2

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

@@ -1,290 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DelegationRuntime } from "../delegation.js";
-import {
-  buildDelegationRequest,
-  buildRouteRequest,
-  createResponsesProxyContext,
-  extractPromptFromChatCompletions,
-  extractPromptFromResponsesInput,
-  openAiErrorPayload,
-  policyDecisionToHttpStatus,
-  promptDigest,
-  promptPreview,
-  providerErrorCodeToHttpStatus,
-  RESPONSES_PROMPT_PREVIEW_CHARS,
-  ResponsesSseBuilder,
-  responsesSseData,
-} from "./responses-mapper.js";
-import type { ProviderCandidate, RouteDecision } from "../types.js";
-
-function candidate(
-  partial: Partial<ProviderCandidate> &
-    Pick<ProviderCandidate, "providerId" | "modelId" | "authTier">,
-): ProviderCandidate {
-  return {
-    authScope: "third-party",
-    health: "healthy",
-    supportsTools: true,
-    supportsStreaming: true,
-    supportsJson: true,
-    supportsImages: false,
-    estimatedCostUsd: 0.01,
-    ...partial,
-  };
-}
-
-const harness = { kind: "other" as const, profile: "proxy" };
-const workspace = { cwd: "/tmp/project", trusted: true };
-
-describe("extractPromptFromResponsesInput", () => {
-  it("reads a plain string input", () => {
-    const parsed = extractPromptFromResponsesInput({
-      model: "gpt-test",
-      input: "explain this code",
-    });
-    expect(parsed.prompt).toBe("explain this code");
-    expect(parsed.model).toBe("gpt-test");
-  });
-
-  it("reads structured input items with content arrays", () => {
-    const parsed = extractPromptFromResponsesInput({
-      input: [
-        {
-          role: "user",
-          content: [
-            { type: "input_text", text: "hello " },
-            { type: "input_text", text: "world" },
-          ],
-        },
-      ],
-    });
-    expect(parsed.prompt).toBe("hello world");
-  });
-
-  it("merges instructions and input", () => {
-    const parsed = extractPromptFromResponsesInput({
-      instructions: "be terse",
-      input: "do the thing",
-    });
-    expect(parsed.prompt).toBe("be terse\n\ndo the thing");
-  });
-
-  it("maps output token and temperature fields", () => {
-    const parsed = extractPromptFromResponsesInput({
-      input: "x",
-      max_output_tokens: 128,
-      temperature: 0.3,
-      stream: true,
-    });
-    expect(parsed.maxOutputTokens).toBe(128);
-    expect(parsed.temperature).toBe(0.3);
-    expect(parsed.stream).toBe(true);
-  });
-
-  it("returns empty prompt for an empty object", () => {
-    expect(extractPromptFromResponsesInput({}).prompt).toBe("");
-  });
-
-  it("rejects non-object bodies with a schema error", () => {
-    expect(() => extractPromptFromResponsesInput(null)).toThrow();
-    expect(() => extractPromptFromResponsesInput("not an object")).toThrow();
-  });
-
-  it("strips unknown top-level keys for OpenAI-compat interop", () => {
-    // Unknown keys (bogus, tools, store, metadata) are stripped, not rejected.
-    expect(() =>
-      extractPromptFromResponsesInput({ input: "x", bogus: true, tools: [] }),
-    ).not.toThrow();
-    expect(() =>
-      extractPromptFromChatCompletions({
-        messages: [],
-        tools: [],
-      }),
-    ).not.toThrow();
-    // But structurally invalid values still throw.
-    expect(() =>
-      extractPromptFromResponsesInput({
-        input: "x",
-        max_output_tokens: "lots",
-      }),
-    ).toThrow();
-  });
-});
-
-describe("prompt digest and preview", () => {
-  it("produces a stable sha256 digest", () => {
-    expect(promptDigest("hello")).toBe(
-      "sha256:2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
-    );
-  });
-
-  it("keeps short previews intact", () => {
-    expect(promptPreview("short", 20)).toBe("short");
-  });
-
-  it("truncates long previews with an ASCII ellipsis", () => {
-    const long = "a".repeat(500);
-    const preview = promptPreview(long, 20);
-    expect(preview.length).toBeLessThanOrEqual(20);
-    expect(preview.endsWith("...")).toBe(true);
-    // ASCII-only: every code point is below 128.
-    expect([...preview].every((ch) => (ch.codePointAt(0) ?? 0) < 128)).toBe(
-      true,
-    );
-  });
-});
-
-describe("buildRouteRequest", () => {
-  it("carries preview and digest but never the raw prompt", () => {
-    // Put a secret marker past the preview cutoff so truncation strips it.
-    const secret = "SUPERSECRETTOKEN-DO-NOT-LEAK-123";
-    const prompt = `${"x".repeat(RESPONSES_PROMPT_PREVIEW_CHARS + 40)} ${secret}`;
-    const route = buildRouteRequest({ prompt, harness, workspace });
-    expect(route.task.promptDigest).toBe(promptDigest(prompt));
-    expect(route.task.promptPreview.endsWith("...")).toBe(true);
-    expect(route.task.promptPreview).not.toContain(secret);
-    expect(JSON.stringify(route)).not.toContain(secret);
-    expect(route.task.requiresStreaming).toBe(true);
-    expect(route.protocolVersion).toBe("offrouter.route.v1");
-  });
-
-  it("honours an explicit request id", () => {
-    const route = buildRouteRequest({
-      prompt: "x",
-      harness,
-      workspace,
-      requestId: "req_explicit",
-    });
-    expect(route.requestId).toBe("req_explicit");
-  });
-});
-
-describe("buildDelegationRequest", () => {
-  it("carries the full prompt and stream mode", () => {
-    const route = buildRouteRequest({ prompt: "x", harness, workspace });
-    const del = buildDelegationRequest({
-      prompt: "FULL SECRET PROMPT",
-      route,
-      maxOutputTokens: 7,
-      temperature: 0.5,
-    });
-    expect(del.prompt).toBe("FULL SECRET PROMPT");
-    expect(del.mode).toBe("stream");
-    expect(del.maxOutputTokens).toBe(7);
-    expect(del.temperature).toBe(0.5);
-    expect(del.route).toBe(route);
-  });
-});
-
-describe("ResponsesSseBuilder", () => {
-  it("emits created, delta, and completed events in OpenAI shape", () => {
-    const now = () => new Date("2025-01-01T00:00:00Z");
-    const builder = new ResponsesSseBuilder("fake-coder", now);
-    const created = builder.createdEvent();
-    expect(created.type).toBe("response.created");
-    expect(created.response.id).toBe(builder.responseId);
-    expect(created.response.object).toBe("response");
-    expect(created.response.status).toBe("in_progress");
-    expect(created.response.model).toBe("fake-coder");
-
-    builder.addText("hello ");
-    builder.addText("world");
-    const delta = builder.deltaEvent("hello ");
-    expect(delta.type).toBe("response.output_text.delta");
-    expect(delta.delta).toBe("hello ");
-    expect(delta.item_id).toBe(builder.messageId);
-
-    const completed = builder.completedEvent();
-    expect(completed.type).toBe("response.completed");
-    expect(completed.response.status).toBe("completed");
-    expect(completed.response.output_text).toBe("hello world");
-    const msg = completed.response.output[0];
-    expect(msg?.type).toBe("message");
-    expect(msg?.content[0]?.text).toBe("hello world");
-  });
-
-  it("includes usage in completed when set", () => {
-    const builder = new ResponsesSseBuilder("m", () => new Date(0));
-    builder.setUsage({ inputTokens: 3, outputTokens: 4, totalTokens: 7 });
-    const completed = builder.completedEvent();
-    expect(completed.response.usage?.total_tokens).toBe(7);
-  });
-});
-
-describe("responsesSseData", () => {
-  it("wraps a payload as an SSE data line", () => {
-    expect(responsesSseData({ type: "x" })).toBe(`data: {"type":"x"}\n\n`);
-  });
-});
-
-describe("error mapping", () => {
-  it("maps provider error codes to HTTP statuses", () => {
-    expect(providerErrorCodeToHttpStatus("auth_failed")).toBe(401);
-    expect(providerErrorCodeToHttpStatus("rate_limited")).toBe(429);
-    expect(providerErrorCodeToHttpStatus("quota_exhausted")).toBe(429);
-    expect(providerErrorCodeToHttpStatus("billing")).toBe(402);
-    expect(providerErrorCodeToHttpStatus("model_not_found")).toBe(404);
-    expect(providerErrorCodeToHttpStatus("overload")).toBe(503);
-    expect(providerErrorCodeToHttpStatus("timeout")).toBe(504);
-    expect(providerErrorCodeToHttpStatus("network")).toBe(502);
-    expect(providerErrorCodeToHttpStatus("invalid_request")).toBe(400);
-    expect(providerErrorCodeToHttpStatus("unknown")).toBe(500);
-  });
-
-  it("builds an OpenAI-style error payload", () => {
-    const payload = openAiErrorPayload(429, "slow down", "rate_limited");
-    expect(payload.error.message).toBe("slow down");
-    expect(payload.error.type).toBe("rate_limit_error");
-    expect(payload.error.code).toBe("rate_limited");
-  });
-
-  it("maps a blocked policy decision to 403", () => {
-    const decision: RouteDecision = {
-      protocolVersion: "offrouter.route.v1",
-      decisionId: "d1",
-      requestId: "r1",
-      route: null,
-      reason: "policy_blocked",
-      explanation: "denied",
-      blocked: true,
-      needsConfiguration: false,
-    };
-    expect(policyDecisionToHttpStatus(decision)).toBe(403);
-  });
-
-  it("maps a needs-configuration decision to 503", () => {
-    const decision: RouteDecision = {
-      protocolVersion: "offrouter.route.v1",
-      decisionId: "d1",
-      requestId: "r1",
-      route: null,
-      reason: "no_candidate_needs_configuration",
-      explanation: "configure providers",
-      blocked: true,
-      needsConfiguration: true,
-    };
-    expect(policyDecisionToHttpStatus(decision)).toBe(503);
-  });
-});
-
-describe("createResponsesProxyContext", () => {
-  it("builds a runtime-backed context mirroring the MCP context shape", () => {
-    const ctx = createResponsesProxyContext({
-      policy: {
-        allowlistedProfiles: ["proxy"],
-        deniedProfilePatterns: ["*-work"],
-      },
-      candidates: [
-        candidate({
-          providerId: "fake",
-          modelId: "fake-coder",
-          authTier: "api-key",
-        }),
-      ],
-      adapters: {},
-    });
-    expect(ctx.runtime).toBeInstanceOf(DelegationRuntime);
-    expect(ctx.candidates).toHaveLength(1);
-    expect(ctx.policy.allowlistedProfiles).toContain("proxy");
-  });
-});