graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
//! 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));
}