From 7fcfb52f760c43ddbc86a52cc5d4b05de788600b Mon Sep 17 00:00:00 2001 From: kaeferfreund <16595697+kaeferfreund@users.noreply.github.com> Date: Sat, 21 Nov 2026 16:33:39 +0000 Subject: [PATCH 1/3] =?UTF-8?q?feat(fx):=20show=20Vercel=20Token=20Pass=20?= =?UTF-8?q?credit=20under=20Usage=20=E2=86=92=20Limits?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fx reported no limits, so a team on Vercel Token Pass could not see in T3 Code how much of the pass was left or when it resets. The fx provider check now reads `fx credits --json` for the signed-in AI Gateway backend and reports the pass as one monthly window. The Vercel team names the account, so several fx instances or environments on one team count once. A used-up pass does not move new threads to the fallback model, because fx keeps running on AI Gateway credits. Co-Authored-By: Claude Fable 5.2 --- docs/user/usage.md | 7 ++ .../provider-fx/src/server/status.test.ts | 27 +++++- packages/provider-fx/src/server/status.ts | 48 ++++++++--- .../src/server/usageLimits.test.ts | 86 +++++++++++++++++++ .../provider-fx/src/server/usageLimits.ts | 73 ++++++++++++++++ packages/shared/src/usageLimits.test.ts | 1 + packages/shared/src/usageLimits.ts | 3 + 7 files changed, 232 insertions(+), 13 deletions(-) create mode 100644 packages/provider-fx/src/server/usageLimits.test.ts create mode 100644 packages/provider-fx/src/server/usageLimits.ts diff --git a/docs/user/usage.md b/docs/user/usage.md index 43f4c94a19328..7a3bdd12c7911 100644 --- a/docs/user/usage.md +++ b/docs/user/usage.md @@ -175,6 +175,13 @@ or endpoint configurations do not report subscription limits. Muse Code reports its session and weekly windows and its tier once the Muse CLI has run in a thread. Until then it shows no limits. Readings are not kept across a server restart. +fx reports how much of its Vercel team's [Token Pass](https://vercel.com/docs/ai-gateway/token-pass) +credit is left and when it resets. This needs fx 0.0.17 or later, a sign-in to Vercel AI Gateway +with `fx login`, and an active Token Pass on the team `fx teams` selects. The bar measures against +the $150 a pass refills to each billing period, so a pass bought partway through a period starts +partly used. With `fx login`, fx keeps running on the team's AI Gateway credits after the pass is +used up; those credits and fx's Codex and Grok subscriptions are not reported. + API-key accounts may not report subscription limits. This also applies to Claude connections using a proxy through `ANTHROPIC_AUTH_TOKEN`. diff --git a/packages/provider-fx/src/server/status.test.ts b/packages/provider-fx/src/server/status.test.ts index f4bab296fdd29..63957e7695f55 100644 --- a/packages/provider-fx/src/server/status.test.ts +++ b/packages/provider-fx/src/server/status.test.ts @@ -129,6 +129,7 @@ describe("checkFxProviderStatus", () => { "status --json", "status --json", "models --json", + "credits --json", ], }, { @@ -172,8 +173,13 @@ describe("checkFxProviderStatus", () => { model: "gpt-5.5", model_source: "Codex subscription", }), - "gateway status --json": status("fx login"), + "gateway status --json": status("fx login", { team: "example-team" }), "gateway models --json": GATEWAY_MODELS, + "gateway credits --json": JSON.stringify({ + kind: "credits", + balance: "12.50", + token_pass: { remaining: "75", resets_at: "2026-12-05T08:00:00.000Z" }, + }), "codex status --json": status("chatgpt subscription"), "codex models --json": models(["gpt-5.5", "gpt-5.4-mini"]), "grok status --json": status("missing"), @@ -183,12 +189,14 @@ describe("checkFxProviderStatus", () => { }, ["local"], ); - // Never `fx acp`, which saves a session; signed-out backends list nothing. + // Never `fx acp`, which saves a session; signed-out backends list nothing, and only the + // gateway has Token Pass credit, whichever backend is fx's default. assert.deepEqual(invoked.map(({ backend, args }) => `${backend ?? ""} ${args}`).toSorted(), [ " --version", " status --json", "codex models --json", "codex status --json", + "gateway credits --json", "gateway models --json", "gateway status --json", "grok status --json", @@ -219,6 +227,16 @@ describe("checkFxProviderStatus", () => { }, { name: "local", unavailableReason: "The configured provider credential is unavailable." }, ]); + assert.deepEqual(draft.usageLimits?.windows, [ + { + id: "token_pass", + kind: "monthly", + label: "Token Pass", + usedPercent: 50, + resetsAt: "2026-12-05T08:00:00.000Z", + }, + ]); + assert.equal(draft.usageLimits?.credentialFingerprint, "vercel-team:example-team"); assert.isDefined(draft.versionAdvisory); }), ); @@ -249,7 +267,7 @@ describe("checkFxProviderStatus", () => { it.effect("stays usable while fx's default backend is signed out", () => Effect.gen(function* () { - const { draft } = yield* check({ + const { draft, invoked } = yield* check({ " status --json": status("missing", { model: "spacexai/grok-4.7" }), "gateway status --json": status("missing"), "gateway models --json": GATEWAY_MODELS, @@ -268,6 +286,9 @@ describe("checkFxProviderStatus", () => { draft.models.map((model) => model.slug), ["default", "codex:gpt-5.5"], ); + // A signed-out gateway has no credit to read, so Limits shows no fx row. + assert.isFalse(invoked.some(({ args }) => args === "credits --json")); + assert.isUndefined(draft.usageLimits); // An earlier backend whose sign-in fx could not report does not hide Codex's. const unreadable = yield* check({ diff --git a/packages/provider-fx/src/server/status.ts b/packages/provider-fx/src/server/status.ts index 49b4b172fcc04..fb74daae7a99f 100644 --- a/packages/provider-fx/src/server/status.ts +++ b/packages/provider-fx/src/server/status.ts @@ -2,6 +2,7 @@ import { type ServerProviderAuth, type ServerProviderModel, type ServerProviderSubProvider, + type ServerProviderUsageLimits, } from "@t3tools/contracts"; import type { FxSettings } from "../settings.ts"; import { createModelCapabilities } from "@t3tools/shared/model"; @@ -38,6 +39,7 @@ import { resolveProviderProbeTimeoutMs, spawnAndCollect, } from "@t3tools/provider-core/server/snapshotProbe"; +import { fxCreditsToLimits } from "./usageLimits.ts"; const fxPresentation = (fullAccess: boolean) => ({ displayName: "fx", @@ -65,6 +67,8 @@ interface FxBackendProbe { readonly signedIn: boolean | undefined; readonly signInHint: string; readonly models: ReadonlyArray | undefined; + /** Token Pass is AI Gateway's, so only the signed-in gateway backend reports it. */ + readonly usageLimits: ServerProviderUsageLimits | undefined; } /** @@ -193,6 +197,7 @@ const FxStatus = Schema.fromJsonString( auth_help: Schema.optional(Schema.String), model: Schema.optional(Schema.String), model_source: Schema.optional(Schema.String), + team: Schema.optional(Schema.String), modes: Schema.optional(Schema.Array(Schema.Struct({ id: Schema.String }))), }), ); @@ -254,6 +259,7 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( settings: FxSettings, environment: NodeJS.ProcessEnv, backend: { readonly id: string; readonly name: string; readonly login?: string }, + checkedAt: string, ) { const env = { ...environment, FX_PROVIDER: backend.id, FX_MODEL: FX_DEFAULT_MODEL_SLUG }; const status = Option.getOrUndefined( @@ -261,12 +267,25 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( ); const auth = fxAuth(status?.auth).status; const signedIn = auth === "unknown" ? undefined : auth === "authenticated"; - const models = - signedIn === false - ? undefined - : Option.getOrUndefined( - Option.flatMap(yield* readFxCli(settings, ["models", "--json"], env), decodeFxModels), - )?.ids.flatMap((id) => nonEmptyTrimmed(id) ?? []); + const [models, usageLimits] = yield* Effect.all( + [ + signedIn === false + ? Effect.undefined + : readFxCli(settings, ["models", "--json"], env).pipe( + Effect.map((output) => + Option.getOrUndefined(Option.flatMap(output, decodeFxModels))?.ids.flatMap( + (id) => nonEmptyTrimmed(id) ?? [], + ), + ), + ), + backend.id === "gateway" && signedIn === true + ? readFxCli(settings, ["credits", "--json"], env).pipe( + Effect.map((credits) => fxCreditsToLimits({ credits, checkedAt, team: status?.team })), + ) + : Effect.undefined, + ], + { concurrency: "unbounded" }, + ); return { id: backend.id, name: backend.name, @@ -276,12 +295,14 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( ? (nonEmptyTrimmed(status?.auth_help) ?? "fx has no credential for this backend.") : `Signed out. Run \`${backend.login}\` on this machine.`, models, + usageLimits, } satisfies FxBackendProbe; }); /** - * Reads `fx --version`, `fx status --json` (the default backend and model) - * and, for every backend, its sign-in and `fx models --json`. + * Reads `fx --version`, `fx status --json` (the default backend and model), + * for every backend its sign-in and `fx models --json`, and the gateway's + * `fx credits --json`. */ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function* ( settings: FxSettings, @@ -342,7 +363,7 @@ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function ...FX_BUILT_IN_BACKENDS, ...(yield* readFxConfiguredBackends(environment)).map((id) => ({ id, name: id })), ], - (backend) => probeFxBackend(settings, probeEnvironment, backend), + (backend) => probeFxBackend(settings, probeEnvironment, backend, checkedAt), { concurrency: "unbounded" }, ); const defaultModel = nonEmptyTrimmed(status?.model); @@ -355,6 +376,7 @@ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function listed.length === 0 || listed.some((backend) => backend.models === undefined); const signedIn = backends.find((backend) => backend.signedIn === true); const statusAuth = fxAuth(status?.auth); + const tokenPass = backends.find((backend) => backend.usageLimits !== undefined)?.usageLimits; const auth: ServerProviderAuth = statusAuth.status !== "authenticated" && signedIn !== undefined ? { status: "authenticated", label: signedIn.name } @@ -382,7 +404,13 @@ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function return snapshot( settings, checkedAt, - { installed: true, version, auth, ...probe }, + { + installed: true, + version, + auth, + ...probe, + ...(tokenPass === undefined ? {} : { usageLimits: tokenPass }), + }, defaultModel, backends, status?.modes?.some((mode) => mode.id === FX_FULL_ACCESS_MODE_ID) ?? false, diff --git a/packages/provider-fx/src/server/usageLimits.test.ts b/packages/provider-fx/src/server/usageLimits.test.ts new file mode 100644 index 0000000000000..048d812f3547c --- /dev/null +++ b/packages/provider-fx/src/server/usageLimits.test.ts @@ -0,0 +1,86 @@ +import { describe, expect, it } from "@effect/vitest"; +import * as Option from "effect/Option"; + +import { fxCreditsToLimits } from "./usageLimits.ts"; + +const checkedAt = "2026-11-21T16:00:00.000Z"; +const limits = (credits: unknown) => + fxCreditsToLimits({ + credits: Option.some(typeof credits === "string" ? credits : JSON.stringify(credits)), + checkedAt, + team: "example-team", + }); +// `fx credits --json` from fx 0.0.17 (src/core/output/output_contracts.zig). +const credits = (tokenPass: unknown) => ({ + kind: "credits", + balance: "9.731069815", + used: "125.268930185", + plan: null, + token_pass: tokenPass, +}); + +describe("fx Token Pass limits", () => { + it("reads the credit left of the $150 a pass refills to", () => { + expect( + limits(credits({ remaining: "79.92906", resets_at: "2026-12-05T08:00:00.000Z" })), + ).toEqual({ + checkedAt, + windows: [ + { + id: "token_pass", + kind: "monthly", + label: "Token Pass", + usedPercent: expect.closeTo(46.71, 2), + resetsAt: "2026-12-05T08:00:00.000Z", + }, + ], + credentialFingerprint: "vercel-team:example-team", + }); + }); + + it.each([ + ["a used-up pass", { remaining: "0", resets_at: "2026-12-05T08:00:00.000Z" }, 100], + ["an untouched pass", { remaining: "150", resets_at: "2026-12-05T08:00:00.000Z" }, 0], + ["more credit than a pass refills to", { remaining: "180.5" }, 0], + ])("reports %s", (_label, tokenPass, usedPercent) => { + expect(limits(credits(tokenPass)).windows.map((window) => window.usedPercent)).toEqual([ + usedPercent, + ]); + }); + + it("leaves out a reset time fx did not report and an account for an API key without a team", () => { + const withoutTeam = fxCreditsToLimits({ + credits: Option.some(JSON.stringify(credits({ remaining: "5", resets_at: null }))), + checkedAt, + team: undefined, + }); + expect(withoutTeam.windows[0]).not.toHaveProperty("resetsAt"); + expect(withoutTeam).not.toHaveProperty("credentialFingerprint"); + }); + + it.each([ + ["a team without an active pass", credits(null)], + ["an fx older than Token Pass", { kind: "credits", balance: "1", used: "2", plan: null }], + ])("shows no limits for %s", (_label, output) => { + expect(limits(output)).toEqual({ + checkedAt, + windows: [], + unavailable: { reason: "unsupported" }, + }); + }); + + it.each([ + ["a credit AI Gateway could not read", credits({ remaining: null })], + ["an amount that is not a number", credits({ remaining: "1.2.3" })], + ["a credits error", { kind: "credits", error: "failed to fetch credits from gateway" }], + ["output that is not JSON", "[credits] balance=1"], + ])("keeps the earlier reading for %s", (_label, output) => { + expect(limits(output).unavailable?.reason).toBe("probeFailed"); + }); + + it("keeps the earlier reading when `fx credits` fails", () => { + expect( + fxCreditsToLimits({ credits: Option.none(), checkedAt, team: "example-team" }).unavailable, + ).toEqual({ reason: "probeFailed", message: "fx could not read the Token Pass credit." }); + }); +}); diff --git a/packages/provider-fx/src/server/usageLimits.ts b/packages/provider-fx/src/server/usageLimits.ts new file mode 100644 index 0000000000000..151d114bd6fd9 --- /dev/null +++ b/packages/provider-fx/src/server/usageLimits.ts @@ -0,0 +1,73 @@ +import type { ServerProviderUsageLimits } from "@t3tools/contracts"; +import * as DateTime from "effect/DateTime"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; +import { + clampPercent, + makeUnavailableUsageLimits, + makeUsageLimits, +} from "@t3tools/provider-core/server/usageLimits"; + +// Vercel reports only the credit left. A pass refills to this each billing period, and a pass +// bought mid-period starts with a prorated share, so its first period reads as partly used. +const TOKEN_PASS_PERIOD_CREDIT_USD = 150; + +/** + * `fx credits --json`, fx 0.0.17+. `token_pass` is null for a team without an + * active pass and absent on an older fx. `remaining` is US dollars, or null + * when AI Gateway could not read the credit. + */ +const FxCredits = Schema.fromJsonString( + Schema.Struct({ + error: Schema.optional(Schema.String), + token_pass: Schema.optional( + Schema.NullOr( + Schema.Struct({ + remaining: Schema.optional(Schema.NullOr(Schema.String)), + resets_at: Schema.optional(Schema.NullOr(Schema.String)), + }), + ), + ), + }), +); +const decodeFxCredits = Schema.decodeUnknownOption(FxCredits); + +/** The Token Pass credit of the Vercel team fx is signed in to, as one Limits window. */ +export function fxCreditsToLimits(input: { + /** Stdout of a successful `fx credits --json`, or none when it failed. */ + readonly credits: Option.Option; + readonly checkedAt: string; + /** Every login on a team spends the same pass, so the team names the account. */ + readonly team: string | undefined; +}): ServerProviderUsageLimits { + const { checkedAt } = input; + const probeFailed = makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: "fx could not read the Token Pass credit.", + }); + const credits = Option.getOrUndefined(Option.flatMap(input.credits, decodeFxCredits)); + if (credits === undefined || credits.error !== undefined) return probeFailed; + if (credits.token_pass === undefined || credits.token_pass === null) { + return makeUnavailableUsageLimits({ checkedAt, reason: "unsupported" }); + } + const remaining = credits.token_pass.remaining?.trim(); + if (!remaining || !/^\d+(\.\d+)?$/.test(remaining)) return probeFailed; + const reset = DateTime.make(credits.token_pass.resets_at ?? ""); + const team = input.team?.trim(); + return { + ...makeUsageLimits({ + checkedAt, + windows: [ + { + id: "token_pass", + kind: "monthly", + label: "Token Pass", + usedPercent: clampPercent(100 - (Number(remaining) / TOKEN_PASS_PERIOD_CREDIT_USD) * 100), + ...(Option.isSome(reset) ? { resetsAt: DateTime.formatIso(reset.value) } : {}), + }, + ], + }), + ...(team ? { credentialFingerprint: `vercel-team:${team}` } : {}), + }; +} diff --git a/packages/shared/src/usageLimits.test.ts b/packages/shared/src/usageLimits.test.ts index 6b553fe5f1555..50f5c33f194e1 100644 --- a/packages/shared/src/usageLimits.test.ts +++ b/packages/shared/src/usageLimits.test.ts @@ -181,6 +181,7 @@ describe("new thread model fallback", () => { ["opencode", "console-custom"], ], ["opencode", ["budget_all"], "opencode/model", false, undefined, []], + ["fx", ["token_pass"], "gateway:moonshotai/kimi-k3.1-pro", false, undefined, undefined], ] as const)( "matches %s pools %s to %s", (driver, ids, model, usesFallback, modelIds, providerIds) => { diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts index 711f3637d0a9f..a0ed349387232 100644 --- a/packages/shared/src/usageLimits.ts +++ b/packages/shared/src/usageLimits.ts @@ -71,6 +71,9 @@ export function exhaustedUsageWindow( return exhausted.find( (window) => !window.id.startsWith("go_") || model.startsWith("opencode-go/"), ); + case "fx": + // fx keeps running on AI Gateway credits once the team's Token Pass is used up. + return exhausted.find((window) => window.id !== "token_pass"); default: return exhausted[0]; } From b612b556e5d04ec7cdc9de7ae3541e57318b236a Mon Sep 17 00:00:00 2001 From: kaeferfreund <16595697+kaeferfreund@users.noreply.github.com> Date: Sat, 21 Nov 2026 18:16:01 +0000 Subject: [PATCH 2/3] fix(fx): a team switch clears the earlier Token Pass reading A failed `fx credits` read keeps the last published reading. The server drops it only when the snapshot's account or workspace changes, and the fx snapshot named neither, so after `fx teams` a failing read kept showing the previous team's credit. The snapshot now carries the gateway team as `auth.workspaceId`. Co-Authored-By: Claude Fable 5.2 --- packages/provider-fx/src/server/status.test.ts | 6 +++++- packages/provider-fx/src/server/status.ts | 18 +++++++++++++----- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/packages/provider-fx/src/server/status.test.ts b/packages/provider-fx/src/server/status.test.ts index 63957e7695f55..5a0edab515f34 100644 --- a/packages/provider-fx/src/server/status.test.ts +++ b/packages/provider-fx/src/server/status.test.ts @@ -203,7 +203,11 @@ describe("checkFxProviderStatus", () => { "local status --json", ]); assert.equal(draft.status, "ready"); - assert.deepEqual(draft.auth, { status: "authenticated", label: "chatgpt subscription" }); + assert.deepEqual(draft.auth, { + status: "authenticated", + label: "chatgpt subscription", + workspaceId: "example-team", + }); assert.deepEqual( draft.models.map((model) => [model.slug, model.name, model.subProvider]), [ diff --git a/packages/provider-fx/src/server/status.ts b/packages/provider-fx/src/server/status.ts index fb74daae7a99f..10e60365fafd6 100644 --- a/packages/provider-fx/src/server/status.ts +++ b/packages/provider-fx/src/server/status.ts @@ -69,6 +69,8 @@ interface FxBackendProbe { readonly models: ReadonlyArray | undefined; /** Token Pass is AI Gateway's, so only the signed-in gateway backend reports it. */ readonly usageLimits: ServerProviderUsageLimits | undefined; + /** The Vercel team those limits belong to. */ + readonly team: string | undefined; } /** @@ -267,6 +269,8 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( ); const auth = fxAuth(status?.auth).status; const signedIn = auth === "unknown" ? undefined : auth === "authenticated"; + const readsTokenPass = backend.id === "gateway" && signedIn === true; + const team = readsTokenPass ? nonEmptyTrimmed(status?.team) : undefined; const [models, usageLimits] = yield* Effect.all( [ signedIn === false @@ -278,9 +282,9 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( ), ), ), - backend.id === "gateway" && signedIn === true + readsTokenPass ? readFxCli(settings, ["credits", "--json"], env).pipe( - Effect.map((credits) => fxCreditsToLimits({ credits, checkedAt, team: status?.team })), + Effect.map((credits) => fxCreditsToLimits({ credits, checkedAt, team })), ) : Effect.undefined, ], @@ -296,6 +300,7 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( : `Signed out. Run \`${backend.login}\` on this machine.`, models, usageLimits, + team, } satisfies FxBackendProbe; }); @@ -376,11 +381,14 @@ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function listed.length === 0 || listed.some((backend) => backend.models === undefined); const signedIn = backends.find((backend) => backend.signedIn === true); const statusAuth = fxAuth(status?.auth); - const tokenPass = backends.find((backend) => backend.usageLimits !== undefined)?.usageLimits; - const auth: ServerProviderAuth = + const tokenPass = backends.find((backend) => backend.usageLimits !== undefined); + const backendAuth: ServerProviderAuth = statusAuth.status !== "authenticated" && signedIn !== undefined ? { status: "authenticated", label: signedIn.name } : statusAuth; + // The server keeps the last reading after a failed read only while this stays the same team. + const auth: ServerProviderAuth = + tokenPass?.team === undefined ? backendAuth : { ...backendAuth, workspaceId: tokenPass.team }; const probe = auth.status === "unauthenticated" ? { status: "error" as const, message: "Run `fx login` to sign in." } @@ -409,7 +417,7 @@ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function version, auth, ...probe, - ...(tokenPass === undefined ? {} : { usageLimits: tokenPass }), + ...(tokenPass?.usageLimits === undefined ? {} : { usageLimits: tokenPass.usageLimits }), }, defaultModel, backends, From 1eccbaf9f305ffe64d20a85316151048a443b453 Mon Sep 17 00:00:00 2001 From: kaeferfreund <16595697+kaeferfreund@users.noreply.github.com> Date: Sat, 21 Nov 2026 21:56:41 +0000 Subject: [PATCH 3/3] fix(fx): Token Pass reading survives an unreadable status and an overdrawn pass An unreadable gateway `fx status` was treated like a signed-out gateway and dropped the published reading, while a failed `fx credits` kept it. It now counts as a failed read. A signed-out gateway still clears it. fx passes on negative amounts and a bare decimal point for the credit left; those read as a failed probe and kept the last percentage. An overdrawn pass now reads as used up. The reading's time is taken when the credit is read, not when the provider check starts. The comment on the fallback rule and the user docs no longer claim that fx always continues on AI Gateway credits: a Token Pass API key stops. Co-Authored-By: Claude Fable 5.2 --- docs/user/usage.md | 11 +++++---- .../provider-fx/src/server/status.test.ts | 12 +++------- packages/provider-fx/src/server/status.ts | 24 +++++++++++-------- .../src/server/usageLimits.test.ts | 1 + .../provider-fx/src/server/usageLimits.ts | 6 ++--- packages/shared/src/usageLimits.ts | 3 ++- 6 files changed, 29 insertions(+), 28 deletions(-) diff --git a/docs/user/usage.md b/docs/user/usage.md index 7a3bdd12c7911..8985e56fe414f 100644 --- a/docs/user/usage.md +++ b/docs/user/usage.md @@ -176,11 +176,12 @@ Muse Code reports its session and weekly windows and its tier once the Muse CLI Until then it shows no limits. Readings are not kept across a server restart. fx reports how much of its Vercel team's [Token Pass](https://vercel.com/docs/ai-gateway/token-pass) -credit is left and when it resets. This needs fx 0.0.17 or later, a sign-in to Vercel AI Gateway -with `fx login`, and an active Token Pass on the team `fx teams` selects. The bar measures against -the $150 a pass refills to each billing period, so a pass bought partway through a period starts -partly used. With `fx login`, fx keeps running on the team's AI Gateway credits after the pass is -used up; those credits and fx's Codex and Grok subscriptions are not reported. +credit is left and when it resets. This needs fx 0.0.17 or later, a Vercel AI Gateway sign-in in +fx (`fx login` or an API key), and an active Token Pass on that sign-in's team. The bar measures +against the $150 a pass refills to each billing period, so a pass bought partway through a period +starts partly used. After the pass is used up, fx keeps running on the team's AI Gateway credits, +except with a Token Pass API key, which stops until the pass resets. Those credits and fx's Codex +and Grok subscriptions are not reported. API-key accounts may not report subscription limits. This also applies to Claude connections using a proxy through `ANTHROPIC_AUTH_TOKEN`. diff --git a/packages/provider-fx/src/server/status.test.ts b/packages/provider-fx/src/server/status.test.ts index 5a0edab515f34..fe5aa5dc50de7 100644 --- a/packages/provider-fx/src/server/status.test.ts +++ b/packages/provider-fx/src/server/status.test.ts @@ -231,15 +231,6 @@ describe("checkFxProviderStatus", () => { }, { name: "local", unavailableReason: "The configured provider credential is unavailable." }, ]); - assert.deepEqual(draft.usageLimits?.windows, [ - { - id: "token_pass", - kind: "monthly", - label: "Token Pass", - usedPercent: 50, - resetsAt: "2026-12-05T08:00:00.000Z", - }, - ]); assert.equal(draft.usageLimits?.credentialFingerprint, "vercel-team:example-team"); assert.isDefined(draft.versionAdvisory); }), @@ -306,6 +297,9 @@ describe("checkFxProviderStatus", () => { status: "authenticated", label: "Codex subscription", }); + // Unlike a signed-out gateway, this is a failed read, so the server keeps the last reading. + assert.equal(unreadable.draft.usageLimits?.unavailable?.reason, "probeFailed"); + assert.isFalse(unreadable.invoked.some(({ args }) => args === "credits --json")); }), ); diff --git a/packages/provider-fx/src/server/status.ts b/packages/provider-fx/src/server/status.ts index 10e60365fafd6..ce0c395149851 100644 --- a/packages/provider-fx/src/server/status.ts +++ b/packages/provider-fx/src/server/status.ts @@ -67,7 +67,7 @@ interface FxBackendProbe { readonly signedIn: boolean | undefined; readonly signInHint: string; readonly models: ReadonlyArray | undefined; - /** Token Pass is AI Gateway's, so only the signed-in gateway backend reports it. */ + /** Token Pass is AI Gateway's, so only the gateway backend reports it, unless it is signed out. */ readonly usageLimits: ServerProviderUsageLimits | undefined; /** The Vercel team those limits belong to. */ readonly team: string | undefined; @@ -261,7 +261,6 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( settings: FxSettings, environment: NodeJS.ProcessEnv, backend: { readonly id: string; readonly name: string; readonly login?: string }, - checkedAt: string, ) { const env = { ...environment, FX_PROVIDER: backend.id, FX_MODEL: FX_DEFAULT_MODEL_SLUG }; const status = Option.getOrUndefined( @@ -269,8 +268,7 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( ); const auth = fxAuth(status?.auth).status; const signedIn = auth === "unknown" ? undefined : auth === "authenticated"; - const readsTokenPass = backend.id === "gateway" && signedIn === true; - const team = readsTokenPass ? nonEmptyTrimmed(status?.team) : undefined; + const team = backend.id === "gateway" ? nonEmptyTrimmed(status?.team) : undefined; const [models, usageLimits] = yield* Effect.all( [ signedIn === false @@ -282,11 +280,17 @@ const probeFxBackend = Effect.fn("probeFxBackend")(function* ( ), ), ), - readsTokenPass - ? readFxCli(settings, ["credits", "--json"], env).pipe( - Effect.map((credits) => fxCreditsToLimits({ credits, checkedAt, team })), - ) - : Effect.undefined, + backend.id !== "gateway" || signedIn === false + ? Effect.undefined + : Effect.gen(function* () { + const checkedAt = DateTime.formatIso(yield* DateTime.now); + // An unreadable sign-in is a failed read, which keeps the last reading; signed out clears it. + const credits = + signedIn === true + ? yield* readFxCli(settings, ["credits", "--json"], env) + : Option.none(); + return fxCreditsToLimits({ credits, checkedAt, team }); + }), ], { concurrency: "unbounded" }, ); @@ -368,7 +372,7 @@ export const checkFxProviderStatus = Effect.fn("checkFxProviderStatus")(function ...FX_BUILT_IN_BACKENDS, ...(yield* readFxConfiguredBackends(environment)).map((id) => ({ id, name: id })), ], - (backend) => probeFxBackend(settings, probeEnvironment, backend, checkedAt), + (backend) => probeFxBackend(settings, probeEnvironment, backend), { concurrency: "unbounded" }, ); const defaultModel = nonEmptyTrimmed(status?.model); diff --git a/packages/provider-fx/src/server/usageLimits.test.ts b/packages/provider-fx/src/server/usageLimits.test.ts index 048d812f3547c..d0df5fbf44cd2 100644 --- a/packages/provider-fx/src/server/usageLimits.test.ts +++ b/packages/provider-fx/src/server/usageLimits.test.ts @@ -40,6 +40,7 @@ describe("fx Token Pass limits", () => { it.each([ ["a used-up pass", { remaining: "0", resets_at: "2026-12-05T08:00:00.000Z" }, 100], + ["an overdrawn pass", { remaining: "-0.42", resets_at: "2026-12-05T08:00:00.000Z" }, 100], ["an untouched pass", { remaining: "150", resets_at: "2026-12-05T08:00:00.000Z" }, 0], ["more credit than a pass refills to", { remaining: "180.5" }, 0], ])("reports %s", (_label, tokenPass, usedPercent) => { diff --git a/packages/provider-fx/src/server/usageLimits.ts b/packages/provider-fx/src/server/usageLimits.ts index 151d114bd6fd9..cd96cce731d37 100644 --- a/packages/provider-fx/src/server/usageLimits.ts +++ b/packages/provider-fx/src/server/usageLimits.ts @@ -52,9 +52,9 @@ export function fxCreditsToLimits(input: { return makeUnavailableUsageLimits({ checkedAt, reason: "unsupported" }); } const remaining = credits.token_pass.remaining?.trim(); - if (!remaining || !/^\d+(\.\d+)?$/.test(remaining)) return probeFailed; + // The amounts fx passes on: an overdrawn pass is negative, and a bare point is allowed. + if (!remaining || !/^-?(\d+\.?\d*|\.\d+)$/.test(remaining)) return probeFailed; const reset = DateTime.make(credits.token_pass.resets_at ?? ""); - const team = input.team?.trim(); return { ...makeUsageLimits({ checkedAt, @@ -68,6 +68,6 @@ export function fxCreditsToLimits(input: { }, ], }), - ...(team ? { credentialFingerprint: `vercel-team:${team}` } : {}), + ...(input.team ? { credentialFingerprint: `vercel-team:${input.team}` } : {}), }; } diff --git a/packages/shared/src/usageLimits.ts b/packages/shared/src/usageLimits.ts index a0ed349387232..466e8f74b01e6 100644 --- a/packages/shared/src/usageLimits.ts +++ b/packages/shared/src/usageLimits.ts @@ -72,7 +72,8 @@ export function exhaustedUsageWindow( (window) => !window.id.startsWith("go_") || model.startsWith("opencode-go/"), ); case "fx": - // fx keeps running on AI Gateway credits once the team's Token Pass is used up. + // Only a Token Pass API key stops when the pass is used up; other sign-ins go on with AI + // Gateway credits, and fx's other backends never use it. The reading cannot tell them apart. return exhausted.find((window) => window.id !== "token_pass"); default: return exhausted[0];