graff — a fast agentic coding harness in Zig: multi-provider, MCP, workflows, DGM evolution loop, TS/Python SDKs
Python
//! Z.AI Coding Plan login. Uses ZCode's public CLI OAuth broker, then
//! provisions a Graff-named API key onto `/api/coding/paas/v4`.
//!
//! Identity stays `graff/<version>`. The provisioned key is named
//! `graff-api-key`, not `zcode-api-key` (ADR 0151).
const std = @import("std");
const builtin = @import("builtin");
const Io = std.Io;
const Value = std.json.Value;
const Allocator = std.mem.Allocator;
const style = &@import("ansi.zig").style;
const util = @import("util.zig");
const strFieldObj = util.strFieldObj;
const intFieldObj = util.intFieldObj;
const signin_link = @import("signin_link.zig");
const credential_store = @import("credential_store.zig");
const provider_mod = @import("provider.zig");
const credential_failover = @import("credential_failover.zig");
const main_mod = @import("main.zig");
const user_agent = "graff/" ++ @import("build_options").version;
const cli_base = "https://zcode.z.ai/api/v1";
const biz_host = "https://api.z.ai";
const default_org_name = "默认机构";
const default_project_name = "默认项目";
pub const api_key_name = "graff-api-key";
pub const oauth_dir = ".zai";
pub const InitData = struct {
authorize_url: []const u8,
flow_id: []const u8,
expires_at: i64,
poll_interval_sec: i64,
};
pub const ReadyData = struct {
access_token: []const u8,
refresh_token: []const u8,
jwt: []const u8,
};
pub const PollStatus = union(enum) {
pending,
failed,
ready: ReadyData,
};
pub const OrgProject = struct {
organization_id: []const u8,
project_id: []const u8,
};
pub const KeySummary = struct {
name: []const u8,
api_key: []const u8,
};
pub fn isLoginName(name: []const u8) bool {
return std.mem.eql(u8, name, "zai") or std.mem.eql(u8, name, "glm") or std.mem.eql(u8, name, "z.ai");
}
/// Env `GRAFF_ZAI_URL` / `ZAI_CODING` win; a coding-plan login otherwise
/// pins the coding host so the next process does not need `ZAI_CODING=1`.
pub fn applyCodingOverride() void {
if (provider_mod.g_zai_url_override != null) return;
provider_mod.g_zai_url_override = provider_mod.zai_coding_url;
}
pub fn currentZaiUrl() []const u8 {
return provider_mod.g_zai_url_override orelse "https://api.z.ai/api/paas/v4/chat/completions";
}
fn authPath(arena: Allocator, home: []const u8) []const u8 {
return credential_store.oauthPath(arena, home, oauth_dir);
}
fn unwrapData(v: Value) !Value {
if (v != .object) return error.BadOAuthResponse;
if (!isSuccessfulRemoteCode(v.object.get("code"))) return error.BadOAuthResponse;
return v.object.get("data") orelse error.BadOAuthResponse;
}
fn asObject(v: Value) !std.json.ObjectMap {
if (v != .object) return error.BadOAuthResponse;
return v.object;
}
pub fn isSuccessfulRemoteCode(code: ?Value) bool {
const c = code orelse return true;
return switch (c) {
.integer => |i| i == 0 or i == 200,
.string => |s| std.mem.eql(u8, s, "0") or std.mem.eql(u8, s, "200"),
.null => true,
else => false,
};
}
pub fn parseInitData(data: std.json.ObjectMap) !InitData {
const url = strFieldObj(data, "authorize_url") orelse return error.BadOAuthResponse;
if (!std.mem.startsWith(u8, url, "https://")) return error.BadOAuthResponse;
const flow_id = strFieldObj(data, "flow_id") orelse return error.BadOAuthResponse;
if (flow_id.len == 0) return error.BadOAuthResponse;
const expires_at = intFieldObj(data, "expires_at", 0);
if (expires_at <= 0) return error.BadOAuthResponse;
const interval = intFieldObj(data, "poll_interval_sec", 0);
if (interval < 1) return error.BadOAuthResponse;
return .{ .authorize_url = url, .flow_id = flow_id, .expires_at = expires_at, .poll_interval_sec = interval };
}
pub fn parsePollData(data: std.json.ObjectMap) !PollStatus {
const status = strFieldObj(data, "status") orelse return error.BadOAuthResponse;
if (std.mem.eql(u8, status, "pending")) return .pending;
if (std.mem.eql(u8, status, "failed")) return .failed;
if (!std.mem.eql(u8, status, "ready")) return error.BadOAuthResponse;
const jwt = strFieldObj(data, "token") orelse return error.BadOAuthResponse;
const provider = data.get("zai") orelse return error.BadOAuthResponse;
if (provider != .object) return error.BadOAuthResponse;
const access = strFieldObj(provider.object, "access_token") orelse strFieldObj(provider.object, "accessToken") orelse return error.BadOAuthResponse;
if (access.len == 0 or jwt.len == 0) return error.BadOAuthResponse;
const refresh = strFieldObj(provider.object, "refresh_token") orelse strFieldObj(provider.object, "refreshToken") orelse "";
return .{ .ready = .{ .access_token = access, .refresh_token = refresh, .jwt = jwt } };
}
pub fn pickOrgAndProject(info: std.json.ObjectMap) ?OrgProject {
const orgs_v = info.get("organizations") orelse return null;
if (orgs_v != .array or orgs_v.array.items.len == 0) return null;
var chosen_org: ?std.json.ObjectMap = null;
for (orgs_v.array.items) |item| {
if (item != .object) continue;
const name = strFieldObj(item.object, "organizationName") orelse "";
if (std.mem.indexOf(u8, name, default_org_name) != null) {
chosen_org = item.object;
break;
}
if (chosen_org == null) chosen_org = item.object;
}
const org = chosen_org orelse return null;
const org_id = strFieldObj(org, "organizationId") orelse return null;
const projects_v = org.get("projects") orelse return null;
if (projects_v != .array or projects_v.array.items.len == 0) return null;
var chosen_project: ?std.json.ObjectMap = null;
for (projects_v.array.items) |item| {
if (item != .object) continue;
const name = strFieldObj(item.object, "projectName") orelse "";
if (std.mem.indexOf(u8, name, default_project_name) != null) {
chosen_project = item.object;
break;
}
if (chosen_project == null) chosen_project = item.object;
}
const project = chosen_project orelse return null;
const project_id = strFieldObj(project, "projectId") orelse return null;
if (org_id.len == 0 or project_id.len == 0) return null;
return .{ .organization_id = org_id, .project_id = project_id };
}
pub fn findGraffKey(keys: []const KeySummary) ?[]const u8 {
for (keys) |item| {
if (std.mem.eql(u8, item.name, api_key_name) and item.api_key.len > 0) return item.api_key;
}
return null;
}
pub fn composeApiKey(arena: Allocator, id: []const u8, secret: []const u8) ![]const u8 {
if (id.len == 0) return error.BadOAuthResponse;
if (secret.len == 0) return error.BadOAuthResponse;
return std.fmt.allocPrint(arena, "{s}.{s}", .{ id, secret });
}
fn parseJsonObject(arena: Allocator, raw: []const u8) !std.json.ObjectMap {
const v = try std.json.parseFromSliceLeaky(Value, arena, raw, .{ .allocate = .alloc_always });
if (v != .object) return error.BadOAuthResponse;
return v.object;
}
fn httpJson(
io: Io,
gpa: Allocator,
arena: Allocator,
method: std.http.Method,
url: []const u8,
body: ?[]const u8,
extra: []const std.http.Header,
) !Value {
var client: std.http.Client = .{ .allocator = gpa, .io = io };
defer client.deinit();
var aw: Io.Writer.Allocating = .init(arena);
var extra_buf: [8]std.http.Header = undefined;
const n = @min(extra.len, extra_buf.len);
if (n > 0) @memcpy(extra_buf[0..n], extra[0..n]);
_ = try client.fetch(.{
.location = .{ .url = url },
.method = method,
.payload = body,
.response_writer = &aw.writer,
.headers = .{
.content_type = if (body != null) .{ .override = "application/json" } else .omit,
.user_agent = .{ .override = user_agent },
},
.extra_headers = extra_buf[0..n],
});
return std.json.parseFromSliceLeaky(Value, arena, aw.writer.buffered(), .{ .allocate = .alloc_always });
}
fn writeAuth(
io: Io,
arena: Allocator,
home: []const u8,
api_key: []const u8,
access: []const u8,
refresh: []const u8,
expires_at: i64,
) !void {
const base = try std.fmt.allocPrint(arena, "{s}/{s}", .{ home, oauth_dir });
const credentials = try std.fmt.allocPrint(arena, "{s}/credentials", .{base});
for ([_][]const u8{ base, credentials }) |path| {
Io.Dir.cwd().createDir(io, path, credential_store.private_dir) catch {};
const dir = Io.Dir.cwd().openDir(io, path, .{ .iterate = true }) catch continue;
defer dir.close(io);
if (builtin.os.tag != .windows) dir.setPermissions(io, credential_store.private_dir) catch {};
}
var obj: std.json.ObjectMap = .empty;
try obj.put(arena, "api_key", .{ .string = api_key });
try obj.put(arena, "access_token", .{ .string = access });
try obj.put(arena, "refresh_token", .{ .string = refresh });
try obj.put(arena, "expires_at", .{ .integer = expires_at });
try obj.put(arena, "coding", .{ .bool = true });
var aw: Io.Writer.Allocating = .init(arena);
var stringify: std.json.Stringify = .{ .writer = &aw.writer };
try stringify.write(Value{ .object = obj });
try credential_store.replaceFile(io, Io.Dir.cwd(), authPath(arena, home), aw.writer.buffered(), credential_store.private_file);
}
/// Reads the provisioned Coding Plan API key. Sets the coding host unless an
/// env override already won. `gpa`/`force`/`stale` match the kimi/xai loader
/// signature; the key is long-lived so there is no refresh in this module.
pub fn loadZaiOAuth(io: Io, gpa: Allocator, arena: Allocator, home: []const u8, force: bool, stale: ?[]const u8) ?[]const u8 {
_ = gpa;
_ = force;
_ = stale;
const data = Io.Dir.cwd().readFileAlloc(io, authPath(arena, home), arena, .limited(64 * 1024)) catch return null;
const v = std.json.parseFromSliceLeaky(Value, arena, data, .{ .allocate = .alloc_always }) catch return null;
if (v != .object) return null;
const key = strFieldObj(v.object, "api_key") orelse return null;
if (key.len == 0) return null;
applyCodingOverride();
return key;
}
fn bizGet(io: Io, gpa: Allocator, arena: Allocator, url: []const u8, authorization: []const u8) !Value {
const extra = [_]std.http.Header{.{ .name = "Authorization", .value = authorization }};
return unwrapData(try httpJson(io, gpa, arena, .GET, url, null, &extra));
}
fn bizPost(io: Io, gpa: Allocator, arena: Allocator, url: []const u8, authorization: []const u8, body: []const u8) !Value {
const extra = [_]std.http.Header{.{ .name = "Authorization", .value = authorization }};
return unwrapData(try httpJson(io, gpa, arena, .POST, url, body, &extra));
}
fn jsonObject(arena: Allocator, obj: std.json.ObjectMap) ![]const u8 {
var aw: Io.Writer.Allocating = .init(arena);
var stringify: std.json.Stringify = .{ .writer = &aw.writer };
try stringify.write(Value{ .object = obj });
return aw.writer.buffered();
}
fn summariesFrom(arena: Allocator, v: Value) ![]KeySummary {
const items = switch (v) {
.array => |a| a.items,
.object => |o| blk: {
if (o.get("data")) |inner| if (inner == .array) break :blk inner.array.items;
return &.{};
},
else => return &.{},
};
var out: std.ArrayList(KeySummary) = .empty;
for (items) |item| {
if (item != .object) continue;
const name = strFieldObj(item.object, "name") orelse "";
const key = strFieldObj(item.object, "apiKey") orelse "";
if (key.len == 0) continue;
try out.append(arena, .{ .name = name, .api_key = key });
}
return out.items;
}
fn provisionApiKey(io: Io, gpa: Allocator, arena: Allocator, oauth_access: []const u8) ![]const u8 {
var login_obj: std.json.ObjectMap = .empty;
try login_obj.put(arena, "token", .{ .string = oauth_access });
const extra = [_]std.http.Header{};
const login_v = try httpJson(io, gpa, arena, .POST, biz_host ++ "/api/auth/z/login", try jsonObject(arena, login_obj), &extra);
const login_data = try asObject(try unwrapData(login_v));
const biz = strFieldObj(login_data, "access_token") orelse strFieldObj(login_data, "accessToken") orelse return error.BadOAuthResponse;
const authorization = try std.fmt.allocPrint(arena, "Bearer {s}", .{biz});
const customer = try asObject(try bizGet(io, gpa, arena, biz_host ++ "/api/biz/customer/getCustomerInfo", authorization));
const loc = pickOrgAndProject(customer) orelse return error.BadOAuthResponse;
const list_url = try std.fmt.allocPrint(
arena,
"{s}/api/biz/v1/organization/{s}/projects/{s}/api_keys",
.{ biz_host, loc.organization_id, loc.project_id },
);
const listed = try summariesFrom(arena, try bizGet(io, gpa, arena, list_url, authorization));
var api_id = findGraffKey(listed);
if (api_id == null) {
var create_obj: std.json.ObjectMap = .empty;
try create_obj.put(arena, "name", .{ .string = api_key_name });
const created = try asObject(try bizPost(io, gpa, arena, list_url, authorization, try jsonObject(arena, create_obj)));
api_id = strFieldObj(created, "apiKey");
}
const id = api_id orelse return error.BadOAuthResponse;
const copy_url = try std.fmt.allocPrint(arena, "{s}/copy/{s}", .{ list_url, id });
const secret_data = try asObject(try bizGet(io, gpa, arena, copy_url, authorization));
const secret = strFieldObj(secret_data, "secretKey") orelse return error.BadOAuthResponse;
return composeApiKey(arena, id, secret);
}
/// `graff login zai`: open the Z.AI Coding Plan authorize URL, poll the CLI
/// broker, provision a Graff-named API key, and store it for `/api/coding/paas/v4`.
pub fn login(io: Io, gpa: Allocator, arena: Allocator, home: []const u8) !void {
var obuf: [4096]u8 = undefined;
var ow = Io.File.stdout().writer(io, &obuf);
const out = &ow.interface;
var raw: [32]u8 = undefined;
io.random(&raw);
const poll_token = std.fmt.bytesToHex(raw, .lower);
const bearer = try std.fmt.allocPrint(arena, "Bearer {s}", .{&poll_token});
const init_headers = [_]std.http.Header{.{ .name = "Authorization", .value = bearer }};
var init_obj: std.json.ObjectMap = .empty;
try init_obj.put(arena, "provider", .{ .string = "zai" });
const init_v = httpJson(io, gpa, arena, .POST, cli_base ++ "/oauth/cli/init", try jsonObject(arena, init_obj), &init_headers) catch |err| {
try out.print("\xe2\x9c\x97 Z.AI login failed: {t}\n", .{err});
try out.flush();
return;
};
const init_data = asObject(unwrapData(init_v) catch {
try out.writeAll("\xe2\x9c\x97 Z.AI login failed: bad init response\n");
try out.flush();
return;
}) catch {
try out.writeAll("\xe2\x9c\x97 Z.AI login failed: bad init response\n");
try out.flush();
return;
};
const init = parseInitData(init_data) catch {
try out.writeAll("\xe2\x9c\x97 Z.AI login failed: invalid authorize URL\n");
try out.flush();
return;
};
try out.print("\nTo log in to Z.AI Coding Plan, open this URL (browser should open automatically):\n\n {s}\n", .{init.authorize_url});
try signin_link.offer(io, out, init.authorize_url);
try out.writeAll("\nwaiting for authorization\xe2\x80\xa6\n");
try out.flush();
signin_link.open(io, init.authorize_url);
const poll_url = try std.fmt.allocPrint(arena, "{s}/oauth/cli/poll/{s}", .{ cli_base, init.flow_id });
var ready: ?ReadyData = null;
var attempts: usize = 0;
while (attempts < 360) : (attempts += 1) {
io.sleep(Io.Duration.fromSeconds(init.poll_interval_sec), .awake) catch {};
const now_s: i64 = @divTrunc(util.unixMs(io), 1000);
if (now_s >= init.expires_at) break;
const poll_v = httpJson(io, gpa, arena, .GET, poll_url, null, &init_headers) catch continue;
const poll_data = asObject(unwrapData(poll_v) catch continue) catch continue;
const status = parsePollData(poll_data) catch continue;
switch (status) {
.pending => continue,
.failed => {
try out.writeAll("\xe2\x9c\x97 authorization failed \xe2\x80\x94 run `graff login zai` again\n");
try out.flush();
return;
},
.ready => |r| {
ready = r;
break;
},
}
}
const tokens = ready orelse {
try out.writeAll("\xe2\x9c\x97 timed out waiting for authorization\n");
try out.flush();
return;
};
const api_key = provisionApiKey(io, gpa, arena, tokens.access_token) catch |err| {
try out.print("\xe2\x9c\x97 signed in but could not provision a Coding Plan key: {t}\n", .{err});
try out.flush();
return;
};
try writeAuth(io, arena, home, api_key, tokens.access_token, tokens.refresh_token, init.expires_at);
applyCodingOverride();
try out.print("{s}\xe2\x9c\x93{s} logged into Z.AI Coding Plan \xe2\x80\x94 wrote {s}. /model zai\n", .{ style.green, style.reset, authPath(arena, home) });
try out.flush();
}
test "isLoginName: zai aliases" {
try std.testing.expect(isLoginName("zai"));
try std.testing.expect(isLoginName("glm"));
try std.testing.expect(isLoginName("z.ai"));
try std.testing.expect(!isLoginName("xai"));
try std.testing.expect(!isLoginName("codegraff"));
}
test "parseInitData: requires https authorize URL and positive interval" {
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const a = arena_state.allocator();
const good = try parseJsonObject(a, "{\"authorize_url\":\"https://chat.z.ai/a\",\"flow_id\":\"f1\",\"expires_at\":9999999999,\"poll_interval_sec\":2}");
const init = try parseInitData(good);
try std.testing.expectEqualStrings("https://chat.z.ai/a", init.authorize_url);
try std.testing.expectEqualStrings("f1", init.flow_id);
try std.testing.expectEqual(@as(i64, 2), init.poll_interval_sec);
const http = try parseJsonObject(a, "{\"authorize_url\":\"http://evil.example/a\",\"flow_id\":\"f1\",\"expires_at\":9,\"poll_interval_sec\":2}");
try std.testing.expectError(error.BadOAuthResponse, parseInitData(http));
const no_interval = try parseJsonObject(a, "{\"authorize_url\":\"https://chat.z.ai/a\",\"flow_id\":\"f1\",\"expires_at\":9,\"poll_interval_sec\":0}");
try std.testing.expectError(error.BadOAuthResponse, parseInitData(no_interval));
}
test "parsePollData: pending, failed, ready, missing token" {
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const a = arena_state.allocator();
const pending = try parseJsonObject(a, "{\"status\":\"pending\"}");
try std.testing.expect(try parsePollData(pending) == .pending);
const failed = try parseJsonObject(a, "{\"status\":\"failed\"}");
try std.testing.expect(try parsePollData(failed) == .failed);
const ready = try parseJsonObject(a, "{\"status\":\"ready\",\"token\":\"jwt\",\"zai\":{\"access_token\":\"oa\",\"refresh_token\":\"rt\"}}");
const got = try parsePollData(ready);
try std.testing.expectEqualStrings("oa", got.ready.access_token);
try std.testing.expectEqualStrings("rt", got.ready.refresh_token);
try std.testing.expectEqualStrings("jwt", got.ready.jwt);
const missing = try parseJsonObject(a, "{\"status\":\"ready\",\"token\":\"jwt\"}");
try std.testing.expectError(error.BadOAuthResponse, parsePollData(missing));
}
test "pickOrgAndProject: default-name match, else first" {
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const a = arena_state.allocator();
const named_json = try std.fmt.allocPrint(a, "{{\"organizations\":[{{\"organizationId\":\"o2\",\"organizationName\":\"other\",\"projects\":[{{\"projectId\":\"p2\",\"projectName\":\"x\"}}]}},{{\"organizationId\":\"o1\",\"organizationName\":\"pre {s}\",\"projects\":[{{\"projectId\":\"p0\",\"projectName\":\"skip\"}},{{\"projectId\":\"p1\",\"projectName\":\"{s}\"}}]}}]}}", .{ default_org_name, default_project_name });
const named = try parseJsonObject(a, named_json);
const loc = pickOrgAndProject(named).?;
try std.testing.expectEqualStrings("o1", loc.organization_id);
try std.testing.expectEqualStrings("p1", loc.project_id);
const first = try parseJsonObject(a, "{\"organizations\":[{\"organizationId\":\"ox\",\"organizationName\":\"acme\",\"projects\":[{\"projectId\":\"px\",\"projectName\":\"eng\"}]}]}");
const loc2 = pickOrgAndProject(first).?;
try std.testing.expectEqualStrings("ox", loc2.organization_id);
try std.testing.expectEqualStrings("px", loc2.project_id);
const empty = try parseJsonObject(a, "{\"organizations\":[]}");
try std.testing.expect(pickOrgAndProject(empty) == null);
}
test "findGraffKey + composeApiKey: graff-api-key and id.secret" {
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const a = arena_state.allocator();
const keys = [_]KeySummary{
.{ .name = "other", .api_key = "aaa" },
.{ .name = api_key_name, .api_key = "kid" },
};
try std.testing.expectEqualStrings("kid", findGraffKey(&keys).?);
try std.testing.expect(findGraffKey(&.{.{ .name = "other", .api_key = "aaa" }}) == null);
try std.testing.expectEqualStrings("kid.sec", try composeApiKey(a, "kid", "sec"));
try std.testing.expectError(error.BadOAuthResponse, composeApiKey(a, "kid", ""));
}
test "isSuccessfulRemoteCode: 0/200 and string forms" {
try std.testing.expect(isSuccessfulRemoteCode(null));
try std.testing.expect(isSuccessfulRemoteCode(.{ .integer = 0 }));
try std.testing.expect(isSuccessfulRemoteCode(.{ .integer = 200 }));
try std.testing.expect(isSuccessfulRemoteCode(.{ .string = "0" }));
try std.testing.expect(isSuccessfulRemoteCode(.{ .string = "200" }));
try std.testing.expect(!isSuccessfulRemoteCode(.{ .integer = 401 }));
try std.testing.expect(!isSuccessfulRemoteCode(.{ .string = "no" }));
}
test "writeAuth/loadZaiOAuth: 0600 file, api_key round-trip, coding URL" {
if (builtin.os.tag == .windows) return;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{ .iterate = true });
defer tmp.cleanup();
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const arena = arena_state.allocator();
const home = try std.fmt.allocPrint(arena, ".zig-cache/tmp/{s}", .{&tmp.sub_path});
const saved = provider_mod.g_zai_url_override;
provider_mod.g_zai_url_override = null;
defer provider_mod.g_zai_url_override = saved;
try writeAuth(io, arena, home, "id.secret", "oa", "rt", 42);
const credentials = try tmp.dir.openDir(io, ".zai/credentials", .{});
defer credentials.close(io);
const file = try credentials.openFile(io, "graff-oauth.json", .{});
defer file.close(io);
try std.testing.expectEqual(@as(u32, 0o600), (try file.stat(io)).permissions.toMode() & 0o777);
const key = loadZaiOAuth(io, std.testing.allocator, arena, home, false, null).?;
try std.testing.expectEqualStrings("id.secret", key);
try std.testing.expectEqualStrings(provider_mod.zai_coding_url, provider_mod.g_zai_url_override.?);
}
test "applyCodingOverride: env override wins" {
const saved = provider_mod.g_zai_url_override;
defer provider_mod.g_zai_url_override = saved;
provider_mod.g_zai_url_override = "https://example.test/v4";
applyCodingOverride();
try std.testing.expectEqualStrings("https://example.test/v4", provider_mod.g_zai_url_override.?);
provider_mod.g_zai_url_override = null;
applyCodingOverride();
try std.testing.expectEqualStrings(provider_mod.zai_coding_url, provider_mod.g_zai_url_override.?);
}
test "preferPlan parks a metered ZAI_API_KEY behind a coding-plan login" {
if (builtin.os.tag == .windows) return;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{ .iterate = true });
defer tmp.cleanup();
var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena_state.deinit();
const arena = arena_state.allocator();
const home = try std.fmt.allocPrint(arena, ".zig-cache/tmp/{s}", .{&tmp.sub_path});
const saved = provider_mod.g_zai_url_override;
provider_mod.g_zai_url_override = null;
defer provider_mod.g_zai_url_override = saved;
credential_failover.resetForTest();
defer credential_failover.resetForTest();
try writeAuth(io, arena, home, "id.secret", "oa", "rt", 42);
const spec = provider_mod.specFor("zai").?;
var value: ?[]const u8 = "sk-metered";
var source: provider_mod.Keys.CredentialSource = .environment;
credential_failover.preferPlan(io, std.testing.allocator, arena, home, spec, &value, &source);
try std.testing.expectEqualStrings("id.secret", value.?);
try std.testing.expectEqual(provider_mod.Keys.CredentialSource.login, source);
try std.testing.expect(credential_failover.standingBy("zai"));
}