[Bug]: GitHub Copilot's plan quota never shows in Usage → Limits

[pWoLiAn]

Before submitting

• I searched existing issues and did not find a duplicate.
• I included enough detail to reproduce or investigate the problem.

Area

apps/server

Steps to reproduce

1. Sign in to GitHub Copilot CLI (copilot login) on a Copilot plan, and enable GitHub Copilot under Settings → Providers (ACP registry).
2. Send a Copilot thread any message and wait for the reply.
3. Open Usage → Limits.

Expected behavior

GitHub Copilot is listed with its monthly allowances (premium requests, plus chat/completions on plans that cap them) and the reset date, as Codex, Claude, Cursor, Grok, OpenCode and Antigravity are.

Actual behavior

Copilot is not listed. It runs through the generic packages/provider-acp-registry driver (copilotAcp.ts handles only subagent routing), and that driver never sets usageLimits, so providersWithLimits drops it. Over ACP, Copilot sends only per-session context token counts (usage_update), never plan quota.

The quota is available. The Copilot CLI's own /usage and the VS Code Copilot extension read it from GET https://api.github.com/copilot_internal/user, using the same GitHub auth that Copilot CLI already holds.

Impact

Minor bug or occasional failure

Version or commit

T3 Code (Beta) 0.1.1; checked against main @ 066c8fc

Environment

macOS 26.6.2, desktop app, GitHub Copilot CLI 1.0.101 (ACP mode), Copilot Individual plan

Logs or stack traces

# GET /copilot_internal/user (abridged; identifiers removed)
{
  "copilot_plan": "individual",
  "quota_reset_date_utc": "2026-11-01T00:00:00.000Z",
  "quota_snapshots": {
    "chat":                 { "entitlement": 200,  "remaining": 196,  "percent_remaining": 98.3,  "unlimited": false, "overage_permitted": false },
    "completions":          { "entitlement": 2000, "remaining": 2000, "percent_remaining": 100.0, "unlimited": false, "overage_permitted": false },
    "premium_interactions": { "entitlement": 0,    "remaining": 0,    "percent_remaining": 0.0,   "unlimited": false, "overage_permitted": false }
  }
}

Workaround

Run /usage inside Copilot CLI, or open GitHub → Settings → Billing → Premium requests. There is nothing in T3 itself.

Proposed fix

Add a Copilot usage reader, following apps/server/src/provider/{codex,claude,antigravity}UsageLimits.ts. On each status check, the ACP-registry driver for the Copilot agent would:

• call /copilot_internal/user with the token Copilot CLI uses (or gh auth token as a fallback);
• map each quota_snapshots entry with unlimited: false and entitlement > 0 to a monthly window that resets at quota_reset_date_utc;
• skip unlimited entries and zero-entitlement entries (e.g. premium_interactions on plans without premium requests), and note when overage_permitted is true;
• show one row per GitHub login, so the same account on several environments counts once.

The endpoint is undocumented (copilot_internal), so the reader should treat a missing or failed response as "no limits reported" rather than as an error. Mobile also needs a "GitHub Copilot" label (DRIVER_LABEL in UsageLimitsPooled.tsx).

Related: #18235 (the same gap for Muse Code), #193 (original Copilot CLI support).

Filed with Claude Opus 5.5 in GitHub Copilot CLI.

[asterxsk]

Implementation recommendation

Checked against main today. The ACP-registry driver already builds every Copilot snapshot through baseSnapshot() in packages/provider-acp-registry/src/server/driver.ts, and providersWithLimits() in packages/shared/src/usageLimits.ts only gates on provider.usageLimits !== undefined — no allowlist — so this needs a reader plus one wiring point, not new plumbing.

Concretely:

1. New reader: packages/provider-acp-registry/src/server/copilotUsageLimits.ts

Model it on packages/provider-cursor/src/server/usageLimits.ts: an Effect.fn that resolves credentials, calls the endpoint through effect/http HttpClient, decodes with Schema, and returns makeUsageLimits / makeUnavailableUsageLimits from @t3tools/provider-core/server/usageLimits. Export a pure copilotUsageResponseToLimits(response, checkedAt) so the mapping is unit-testable without HTTP.

2. Window ids in packages/shared/src/usageLimits.ts

Add a COPILOT_USAGE_WINDOWS constant next to CURSOR_USAGE_WINDOWS, with stable ids and labels:

export const COPILOT_USAGE_WINDOWS = [
  { id: "premium_interactions", label: "Premium requests" },
  { id: "chat", label: "Chat" },
  { id: "completions", label: "Completions" },
] as const;

Ids must be stable because ProviderUsageLimitsUpdate merges sparse updates by id.

3. Wire it into the driver snapshot

In driver.ts, when settings.agentId === "github-copilot-cli", attach the result to the snapshot the same way packages/provider-cursor/src/server/driver.ts does:

Effect.map((usageLimits) => ({ ...snapshot, usageLimits }))

Guard it so a slow or failing quota request never delays or fails provider status: short timeout (~5s), and on failure return the snapshot without usageLimits (or with makeUnavailableUsageLimits({ reason: "probeFailed" }) if you want the "limits unavailable" affordance). applyUsageLimitsUpdate already retains the last good bars across failed probes.

4. Credential resolution order

Match Copilot CLI's documented precedence rather than inventing a new login flow:

1. COPILOT_GITHUB_TOKEN, then GH_TOKEN, then GITHUB_TOKEN from the instance environment.
2. Copilot CLI's own token store: COPILOT_HOME if set, else ~/.copilot — apps.json (current) or legacy hosts.json, oauth_token; otherwise the OS credential store Copilot CLI used.
3. Fallback: gh auth token through HostProcess for users who only ran gh auth login.

Never persist the token. Store only a credentialFingerprint (hash of host + login) in ServerProviderUsageLimits, so the same GitHub login on two environments pools into one row instead of two.

5. Endpoint contract

GET https://api.github.com/copilot_internal/user with the bearer token. For GitHub Enterprise, the same path under the instance's API host. This endpoint is undocumented and expects editor-style headers (Editor-Version, Editor-Plugin-Version, User-Agent, X-Github-Api-Version); send them, and treat the whole reader as best-effort. Each refresh costs one request — rely on the existing five-minute per-environment throttle and do not add polling.

6. Mapping rules

For each quota_snapshots entry:

• skip unlimited: true;
• skip entitlement <= 0 (e.g. premium_interactions on plans without premium requests);
• usedPercent = clampPercent(100 - percent_remaining), falling back to (entitlement - remaining) / entitlement * 100;
• kind: "monthly", resetsAt from top-level quota_reset_date_utc, falling back to quota_reset_date (quota_reset_at is 0 in practice);
• label from the constant above, and put copilot_plan into provider.auth.label so the account row shows the plan;
• when overage_permitted is true and the quota is exhausted, keep the bar at 100% and surface it as overage, not as a hard failure — Copilot keeps serving. externalUsage can link to https://github.com/settings/billing.

7. Failure semantics

• 401/403 → treat as "not signed in to Copilot", omit usageLimits; do not show a probe error.
• 404/timeout/5xx/malformed JSON → makeUnavailableUsageLimits({ reason: "probeFailed" }).
• Never let this participate in provider readiness or the composer's usable-provider check.

8. UI

DRIVER_LABEL in apps/mobile/src/features/usage/UsageLimitsPooled.tsx has no ACP entry, so an ACP provider falls back to the raw driver string. Use displayName (Copilot) or add an acpRegistry label. Web already renders from displayName/auth.label. If mobile widgets are meant to include Copilot, extend apps/mobile/src/widgets/subscriptionUsageSnapshot.ts.

9. Tests

Fixtures for: Individual (chat + completions capped, premium_interactions entitlement 0), Business (premium 3000 with chat/completions unlimited), exhausted quota with overage_permitted, 401, malformed JSON, and a missing quota_reset_date_utc. Plus a driver test asserting a failed quota read never changes status or installed.

Upstream note

ACP's usage_update carries only context-window tokens and cumulative cost; the session-usage RFD explicitly defers rate limits and quotas. So the undocumented copilot_internal/user call is the only path today. If Copilot CLI later reports plan quota in usage_update._meta, prefer that and keep the HTTP reader as fallback. Worth also raising a quota RFD with agentclientprotocol/agent-client-protocol, since every ACP provider has this gap, not just Copilot.