Skip to content

graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs

Python
26.8 KB
Raw Blame
//! Tests carved out of pricing.zig, which sits against the 600-line cap.

const std = @import("std");
const pricing = @import("pricing.zig");
const provider_mod = @import("provider.zig");

test "CostTally token and call counters saturate" {
    var tally: pricing.CostTally = .{
        .in_tokens = std.math.maxInt(u64) - 1,
        .cache_tokens = std.math.maxInt(u64),
        .cache_write_tokens = std.math.maxInt(u64),
        .out_tokens = std.math.maxInt(u64) - 2,
        .api_calls = std.math.maxInt(u64),
        .sub_calls = std.math.maxInt(u64),
    };
    tally.add(std.testing.io, .sub, "gpt-5.5", 10, 10, 10, 10);
    try std.testing.expectEqual(std.math.maxInt(u64), tally.in_tokens);
    try std.testing.expectEqual(std.math.maxInt(u64), tally.cache_tokens);
    try std.testing.expectEqual(std.math.maxInt(u64), tally.cache_write_tokens);
    try std.testing.expectEqual(std.math.maxInt(u64), tally.out_tokens);
    try std.testing.expectEqual(std.math.maxInt(u64), tally.api_calls);
    try std.testing.expectEqual(std.math.maxInt(u64), tally.sub_calls);
}

test "modelInTable: known models present, unknown absent" {
    try std.testing.expect(pricing.modelInTable("gpt-5.5"));
    try std.testing.expect(pricing.modelInTable("claude-opus-4-8"));
    try std.testing.expect(!pricing.modelInTable("not-a-real-model"));
}

test "priceFor: known model priced, unknown is null" {
    try std.testing.expect(pricing.priceFor("gpt-5.5") != null);
    try std.testing.expect(pricing.priceFor("claude-opus-4-8") != null);
    try std.testing.expect(pricing.priceFor("no-such-model") == null);
}

test "resolveModelName exact aliases and miss" {
    const keys = provider_mod.Keys{ .values = @splat(null) };
    try std.testing.expect(pricing.resolveModelName(keys, "gpt-5.5") != null); // exact name
    try std.testing.expectEqualStrings("glm-5.2", pricing.resolveModelName(keys, "glm5.2").?); // natural alias
    try std.testing.expectEqualStrings("glm-5.3", pricing.resolveModelName(keys, "glm5.3").?);
    try std.testing.expect(pricing.resolveModelName(keys, "totally-unknown-zzz") == null);
}

test "resolveModelName (#377): family-prefixed spelling resolves to the provider's native row" {
    const keys = provider_mod.Keys{ .values = @splat(null) };
    try std.testing.expectEqualStrings("k3", pricing.resolveModelName(keys, "kimi-k3").?);
    try std.testing.expect(pricing.familyAliasEquals("kimi", "k3", "kimi-k3"));
    try std.testing.expect(pricing.familyAliasEquals("kimi", "k3", "kimi_k3"));
    try std.testing.expect(!pricing.familyAliasEquals("kimi", "k3", "kimi-k30"));
    try std.testing.expect(!pricing.familyAliasEquals("codex", "k3", "kimi-k3"));
    var moon_values: [provider_mod.provider_specs.len]?[]const u8 = @splat(null);
    for (provider_mod.provider_specs, 0..) |spec, i| {
        if (std.mem.eql(u8, spec.id, "moonshot")) moon_values[i] = "k";
    }
    const moonshot_only = provider_mod.Keys{ .values = moon_values };
    try std.testing.expectEqualStrings("kimi-k3", pricing.resolveModelName(moonshot_only, "kimi-k3").?);
}

test "resolveModelName: 5.6 sol prefers Codex gpt-5.6-sol over a gateway slug" {
    const saved = pricing.active_model_table;
    defer pricing.active_model_table = saved;
    const rows = [_]pricing.ModelInfo{
        .{ .provider = "codegraff", .name = "openai/gpt-5.6-sol", .context = 272_000 },
        .{ .provider = "openai", .name = "gpt-5.6", .context = 1_050_000 },
        .{ .provider = "codex", .name = "gpt-5.6-sol", .context = 272_000 },
    };
    pricing.active_model_table = &rows;
    var keys: provider_mod.Keys = .{ .values = @splat(null) };
    _ = keys.set("codex", "tok", .login);
    _ = keys.set("openai", "sk", .environment);
    _ = keys.set("codegraff", "cg", .login);
    try std.testing.expectEqualStrings("gpt-5.6-sol", pricing.resolveModelName(keys, "5.6 sol").?);
}

test "usdFor: per-million math, cache writes, and negative clamping" {
    const p = pricing.priceFor("gpt-5.5").?; // $5 in / $30 out / $0.5 cache per 1M
    try std.testing.expectApproxEqAbs(@as(f64, 5.0), pricing.usdFor(p, 1_000_000, 0, 0), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 0.5), pricing.usdFor(p, 0, 1_000_000, 0), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 3.0), pricing.usdFor(p, 0, 0, 100_000), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 0.0), pricing.usdFor(p, -42, -1, 0), 1e-9); // clamped
    // GPT-5.6 (OpenAI model pages): $4 in / $20 out / $0.4 cached; cache
    // writes at 1.25× input; above 272K input tokens the whole request bills
    // 2× input and 1.5× output.
    const p56 = pricing.priceFor("gpt-5.6").?;
    try std.testing.expectApproxEqAbs(@as(f64, 0.5), pricing.usdForUsage(p56, "gpt-5.6", 0, 0, 100_000, 0), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 0.4 + 2.0), pricing.usdForUsage(p56, "gpt-5.6", 100_000, 0, 0, 100_000), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 2.4 + 3.0), pricing.usdForUsage(p56, "gpt-5.6", 300_000, 0, 0, 100_000), 1e-9); // long-context tier
    const terra = pricing.priceFor("gpt-5.6-terra").?; // $2 / $12 / $0.2
    try std.testing.expectApproxEqAbs(@as(f64, 0.2 + 0.02 + 12.0), pricing.usdForUsage(terra, "gpt-5.6-terra", 100_000, 100_000, 0, 1_000_000), 1e-9);
    const luna = pricing.priceFor("gpt-5.6-luna").?; // $0.2 / $1.2 / $0.02
    try std.testing.expectApproxEqAbs(@as(f64, 0.02 + 0.002 + 1.2), pricing.usdForUsage(luna, "gpt-5.6-luna", 100_000, 100_000, 0, 1_000_000), 1e-9);
    // GPT-6.1 Sol: $2 in / $10 out / $0.1 cached (5% of input), cache writes
    // $2.5; above 272K input 2x input and cache, 1.5x output.
    const sol61 = pricing.priceFor("gpt-6.1-sol").?;
    try std.testing.expectApproxEqAbs(@as(f64, 0.25), pricing.usdForUsage(sol61, "gpt-6.1-sol", 0, 0, 100_000, 0), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 0.2 + 0.01 + 10.0), pricing.usdForUsage(sol61, "gpt-6.1-sol", 100_000, 100_000, 0, 1_000_000), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 0.8 + 0.04 + 1.5), pricing.usdForUsage(sol61, "gpt-6.1-sol", 200_000, 200_000, 0, 100_000), 1e-9); // long-context tier
    try std.testing.expectEqual(@as(u64, 1_050_000), pricing.contextFor("openai", "gpt-6.1-sol"));
    try std.testing.expectEqual(@as(u64, 500_000), pricing.contextFor("codex", "gpt-6.1-sol"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-6.1-sol"));
}

test "Sol subscription context honors route caps and smaller catalogs" {
    const saved_models = pricing.active_model_table;
    const saved_overlay = pricing.context_overlay;
    const saved_pct = provider_mod.g_compact_pct_override;
    defer pricing.active_model_table = saved_models;
    defer pricing.context_overlay = saved_overlay;
    defer provider_mod.g_compact_pct_override = saved_pct;
    provider_mod.g_compact_pct_override = null;
    const keys: provider_mod.Keys = .{ .values = @splat(null) };
    for ([_][]const u8{ "codex", "chatgpt-new" }) |route| {
        pricing.active_model_table = pricing.model_table[0..];
        const p = keys.build(provider_mod.specFor(route).?, "", "gpt-6.1-sol");
        try std.testing.expectEqual(@as(u64, 500_000), p.context);
        try std.testing.expectEqual(@as(u64, 400_000), p.compactAt());
        try std.testing.expectEqual(pricing.codex_context_window, pricing.contextFor(route, "gpt-6-sol"));
        try std.testing.expectEqual(@as(u64, 128_000), pricing.contextFor("codex", "gpt-5.3-codex-spark"));
        for ([_]u64{ 272_000, 500_000, 1_050_000 }) |advertised| {
            const rows = [_]pricing.ModelInfo{.{ .provider = route, .name = "gpt-6.1-sol", .context = advertised }};
            pricing.active_model_table = &rows;
            try std.testing.expectEqual(@min(advertised, @as(u64, 500_000)), pricing.contextFor(route, "gpt-6.1-sol"));
        }
        // A name-only API window cannot bypass the subscription clamp.
        pricing.active_model_table = &.{};
        pricing.context_overlay = &.{.{ .provider = "", .name = "gpt-6.1-sol", .context = 1_050_000 }};
        try std.testing.expectEqual(@as(u64, 500_000), pricing.contextFor(route, "gpt-6.1-sol"));
        pricing.context_overlay = &.{};
        pricing.active_model_table = &.{.{ .provider = "openai", .name = "gpt-6.1-sol", .context = 1_050_000 }};
        try std.testing.expectEqual(@as(u64, 500_000), pricing.contextFor(route, "gpt-6.1-sol"));
        try std.testing.expectEqual(@as(u64, 1_050_000), pricing.contextFor("openai", "gpt-6.1-sol"));
    }
}

test "grok-4.6 window is 500k and compact-at is 80%" {
    const window = pricing.contextFor("xai", "grok-4.6");
    try std.testing.expectEqual(@as(u64, 500_000), window);
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("xai", "grok-4.3")); // other xAI rows unchanged
    try std.testing.expectEqual(@as(u64, pricing.default_context), pricing.contextFor("nope", "unknown-xyz"));
    const p = provider_mod.Provider{
        .id = "xai",
        .kind = .responses,
        .auth = .bearer,
        .url = "",
        .api_key = "k",
        .model = "grok-4.6",
        .context = window,
    };
    try std.testing.expectEqual(@as(u64, 400_000), p.compactAt()); // 80% of 500k
}

test "grok-4.6 prices: low band under 200k, high band for the whole request at ≥200k" {
    const p = pricing.priceFor("grok-4.6") orelse return error.MissingGrok46Price;
    try std.testing.expectEqual(@as(u64, 200_000), p.high_at);
    // 10k uncached + 2k cached + 500 out @ $2 / $0.50 / $6
    try std.testing.expectApproxEqAbs(@as(f64, 0.024), pricing.usdFor(p, 10_000, 2_000, 500), 1e-12);
    // 199_999 stays on the low band
    try std.testing.expectApproxEqAbs(@as(f64, 0.399998), pricing.usdFor(p, 199_999, 0, 0), 1e-12);
    // 200k uncached + 1k out uses $4 / $12 for every token
    try std.testing.expectApproxEqAbs(@as(f64, 0.812), pricing.usdFor(p, 200_000, 0, 1_000), 1e-12);
    // 190k uncached + 20k cached = 210k prompt → high band on all tokens @ $4 / $1 (cached) / $12 out unused here
    try std.testing.expectApproxEqAbs(@as(f64, 0.78), pricing.usdFor(p, 190_000, 20_000, 0), 1e-12);
    // grok-4.3 stays flat even above 200k
    const old = pricing.priceFor("grok-4.3").?;
    try std.testing.expectEqual(@as(u64, 0), old.high_at);
    try std.testing.expectApproxEqAbs(@as(f64, 0.25), pricing.usdFor(old, 200_000, 0, 0), 1e-12);
}

test "xAI default model is grok-4.7 and is catalogued" {
    const spec = provider_mod.specFor("xai") orelse return error.MissingXaiSpec;
    try std.testing.expectEqualStrings("grok-4.7", spec.default_model);
    try std.testing.expect(pricing.providerModelInTable("xai", "grok-4.7"));
    try std.testing.expect(pricing.providerModelInTable("xai", "grok-4.6"));
}

test "grok-4.7 window and dual-band prices match 4.6" {
    try std.testing.expectEqual(@as(u64, 500_000), pricing.contextFor("xai", "grok-4.7"));
    const p = pricing.priceFor("grok-4.7") orelse return error.MissingGrok47Price;
    try std.testing.expectEqual(@as(u64, 200_000), p.high_at);
    try std.testing.expectApproxEqAbs(@as(f64, 0.024), pricing.usdFor(p, 10_000, 2_000, 500), 1e-12);
    try std.testing.expectApproxEqAbs(@as(f64, 0.812), pricing.usdFor(p, 200_000, 0, 1_000), 1e-12);
}

test "contextFor known model and default fallback" {
    try std.testing.expectEqual(@as(u64, 1_048_576), pricing.contextFor("kimi", "k3"));
    try std.testing.expectEqual(@as(u64, pricing.default_context), pricing.contextFor("nope", "unknown-xyz"));
}

test "contextFor gives Claude Agent the 1M window Claude Code runs" {
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("claude-agent", "claude-opus-5-5"));
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("claude-agent", "claude-sonnet-5-5[1m]"));
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("claude-agent", "claude-opus-4-5[1m]"));
    try std.testing.expectEqual(@as(u64, pricing.default_context), pricing.contextFor("nope", "unknown-xyz"));
}

test "Kimi discovery preserves Codex and chooses the newest pure generation" {
    const saved = pricing.active_model_table;
    defer pricing.active_model_table = saved;
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const discovered = [_]pricing.ModelInfo{
        .{ .provider = "kimi", .name = "kimi-for-coding", .context = 262_144 },
        .{ .provider = "kimi", .name = "k2p7", .context = 262_144 },
        .{ .provider = "kimi", .name = "k3", .context = 1_048_576, .protocol = .anthropic, .supports_reasoning = true, .support_efforts = &.{"max"}, .default_effort = "max" },
    };
    try std.testing.expect(pricing.activateKimiModels(arena_state.allocator(), &discovered));
    try std.testing.expectEqualStrings("k3", pricing.providerDefaultModel("kimi", "fallback"));
    try std.testing.expectEqual(pricing.ModelProtocol.anthropic, pricing.kimiProtocol("k3"));
    try std.testing.expect(pricing.kimiSupportsThinking("k3"));
    try std.testing.expectEqualStrings("max", pricing.kimiThinkingEffort("k3", "medium").?);
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.6-sol"));
    try std.testing.expect(!pricing.providerModelInTable("kimi", "kimi-for-coding-highspeed"));
    const codex = [_]pricing.ModelInfo{.{ .provider = "codex", .name = "future-sol", .context = 270_000 }};
    try std.testing.expect(pricing.activateCodexModels(arena_state.allocator(), &codex));
    try std.testing.expect(pricing.providerModelInTable("kimi", "k3"));
}

test "Codex discovery replaces only the baked Codex fallback" {
    const saved = pricing.active_model_table;
    defer pricing.active_model_table = saved;
    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
    defer arena_state.deinit();
    const discovered = [_]pricing.ModelInfo{
        .{ .provider = "codex", .name = "future-sol", .context = 372_000 },
        .{ .provider = "codex", .name = "future-luna", .context = 128_000 },
    };
    try std.testing.expect(pricing.activateCodexModels(arena_state.allocator(), &discovered));
    try std.testing.expect(pricing.providerModelInTable("codex", "future-sol"));
    try std.testing.expect(pricing.providerModelInTable("codex", "future-luna"));
    try std.testing.expect(!pricing.providerModelInTable("codex", "gpt-5.5"));
    try std.testing.expectEqual(pricing.codex_context_window, pricing.contextFor("codex", "future-sol"));
    try std.testing.expectEqualStrings("future-sol", pricing.providerDefaultModel("codex", "fallback"));
    try std.testing.expect(pricing.providerModelInTable("openai", "gpt-5.6"));
}

test "baked Codex catalog is an offline fallback, not rollout data" {
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-6-astra"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.6-sol"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.6-terra"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.6-luna"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.5"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.4"));
    try std.testing.expect(pricing.providerModelInTable("codex", "gpt-5.3-codex-spark"));
    try std.testing.expectEqual(pricing.codex_context_window, pricing.contextFor("codex", "gpt-5.6-sol"));
    try std.testing.expectEqualStrings("gpt-6-astra", pricing.providerDefaultModel("codex", "fallback"));
    try std.testing.expect(!pricing.providerModelInTable("codex", "gpt-5.5-codex"));
    try std.testing.expect(!pricing.providerModelInTable("codex", "gpt-5-codex"));
    try std.testing.expect(pricing.providerModelInTable("openai", "gpt-5-codex"));
    try std.testing.expect(pricing.providerModelInTable("openai", "gpt-5.6"));
}

test "every built-in provider default_model is catalog-present for that provider" {
    for (provider_mod.provider_specs) |spec|
        try std.testing.expect(pricing.providerModelInTable(spec.id, spec.default_model));
}

test "refresh overlay augments price/context lookups (codex cap still applies)" {
    const saved_p = pricing.price_overlay;
    const saved_c = pricing.context_overlay;
    defer pricing.price_overlay = saved_p;
    defer pricing.context_overlay = saved_c;
    const po = [_]pricing.ModelPrice{.{ .name = "future-model-x", .in = 9, .out = 9, .cache = 1 }};
    const co = [_]pricing.ModelInfo{.{ .provider = "", .name = "future-model-x", .context = 999_000 }};
    pricing.price_overlay = &po;
    pricing.context_overlay = &co;
    try std.testing.expect(pricing.priceFor("future-model-x") != null);
    try std.testing.expectEqual(@as(u64, 999_000), pricing.contextFor("openai", "future-model-x"));
    try std.testing.expectEqual(pricing.codex_context_window, pricing.contextFor("codex", "future-model-x"));
}

test "Xiaomi catalog follows the live /v1/models list" {
    const spec = provider_mod.specFor("xiaomi") orelse return error.MissingXiaomiSpec;
    try std.testing.expectEqualStrings("mimo-v2.6-pro", spec.default_model);
    try std.testing.expectEqual(provider_mod.ProviderSpec.CatalogKind.openai, spec.catalog);
    try std.testing.expectEqualStrings("https://api.xiaomimimo.com/v1/models", spec.models_url);
    try std.testing.expect(pricing.providerModelInTable("xiaomi", "mimo-v2.6-pro"));
    try std.testing.expect(pricing.providerModelInTable("xiaomi", "mimo-v2.6-flash"));
    try std.testing.expect(pricing.providerModelInTable("xiaomi", "mimo-v2.6-pro-ultraspeed"));
    try std.testing.expect(pricing.providerModelInTable("xiaomi", "mimo-v2.5-pro"));
    try std.testing.expectEqual(@as(u64, 1_048_576), pricing.contextFor("xiaomi", "mimo-v2.6-pro"));
    const p = pricing.priceFor("mimo-v2.6-pro") orelse return error.MissingMimo26Price;
    try std.testing.expectEqual(@as(f64, 0.435), p.in);
    try std.testing.expectEqual(@as(f64, 0.87), p.out);
    try std.testing.expectEqual(@as(f64, 0.0036), p.cache);
}

test "Z.AI default is GLM-5.3 with official prices and a 1M window" {
    const spec = provider_mod.specFor("zai") orelse return error.MissingZaiSpec;
    try std.testing.expectEqualStrings("glm-5.3", spec.default_model);
    try std.testing.expect(spec.takes_effort);
    try std.testing.expectEqual(provider_mod.ProviderSpec.CatalogKind.openai, spec.catalog);
    try std.testing.expectEqualStrings("https://api.z.ai/api/paas/v4/models", spec.models_url);
    try std.testing.expect(pricing.providerModelInTable("zai", "glm-5.3"));
    try std.testing.expect(pricing.providerModelInTable("zai", "glm-5-turbo"));
    try std.testing.expect(pricing.providerModelInTable("zai", "glm-5v-turbo"));
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("zai", "glm-5.3"));
    const p = pricing.priceFor("glm-5.3") orelse return error.MissingGlm53Price;
    try std.testing.expectEqual(@as(f64, 1.4), p.in);
    try std.testing.expectEqual(@as(f64, 4.4), p.out);
    try std.testing.expectEqual(@as(f64, 0.26), p.cache);
}

test "Vercel AI Gateway defaults to Qwen3.8-27B on the coding-agent surface" {
    const spec = provider_mod.specFor("vercel") orelse return error.MissingVercelSpec;
    try std.testing.expectEqualStrings("alibaba/qwen3.8-27b", spec.default_model);
    try std.testing.expect(spec.takes_effort);
    try std.testing.expectEqual(provider_mod.ProviderSpec.CatalogKind.openai, spec.catalog);
    try std.testing.expectEqualStrings("https://ai-gateway.vercel.sh/coding-agent/v1/chat/completions", spec.url);
    try std.testing.expectEqualStrings("https://ai-gateway.vercel.sh/coding-agent/v1/models", spec.models_url);
    try std.testing.expectEqualStrings("AI_GATEWAY_API_KEY", spec.env_key);
    try std.testing.expect(pricing.providerModelInTable("vercel", "alibaba/qwen3.8-27b"));
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("vercel", "alibaba/qwen3.8-27b"));
    const p = pricing.priceFor("alibaba/qwen3.8-27b") orelse return error.MissingQwen38Price;
    try std.testing.expectEqual(@as(f64, 0.55), p.in);
    try std.testing.expectEqual(@as(f64, 3.3), p.out);
    try std.testing.expectEqual(@as(f64, 0.11), p.cache);
}

test "OpenRouter defaults to Claude Sonnet 4.6 on the chat completions surface" {
    const spec = provider_mod.specFor("openrouter") orelse return error.MissingOpenRouterSpec;
    try std.testing.expectEqualStrings("anthropic/claude-sonnet-4.6", spec.default_model);
    try std.testing.expect(spec.takes_effort);
    try std.testing.expectEqual(provider_mod.ProviderSpec.CatalogKind.openai, spec.catalog);
    try std.testing.expectEqualStrings("https://openrouter.ai/api/v1/chat/completions", spec.url);
    try std.testing.expectEqualStrings("https://openrouter.ai/api/v1/models", spec.models_url);
    try std.testing.expectEqualStrings("OPENROUTER_API_KEY", spec.env_key);
    try std.testing.expect(pricing.providerModelInTable("openrouter", "anthropic/claude-sonnet-4.6"));
    try std.testing.expectEqual(@as(u64, 1_000_000), pricing.contextFor("openrouter", "anthropic/claude-sonnet-4.6"));
}

test "startup preference stays on providers that advertise the preferred model" {
    const saved = pricing.active_model_table;
    defer pricing.active_model_table = saved;
    const rows = [_]pricing.ModelInfo{
        .{ .provider = "codegraff", .name = "mimo-v2.6-pro", .context = 1_048_576 },
        .{ .provider = "xiaomi", .name = "mimo-v2.6-pro", .context = 1_048_576 },
        .{ .provider = "codex", .name = "gpt-5.6-sol", .context = 272_000 },
    };
    pricing.active_model_table = &rows;
    try std.testing.expectEqualStrings("mimo-v2.6-pro", pricing.providerDefaultModel("codegraff", "old-default"));
    try std.testing.expectEqualStrings("mimo-v2.6-pro", pricing.providerDefaultModel("xiaomi", "old-default"));
    try std.testing.expectEqualStrings("gpt-5.6-sol", pricing.providerDefaultModel("codex", "old-default"));
    try std.testing.expectEqualStrings("deepseek-v4-pro", pricing.providerDefaultModel("deepseek", "deepseek-v4-pro"));
}

test "provider defaults preserve explicit model selection" {
    var keys: provider_mod.Keys = .{ .values = @splat(null) };
    try std.testing.expect(keys.set("codegraff", "test-key", .login));
    try std.testing.expectEqualStrings("mimo-v2.6-pro", (try keys.defaultProvider()).model);
    try std.testing.expectEqualStrings("deepseek-v4-pro", (try keys.providerById("codegraff", "deepseek-v4-pro")).model);
    try std.testing.expect(keys.set("xiaomi", "test-key", .environment));
    try std.testing.expectEqualStrings("xiaomi", (try keys.defaultProvider()).id);
    try std.testing.expectEqualStrings("mimo-v2.6-pro", (try keys.defaultProvider()).model);
}

test "pricing Astra has metered catalog entries and cache write premium" {
    try std.testing.expect(pricing.providerModelInTable("openai", "gpt-6-astra"));
    try std.testing.expect(pricing.providerModelInTable("codegraff", "gpt-6-astra"));
    const p = pricing.priceForProvider("openai", "gpt-6-astra").?;
    try std.testing.expectApproxEqAbs(@as(f64, 1.25), pricing.usdForUsage(p, p.name, 0, 0, 100_000, 0), 1e-9);
    try std.testing.expectApproxEqAbs(@as(f64, 13.5), pricing.usdForUsage(p, p.name, 300_000, 0, 0, 100_000), 1e-9);
}

test "pricing gateway aliases do not inherit vendor rates or cache writes" {
    const gateway = pricing.priceForProvider("codegraff", "gpt-6-sol").?;
    const direct = pricing.priceForProvider("openai", "gpt-6-sol").?;
    try std.testing.expectApproxEqAbs(@as(f64, 2.2), gateway.in, 1e-9);
    try std.testing.expectEqual(@as(f64, 2), direct.in);
    const astra = pricing.priceForProvider("codegraff", "gpt-6-astra").?;
    try std.testing.expectApproxEqAbs(@as(f64, 1.1), pricing.usdForUsage(astra, astra.name, 0, 0, 100_000, 0), 1e-9);
}

test "pricing gateway tally respects priced and free rows without vendor fallback" {
    var tally: pricing.CostTally = .{};
    tally.addForProvider(std.testing.io, .priced, "codegraff", "deepseek-v4-pro", 100_000, 100_000, 0, 100_000);
    try std.testing.expectApproxEqAbs(@as(f64, 0.13086), tally.usd, 1e-9);
    const zero = pricing.priceForProvider("codegraff", "ling-3.0-flash-fin").?;
    try std.testing.expectEqual(@as(f64, 0), pricing.usdFor(zero, 100, 100, 100));
    // A retired gateway alias has no gateway row and never borrows the vendor's.
    try std.testing.expect(pricing.priceFor("gpt-5.5") != null);
    try std.testing.expect(pricing.priceForProvider("codegraff", "gpt-5.5") == null);
}

test "pricing gateway overrides name-only runtime prices and long bands" {
    const old = pricing.price_overlay;
    defer pricing.price_overlay = old;
    pricing.price_overlay = &.{.{ .name = "grok-4.7", .in = 99, .out = 99, .cache = 99 }};
    const gateway = pricing.priceForProvider("codegraff", "grok-4.7").?;
    try std.testing.expectApproxEqAbs(@as(f64, 2), pricing.usdFor(gateway, 200_000, 0, 100_000), 1e-9);
    try std.testing.expectEqual(@as(f64, 99), pricing.priceFor("grok-4.7").?.in);
}

test "pricing cached overlay preserves long context tariff" {
    const old = pricing.price_overlay;
    const old_context = pricing.context_overlay;
    defer {
        pricing.price_overlay = old;
        pricing.context_overlay = old_context;
    }
    pricing.price_overlay = &.{};
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    const io = std.testing.io;
    try tmp.dir.writeFile(io, .{ .sub_path = ".codegraff-models.json", .data = "{\"models\":[{\"name\":\"gpt-6-astra\",\"in\":10,\"out\":50,\"cache\":1}]}" });
    var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
    defer arena.deinit();
    const home = try tmp.dir.realPathFileAlloc(io, ".", arena.allocator());
    @import("models_cache.zig").loadOverlay(io, arena.allocator(), home);
    const p = pricing.priceFor("gpt-6-astra").?;
    try std.testing.expectEqual(@as(u64, 272_000), p.high_at);
    try std.testing.expectApproxEqAbs(@as(f64, 13.5), pricing.usdForUsage(p, p.name, 300_000, 0, 0, 100_000), 1e-9);
}

test "pricing footer preserves small nonzero metered costs" {
    var tally: pricing.CostTally = .{};
    tally.addForProvider(std.testing.io, .priced, "codegraff", "mimo-v2.6-flash", 29, 8064, 0, 21);
    const snapshot = tally.snap(std.testing.io);
    var buf: [512]u8 = undefined;
    var writer: std.Io.Writer = .fixed(&buf);
    try pricing.CostTally.render(snapshot, &writer);
    const text = writer.buffered();
    const dollar = std.mem.indexOfScalar(u8, text, '$') orelse return error.MissingCost;
    const reported = try std.fmt.parseFloat(f64, text[dollar + 1 ..]);
    try std.testing.expect(reported > 0);
    try std.testing.expectApproxEqAbs(snapshot.usd, reported, 5e-9);
}

test "pricing Astra resolves using only a gateway credential" {
    const previous = pricing.active_model_table;
    defer pricing.active_model_table = previous;
    pricing.active_model_table = &pricing.model_table;
    var keys: provider_mod.Keys = .{ .values = @splat(null) };
    _ = keys.set("codegraff", "fixture", .environment);
    const resolved = try keys.providerFor("gpt-6-astra");
    try std.testing.expectEqualStrings("codegraff", resolved.id);
    try std.testing.expectEqual(@as(u64, 1_050_000), resolved.context);
    try std.testing.expectEqual(@import("billing.zig").Billing.priced, @import("billing.zig").forProvider(resolved));
}