import { expect, test } from "bun:test";
import { mkdtemp, readFile, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";

import { formatToml, preserveReasoningOptions, syncProvider, type SyncProvider } from "../src/sync/index.js";
import {
  anthropic,
  buildAnthropicModel,
  parseAnthropicPricing,
  type AnthropicModel,
} from "../src/sync/providers/anthropic.js";
import { buildDeepInfraModel, type DeepInfraModel } from "../src/sync/providers/deepinfra.js";
import {
  buildDigitalOceanModel,
  digitalocean,
  fetchDigitalOceanModels,
  parseDigitalOceanModels,
  resolveDigitalOceanBaseModel,
  type DigitalOceanSourceModel,
} from "../src/sync/providers/digitalocean.js";
import {
  buildEmpiriolabsModel,
  empiriolabs,
  resolveEmpiriolabsBaseModel,
  type EmpiriolabsModel,
} from "../src/sync/providers/empiriolabs.js";
import {
  buildOpenRouterModel,
  openrouter,
  resolveCanonicalBaseModel,
  type OpenRouterModel,
} from "../src/sync/providers/openrouter.js";
import { buildLLMGatewayModel, type LLMGatewayModel } from "../src/sync/providers/llmgateway.js";
import { openai, parseOpenAIModels } from "../src/sync/providers/openai.js";
import { resolveVeniceBaseModel } from "../src/sync/providers/venice.js";
import { buildVercelModel, vercel } from "../src/sync/providers/vercel.js";
import { buildWandbModel, type WandbModel } from "../src/sync/providers/wandb.js";
import { buildXAIModel } from "../src/sync/providers/xai.js";

function anthropicModel(overrides: Partial<AnthropicModel> = {}): AnthropicModel {
  return {
    id: "claude-sonnet-5",
    display_name: "Claude Sonnet 5",
    created_at: "2026-06-30T00:00:00Z",
    max_input_tokens: 1_000_000,
    max_tokens: 128_000,
    capabilities: {
      image_input: { supported: true },
      pdf_input: { supported: true },
      structured_outputs: { supported: true },
      thinking: {
        supported: true,
        types: { adaptive: { supported: true } },
      },
      effort: {
        supported: true,
        low: { supported: true },
        medium: { supported: true },
        high: { supported: true },
        xhigh: { supported: true },
        max: { supported: true },
      },
    },
    ...overrides,
  };
}

const anthropicPricingMarkdown = `
## Model pricing

| Model | Base Input Tokens | 5m Cache Writes | 1h Cache Writes | Cache Hits & Refreshes | Output Tokens |
| --- | --- | --- | --- | --- | --- |
| Claude Opus 4.8 | $5 / MTok | $6.25 / MTok | $10 / MTok | $0.50 / MTok | $25 / MTok |
| Claude Opus 4.1 ([deprecated](/deprecated)) | $15 / MTok | $18.75 / MTok | $30 / MTok | $1.50 / MTok | $75 / MTok |
| Claude Sonnet 5 [through August 31, 2026](/pricing) | $2 / MTok | $2.50 / MTok | $4 / MTok | $0.20 / MTok | $10 / MTok |
| Claude Sonnet 5 starting September 1, 2026 | $3 / MTok | $3.75 / MTok | $6 / MTok | $0.30 / MTok | $15 / MTok |
| Claude Sonnet 4.6 | $3 / MTok | $3.75 / MTok | $6 / MTok | $0.30 / MTok | $15 / MTok |
| Claude Sonnet 4.5 | $3 / MTok | $3.75 / MTok | $6 / MTok | $0.30 / MTok | $15 / MTok |

## Cloud platform pricing
`;

test("parses current and future Anthropic pricing rows", () => {
  const introductory = parseAnthropicPricing(anthropicPricingMarkdown, new Date("2026-07-04T00:00:00Z"));
  expect(introductory.get("claude sonnet 5")).toMatchObject({
    input: 2,
    output: 10,
    cacheRead: 0.2,
    cacheWrite: 2.5,
  });
  expect(introductory.get("claude opus 4.1")?.deprecated).toBe(true);

  const standard = parseAnthropicPricing(anthropicPricingMarkdown, new Date("2026-09-01T00:00:00Z"));
  expect(standard.get("claude sonnet 5")).toMatchObject({ input: 3, output: 15 });
});

test("syncs Anthropic capabilities and exact effort levels", () => {
  const model = buildAnthropicModel(anthropicModel(), {
    name: "Claude Sonnet 5",
    description: "Balanced Claude model for coding and agentic workflows",
    release_date: "2026-06-30",
    last_updated: "2026-06-30",
    attachment: true,
    reasoning: true,
    reasoning_options: [{ type: "toggle" }, { type: "budget_tokens", min: 1_024 }],
    tool_call: true,
    open_weights: false,
    cost: { input: 2, output: 10 },
    limit: { context: 1_000_000, output: 128_000 },
    modalities: { input: ["text", "image", "pdf"], output: ["text"] },
  });

  expect(model).toMatchObject({
    reasoning: true,
    reasoning_options: [
      { type: "toggle" },
      { type: "effort", values: ["low", "medium", "high", "xhigh", "max"] },
    ],
    structured_output: true,
    limit: { context: 1_000_000, output: 128_000 },
    modalities: { input: ["text", "image", "pdf"], output: ["text"] },
  });
});

test("adds manual budget control for new Anthropic models", () => {
  const model = buildAnthropicModel(anthropicModel({
    capabilities: {
      thinking: {
        supported: true,
        types: { enabled: { supported: true } },
      },
    },
  }), undefined, "anthropic/claude-sonnet-5");

  expect(model.reasoning_options).toEqual([{ type: "budget_tokens" }]);
});

test("labels Anthropic aliases as latest", () => {
  const model = buildAnthropicModel(anthropicModel({
    id: "claude-sonnet-5",
    canonical_id: "claude-sonnet-5-20260630",
  }), undefined, "anthropic/claude-sonnet-5");

  expect(model.name).toBe("Claude Sonnet 5 (latest)");
});

test("Anthropic sync preserves base model inheritance", () => {
  const resolved = {
    base_model: "anthropic/claude-opus-4-5",
    name: "Claude Opus 4.5 (latest)",
    description: "Flagship Claude model",
    release_date: "2025-11-24",
    last_updated: "2025-11-24",
    attachment: true,
    reasoning: true,
    tool_call: true,
    knowledge: "2025-05",
    open_weights: false,
    cost: { input: 5, output: 25 },
    limit: { context: 200_000, output: 64_000 },
    modalities: { input: ["text" as const, "image" as const], output: ["text" as const] },
  };
  const translated = anthropic.translateModel(anthropicModel({
    id: "claude-opus-4-5",
    canonical_id: "claude-opus-4-5-20251101",
    display_name: "Claude Opus 4.5",
    created_at: "2025-11-24T00:00:00Z",
    max_input_tokens: 200_000,
    max_tokens: 64_000,
  }), {
    existing: () => resolved,
    authored: () => ({ base_model: "anthropic/claude-opus-4-5" }),
  });

  expect(translated?.model).toMatchObject({
    base_model: "anthropic/claude-opus-4-5",
    name: "Claude Opus 4.5 (latest)",
  });
  expect(translated?.model).not.toHaveProperty("knowledge");
  expect(translated?.model).not.toHaveProperty("release_date");
});

test("filters customer-owned OpenAI models from availability tracking", () => {
  expect(parseOpenAIModels({
    object: "list",
    data: [
      { id: "gpt-5.5", object: "model", created: 1, owned_by: "system" },
      { id: "ft:gpt-5.5:org:custom", object: "model", created: 2, owned_by: "org-example" },
      { id: "custom-model", object: "model", created: 3, owned_by: "org-example" },
    ],
  }).map((model) => model.id)).toEqual(["gpt-5.5"]);
});

test("OpenAI availability sync preserves authored metadata", () => {
  const authored = {
    base_model: "openai/gpt-5.5",
    cost: { input: 5, output: 30 },
  };
  expect(openai.translateModel(
    { id: "gpt-5.5", object: "model", created: 1, owned_by: "system" },
    { existing: () => authored as never, authored: () => authored },
  )).toEqual({ id: "gpt-5.5", model: authored });
});

test("OpenAI availability sync retains models absent from a scoped response", async () => {
  const dir = await mkdtemp(path.join(tmpdir(), "sync-openai-"));
  const modelsDir = path.join(dir, "providers", "openai", "models");
  await Bun.write(path.join(modelsDir, "gpt-existing.toml"), [
    'name = "Existing GPT"',
    'release_date = "2026-01-01"',
    'last_updated = "2026-01-01"',
    "attachment = false",
    "reasoning = false",
    "tool_call = true",
    "open_weights = false",
    "",
    "[cost]",
    "input = 1",
    "output = 2",
    "",
    "[limit]",
    "context = 1_000",
    "output = 100",
    "",
    "[modalities]",
    'input = ["text"]',
    'output = ["text"]',
    "",
  ].join("\n"));

  try {
    const result = await syncProvider({
      ...openai,
      modelsDir,
      async fetchModels() {
        return {
          object: "list",
          data: [{ id: "gpt-scoped", object: "model", created: 1, owned_by: "system" }],
        };
      },
    });
    expect(result.deleted).toBe(0);
    expect(result.unchanged).toBe(1);
    expect(await Bun.file(path.join(modelsDir, "gpt-existing.toml")).exists()).toBe(true);
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

function digitalOceanModel(overrides: Partial<DigitalOceanSourceModel> = {}): DigitalOceanSourceModel {
  return {
    id: "anthropic-claude-4.6-sonnet",
    name: "Claude Sonnet 4.6",
    lifecycle_status: "active",
    type: "chat",
    thinking: true,
    reasoning_efforts: ["low", "medium", "high"],
    context_window: 1_000_000,
    max_output_tokens: 8_192,
    availability: ["serverless"],
    modalities: { input: ["text", "image", "pdf"], output: ["text"] },
    settings: [{ name: "max_tokens", max: 64_000 }],
    created_at: "2026-02-17T00:00:00Z",
    pricing: {
      input: 3,
      output: 15,
      cacheRead: 0.3,
    },
    ...overrides,
  };
}

test("syncs DigitalOcean catalog limits and extended pricing thresholds", () => {
  const model = buildDigitalOceanModel(digitalOceanModel({
    pricing: {
      input: 3,
      output: 15,
      cacheRead: 0.3,
      extended: {
        context: 272_000,
        input: 6,
        output: 22.5,
        cacheRead: 0.6,
        cacheWrite: 7.5,
      },
    },
  }), {
    name: "Claude Sonnet 4.6",
    description: "Curated DigitalOcean description",
    family: "claude-sonnet",
    release_date: "2026-02-17",
    last_updated: "2026-03-13",
    attachment: true,
    reasoning: true,
    reasoning_options: [{ type: "effort", values: ["low", "medium", "high"] }],
    temperature: true,
    tool_call: true,
    open_weights: false,
    cost: {
      input: 2,
      output: 10,
      cache_read: 0.3,
      cache_write: 3.75,
      tiers: [{
        tier: { type: "context", size: 200_000 },
        input: 4,
        output: 15,
        cache_read: 0.6,
        cache_write: 7.5,
      }],
    },
    limit: { context: 200_000, output: 64_000 },
    modalities: { input: ["text", "image", "pdf"], output: ["text"] },
  });

  expect(model).toMatchObject({
    description: "Curated DigitalOcean description",
    last_updated: "2026-03-13",
    cost: {
      input: 3,
      output: 15,
      cache_read: 0.3,
      cache_write: 3.75,
      tiers: [{
        tier: { type: "context", size: 272_000 },
        input: 6,
        output: 22.5,
        cache_read: 0.6,
        cache_write: 7.5,
      }],
    },
    limit: { context: 1_000_000, output: 8_192 },
  });
});

test("skips existing dedicated-only DigitalOcean models without token pricing", () => {
  const existing = {
    name: "Mistral 7B Instruct v0.3",
    description: "Mistral model for multilingual chat and dedicated inference",
    family: "mistral" as const,
    release_date: "2024-05-22",
    last_updated: "2024-05-22",
    attachment: false,
    reasoning: false,
    temperature: true,
    tool_call: true,
    open_weights: true,
    limit: { context: 32_768, output: 32_768 },
    modalities: { input: ["text" as const], output: ["text" as const] },
  };
  const translated = digitalocean.translateModel(digitalOceanModel({
    id: "mistral-7b-instruct-v0.3",
    name: "Mistral 7B Instruct v0.3",
    thinking: false,
    context_window: 32_768,
    modalities: { input: ["text"], output: ["text"] },
    settings: [{ name: "max_tokens", max: 8_192 }],
    pricing: undefined,
  }), {
    existing: () => existing,
    authored: () => existing,
  });

  expect(translated).toBeUndefined();
});

test("syncs existing DigitalOcean image models with catalog output limits", () => {
  const existing = {
    name: "GPT Image 1.5",
    description: "Image generation model",
    family: "gpt-image" as const,
    release_date: "2025-11-25",
    last_updated: "2025-11-25",
    attachment: true,
    reasoning: false,
    temperature: false,
    tool_call: false,
    open_weights: false,
    cost: { input: 5, output: 10 },
    limit: { context: 0, output: 0 },
    modalities: { input: ["text" as const, "image" as const], output: ["image" as const] },
  };
  const translated = digitalocean.translateModel(digitalOceanModel({
    id: "openai-gpt-image-1.5",
    name: "GPT Image 1.5",
    context_window: undefined,
    max_output_tokens: 16_384,
    modalities: { input: ["text", "image"], output: ["text", "image"] },
    settings: [],
    pricing: { input: 6, output: 12 },
  }), {
    existing: () => existing,
    authored: () => existing,
  });

  expect(translated?.model).toMatchObject({
    cost: { input: 6, output: 12 },
    limit: { context: 0, output: 16_384 },
  });
});

test("filters unmanaged DigitalOcean models and joins catalog data by ID", () => {
  const models = parseDigitalOceanModels({
    models: [
      digitalOceanModel({ id: "kimi-k2.5", name: "Kimi K2", pricing: undefined }),
      digitalOceanModel({
        id: "bge-m3",
        name: "BGE M3",
        type: "embedding",
        modalities: { input: ["text"], output: ["text"] },
        pricing: undefined,
      }),
    ],
    catalog: [
      {
        model_id: "kimi-k2.5",
        name: "Kimi K2.5",
        context_window: "256000",
        max_output_tokens: "32768",
        availability: ["serverless", "dedicated"],
        pricing: {
          input_price_per_million: 0.000000375,
          output_price_per_million: 0.000002025,
          cache_read_input_price_per_million: 0.000000203,
        },
        pricing_detail: {
          variants: [{
            tier: "MODEL_PRICING_TIER_EXTENDED_272K",
            mode: "MODEL_BILLING_MODE_INTERACTIVE",
            prices: {
              input_price_per_million: 0.00000075,
              output_price_per_million: 0.000003,
            },
          }],
        },
      },
      {
        model_id: "bge-m3",
        name: "BGE M3",
        availability: ["serverless"],
      },
    ],
  });

  expect(models).toHaveLength(1);
  expect(models[0]).toMatchObject({
    id: "kimi-k2.5",
    context_window: "256000",
    max_output_tokens: "32768",
    pricing: {
      input: 0.375,
      output: 2.025,
      cacheRead: 0.203,
      extended: {
        context: 272_000,
        input: 0.75,
        output: 3,
      },
    },
  });
});

test("maps DigitalOcean 1M catalog pricing to its 200K threshold", () => {
  const models = parseDigitalOceanModels({
    models: [digitalOceanModel({ pricing: undefined })],
    catalog: [{
      model_id: "anthropic-claude-4.6-sonnet",
      name: "Claude Sonnet 4.6",
      context_window: "1000000",
      max_output_tokens: "64000",
      availability: ["serverless"],
      modalities: { input: ["text", "image"], output: ["text"] },
      pricing: {
        input_price_per_million: 0.000003,
        output_price_per_million: 0.000015,
      },
      pricing_detail: {
        variants: [{
          tier: "MODEL_PRICING_TIER_EXTENDED_1M",
          mode: "MODEL_BILLING_MODE_INTERACTIVE",
          prices: {
            input_price_per_million: 0.000006,
            output_price_per_million: 0.0000225,
          },
        }],
      },
    }],
  });

  expect(models[0]?.pricing?.extended).toEqual({
    context: 200_000,
    input: 6,
    output: 22.5,
    cacheRead: undefined,
    cacheWrite: undefined,
  });
});

test("syncs DigitalOcean reasoning capability, efforts, and lifecycle status", () => {
  const model = buildDigitalOceanModel(digitalOceanModel({
    lifecycle_status: "deprecated",
    thinking: false,
    reasoning_efforts: ["none", "low", "medium", "high", "max", "unsupported"],
  }), {
    name: "Claude Sonnet 4.6",
    description: "Curated DigitalOcean description",
    family: "claude-sonnet",
    release_date: "2026-02-17",
    last_updated: "2026-03-13",
    attachment: true,
    reasoning: false,
    reasoning_options: [{ type: "effort", values: ["low", "medium", "high"] }],
    temperature: true,
    tool_call: true,
    open_weights: false,
    status: "beta",
    cost: { input: 3, output: 15 },
    limit: { context: 200_000, output: 64_000 },
    modalities: { input: ["text", "image"], output: ["text"] },
  });

  expect(model).toMatchObject({
    status: "deprecated",
    reasoning: true,
    reasoning_options: [{ type: "effort", values: ["none", "low", "medium", "high", "max"] }],
  });
});

test("resolves DigitalOcean IDs to canonical model metadata", () => {
  expect(resolveDigitalOceanBaseModel("openai-gpt-5.5")).toBe("openai/gpt-5.5");
  expect(resolveDigitalOceanBaseModel("deepseek-v4-pro")).toBe("deepseek/deepseek-v4-pro");
});

test("new DigitalOcean base models inherit intrinsic capabilities", () => {
  const model = buildDigitalOceanModel(
    digitalOceanModel({
      id: "openai-gpt-5.5",
      name: "GPT-5.5",
      thinking: undefined,
      reasoning_efforts: undefined,
    }),
    undefined,
    "openai/gpt-5.5",
  );

  expect(model).toMatchObject({ base_model: "openai/gpt-5.5" });
  expect(model).not.toHaveProperty("open_weights");
  expect(model).not.toHaveProperty("family");
  expect(model).not.toHaveProperty("release_date");
  expect(model).not.toHaveProperty("knowledge");
  expect(model).not.toHaveProperty("reasoning");
  expect(model).not.toHaveProperty("temperature");
});

test("xAI sync factors inherited base model fields", () => {
  const model = buildXAIModel(
    {
      id: "grok-4.5",
      created: Date.parse("2026-06-29T00:00:00Z") / 1000,
      input_modalities: ["text", "image"],
      output_modalities: ["text"],
      prompt_text_token_price: 20_000,
      cached_prompt_text_token_price: 5_000,
      completion_text_token_price: 60_000,
      max_prompt_length: 500_000,
    },
    {
      base_model: "xai/grok-4.5",
      name: "Grok 4.5",
      description: "xAI's latest Grok for chat, coding, agentic tools, and lower hallucination risk",
      family: "grok",
      release_date: "2026-07-08",
      last_updated: "2026-07-08",
      attachment: true,
      reasoning: true,
      reasoning_options: [{ type: "effort", values: ["low", "medium", "high"] }],
      temperature: true,
      tool_call: true,
      structured_output: true,
      open_weights: false,
      cost: {
        input: 2,
        output: 6,
        cache_read: 0.5,
        tiers: [{ tier: { size: 200_000 }, input: 4, output: 12, cache_read: 1 }],
      },
      limit: { context: 500_000, output: 500_000 },
      modalities: { input: ["text", "image"], output: ["text"] },
    },
  );

  expect(model).toMatchObject({
    base_model: "xai/grok-4.5",
    reasoning_options: [{ type: "effort", values: ["low", "medium", "high"] }],
    cost: {
      input: 2,
      output: 6,
      cache_read: 0.5,
      tiers: [{ tier: { size: 200_000 }, input: 4, output: 12, cache_read: 1 }],
    },
  });
  expect(model).not.toHaveProperty("name");
  expect(model).not.toHaveProperty("family");
  expect(model).not.toHaveProperty("release_date");
  expect(model).not.toHaveProperty("last_updated");
  expect(model).not.toHaveProperty("limit");
});

test("skips new DigitalOcean models with incomplete pricing or limits", () => {
  const translated = digitalocean.translateModel(
    digitalOceanModel({ pricing: undefined }),
    { existing: () => undefined, authored: () => undefined },
  );
  expect(translated).toBeUndefined();
});

test("fetches every page of the DigitalOcean catalog", async () => {
  const requests: string[] = [];
  const first = digitalOceanModel({ id: "first", pricing: undefined });
  const second = digitalOceanModel({ id: "second", pricing: undefined });
  const fetcher = ((input: string | URL | Request) => {
    const url = String(input);
    requests.push(url);
    if (url.includes("/catalog/first-catalog-id")) {
      return Promise.resolve(new Response(JSON.stringify({
        data: {
          id: "first-catalog-id",
          model_id: "first",
          name: "Stale First Detail",
          context_window: "50",
          max_output_tokens: "10",
          availability: ["dedicated"],
          modalities: { input: ["text", "image"], output: ["text"] },
          pricing: { input_price_per_million: 0.000009, output_price_per_million: 0.000009 },
          pricing_detail: { variants: [] },
        },
      })));
    }
    if (url.includes("/catalog/second-catalog-id")) {
      return Promise.resolve(new Response(JSON.stringify({
        data: { id: "second-catalog-id", model_id: "second", name: "Second", availability: ["serverless"] },
      })));
    }
    if (url.includes("/catalog") && url.includes("page=2")) {
      return Promise.resolve(new Response(JSON.stringify({
        data: [{ id: "second-catalog-id", model_id: "second", name: "Second", availability: ["serverless"] }],
        meta: { total: 2, page: 2, pages: 2 },
      })));
    }
    if (url.includes("/catalog")) {
      return Promise.resolve(new Response(JSON.stringify({
        data: [{
          id: "first-catalog-id",
          model_id: "first",
          name: "First",
          context_window: "100",
          max_output_tokens: "90",
          availability: ["serverless"],
          pricing: { input_price_per_million: 0.000001, output_price_per_million: 0.000002 },
        }],
        meta: { total: 2, page: 1, pages: 2 },
      })));
    }
    if (url.includes("?page=2")) {
      return Promise.resolve(new Response(JSON.stringify({ models: [second] })));
    }
    return Promise.resolve(new Response(JSON.stringify({
      models: [first],
      links: { pages: { next: "https://api.digitalocean.com/v2/gen-ai/models?page=2" } },
    })));
  }) as typeof fetch;

  const result = await fetchDigitalOceanModels("test-key", fetcher);
  expect(result.models.map((model) => model.id)).toEqual(["first", "second"]);
  expect(result.catalog.map((model) => model.model_id)).toEqual(["first", "second"]);
  expect(result.catalog[0]).toMatchObject({
    name: "First",
    context_window: "100",
    max_output_tokens: "90",
    availability: ["serverless"],
    pricing: { input_price_per_million: 0.000001, output_price_per_million: 0.000002 },
    modalities: { input: ["text", "image"], output: ["text"] },
    pricing_detail: { variants: [] },
  });
  expect(requests).toHaveLength(6);
});

function deepInfraModel(model_name: string, tags: string[]): DeepInfraModel {
  return {
    model_name,
    type: "text-generation",
    tags,
    pricing: {
      cents_per_input_token: 0.00001,
      cents_per_output_token: 0.00002,
    },
    max_tokens: 262_144,
  };
}

test("formats interleaved as a root field before reasoning option tables", () => {
  const content = formatToml({
    id: "example/model",
    name: "Example Model",
    description: "Example model for sync formatting regression tests",
    release_date: "2026-01-01",
    last_updated: "2026-01-01",
    attachment: false,
    reasoning: true,
    reasoning_options: [{ type: "toggle" }],
    tool_call: true,
    interleaved: true,
    open_weights: false,
    cost: { input: 1, output: 2 },
    limit: { context: 1_000, output: 100 },
    modalities: { input: ["text"], output: ["text"] },
  });

  expect(Bun.TOML.parse(content)).toMatchObject({
    interleaved: true,
    reasoning_options: [{ type: "toggle" }],
  });
});

test("formats empty reasoning options outside the interleaved table", () => {
  const content = formatToml({
    id: "example/model",
    name: "Example Model",
    description: "Example model for sync formatting regression tests",
    release_date: "2026-01-01",
    last_updated: "2026-01-01",
    attachment: false,
    reasoning: true,
    reasoning_options: [],
    tool_call: true,
    interleaved: { field: "reasoning_content" },
    open_weights: false,
    cost: { input: 1, output: 2 },
    limit: { context: 1_000, output: 100 },
    modalities: { input: ["text"], output: ["text"] },
  });

  expect(Bun.TOML.parse(content)).toMatchObject({
    interleaved: { field: "reasoning_content" },
    reasoning_options: [],
  });
});

test("formats provider overrides and experimental modes", () => {
  const content = formatToml({
    id: "example/model",
    name: "Example Model",
    description: "Example model for sync formatting regression tests",
    release_date: "2026-01-01",
    last_updated: "2026-01-01",
    attachment: false,
    reasoning: false,
    tool_call: true,
    open_weights: false,
    limit: { context: 1_000, output: 100 },
    modalities: { input: ["text"], output: ["text"] },
    provider: { body: { custom_flag: true } },
    experimental: {
      modes: {
        fast: {
          cost: { input: 2, output: 4 },
          provider: {
            body: { speed: "fast" },
            headers: { "anthropic-beta": "fast-mode-2026-02-01" },
          },
        },
      },
    },
  });

  expect(Bun.TOML.parse(content)).toMatchObject({
    provider: { body: { custom_flag: true } },
    experimental: {
      modes: {
        fast: {
          cost: { input: 2, output: 4 },
          provider: {
            body: { speed: "fast" },
            headers: { "anthropic-beta": "fast-mode-2026-02-01" },
          },
        },
      },
    },
  });
});

test("DeepInfra preserves live modalities for new base models", () => {
  const model = buildDeepInfraModel(
    deepInfraModel("Qwen/Qwen3.5-9B", ["multimodal", "input-video"]),
    undefined,
    "alibaba/qwen3.5-9b",
  );

  expect(model).toMatchObject({
    attachment: true,
    modalities: { input: ["text", "image", "video"] },
  });
});

test("DeepInfra excludes incorrectly tagged Gemma 4 audio input", () => {
  const model = buildDeepInfraModel(
    deepInfraModel("google/gemma-4-31B-it", ["multimodal", "input-audio", "input-video"]),
    { modalities: { input: ["text", "image", "audio", "video"] } },
    "google/gemma-4-31b-it",
  );

  expect(model).toMatchObject({
    modalities: { input: ["text", "image", "video"] },
  });
});

test("DeepInfra preserves descriptions for standalone models", () => {
  const model = buildDeepInfraModel(
    deepInfraModel("example/model", []),
    {
      name: "Example Model",
      description: "Authored standalone model description",
      release_date: "2026-01-01",
      last_updated: "2026-01-01",
      attachment: false,
      reasoning: false,
      tool_call: false,
      open_weights: true,
      cost: { input: 1, output: 2 },
      limit: { context: 262_144, output: 8_192 },
      modalities: { input: ["text"], output: ["text"] },
    },
  );

  expect(model).toMatchObject({
    description: "Authored standalone model description",
  });
});

test("W&B preserves curated model dates", () => {
  const model: WandbModel = {
    id: "example/model",
    name: "Example Model",
    description: "Example model used to verify W&B date preservation",
    attachment: false,
    reasoning: false,
    tool_call: true,
    release_date: "2024-07-01",
    last_updated: "2024-07-01",
    open_weights: true,
  };

  expect(buildWandbModel(model, {
    release_date: "2024-07-23",
    last_updated: "2024-07-23",
  })).toMatchObject({
    release_date: "2024-07-23",
    last_updated: "2024-07-23",
  });
});

test("formats reasoning efforts from lowest to highest", () => {
  const content = formatToml({
    id: "example/model",
    name: "Example Model",
    description: "Example model for sync formatting regression tests",
    release_date: "2026-01-01",
    last_updated: "2026-01-01",
    attachment: false,
    reasoning: true,
    reasoning_options: [{
      type: "effort",
      values: ["max", "xhigh", "high", "medium", "low", "minimal", "none", "default"],
    }],
    tool_call: true,
    open_weights: false,
    cost: { input: 1, output: 2 },
    limit: { context: 1_000, output: 100 },
    modalities: { input: ["text"], output: ["text"] },
  });

  expect(content).toContain(
    'values = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "default"]',
  );
});

test("defaults new reasoning models to empty reasoning options", () => {
  expect(preserveReasoningOptions({ reasoning: true }, undefined)).toEqual({
    reasoning: true,
    reasoning_options: [],
  });
});

test("syncs OpenRouter reasoning efforts from model metadata", () => {
  const model = buildOpenRouterModel(openRouterModel({
    reasoning: {
      mandatory: false,
      supported_efforts: ["max", "xhigh", "high", "medium", "low"],
    },
  }), undefined);

  expect(model).toMatchObject({
    base_model: "anthropic/claude-sonnet-5",
    reasoning_options: [
      { type: "effort", values: ["max", "xhigh", "high", "medium", "low"] },
    ],
  });
});

test("uses OpenRouter model context when top provider reports a shorter context", () => {
  const model = buildOpenRouterModel(openRouterModel({
    context_length: 1_048_576,
    top_provider: {
      context_length: 32_000,
      max_completion_tokens: 8_192,
    },
  }), undefined);

  expect(model).toMatchObject({
    limit: {
      context: 1_048_576,
      output: 8_192,
    },
  });
});

test("factors OpenRouter Pro routes against canonical OpenAI metadata", () => {
  const model = buildOpenRouterModel(openRouterModel({
    id: "openai/gpt-5.6-sol-pro",
    name: "OpenAI: GPT-5.6 Sol Pro",
    knowledge_cutoff: "2026-02-16",
    context_length: 1_050_000,
    top_provider: {
      context_length: 1_050_000,
      max_completion_tokens: 128_000,
    },
  }), undefined);

  expect([
    resolveCanonicalBaseModel("openai/gpt-5.6-luna-pro"),
    resolveCanonicalBaseModel("openai/gpt-5.6-sol-pro"),
    resolveCanonicalBaseModel("openai/gpt-5.6-terra-pro"),
  ]).toEqual([
    "openai/gpt-5.6-luna",
    "openai/gpt-5.6-sol",
    "openai/gpt-5.6-terra",
  ]);
  expect(model).toMatchObject({
    base_model: "openai/gpt-5.6-sol",
    name: "GPT-5.6 Sol Pro",
  });
  expect("family" in model).toBe(false);
  expect("release_date" in model).toBe(false);
});

test("resolves Venice Pro routes to canonical OpenAI metadata", () => {
  expect([
    resolveVeniceBaseModel("openai-gpt-56-luna-pro", "GPT-5.6 Luna Pro"),
    resolveVeniceBaseModel("openai-gpt-56-sol-pro", "GPT-5.6 Sol Pro"),
    resolveVeniceBaseModel("openai-gpt-56-terra-pro", "GPT-5.6 Terra Pro"),
  ]).toEqual([
    "openai/gpt-5.6-luna",
    "openai/gpt-5.6-sol",
    "openai/gpt-5.6-terra",
  ]);
});

test("preserves authored OpenRouter reasoning options over model metadata", () => {
  const model = buildOpenRouterModel(openRouterModel({
    reasoning: {
      mandatory: false,
      supported_efforts: ["max", "xhigh", "high", "medium", "low"],
    },
  }), {
    name: "Claude Sonnet 5",
    description: "Balanced Claude model for coding and agentic workflows",
    release_date: "2026-06-30",
    last_updated: "2026-06-30",
    attachment: true,
    reasoning: true,
    reasoning_options: [{ type: "toggle" }],
    tool_call: true,
    open_weights: false,
    cost: { input: 2, output: 10 },
    limit: { context: 1_000_000, output: 128_000 },
    modalities: { input: ["text", "image", "pdf"], output: ["text"] },
  });

  expect(model).toMatchObject({
    reasoning_options: [{ type: "toggle" }],
  });
});

test("upgrades empty OpenRouter reasoning options from model metadata", () => {
  const model = buildOpenRouterModel(openRouterModel({
    reasoning: {
      mandatory: false,
      supported_efforts: ["high", "medium", "low"],
    },
  }), {
    name: "Claude Sonnet 5",
    description: "Balanced Claude model for coding and agentic workflows",
    release_date: "2026-06-30",
    last_updated: "2026-06-30",
    attachment: true,
    reasoning: true,
    reasoning_options: [],
    tool_call: true,
    open_weights: false,
    cost: { input: 2, output: 10 },
    limit: { context: 1_000_000, output: 128_000 },
    modalities: { input: ["text", "image", "pdf"], output: ["text"] },
  });

  expect(model).toMatchObject({
    reasoning_options: [
      { type: "effort", values: ["high", "medium", "low"] },
    ],
  });
});

test("factors new LLM Gateway models against the canonical base metadata", () => {
  const model = buildLLMGatewayModel(llmGatewayModel(), undefined);

  expect(model).toEqual({
    base_model: "anthropic/claude-fable-5",
    cost: {
      input: 10,
      output: 50,
      cache_read: 1,
      cache_write: 12.5,
    },
  });
  expect("name" in model).toBe(false);
  expect("modalities" in model).toBe(false);
});

test("factors aliased LLM Gateway routes against canonical metadata", () => {
  const model = buildLLMGatewayModel(llmGatewayModel({
    id: "glm-5-2",
    name: "GLM-5.2 (260617)",
    family: "bytedance",
    context_length: 1_024_000,
    pricing: {
      prompt: "1.4e-6",
      completion: "4.4e-6",
      input_cache_read: "0.26e-6",
    },
  }), undefined);

  expect(model).toEqual({
    base_model: "zhipuai/glm-5.2",
    cost: {
      input: 1.4,
      output: 4.4,
      cache_read: 0.26,
    },
    limit: {
      context: 1_024_000,
    },
  });
});

test("parses Vercel pricing tiers with an implicit zero minimum", () => {
  const [model] = vercel.parseModels({
    data: [{
      id: "openai/gpt-5.6-luna",
      name: "GPT-5.6 Luna",
      created: 1_780_963_200,
      context_window: 1_050_000,
      max_tokens: 128_000,
      type: "language",
      pricing: {
        input: "0.000001",
        output: "0.000006",
        input_cache_read: "0.0000001",
        input_cache_read_tiers: [
          { cost: "0.0000001", max: 272_000 },
          { cost: "0.0000002", min: 272_000 },
        ],
      },
    }],
  });

  expect(model).toBeDefined();
  expect(buildVercelModel(model!, undefined)).toMatchObject({
    cost: { input: 1, output: 6, cache_read: 0.1 },
  });
});

test("skips LLM Gateway base_model factoring when no metadata entry exists", () => {
  const model = buildLLMGatewayModel(
    llmGatewayModel({ id: "claude-fable-does-not-exist" }),
    undefined,
  );

  expect("base_model" in model).toBe(false);
  expect(model).toMatchObject({ name: "Claude Fable 5" });
});

test("preserves the authored header comment block when rewriting a changed model", async () => {
  const dir = await mkdtemp(path.join(tmpdir(), "sync-header-"));
  const modelsDir = path.join(dir, "providers", "example", "models");
  await Bun.write(path.join(modelsDir, "example-model.toml"), [
    "# Documented quirk: this route needs a manual note.",
    "# https://example.com/docs (accessed 2026-06-25)",
    'name = "Example Model"',
    'release_date = "2026-01-01"',
    'last_updated = "2026-01-01"',
    "attachment = false",
    "reasoning = false",
    "tool_call = true",
    "open_weights = false",
    "",
    "[cost]",
    "input = 1",
    "output = 2",
    "",
    "[limit]",
    "context = 1_000",
    "output = 100",
    "",
    "[modalities]",
    'input = ["text"]',
    'output = ["text"]',
    "",
  ].join("\n"));

  const provider: SyncProvider<{ id: string }> = {
    id: "example",
    name: "Example",
    modelsDir,
    deleteMissing: false,
    async fetchModels() {
      return [{ id: "example-model" }];
    },
    parseModels(raw) {
      return raw as { id: string }[];
    },
    translateModel(model) {
      return {
        id: model.id,
        model: {
          name: "Example Model",
          description: "Example model used to verify sync formatting behavior",
          release_date: "2026-01-01",
          last_updated: "2026-01-01",
          attachment: false,
          reasoning: false,
          tool_call: true,
          open_weights: false,
          cost: { input: 3, output: 9 },
          limit: { context: 1_000, output: 100 },
          modalities: { input: ["text"], output: ["text"] },
        },
      };
    },
  };

  try {
    const result = await syncProvider(provider);
    expect(result.updated).toBe(1);
    const written = await readFile(path.join(modelsDir, "example-model.toml"), "utf8");
    expect(written).toStartWith(
      "# Documented quirk: this route needs a manual note.\n# https://example.com/docs (accessed 2026-06-25)\n",
    );
    expect(written).toContain("input = 3");
  } finally {
    await rm(dir, { recursive: true, force: true });
  }
});

test("retains authored data when OpenRouter reports an unavailable stub", () => {
  const authored = {
    name: "Claude Fable Latest",
    reasoning: true as const,
    reasoning_options: [{ type: "effort" as const, values: ["low", "high"] as const }],
    tool_call: true as const,
    structured_output: true as const,
  };
  const translated = openrouter.translateModel(unavailableStub(), {
    existing: () => undefined,
    authored: () => authored as never,
  });

  expect(translated).toEqual({ id: "~anthropic/claude-fable-latest", model: authored as never });
});

test("skips an unavailable OpenRouter stub with no authored file", () => {
  const translated = openrouter.translateModel(unavailableStub(), {
    existing: () => undefined,
    authored: () => undefined,
  });

  expect(translated).toBeUndefined();
});

test("parses nullable EmpirioLabs release dates", () => {
  expect(empiriolabs.parseModels({
    data: [{ id: "unknown-text-model", category: "text", model_released_at: null }],
  })).toHaveLength(1);
});

test("syncs EmpirioLabs pricing tiers and reasoning controls", () => {
  const model: EmpiriolabsModel = {
    id: "minimax-m3",
    display_name: "MiniMax M3",
    category: "text",
    context_length: 1_000_000,
    max_output_tokens: null,
    capabilities: { reasoning: true },
    features: ["reasoning", "function_calling"],
    structured_output: "json_object",
    input_modalities: ["text", "image", "video"],
    output_modalities: ["text"],
    supported_parameters: [
      { name: "temperature" },
      { name: "max_completion_tokens", max: 524_288 },
      { name: "enable_thinking" },
      { name: "reasoning_effort", options: ["none", "low", "medium", "high", "max"] },
      { name: "thinking_budget", min: 1_024, max: 32_768 },
    ],
    pricing: [
      { prompt: "0.000000225", completion: "0.0000009", input_cache_read: "0.000000045" },
      {
        prompt: "0.00000045",
        completion: "0.0000018",
        input_cache_read: "0.000000045",
        min_context: 512_000,
      },
    ],
  };

  expect(buildEmpiriolabsModel(model, { base_model: "minimax/MiniMax-M3" })).toMatchObject({
    base_model: "minimax/MiniMax-M3",
    structured_output: true,
    reasoning_options: [
      { type: "toggle" },
      { type: "effort", values: ["none", "low", "medium", "high", "max"] },
      { type: "budget_tokens", min: 1_024, max: 32_768 },
    ],
    cost: {
      input: 0.225,
      output: 0.9,
      cache_read: 0.045,
      tiers: [{
        tier: { type: "context", size: 512_000 },
        input: 0.45,
        output: 1.8,
        cache_read: 0.045,
      }],
    },
    limit: { context: 1_000_000, output: 524_288 },
  });
});

test("maps EmpirioLabs aliases to canonical model metadata", () => {
  expect(resolveEmpiriolabsBaseModel("fugu-ultra")).toBe("sakana/fugu-ultra");
  expect(resolveEmpiriolabsBaseModel("muse-spark-1-1")).toBe("meta/muse-spark-1.1");
  expect(resolveEmpiriolabsBaseModel("step-3-5-flash")).toBe("stepfun/step-3.5-flash");
});

function unavailableStub(): OpenRouterModel {
  return openRouterModel({
    id: "~anthropic/claude-fable-latest",
    name: "Anthropic: Claude Fable Latest",
    supported_parameters: [],
    pricing: { prompt: "-1", completion: "-1" },
    reasoning: { mandatory: true },
    top_provider: { context_length: null, max_completion_tokens: null },
  });
}

function llmGatewayModel(overrides: Partial<LLMGatewayModel> = {}): LLMGatewayModel {
  return {
    id: "claude-fable-5",
    name: "Claude Fable 5",
    created: 1_780_963_200,
    family: "anthropic",
    architecture: {
      input_modalities: ["text", "image"],
      output_modalities: ["text"],
    },
    pricing: {
      prompt: "10.0e-6",
      completion: "50.0e-6",
      input_cache_read: "1.0e-6",
      input_cache_write: "12.5e-6",
      internal_reasoning: "0",
    },
    context_length: 1_000_000,
    supported_parameters: ["temperature", "max_tokens", "top_p", "effort", "reasoning"],
    structured_outputs: true,
    ...overrides,
  };
}

function openRouterModel(overrides: Partial<OpenRouterModel> = {}): OpenRouterModel {
  return {
    id: "anthropic/claude-sonnet-5",
    name: "Anthropic: Claude Sonnet 5",
    created: 1_782_777_600,
    hugging_face_id: null,
    knowledge_cutoff: "2026-01-31",
    context_length: 1_000_000,
    architecture: {
      input_modalities: ["text", "image", "file"],
      output_modalities: ["text"],
    },
    pricing: {
      prompt: "0.000002",
      completion: "0.00001",
      input_cache_read: "0.0000002",
      input_cache_write: "0.0000025",
    },
    top_provider: {
      context_length: 1_000_000,
      max_completion_tokens: 128_000,
    },
    supported_parameters: ["include_reasoning", "reasoning", "structured_outputs", "tools"],
    ...overrides,
  };
}