import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs"; import { tmpdir } from "node:os"; import path from "node:path"; import { fileURLToPath } from "node:url"; import { InMemoryCredentialStore, type OAuthCredential, } from "@earendil-works/pi-ai"; import { initTheme } from "@earendil-works/pi-coding-agent"; import { afterEach, describe, expect, it, vi } from "vitest"; import { createPiSession, type PiSession, } from "../../../test/fixture/create-pi-session.ts"; import { codexAccountId } from "../src/providers/codex.ts"; describe("quota contract", () => { let session: PiSession | undefined; afterEach(async () => { vi.unstubAllGlobals(); await session?.dispose(); session = undefined; }); it("loads in real Pi extension runtime", async () => { const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ extensionPaths: [extensionPath] }); expect(session.extensions).toHaveLength(1); expect(session.extensions[0]!.path).toBe(extensionPath); }, 15000); it("writes its opt-in lifecycle trace inside the fixture sandbox", async () => { const root = mkdtempSync(path.join(tmpdir(), "pi-ext-quota-debug-")); try { const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ cwd: root, extensionPaths: [extensionPath], env: { PI_QUOTA_DEBUG: "1" }, }); const runner = session.session.extensionRunner; await runner.emit({ type: "session_start", reason: "startup" }); await runner.emit({ type: "session_shutdown", reason: "quit" }); const stateHome = session.env["XDG_STATE_HOME"]; if (!stateHome) throw new Error("missing sandbox state home"); const directory = path.join(stateHome, "pi-ext", "debug", "quota"); const [file] = readdirSync(directory); if (!file) throw new Error("missing debug file"); const events = readFileSync(path.join(directory, file), "utf8") .trim() .split("\n") .map((line) => JSON.parse(line).event); expect(events).toEqual( expect.arrayContaining(["session.start", "session.shutdown"]), ); } finally { await session?.dispose(); session = undefined; rmSync(root, { recursive: true, force: true }); } }); function codexToken(accountId: string) { const claim = Buffer.from( JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: accountId }, }), ).toString("base64url"); return `header.${claim}.signature`; } function quotaCommandContext( model: string | { provider: string; api: string } = "openai-codex", ) { if (!session) throw new Error("missing session"); initTheme("default", false); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; runner.setUIContext(ui, "tui"); const ctx = Object.create(runner.createCommandContext()); Object.defineProperty(ctx, "model", { value: typeof model === "string" ? { provider: model } : model, }); const command = runner.getCommand("quota"); if (!command) throw new Error("missing /quota command"); return { command, ctx }; } function installCodexRefresh( refresh: (credential: OAuthCredential) => Promise, ) { if (!session) throw new Error("missing session"); const runtime = session.session.modelRuntime; const provider = runtime.getProvider("openai-codex"); if (!provider?.auth.oauth) throw new Error("missing native Codex OAuth"); runtime.registerNativeProvider({ ...provider, auth: { ...provider.auth, oauth: { ...provider.auth.oauth, refresh: (credential, _signal) => refresh(credential), toAuth: async (credential) => ({ apiKey: credential.access }), }, }, }); } it("does not restore the widget after dismissal while a provider fetch is pending", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("acct-race"), refresh: "refresh-race", expires: Date.now() + 3_600_000, })); const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ credentials, extensionPaths: [extensionPath], }); let resolveFetch!: (response: Response) => void; const fetch = vi.fn( () => new Promise((resolve) => (resolveFetch = resolve)), ); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext(); const opening = command.handler("", ctx); await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(1)); await command.handler("", ctx); resolveFetch(Response.json({ rate_limit: {} })); await opening; const widgetCalls = vi.mocked(ctx.ui.setWidget).mock.calls; expect(widgetCalls.at(-1)?.[1]).toBeUndefined(); expect(session.errors).toEqual([]); }, 15000); it("keeps newest A quota through A→B→A and stale A fallback", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("acct-aba"), refresh: "refresh-aba", expires: Date.now() + 3_600_000, })); await credentials.modify("anthropic", async () => ({ type: "api_key", key: "anthropic-test-key", })); const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ credentials, extensionPaths: [extensionPath], }); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; runner.setUIContext(ui, "tui"); const codex = session.session.modelRuntime.getModels("openai-codex")[0]; const anthropic = session.session.modelRuntime.getModels("anthropic")[0]; if (!codex || !anthropic) throw new Error("missing native quota models"); const requests: Array<{ resolve: (response: Response) => void; reject: (error: Error) => void; }> = []; vi.stubGlobal( "fetch", vi.fn( () => new Promise((resolve, reject) => requests.push({ resolve, reject }), ), ), ); const firstA = session.session.setModel(codex); await vi.waitFor(() => expect(requests).toHaveLength(1)); const opening = runner .getCommand("quota") ?.handler("", runner.createCommandContext()); if (!opening) throw new Error("missing /quota command"); const switchingB = session.session.setModel(anthropic); await vi.waitFor(() => expect(requests).toHaveLength(2)); const latestA = session.session.setModel(codex); await vi.waitFor(() => expect(requests).toHaveLength(3)); requests[2]?.resolve( Response.json({ rate_limit: { primary_window: { used_percent: 20, limit_window_seconds: 18000 }, }, }), ); requests[0]?.resolve( Response.json({ rate_limit: { primary_window: { used_percent: 80, limit_window_seconds: 18000 }, }, }), ); requests[1]?.resolve(Response.json({ five_hour: { utilization: 35 } })); await Promise.all([firstA, switchingB, latestA, opening]); await runner .getCommand("quota") ?.handler("", runner.createCommandContext()); const fallback = runner .getCommand("quota") ?.handler("", runner.createCommandContext()); if (!fallback) throw new Error("missing /quota command"); await vi.waitFor(() => expect(requests).toHaveLength(4)); requests[3]?.reject(new Error("offline")); await fallback; expect(JSON.stringify(vi.mocked(ui.setWidget).mock.calls.at(-1))).toContain( "20%", ); expect(session.errors).toEqual([]); }, 15000); it("keeps response-header quota when an older poll fails over", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("acct-headers"), refresh: "refresh-headers", expires: Date.now() + 3_600_000, })); const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ credentials, extensionPaths: [extensionPath], }); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; runner.setUIContext(ui, "tui"); const codex = session.session.modelRuntime.getModels("openai-codex")[0]; if (!codex) throw new Error("missing native Codex model"); const requests: Array<{ resolve: (response: Response) => void; reject: (error: Error) => void; }> = []; vi.stubGlobal( "fetch", vi.fn( () => new Promise((resolve, reject) => requests.push({ resolve, reject }), ), ), ); const selecting = session.session.setModel(codex); await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(1)); const opening = runner .getCommand("quota") ?.handler("", runner.createCommandContext()); if (!opening) throw new Error("missing /quota command"); await runner.emit({ type: "after_provider_response", status: 200, headers: { "x-codex-primary-used-percent": "42" }, }); requests[0]?.resolve( Response.json({ rate_limit: { primary_window: { used_percent: 80, limit_window_seconds: 18000 }, secondary_window: { used_percent: 12, limit_window_seconds: 604800 }, }, credits: { balance: "12.5" }, }), ); await Promise.all([selecting, opening]); await runner .getCommand("quota") ?.handler("", runner.createCommandContext()); const fallback = runner .getCommand("quota") ?.handler("", runner.createCommandContext()); if (!fallback) throw new Error("missing /quota command"); await vi.waitFor(() => expect(requests).toHaveLength(2)); requests[1]?.reject(new Error("offline")); await fallback; const widget = JSON.stringify(vi.mocked(ui.setWidget).mock.calls.at(-1)); expect(widget).toContain("42%"); expect(widget).toContain("5h"); expect(widget).toContain("Weekly"); expect(widget).toContain("Credits"); expect(widget).toContain("12.5 left"); expect(widget).not.toContain("credits left"); expect(widget).not.toContain("80%"); expect(session.errors).toEqual([]); }, 15000); it("retains metadata from two successive partial headers while a poll is pending", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("synthetic-two-headers"), refresh: "unused", expires: Date.now() + 3600000, })); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], }); let resolve!: (response: Response) => void; const fetch = vi.fn( () => new Promise((done) => { resolve = done; }), ); vi.stubGlobal("fetch", fetch); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; runner.setUIContext(ui, "tui"); const codex = session.session.modelRuntime.getModels("openai-codex")[0]!; const selecting = session.session.setModel(codex); await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(1)); const opening = runner .getCommand("quota")! .handler("", runner.createCommandContext()); await runner.emit({ type: "after_provider_response", status: 200, headers: { "x-codex-primary-used-percent": "20", "x-codex-primary-window-minutes": "10080", "x-codex-primary-reset-at": String( Math.floor(Date.now() / 1000) + 7200, ), }, }); await runner.emit({ type: "after_provider_response", status: 200, headers: { "x-codex-primary-used-percent": "42" }, }); resolve( Response.json({ rate_limit: { primary_window: { used_percent: 80, limit_window_seconds: 18000 }, }, }), ); await Promise.all([selecting, opening]); const rows = ui.setWidget.mock.calls.at(-1)?.[1] as string[]; expect(rows.join("\n")).toContain("Weekly"); expect(rows.join("\n")).toContain("42%"); expect(rows.join("\n")).toContain("resets in"); expect(rows.join("\n")).not.toContain("5h"); expect(session.errors).toEqual([]); }, 15000); it("keeps header-only Groq quota across refreshes that cannot poll", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("groq", async () => ({ type: "api_key", key: "synthetic-key", })); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], }); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; runner.setUIContext(ui, "tui"); vi.stubGlobal( "fetch", vi.fn(async () => { throw new Error("Groq quota must not poll"); }), ); const model = session.session.modelRuntime.getModels("groq")[0]; if (!model) throw new Error("missing native Groq model"); await session.session.setModel(model); // Live chat-completion sample, 2026-10-28. await runner.emit({ type: "after_provider_response", status: 200, headers: { "x-ratelimit-limit-requests": "1000", "x-ratelimit-limit-tokens": "8000", "x-ratelimit-remaining-requests": "999", "x-ratelimit-remaining-tokens": "7986", "x-ratelimit-reset-requests": "1m26.4s", "x-ratelimit-reset-tokens": "105ms", }, }); const command = runner.getCommand("quota"); if (!command) throw new Error("missing /quota command"); await command.handler("", runner.createCommandContext()); const rows = JSON.stringify(vi.mocked(ui.setWidget).mock.calls.at(-1)); expect(rows).toContain("Requests/day"); expect(rows).toContain("1 / 1,000 used"); expect(rows).not.toContain("resets"); expect(rows).not.toContain("Quota unavailable"); expect(fetch).not.toHaveBeenCalled(); expect(session.errors).toEqual([]); }, 15000); it("renders a weekly-only Codex response-header quota in /quota", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("acct-weekly"), refresh: "refresh-weekly", expires: Date.now() + 3_600_000, })); const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ credentials, extensionPaths: [extensionPath], }); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; runner.setUIContext(ui, "tui"); vi.stubGlobal( "fetch", vi.fn(async () => Response.json({ rate_limit: {} })), ); const codex = session.session.modelRuntime.getModels("openai-codex")[0]; if (!codex) throw new Error("missing native Codex model"); await session.session.setModel(codex); await runner .getCommand("quota") ?.handler("", runner.createCommandContext()); await runner.emit({ type: "after_provider_response", status: 200, headers: { "x-codex-secondary-used-percent": "42", "x-codex-secondary-window-minutes": "10080", }, }); const widget = JSON.stringify(vi.mocked(ui.setWidget).mock.calls.at(-1)); expect(widget).toContain("Weekly"); expect(widget).toContain("42%"); expect(widget).not.toContain("5h"); expect(session.errors).toEqual([]); }, 15000); it("uses active stored Codex OAuth token, never fixture auth files", async () => { const credentials = new InMemoryCredentialStore(); const token = codexToken("acct-active"); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: token, refresh: "refresh-active", expires: Date.now() + 3_600_000, })); const root = mkdtempSync(path.join(tmpdir(), "pi-ext-quota-auth-")); try { const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ cwd: root, credentials, extensionPaths: [extensionPath], }); writeFileSync( path.join(session.agentDir, "auth.json"), JSON.stringify({ "openai-codex": { type: "oauth", access: codexToken("acct-default"), refresh: "refresh-default", expires: Date.now() + 3_600_000, accountId: "acct-default", }, }), ); const codexHome = path.join(session.env["HOME"]!, ".codex"); mkdirSync(codexHome, { recursive: true }); writeFileSync( path.join(codexHome, "auth.json"), JSON.stringify({ tokens: { access_token: codexToken("acct-codex"), account_id: "acct-codex", }, }), ); const fetch = vi.fn(async (_input: string | URL, _init?: RequestInit) => { return Response.json({ rate_limit: {} }); }); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext(); await command.handler("", ctx); expect(fetch).toHaveBeenCalledTimes(1); const [url, init] = fetch.mock.calls[0]!; expect(String(url)).toBe("https://chatgpt.com/backend-api/wham/usage"); const headers = new Headers(init?.headers); expect(headers.get("Authorization")).toBe(`Bearer ${token}`); expect(headers.get("ChatGPT-Account-Id")).toBe("acct-active"); expect(session.errors).toEqual([]); } finally { await session?.dispose(); session = undefined; rmSync(root, { recursive: true, force: true }); } }, 15000); it.each([ ["malformed token", "not-a-jwt"], ["missing Codex account claim", "header.e30.signature"], ["no OAuth credential", undefined], ] as const)( "does not request Codex quota with %s", async (_name, access) => { const credentials = new InMemoryCredentialStore(); if (access) { await credentials.modify("openai-codex", async () => ({ type: "oauth", access, refresh: "refresh", expires: Date.now() + 3_600_000, })); } const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ credentials, extensionPaths: [extensionPath], }); const fetch = vi.fn(async (input: string | URL) => { throw new Error(`unexpected network endpoint: ${input}`); }); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext(); await command.handler("", ctx); expect(fetch).not.toHaveBeenCalled(); expect(session.errors).toEqual([]); }, 15000, ); it("refreshes expired Codex OAuth before polling with refreshed account", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("acct-old"), refresh: "refresh-old", expires: Date.now() - 1, account_id: "acct-old-credential", })); const extensionPath = fileURLToPath( new URL("../index.ts", import.meta.url), ); session = await createPiSession({ credentials, extensionPaths: [extensionPath], }); const refreshed = codexToken("acct-refreshed"); const refresh = vi.fn(async () => ({ type: "oauth" as const, access: refreshed, refresh: "refresh-new", expires: Date.now() + 3_600_000, account_id: "acct-old-credential", })); installCodexRefresh(refresh); const fetch = vi.fn(async (_input: string | URL, _init?: RequestInit) => Response.json({ rate_limit: {} }), ); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext(); await command.handler("", ctx); expect(refresh).toHaveBeenCalledTimes(1); expect(fetch).toHaveBeenCalledTimes(1); const [url, init] = fetch.mock.calls[0]!; expect(String(url)).toBe("https://chatgpt.com/backend-api/wham/usage"); const headers = new Headers(init?.headers); expect(headers.get("Authorization")).toBe(`Bearer ${refreshed}`); expect(headers.get("ChatGPT-Account-Id")).toBe("acct-refreshed"); expect(session.errors).toEqual([]); }, 15000); it("derives Codex account identity only from the supplied token", () => { const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString("base64url"); const token = `header.${encode({ "https://api.openai.com/auth": { chatgpt_account_id: "acct-session" } })}.signature`; expect(codexAccountId(token)).toBe("acct-session"); expect( codexAccountId( `header.${encode({ account_id: "acct-other" })}.signature`, ), ).toBeUndefined(); expect( codexAccountId( `header.${encode({ "https://api.openai.com/auth": { chatgpt_account_id: "\n" } })}.signature`, ), ).toBeUndefined(); expect(codexAccountId("malformed-token")).toBeUndefined(); }); it.each([ [ "coexisting aliases and scoped limits", { five_hour: { utilization: 6 }, seven_day: { utilization: 54 }, limits: [ { kind: "session", percent: 6, is_active: false }, { kind: "weekly_all", percent: 54, is_active: false }, { kind: "weekly_scoped", percent: 81, scope: { model: { display_name: "Fable" } }, is_active: true, }, ], }, 3, ], [ "missing legacy windows", { limits: [ { kind: "weekly_scoped", percent: 81, scope: { model: { display_name: "Fable" } }, is_active: false, }, ], }, 1, ], ] as const)( "renders Anthropic %s through registered /quota", async (_name, response, bucketCount) => { const credentials = new InMemoryCredentialStore(); await credentials.modify("anthropic", async () => ({ type: "api_key", key: "synthetic-key", })); session = await createPiSession({ credentials, extensionPaths: [ fileURLToPath(new URL("../index.ts", import.meta.url)), ], }); const fetch = vi.fn(async (_input: string | URL) => Response.json(response), ); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext("anthropic"); await command.handler("", ctx); expect(String(fetch.mock.calls[0]?.[0] ?? "")).toBe( "https://api.anthropic.com/api/oauth/usage", ); const rows = vi .mocked(ctx.ui.setWidget) .mock.calls.at(-1)?.[1] as string[]; expect(rows.filter((line) => line.includes(" used"))).toHaveLength( bucketCount, ); expect(rows.join("\n")).toContain("Fable"); expect(rows.join("\n")).toContain("81%"); expect(rows.join("\n")).not.toMatch(/[^0-9]0%/); expect(session.errors).toEqual([]); }, 15000, ); it("shows current M Plan percentages and the binding shared window through /quota", async () => { const credentials = new InMemoryCredentialStore(); const key = "sk-cp-synthetic-quota-key"; await credentials.modify("minimax", async () => ({ type: "api_key", key, })); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], }); // Reduced live M Plan shape (2026-11-09), with synthetic reset times. const fetch = vi.fn(async (_input: string | URL, _init?: RequestInit) => Response.json({ model_remains: [ { model_name: "general", current_interval_total_count: 0, current_interval_usage_count: 0, current_interval_remaining_percent: 99, end_time: Date.now() + 18000000, current_weekly_total_count: 0, current_weekly_usage_count: 0, current_weekly_remaining_percent: 97, weekly_end_time: Date.now() + 604800000, }, ], base_resp: { status_code: 0, status_msg: "success" }, }), ); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext("minimax"); await command.handler("", ctx); expect(fetch).toHaveBeenCalledTimes(1); const [url, init] = fetch.mock.calls[0]!; expect(String(url)).toBe("https://www.minimax.io/v1/token_plan/remains"); expect(new Headers(init?.headers).get("Authorization")).toBe( `Bearer ${key}`, ); expect(init?.redirect).toBe("error"); const rows = vi.mocked(ctx.ui.setWidget).mock.calls.at(-1)?.[1] as string[]; expect(rows.find((row) => row.includes("5h"))).toContain("1% used"); expect(rows.find((row) => row.includes("Weekly"))).toContain("3% used"); expect(rows.join("\n")).toContain("resets in"); expect(rows.join("\n")).not.toContain("0 / 0"); expect(rows.join("\n")).not.toContain(key); expect(vi.mocked(ctx.ui.setStatus).mock.calls.at(-1)?.[1]).toContain( "Weekly 3%", ); expect(session.errors).toEqual([]); }, 15000); it.each(["provider", "auth"] as const)( "never sends MiniMax credentials through /quota with %s region mismatch", async (source) => { const key = ["sk", "cp", "fixture"].join("-"); const credentials = new InMemoryCredentialStore(); await credentials.modify("minimax", async () => ({ type: "api_key", key, })); session = await createPiSession({ credentials, extensionPaths: [ fileURLToPath(new URL("../index.ts", import.meta.url)), ], }); const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext("minimax"); if (source === "provider") { const provider = ctx.modelRegistry.getProvider("minimax"); if (!provider) throw new Error("Missing native MiniMax provider"); vi.spyOn(ctx.modelRegistry, "getProvider").mockReturnValue({ ...provider, baseUrl: "https://api.minimaxi.com/anthropic", }); } else { vi.spyOn(ctx.modelRegistry, "getProviderAuth").mockResolvedValue({ auth: { apiKey: key, baseUrl: "https://api.minimaxi.com/anthropic", }, }); } await command.handler("", ctx); expect(fetch).not.toHaveBeenCalled(); expect( JSON.stringify(vi.mocked(ctx.ui.setWidget).mock.calls), ).not.toContain("sk-cp-fixture"); expect(session.errors).toEqual([]); }, 15000, ); async function secondaryQuotaSession() { const credentials = new InMemoryCredentialStore(); await credentials.modify("anthropic", async () => ({ type: "api_key", key: "synthetic-anthropic-key", })); await credentials.modify("minimax", async () => ({ type: "api_key", key: "sk-cp-synthetic-secondary", })); // A sibling extension shares Pi's bus: it reports activity and hosts the footer. let bus!: { emit: (channel: string, data: unknown) => void }; const segments = new Map(); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], extensionFactories: [ (pi) => { bus = pi.events; pi.events.on("footer:segment", (data) => { const segment = data as { id: string; text?: string; accept: () => void; }; segment.accept(); if (segment.text === undefined) segments.delete(segment.id); else segments.set(segment.id, segment.text); }); }, ], }); const calls = { anthropic: 0, minimax: 0 }; vi.stubGlobal( "fetch", vi.fn(async (input: string | URL) => { const url = String(input); if (url === "https://api.anthropic.com/api/oauth/usage") { calls.anthropic++; return Response.json({ five_hour: { utilization: 35 } }); } if (url === "https://www.minimax.io/v1/token_plan/remains") { calls.minimax++; return Response.json({ model_remains: [ { model_name: "general", current_interval_total_count: 0, current_interval_usage_count: 0, current_interval_remaining_percent: 88, }, ], base_resp: { status_code: 0, status_msg: "success" }, }); } throw new Error(`unexpected network endpoint: ${url}`); }), ); const runner = session.session.extensionRunner; const ui = { ...runner.getUIContext(), setStatus: vi.fn(), setWidget: vi.fn(), }; initTheme("default", false); runner.setUIContext(ui, "tui"); // Same-model selection emits no model_select; alternate models to trigger it. const model = (provider: string, index = 0) => { const found = session?.session.modelRuntime.getModels(provider)[index]; if (!found) throw new Error(`missing native ${provider} model`); return found; }; const openQuota = async () => { const command = runner.getCommand("quota"); if (!command) throw new Error("missing /quota command"); await command.handler("", runner.createCommandContext()); }; const widget = () => (ui.setWidget.mock.calls.at(-1)?.[1] as string[] | undefined)?.join( "\n", ) ?? ""; return { bus, segments, calls, runner, model, openQuota, widget }; } it("shows event-reported MiniMax quota beside the active Anthropic provider until session_start", async () => { const { bus, segments, calls, runner, model, openQuota, widget } = await secondaryQuotaSession(); vi.useFakeTimers({ toFake: ["setInterval", "clearInterval"] }); try { if (!session) throw new Error("missing session"); await session.session.setModel(model("anthropic")); await openQuota(); await vi.waitFor(() => expect(segments.get("quota:anthropic")).toContain("35%"), ); for (const invalid of [ null, "minimax", { provider: 7 }, { provider: "MiniMax" }, { provider: "google" }, { provider: "toString" }, ]) bus.emit("quota:provider-activity", invalid); await new Promise((resolve) => setTimeout(resolve, 20)); expect(calls.minimax).toBe(0); expect([...segments.keys()]).toEqual(["quota:anthropic"]); bus.emit("quota:provider-activity", { provider: "minimax" }); await vi.waitFor(() => expect(segments.get("quota:minimax")).toBe("MiniMax 5h 12%"), ); expect(calls.minimax).toBe(1); expect(segments.get("quota:anthropic")).toMatch(/^5h 35%/); expect(widget()).toContain("● Anthropic"); expect(widget()).toContain("● MiniMax"); expect(widget()).toContain("12% used"); // Periodic refresh and header updates keep the secondary provider. const before = { ...calls }; await vi.advanceTimersByTimeAsync(300000); await vi.waitFor(() => { expect(calls.anthropic).toBe(before.anthropic + 1); expect(calls.minimax).toBe(before.minimax + 1); }); await runner.emit({ type: "after_provider_response", status: 200, headers: { "anthropic-ratelimit-unified-5h-utilization": "0.41" }, }); expect(segments.get("quota:anthropic")).toMatch(/^5h 41%/); expect(segments.get("quota:minimax")).toBe("MiniMax 5h 12%"); expect(widget()).toContain("● MiniMax"); await session.session.setModel(model("anthropic", 1)); expect(calls.anthropic).toBe(before.anthropic + 2); expect(calls.minimax).toBe(before.minimax + 2); expect(segments.has("quota:minimax")).toBe(true); await runner.emit({ type: "session_start", reason: "startup" }); expect(segments.size).toBe(0); await session.session.setModel(model("anthropic")); expect(calls.anthropic).toBe(before.anthropic + 3); await vi.waitFor(() => expect(segments.has("quota:anthropic")).toBe(true), ); expect(segments.has("quota:minimax")).toBe(false); expect(calls.minimax).toBe(before.minimax + 2); expect(session.errors).toEqual([]); } finally { vi.useRealTimers(); } }, 15000); it("does not duplicate an event-reported provider that is already active", async () => { const { bus, segments, calls, model, openQuota, widget } = await secondaryQuotaSession(); if (!session) throw new Error("missing session"); await session.session.setModel(model("minimax")); await openQuota(); const polled = calls.minimax; bus.emit("quota:provider-activity", { provider: "minimax" }); await new Promise((resolve) => setTimeout(resolve, 20)); expect(calls.minimax).toBe(polled); await session.session.setModel(model("minimax", 1)); expect(calls.minimax).toBe(polled + 1); expect([...segments.keys()]).toEqual(["quota:minimax"]); expect(segments.get("quota:minimax")).toMatch(/^5h 12%/); expect(widget().match(/● MiniMax/g)).toHaveLength(1); expect(calls.anthropic).toBe(0); expect(session.errors).toEqual([]); }, 15000); it("renders independent Zai windows through registered /quota", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("zai", async () => ({ type: "api_key", key: "synthetic-key", })); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], }); vi.stubGlobal( "fetch", vi.fn(async () => Response.json({ success: true, data: { limits: [ { type: "CREDIT_LIMIT", unit: 3, number: 5, usage: 12000, currentValue: 0, remaining: 12000, percentage: 0, }, { type: "CREDIT_LIMIT", unit: 6, number: 1, usage: 60000, currentValue: 60021, remaining: 0, percentage: 100, nextResetTime: Date.now() + 3600000, }, ], }, }), ), ); const { command, ctx } = quotaCommandContext("zai"); await command.handler("", ctx); const rows = vi.mocked(ctx.ui.setWidget).mock.calls.at(-1)?.[1] as string[]; const five = rows.find((line) => line.includes("5h")); const weekly = rows.find((line) => line.includes("Weekly")); expect(five).toContain("(0%)"); expect(five).not.toContain("resets"); expect(weekly).toContain("(100%)"); expect(weekly).toContain("resets"); expect(session.errors).toEqual([]); }, 15000); it("shows the routed physical provider's quota under a virtual selection", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openrouter", async () => ({ type: "api_key", key: "synthetic-key", })); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], }); const fetch = vi.fn(async (_url: string | URL | Request) => Response.json({ data: { is_free_tier: true, free_model_daily_requests: { used: 1, limit: 50, remaining: 49 }, }, }), ); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext({ provider: "grts", api: "pi-virtual", }); Object.defineProperty(ctx, "sessionManager", { value: { getBranch: () => [ { type: "model_change" }, { type: "message", message: { role: "assistant", provider: "openrouter", api: "openai-completions", stopReason: "stop", }, }, ], }, }); await command.handler("", ctx); expect(String(fetch.mock.calls[0]?.[0])).toBe( "https://openrouter.ai/api/v1/key", ); const rows = vi.mocked(ctx.ui.setWidget).mock.calls.at(-1)?.[1] as string[]; expect(rows.join("\n")).toContain("OpenRouter"); expect(rows.join("\n")).toContain("1 / 50 requests used"); expect(session.errors).toEqual([]); }, 15000); it("keeps weekly-only Codex widget free of empty secondary header placeholders", async () => { const credentials = new InMemoryCredentialStore(); await credentials.modify("openai-codex", async () => ({ type: "oauth", access: codexToken("synthetic-weekly"), refresh: "unused", expires: Date.now() + 3600000, })); session = await createPiSession({ credentials, extensionPaths: [fileURLToPath(new URL("../index.ts", import.meta.url))], }); vi.stubGlobal( "fetch", vi.fn(async () => Response.json({ rate_limit: { primary_window: { used_percent: 42, limit_window_seconds: 604800 }, secondary_window: null, }, }), ), ); const model = session.session.modelRuntime.getModels("openai-codex")[0]; if (!model) throw new Error("missing native Codex model"); await session.session.setModel(model); const { command, ctx } = quotaCommandContext(); await command.handler("", ctx); await session.session.extensionRunner.emit({ type: "after_provider_response", status: 200, headers: { "x-codex-primary-used-percent": "43", "x-codex-primary-window-minutes": "10080", "x-codex-secondary-used-percent": "0", "x-codex-secondary-window-minutes": "0", }, }); const rows = vi.mocked(ctx.ui.setWidget).mock.calls.at(-1)?.[1] as string[]; expect(rows.join("\n")).not.toContain("Secondary"); expect(rows.join("\n")).toContain("Weekly"); expect(rows.join("\n")).toContain("43%"); expect(rows.join("\n")).not.toContain("5h"); expect(vi.mocked(ctx.ui.setStatus).mock.calls.at(-1)?.[1]).toContain( "Weekly 43%", ); expect(session.errors).toEqual([]); }, 15000); it.each(["google", "google-gemini-cli"])( "never requests excluded Google provider %s", async (provider) => { session = await createPiSession({ extensionPaths: [ fileURLToPath(new URL("../index.ts", import.meta.url)), ], }); const fetch = vi.fn(); vi.stubGlobal("fetch", fetch); const { command, ctx } = quotaCommandContext(provider); await command.handler("", ctx); expect(fetch).not.toHaveBeenCalled(); }, 15000, ); });