Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

8.5 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import {
  CustomEndpointComplexSchema,
  CustomEndpointSchema,
  CustomEndpointSimpleSchema,
} from "./config-schema.js";

function invalidCustomEndpointMessage(input: unknown): string {
  const result = CustomEndpointSchema.safeParse(input);
  expect(result.success).toBe(false);
  if (result.success) return "";
  return result.error.issues.map((issue) => issue.message).join(" ");
}

describe("CustomEndpointSimpleSchema", () => {
  test("accepts a valid simple endpoint and round-trips through CustomEndpointSchema", () => {
    const input = {
      kind: "simple" as const,
      url: "https://api.example.com/v1",
      format: "openai" as const,
      apiKey: "sk-test-1234",
      modelPrefix: "example/",
      models: ["model-a", "model-b"],
    };

    const parsed = CustomEndpointSchema.parse(input);
    expect(parsed).toEqual(input);
  });

  test("accepts minimal simple endpoint without optional fields", () => {
    const input = {
      kind: "simple" as const,
      url: "https://api.example.com",
      format: "anthropic" as const,
      apiKey: "key",
    };

    const parsed = CustomEndpointSimpleSchema.parse(input);
    expect(parsed.kind).toBe("simple");
    expect(parsed.modelPrefix).toBeUndefined();
    expect(parsed.models).toBeUndefined();
  });

  test('accepts authScheme "none" without an apiKey', () => {
    const input = {
      kind: "simple" as const,
      url: "https://keyless.example.com/v1",
      format: "openai" as const,
      authScheme: "none" as const,
    };

    expect(CustomEndpointSimpleSchema.parse(input)).toEqual(input);
  });

  test("rejects a non-URL `url`", () => {
    expect(() =>
      CustomEndpointSimpleSchema.parse({
        kind: "simple",
        url: "not-a-url",
        format: "openai",
        apiKey: "sk",
      })
    ).toThrow();
  });

  test('rejects an empty apiKey unless authScheme is "none", with an actionable message', () => {
    const message = invalidCustomEndpointMessage({
      kind: "simple",
      url: "https://api.example.com",
      format: "openai",
      apiKey: "",
    });

    expect(message).toContain("authScheme");
    expect(message).toContain("none");
    expect(message).not.toContain("Too small");
  });

  test('rejects an omitted apiKey unless authScheme is "none", with the same guidance', () => {
    const message = invalidCustomEndpointMessage({
      kind: "simple",
      url: "https://api.example.com",
      format: "openai",
    });

    expect(message).toContain("authScheme");
    expect(message).toContain("none");
  });

  test('rejects a non-empty apiKey when authScheme is "none"', () => {
    const message = invalidCustomEndpointMessage({
      kind: "simple",
      url: "https://api.example.com",
      format: "openai",
      authScheme: "none",
      apiKey: "should-not-be-sent",
    });

    expect(message).toContain("Remove apiKey");
  });

  test('treats a whitespace-only apiKey as empty when authScheme is "none"', () => {
    const input = {
      kind: "simple" as const,
      url: "https://api.example.com",
      format: "openai" as const,
      authScheme: "none" as const,
      apiKey: "   ",
    };

    expect(CustomEndpointSimpleSchema.parse(input)).toEqual(input);
  });
});

describe("CustomEndpointComplexSchema", () => {
  test("accepts a valid complex endpoint and round-trips through CustomEndpointSchema", () => {
    const input = {
      kind: "complex" as const,
      displayName: "My vLLM",
      transport: "openai" as const,
      baseUrl: "https://vllm.example.com",
      apiPath: "/v1/chat/completions",
      apiKey: "key-xyz",
      authScheme: "bearer" as const,
      headers: { "X-Custom": "value" },
      streamFormat: "openai-sse" as const,
      modelPrefix: "vllm/",
      models: ["llama-3"],
    };

    const parsed = CustomEndpointSchema.parse(input);
    expect(parsed).toEqual(input);
  });

  test("accepts minimal complex endpoint with only required fields", () => {
    const input = {
      kind: "complex" as const,
      displayName: "Minimal",
      transport: "openai" as const,
      baseUrl: "https://example.com",
      apiKey: "k",
    };

    const parsed = CustomEndpointComplexSchema.parse(input);
    expect(parsed.displayName).toBe("Minimal");
    expect(parsed.headers).toBeUndefined();
    expect(parsed.streamFormat).toBeUndefined();
  });

  test('accepts authScheme "none" without an apiKey', () => {
    const input = {
      kind: "complex" as const,
      displayName: "Keyless Gateway",
      transport: "anthropic" as const,
      baseUrl: "https://keyless.example.com",
      authScheme: "none" as const,
    };

    expect(CustomEndpointComplexSchema.parse(input)).toEqual(input);
  });

  test('rejects an omitted apiKey unless authScheme is "none"', () => {
    const message = invalidCustomEndpointMessage({
      kind: "complex",
      displayName: "Missing Credential Declaration",
      transport: "openai",
      baseUrl: "https://api.example.com",
    });

    expect(message).toContain("authScheme");
    expect(message).toContain("none");
  });

  test.each(["bearer", "x-api-key"] as const)(
    "continues to accept %s authentication with a real key",
    (authScheme) => {
      const input = {
        kind: "complex" as const,
        displayName: "Authenticated Gateway",
        transport: "openai" as const,
        baseUrl: "https://authenticated.example.com",
        authScheme,
        apiKey: "real-test-key",
      };

      expect(CustomEndpointComplexSchema.parse(input)).toEqual(input);
    }
  );
});

describe("CustomEndpointSchema (discriminated union)", () => {
  test("rejects an object missing the `kind` field", () => {
    expect(() =>
      CustomEndpointSchema.parse({
        url: "https://api.example.com",
        format: "openai",
        apiKey: "sk",
      })
    ).toThrow();
  });
});

describe("custom endpoint declared wire", () => {
  const wire = {
    tokenParam: "max_tokens",
    reasoning: {
      enable: [{ path: "/chat_template_kwargs/enable_thinking", value: true }],
      disable: [{ path: "/chat_template_kwargs/enable_thinking", value: false }],
      effort: {
        path: "/reasoning_effort",
        values: { low: "small", high: "large" },
        default: "low",
      },
    },
  };
  for (const kind of ["simple", "complex"] as const) {
    const endpoint = (transport: string, declared: unknown): unknown =>
      kind === "simple"
        ? {
            kind,
            url: "https://example.invalid/v1",
            format: transport,
            apiKey: "fake",
            wire: declared,
          }
        : {
            kind,
            displayName: "Test",
            baseUrl: "https://example.invalid",
            transport,
            apiKey: "fake",
            wire: declared,
          };
    test.each(["chat-completions", "responses"])(`${kind} openai accepts %s`, (api) => {
      const input = endpoint("openai", { ...wire, api });
      expect(input).toEqual(CustomEndpointSchema.parse(input));
    });
    test(`${kind} anthropic accepts Messages and none`, () => {
      const input = endpoint("anthropic", { api: "anthropic-messages", tokenParam: "none" });
      expect(input).toEqual(CustomEndpointSchema.parse(input));
    });
    test(`${kind} rejects an API incompatible with its transport`, () => {
      expect(
        CustomEndpointSchema.safeParse(endpoint("openai", { api: "anthropic-messages" })).success
      ).toBe(false);
      expect(
        CustomEndpointSchema.safeParse(endpoint("anthropic", { api: "responses" })).success
      ).toBe(false);
      if (kind === "complex") {
        expect(
          CustomEndpointSchema.safeParse(endpoint("litellm", { api: "responses" })).success
        ).toBe(false);
        expect(
          CustomEndpointSchema.safeParse(endpoint("litellm", { api: "chat-completions" })).success
        ).toBe(true);
      }
    });
    test.each(["enable", "disable", "effort"])(
      `${kind} %s pointer requires a leading slash`,
      (field) => {
        const value =
          field === "effort" ? { path: "reasoning_effort" } : [{ path: "thinking", value: true }];
        expect(
          CustomEndpointSchema.safeParse(endpoint("openai", { reasoning: { [field]: value } }))
            .success
        ).toBe(false);
      }
    );
    test(`${kind} accepts empty wire and identity effort declaration`, () => {
      expect(CustomEndpointSchema.safeParse(endpoint("openai", {})).success).toBe(true);
      expect(
        CustomEndpointSchema.safeParse(
          endpoint("openai", { reasoning: { effort: { path: "/effort" } } })
        ).success
      ).toBe(true);
    });
  }
});