Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

9.6 KB
Raw Blame
import test from "node:test";
import assert from "node:assert/strict";

const { toJsonErrorPayload } = await import("../../src/shared/utils/upstreamError.ts");
const { createErrorResponse, createErrorResponseFromUnknown } =
  await import("../../src/lib/api/errorResponse.ts");
const { getAccountDisplayName, getProviderDisplayName } =
  await import("../../src/lib/display/names.ts");
const { resolveProviderName } = await import("../../src/lib/display/useProviderNodeMap.ts");

// #15159 wave 1.1 INVERTED — do not restore.
//
// This test used to be:
//   assert.deepEqual(toJsonErrorPayload(payload), payload)
// i.e. it asserted a FULL-OBJECT PASSTHROUGH. That passthrough was the bug, not
// the contract: `toJsonErrorPayload` has 21 call sites across 13 production
// files that each serialize its return value straight into an HTTP response
// body, so returning the upstream object verbatim let the provider put ANY
// field it liked into the client-visible payload. Proven with
// `{"error":{"message":"boom at /srv/app/dist/client.js:44:12
// api_key=sk-live-SECRET123","token":"sk-live-XYZ","internal_path":"/srv/app/internal"}}`
// — key, server path and both unrelated fields came back intact.
//
// The helper now builds the `error` record from an explicit allow-list
// (message/type/code/param/reason/status) and sanitizes every string through
// `sanitizeErrorMessage`. The full regression guard — including proof that
// sibling fields are dropped and credentials are redacted — lives in
// tests/unit/upstream-error-payload-sanitization.test.ts.
test("toJsonErrorPayload: keeps the allow-listed fields of an upstream error payload", () => {
  assert.deepEqual(
    toJsonErrorPayload({
      error: {
        message: "provider exploded",
        code: "quota_exceeded",
      },
    }),
    {
      error: {
        message: "provider exploded",
        type: "upstream_error",
        code: "quota_exceeded",
      },
    }
  );
});

test("toJsonErrorPayload: normalizes object payloads with string error", () => {
  assert.deepEqual(toJsonErrorPayload({ error: "plain provider error" }), {
    error: {
      message: "plain provider error",
      type: "upstream_error",
      code: "upstream_error",
    },
  });
});

test("toJsonErrorPayload: wraps plain objects under error key", () => {
  assert.deepEqual(toJsonErrorPayload({ status: 503, message: "backend down" }), {
    error: {
      message: "backend down",
      type: "upstream_error",
      code: "upstream_error",
      status: 503,
    },
  });
});

test("toJsonErrorPayload: extracts provider errors arrays into message strings", () => {
  assert.deepEqual(
    toJsonErrorPayload({
      errors: ["content-type must be multipart/form-data"],
      name: "bad request",
    }),
    {
      error: {
        message: "content-type must be multipart/form-data",
        type: "upstream_error",
        code: "upstream_error",
        details: {
          errors: ["content-type must be multipart/form-data"],
          name: "bad request",
        },
      },
    }
  );
});

test("toJsonErrorPayload: normalizes object entries in provider errors arrays", () => {
  assert.deepEqual(
    toJsonErrorPayload({
      errors: [
        { message: "first provider error" },
        { detail: "second provider error" },
        { code: "invalid_request", field: "prompt" },
      ],
      name: "bad request",
    }),
    {
      error: {
        message:
          'first provider error, second provider error, {"code":"invalid_request","field":"prompt"}',
        type: "upstream_error",
        code: "upstream_error",
        details: {
          errors: [
            { message: "first provider error" },
            { detail: "second provider error" },
            { code: "invalid_request", field: "prompt" },
          ],
          name: "bad request",
        },
      },
    }
  );
});

test("toJsonErrorPayload: parses JSON strings recursively", () => {
  const raw = JSON.stringify({ error: { message: "nested json", code: "bad_request" } });
  assert.deepEqual(toJsonErrorPayload(raw), {
    error: {
      message: "nested json",
      type: "upstream_error",
      code: "bad_request",
    },
  });
});

test("toJsonErrorPayload: falls back for blank strings and unsupported values", () => {
  const fallback = {
    error: {
      message: "custom fallback",
      type: "upstream_error",
      code: "upstream_error",
    },
  };

  assert.deepEqual(toJsonErrorPayload("   ", "custom fallback"), fallback);
  assert.deepEqual(toJsonErrorPayload(null, "custom fallback"), fallback);
});

test("toJsonErrorPayload: converts non-JSON strings into normalized error payloads", () => {
  assert.deepEqual(toJsonErrorPayload("gateway timeout"), {
    error: {
      message: "gateway timeout",
      type: "upstream_error",
      code: "upstream_error",
    },
  });
});

test("createErrorResponse: infers error types from status and preserves details", async () => {
  const response = createErrorResponse({
    status: 409,
    message: "Conflict detected",
    details: { field: "name" },
  });
  const body = (await response.json()) as any;

  assert.equal(response.status, 409);
  assert.equal(body.error.message, "Conflict detected");
  assert.equal(body.error.type, "conflict");
  assert.deepEqual(body.error.details, { field: "name" });
  assert.match(body.requestId, /^[0-9a-f-]{36}$/i);
});

test("createErrorResponse: uses explicit type when provided", async () => {
  const response = createErrorResponse({
    status: 418,
    message: "teapot",
    type: "not_found",
  });
  const body = (await response.json()) as any;

  assert.equal(body.error.type, "not_found");
});

test("createErrorResponseFromUnknown: normalizes typed errors", async () => {
  const response = createErrorResponseFromUnknown({
    message: "db exploded",
    status: 503,
    type: "server_error",
    details: { retryable: true },
  });
  const body = (await response.json()) as any;

  assert.equal(response.status, 503);
  assert.equal(body.error.message, "db exploded");
  assert.equal(body.error.type, "server_error");
  assert.deepEqual(body.error.details, { retryable: true });
});

test("createErrorResponseFromUnknown: falls back for non-object errors", async () => {
  const response = createErrorResponseFromUnknown("boom", "fallback message");
  const body = (await response.json()) as any;

  assert.equal(response.status, 500);
  assert.equal(body.error.message, "fallback message");
  assert.equal(body.error.type, "server_error");
});

test("getAccountDisplayName: respects priority order and fallback", () => {
  assert.equal(
    getAccountDisplayName({
      id: "abcdef123456",
      name: "Primary Name",
      displayName: "Display Name",
      email: "[email protected]",
    }),
    "Primary Name"
  );
  assert.equal(
    getAccountDisplayName({
      id: "abcdef123456",
      name: "   ",
      displayName: "Display Name",
      email: "[email protected]",
    }),
    "Display Name"
  );
  assert.equal(
    getAccountDisplayName({
      id: "abcdef123456",
      name: null,
      displayName: " ",
      email: "[email protected]",
    }),
    "[email protected]"
  );
  assert.equal(getAccountDisplayName({ id: "abcdef123456" }), "Account #abcdef");
  assert.equal(getAccountDisplayName(null), "Unknown Account");
});

test("resolveProviderName: returns user-given name from nodeMap for custom provider", () => {
  const nodeMap = new Map([
    ["openai-compatible-chat-abc123", { name: "My LLM", prefix: "my-llm" }],
  ]);
  assert.equal(
    resolveProviderName("openai-compatible-chat-abc123", nodeMap),
    "My LLM",
    "should return the user-given name when present in the map"
  );
  // Falls back to prefix when name is blank
  const mapNoName = new Map([
    ["openai-compatible-chat-abc123", { name: null, prefix: "my-prefix" }],
  ]);
  assert.equal(resolveProviderName("openai-compatible-chat-abc123", mapNoName), "my-prefix");
  // Falls back to de-UUIDed label when no node entry exists
  assert.equal(
    resolveProviderName("openai-compatible-chat-02669115-2545-4896-b003-cb4dac09d441", new Map()),
    "Compatible (openai)"
  );
  // Falls back gracefully for unknown ids not in the map
  assert.equal(resolveProviderName("plain-provider", nodeMap), "plain-provider");
  // Handles null/undefined id
  assert.equal(resolveProviderName(null, nodeMap), "Unknown Provider");
  assert.equal(resolveProviderName(undefined, null), "Unknown Provider");
});

test("getProviderDisplayName: prefers node metadata and simplifies compatible IDs", () => {
  assert.equal(
    getProviderDisplayName("openai-compatible-chat-02669115-2545-4896-b003-cb4dac09d441", {
      name: "Friendly Node",
      prefix: "ignored-prefix",
    }),
    "Friendly Node"
  );
  assert.equal(
    getProviderDisplayName("anthropic-compatible-02669115-2545-4896-b003-cb4dac09d441", {
      name: " ",
      prefix: "Anthropic Prefix",
    }),
    "Anthropic Prefix"
  );
  assert.equal(
    getProviderDisplayName("openai-compatible-chat-02669115-2545-4896-b003-cb4dac09d441"),
    "Compatible (openai)"
  );
  assert.equal(
    getProviderDisplayName("openai-compatible-responses-02669115-2545-4896-b003-cb4dac09d441"),
    "Compatible (openai)"
  );
  // Segment-less anthropic-compatible ids (the actual generated shape, #8326) now
  // resolve to a friendly label too, instead of falling through to the raw ID.
  assert.equal(
    getProviderDisplayName("anthropic-compatible-02669115-2545-4896-b003-cb4dac09d441"),
    "Compatible (anthropic)"
  );
  assert.equal(
    getProviderDisplayName("anthropic-compatible-cc-02669115-2545-4896-b003-cb4dac09d441"),
    "CC Compatible"
  );
  assert.equal(getProviderDisplayName(undefined), "Unknown Provider");
  assert.equal(getProviderDisplayName("plain-provider-id"), "plain-provider-id");
});