The best way to control Claude Code, Codex and more from any computer or phone
feat(opencode): read usage limits from the connected server (#34146)
Yash Singh committed
Nov 12, 2026 at 12:18 UTC
63d5c6dfe44fad3eb29bdee2df00aadc2b57e4c5
10 files changed
+630
-29
packages/contracts/src/providerUsageLimits.ts
+3
@@ -14,6 +14,9 @@ export const ServerProviderUsageWindow = Schema.Struct({
14
id: TrimmedNonEmptyString,
15
kind: Schema.Literals(["session", "weekly", "monthly", "other"]),
16
label: TrimmedNonEmptyString,
17
+ /** When present, this limit applies only to these provider model IDs. */
18
+ modelIds: Schema.optional(Schema.Array(TrimmedNonEmptyString)),
19
+ providerIds: Schema.optional(Schema.Array(TrimmedNonEmptyString)),
20
usedPercent: Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 100 })),
21
resetsAt: Schema.optional(IsoDateTime),
22
windowDurationMins: Schema.optional(NonNegativeInt),
packages/provider-core/src/server/usageLimits.test.ts
+23
@@ -33,6 +33,29 @@ describe("applyUsageLimitsUpdate", () => {
33
},
34
});
35
expect(next).toBe(published);
36
+ const scoped = { checkedAt, windows: [{ ...weekly, modelIds: ["opencode/a"] }] };
37
+ const providerScoped = { checkedAt, windows: [{ ...weekly, providerIds: ["opencode"] }] };
38
+ expect(
39
+ applyUsageLimitsUpdate({
40
+ previous: providerScoped,
41
+ checkedAt,
42
+ update: { windows: [{ ...weekly, providerIds: ["console-custom"] }] },
43
+ })?.windows[0]?.providerIds,
44
+ ).toEqual(["console-custom"]);
45
+ expect(
46
+ applyUsageLimitsUpdate({
47
+ previous: scoped,
48
+ checkedAt,
49
+ update: { windows: [{ ...weekly, modelIds: ["opencode/a"] }] },
50
+ }),
51
+ ).toBe(scoped);
52
+ expect(
53
+ applyUsageLimitsUpdate({
54
+ previous: scoped,
55
+ checkedAt,
56
+ update: { windows: [{ ...weekly, modelIds: ["opencode/b"] }] },
57
+ })?.windows[0]?.modelIds,
58
+ ).toEqual(["opencode/b"]);
59
});
60
61
it("upserts by id and keeps the reset a percent-only update omits", () => {
packages/provider-core/src/server/usageLimits.ts
+10
@@ -94,6 +94,16 @@ function usageWindowEquals(a: ServerProviderUsageWindow, b: ServerProviderUsageW
94
a.kind === b.kind &&
95
a.label === b.label &&
96
a.usedPercent === b.usedPercent &&
97
+ (a.modelIds === b.modelIds ||
98
+ (a.modelIds !== undefined &&
99
+ b.modelIds !== undefined &&
100
+ a.modelIds.length === b.modelIds.length &&
101
+ a.modelIds.every((id, index) => id === b.modelIds?.[index]))) &&
102
+ (a.providerIds === b.providerIds ||
103
+ (a.providerIds !== undefined &&
104
+ b.providerIds !== undefined &&
105
+ a.providerIds.length === b.providerIds.length &&
106
+ a.providerIds.every((id, index) => id === b.providerIds?.[index]))) &&
107
a.resetsAt === b.resetsAt &&
108
a.windowDurationMins === b.windowDurationMins
109
);
packages/provider-opencode/src/server/driver.test.ts
+79
@@ -804,6 +804,81 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
804
}).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
805
);
806
807
+ it.effect.each([
808
+ { status: 200, data: null, reason: "unsupported" },
809
+ { status: 404, data: null, reason: "unsupported" },
810
+ { status: 503, data: null, reason: "probeFailed" },
811
+ {
812
+ status: 200,
813
+ data: {
814
+ workspace: {
815
+ id: "remote-workspace",
816
+ name: "Remote workspace",
817
+ usageURL: "https://opencode.ai/console/remote-workspace",
818
+ },
819
+ budgets: [
820
+ {
821
+ id: "all",
822
+ limit: 20,
823
+ spent: 15,
824
+ scope: "combined",
825
+ per: "set",
826
+ coverage: "all",
827
+ models: [],
828
+ shared: true,
829
+ resetsAt: 1793491200000,
830
+ },
831
+ ],
832
+ },
833
+ reason: undefined,
834
+ },
835
+ ])(
836
+ "reads external workspace usage without local credentials, HTTP $status, $reason",
837
+ (scenario) =>
838
+ Effect.gen(function* () {
839
+ const requested: string[] = [];
840
+ const replay = replayOpenCodeServer(OPENCODE_2_RESPONSES, "secret", requested);
841
+ const server = HttpClient.make((request) => {
842
+ assert.notInclude(request.url, "opencode.ai/zen");
843
+ if (request.url.endsWith("/api/experimental/usage/limits")) {
844
+ assert.strictEqual(request.headers.authorization, "Basic b3BlbmNvZGU6c2VjcmV0");
845
+ return Effect.succeed(
846
+ HttpClientResponse.fromWeb(
847
+ request,
848
+ Response.json(
849
+ {
850
+ location: { directory: "/work" },
851
+ data: scenario.data,
852
+ },
853
+ { status: scenario.status },
854
+ ),
855
+ ),
856
+ );
857
+ }
858
+ return replay.execute(request);
859
+ });
860
+ const instance = yield* create(
861
+ { serverUrl: "https://remote.example", serverPassword: "secret" },
862
+ server,
863
+ );
864
+ const [snapshot] = Array.from(
865
+ yield* instance.snapshot.streamChanges.pipe(
866
+ Stream.filter((snapshot) => snapshot.usageLimits !== undefined),
867
+ Stream.take(1),
868
+ Stream.runCollect,
869
+ ),
870
+ );
871
+ assert.strictEqual(snapshot?.usageLimits?.unavailable?.reason, scenario.reason);
872
+ if (scenario.reason === undefined) {
873
+ assert.strictEqual(snapshot?.usageLimits?.windows[0]?.usedPercent, 75);
874
+ assert.strictEqual(snapshot?.usageLimits?.externalUsage?.label, "Remote workspace");
875
+ assert.deepStrictEqual(snapshot?.usageLimits?.windows[0]?.providerIds, []);
876
+ } else {
877
+ assert.deepStrictEqual(snapshot?.usageLimits?.windows, []);
878
+ }
879
+ }).pipe(Effect.scoped),
880
+ );
881
+
882
it.effect.each(
883
[
884
{ name: "recovers" },
@@ -843,6 +918,10 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
918
);
919
}
920
const path = new URL(request.url).pathname;
921
+ if (path === "/api/experimental/usage/limits")
922
+ return Effect.succeed(
923
+ HttpClientResponse.fromWeb(request, new Response(null, { status: 404 })),
924
+ );
925
if (path === "/api/model") modelReads += 1;
926
const body =
927
path === "/api/info"
packages/provider-opencode/src/server/driver.ts
+26
-1
@@ -8,6 +8,7 @@ import * as Digest from "effect/crypto/Digest";
8
import * as SecureRandom from "effect/crypto/SecureRandom";
9
import * as Deferred from "effect/Deferred";
10
import * as Effect from "effect/Effect";
11
+import * as DateTime from "effect/DateTime";
12
import * as Equal from "effect/Equal";
13
import * as Option from "effect/Option";
14
import * as FileSystem from "effect/FileSystem";
@@ -459,7 +460,7 @@ export const OpenCodeDriver: ProviderDriver<
460
),
461
);
462
462
- const checkUsageLimits = readOpenCodeGoUsageLimits({
463
+ const legacyUsageLimits = readOpenCodeGoUsageLimits({
464
enabled: effectiveConfig.enabled,
465
serverUrl: effectiveConfig.serverUrl,
466
environment: processEnv,
@@ -469,6 +470,30 @@ export const OpenCodeDriver: ProviderDriver<
470
Effect.provideService(HttpClient.HttpClient, httpClient),
471
Effect.provideService(Digest.Digest, digest),
472
);
473
+ let unsupportedUsageVersion: string | undefined;
474
+ const checkUsageLimits = Effect.gen(function* () {
475
+ if (!effectiveConfig.enabled) return yield* legacyUsageLimits;
476
+ const runtime = yield* runtimeProbe.get;
477
+ if (runtime.generation === "v1" || runtime.version === unsupportedUsageVersion)
478
+ return yield* legacyUsageLimits;
479
+ const limits = yield* openCode2Server.withConnection((connection) =>
480
+ connection.usageLimits(host.paths.cwd),
481
+ );
482
+ if (limits === undefined) unsupportedUsageVersion = runtime.version;
483
+ return limits ?? (yield* legacyUsageLimits);
484
+ }).pipe(
485
+ Effect.timeout("10 seconds"),
486
+ Effect.catch(() =>
487
+ Effect.map(DateTime.now, (now) => ({
488
+ checkedAt: DateTime.formatIso(now),
489
+ windows: [],
490
+ unavailable: {
491
+ reason: "probeFailed" as const,
492
+ message: "OpenCode could not read workspace usage.",
493
+ },
494
+ })),
495
+ ),
496
+ );
497
const checkProvider = Effect.all(
498
{
499
// A configured loopback server reports its running version. Probe the local
packages/provider-opencode/src/server/v2/OpenCode2Client.test.ts
+203
@@ -248,3 +248,206 @@ describe("OpenCode2Client native image jobs", () => {
248
}),
249
);
250
});
251
+
252
+describe("OpenCode2Client usage limits", () => {
253
+ it.effect("reads the connected workspace and maps Go and Console budgets", () =>
254
+ Effect.gen(function* () {
255
+ let workspace = "wrk_remote";
256
+ let usageURL: string | undefined;
257
+ const transport = HttpClient.make((request) => {
258
+ assert.strictEqual(request.headers.authorization, utf8Basic("remote-password"));
259
+ assert.deepStrictEqual(Array.from(request.urlParams), [
260
+ ["location[directory]", "/remote/project"],
261
+ ]);
262
+ if (request.url === "https://remote.example/prefix/api/provider")
263
+ return Effect.succeed(
264
+ HttpClientResponse.fromWeb(
265
+ request,
266
+ Response.json({
267
+ data: [
268
+ { id: "opencode", integrationID: "opencode" },
269
+ { id: "console-custom", integrationID: "opencode" },
270
+ { id: "opencode-go", integrationID: "opencode" },
271
+ { id: "anthropic", integrationID: "anthropic" },
272
+ { id: "byok" },
273
+ ],
274
+ }),
275
+ ),
276
+ );
277
+ assert.strictEqual(
278
+ request.url,
279
+ "https://remote.example/prefix/api/experimental/usage/limits",
280
+ );
281
+ return Effect.succeed(
282
+ HttpClientResponse.fromWeb(
283
+ request,
284
+ Response.json({
285
+ location: { directory: "/remote/project" },
286
+ data: {
287
+ workspace: {
288
+ id: workspace,
289
+ name: workspace,
290
+ usageURL: usageURL ?? "https://opencode.ai/console/" + workspace,
291
+ },
292
+ go: {
293
+ rolling: { percent: 23, limited: false, resetsAt: 1793491200000 },
294
+ weekly: { percent: 99, limited: true, resetsAt: 1793491200000 },
295
+ monthly: { percent: 12, limited: false, resetsAt: 1793491200000 },
296
+ },
297
+ budgets: [
298
+ {
299
+ id: "all",
300
+ limit: 20,
301
+ spent: 15,
302
+ scope: "combined",
303
+ per: "set",
304
+ coverage: "all",
305
+ models: [],
306
+ vendors: [],
307
+ picked: false,
308
+ shared: true,
309
+ resetsAt: 1793491200000,
310
+ },
311
+ {
312
+ id: "models",
313
+ limit: 10,
314
+ spent: 12,
315
+ scope: "each",
316
+ per: "model",
317
+ coverage: "models",
318
+ models: [
319
+ { providerID: "opencode", modelID: "a", name: "Model A", spent: 12 },
320
+ { providerID: "opencode", modelID: "b", name: "Model B", spent: 2 },
321
+ ],
322
+ vendors: [],
323
+ picked: true,
324
+ shared: false,
325
+ resetsAt: 1793491200000,
326
+ },
327
+ {
328
+ id: "zz_missing",
329
+ limit: 10,
330
+ spent: 10,
331
+ scope: "each",
332
+ per: "model",
333
+ coverage: "models",
334
+ models: [{ providerID: "opencode", modelID: "unknown", name: "Unknown spend" }],
335
+ shared: false,
336
+ resetsAt: 1793491200000,
337
+ },
338
+ {
339
+ id: "zero",
340
+ limit: 0,
341
+ spent: 0,
342
+ scope: "each",
343
+ per: "set",
344
+ coverage: "all",
345
+ models: [],
346
+ vendors: [],
347
+ picked: false,
348
+ shared: false,
349
+ resetsAt: 1793491200000,
350
+ },
351
+ ],
352
+ },
353
+ }),
354
+ ),
355
+ );
356
+ });
357
+ const opencode = yield* OpenCode2Client.make.pipe(
358
+ Effect.provideService(HttpClient.HttpClient, transport),
359
+ );
360
+ const api = yield* opencode.connect({
361
+ baseUrl: "https://remote.example/prefix",
362
+ password: "remote-password",
363
+ });
364
+ const first = yield* api.usageLimits("/remote/project");
365
+ assert.isDefined(first);
366
+ assert.deepStrictEqual(
367
+ first?.windows.map((window) => window.usedPercent),
368
+ [23, 100, 12, 75, 100, 20, 100, 100],
369
+ );
370
+ assert.isTrue(
371
+ first?.windows.every((window) => window.resetsAt === "2026-11-01T00:00:00.000Z"),
372
+ );
373
+ assert.include(first?.windows[3]?.label ?? "", "Shared");
374
+ assert.include(first?.windows[4]?.label ?? "", "Model A");
375
+ assert.deepStrictEqual(first?.windows[4]?.modelIds, ["opencode/a"]);
376
+ assert.strictEqual(first?.windows[3]?.modelIds, undefined);
377
+ assert.deepStrictEqual(first?.windows[3]?.providerIds, ["opencode", "console-custom"]);
378
+ assert.deepStrictEqual(first?.windows[7]?.modelIds, []);
379
+ assert.include(first?.windows[7]?.label ?? "", "Most used model");
380
+ assert.strictEqual(first?.credentialFingerprint, undefined);
381
+ workspace = "wrk_switched";
382
+ const next = yield* api.usageLimits("/remote/project");
383
+ assert.strictEqual(next?.externalUsage?.label, "wrk_switched");
384
+ assert.strictEqual(next?.externalUsage?.url, "https://opencode.ai/console/wrk_switched");
385
+ for (const url of [
386
+ "not a URL",
387
+ "javascript:alert(1)",
388
+ "custom-app://usage",
389
+ "file:///tmp/usage",
390
+ ]) {
391
+ usageURL = url;
392
+ const invalid = yield* api.usageLimits("/remote/project");
393
+ assert.strictEqual(invalid?.externalUsage, undefined);
394
+ assert.deepStrictEqual(invalid?.windows, next?.windows);
395
+ }
396
+ usageURL = "http://console.example/workspace/usage";
397
+ assert.strictEqual((yield* api.usageLimits("/remote/project"))?.externalUsage?.url, usageURL);
398
+ }),
399
+ );
400
+
401
+ it.effect("recognizes an older server's SPA fallback", () =>
402
+ Effect.gen(function* () {
403
+ const opencode = yield* OpenCode2Client.make.pipe(
404
+ Effect.provideService(
405
+ HttpClient.HttpClient,
406
+ HttpClient.make((request) =>
407
+ Effect.succeed(
408
+ HttpClientResponse.fromWeb(
409
+ request,
410
+ new Response("<!doctype html><title>OpenCode</title>", {
411
+ headers: { "content-type": "text/html; charset=utf-8" },
412
+ }),
413
+ ),
414
+ ),
415
+ ),
416
+ ),
417
+ );
418
+ const api = yield* opencode.connect({ baseUrl: "https://old.example", password: "secret" });
419
+ assert.strictEqual(yield* api.usageLimits("/remote"), undefined);
420
+ }),
421
+ );
422
+
423
+ it.effect("distinguishes missing endpoints, signed out, and failed remote probes", () =>
424
+ Effect.gen(function* () {
425
+ for (const [status, body, reason] of [
426
+ [404, {}, undefined],
427
+ [405, {}, undefined],
428
+ [200, { location: { directory: "/remote" }, data: null }, "unsupported"],
429
+ [503, {}, "probeFailed"],
430
+ [401, {}, "probeFailed"],
431
+ [200, { data: { workspace: {} } }, "probeFailed"],
432
+ ] as const) {
433
+ const opencode = yield* OpenCode2Client.make.pipe(
434
+ Effect.provideService(
435
+ HttpClient.HttpClient,
436
+ HttpClient.make((request) =>
437
+ Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(body, { status }))),
438
+ ),
439
+ ),
440
+ );
441
+ const api = yield* opencode.connect({
442
+ baseUrl: "https://remote.example",
443
+ password: "secret",
444
+ });
445
+ const result = yield* api.usageLimits("/remote");
446
+ if (reason === undefined) assert.strictEqual(result, undefined);
447
+ else assert.strictEqual(result?.unavailable?.reason, reason);
448
+ if (status === 200 && reason === "unsupported")
449
+ assert.include(result?.unavailable?.message ?? "", "signed in");
450
+ }
451
+ }),
452
+ );
453
+});
packages/provider-opencode/src/server/v2/OpenCode2Client.ts
+12
@@ -16,6 +16,8 @@ import * as HttpClientError from "effect/http/HttpClientError";
16
import * as HttpClientRequest from "effect/http/HttpClientRequest";
17
import * as HttpClientResponse from "effect/http/HttpClientResponse";
18
19
+import { readServerUsageLimits } from "./usageLimits.ts";
20
+
21
/** OpenCode 2 accepts only HTTP Basic auth, always with this user name. */
22
const OPENCODE_USERNAME = "opencode";
23
@@ -93,6 +95,9 @@ const decodeImageJob = Schema.decodeUnknownOption(NativeImageJob);
95
/** events resolves on subscription acceptance; subscribe before work because the stream is volatile. */
96
export interface OpenCode2Api {
97
readonly client: OpenCodeClient;
98
+ readonly usageLimits: (
99
+ directory: string,
100
+ ) => Effect.Effect<import("@t3tools/contracts").ServerProviderUsageLimits | undefined>;
101
readonly shellJobs?: (
102
sessionID: string,
103
) => Effect.Effect<typeof ShellJobs.Type, HttpClientError.HttpClientError | Schema.SchemaError>;
@@ -263,6 +268,13 @@ export const make = Effect.gen(function* () {
268
Effect.provideService(HttpClient.HttpClient, fillCompactionRecents(authenticated)),
269
Effect.map((client) => ({
270
client,
271
+ usageLimits: (directory) =>
272
+ readServerUsageLimits(directory).pipe(
273
+ Effect.provideService(
274
+ HttpClient.HttpClient,
275
+ HttpClient.mapRequest(authenticated, HttpClientRequest.prependUrl(baseUrl)),
276
+ ),
277
+ ),
278
shellJobs: Effect.fn("OpenCode2Client.shellJobs")(function (sessionID: string) {
279
return authenticated
280
.get(`${baseUrl}/api/experimental/job`, {
packages/provider-opencode/src/server/v2/usageLimits.ts
new
+188
@@ -0,0 +1,188 @@
1
+import type { ServerProviderUsageWindow } from "@t3tools/contracts";
2
+import {
3
+ clampPercent,
4
+ makeUnavailableUsageLimits,
5
+ makeUsageLimits,
6
+} from "@t3tools/provider-core/server/usageLimits";
7
+import * as DateTime from "effect/DateTime";
8
+import * as Effect from "effect/Effect";
9
+import * as Schema from "effect/Schema";
10
+import * as HttpClient from "effect/http/HttpClient";
11
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
12
+
13
+const Instant = Schema.Finite.check(
14
+ Schema.isBetween({ minimum: -8640000000000000, maximum: 8640000000000000 }),
15
+);
16
+const Meter = Schema.Struct({
17
+ percent: Schema.Finite,
18
+ limited: Schema.Boolean,
19
+ resetsAt: Instant,
20
+});
21
+const BudgetModel = Schema.Struct({
22
+ providerID: Schema.String,
23
+ modelID: Schema.String,
24
+ name: Schema.String,
25
+ spent: Schema.optionalKey(Schema.Finite),
26
+});
27
+// Decode only fields needed by T3, independently of the pinned 2.0 client.
28
+const ResponseBody = Schema.Struct({
29
+ location: Schema.Struct({ directory: Schema.String }),
30
+ data: Schema.NullOr(
31
+ Schema.Struct({
32
+ workspace: Schema.Struct({
33
+ id: Schema.String,
34
+ name: Schema.optionalKey(Schema.String),
35
+ usageURL: Schema.String,
36
+ }),
37
+ go: Schema.optionalKey(Schema.Struct({ rolling: Meter, weekly: Meter, monthly: Meter })),
38
+ budgets: Schema.Array(
39
+ Schema.Struct({
40
+ id: Schema.String,
41
+ limit: Schema.Finite,
42
+ spent: Schema.Finite,
43
+ scope: Schema.Literals(["each", "combined"]),
44
+ per: Schema.Literals(["set", "model"]),
45
+ coverage: Schema.Literals(["all", "models"]),
46
+ models: Schema.Array(BudgetModel),
47
+ shared: Schema.Boolean,
48
+ resetsAt: Instant,
49
+ }),
50
+ ),
51
+ }),
52
+ ),
53
+});
54
+
55
+const Providers = Schema.Struct({
56
+ data: Schema.Array(
57
+ Schema.Struct({
58
+ id: Schema.String,
59
+ integrationID: Schema.optionalKey(Schema.String),
60
+ }),
61
+ ),
62
+});
63
+
64
+const resetTime = (ms: number) => DateTime.formatIso(DateTime.makeUnsafe(ms));
65
+const budgetPercent = (spent: number, limit: number) =>
66
+ limit <= 0 ? 100 : clampPercent((spent / limit) * 100);
67
+
68
+/** Undefined alone permits the legacy credential reader; null data is authoritative. */
69
+export const readServerUsageLimits = Effect.fn("OpenCode2Client.usageLimits")(function* (
70
+ directory: string,
71
+) {
72
+ const checkedAt = DateTime.formatIso(yield* DateTime.now);
73
+ return yield* Effect.gen(function* () {
74
+ const response = yield* HttpClient.get("/api/experimental/usage/limits", {
75
+ urlParams: { "location[directory]": directory },
76
+ });
77
+ if (
78
+ response.status === 404 ||
79
+ response.status === 405 ||
80
+ (response.status === 200 &&
81
+ response.headers["content-type"]?.split(";")[0]?.trim() === "text/html")
82
+ )
83
+ return undefined;
84
+ const body = yield* HttpClientResponse.filterStatusOk(response).pipe(
85
+ Effect.flatMap(HttpClientResponse.schemaBodyJson(ResponseBody)),
86
+ );
87
+ if (body.data === null)
88
+ return makeUnavailableUsageLimits({
89
+ checkedAt,
90
+ reason: "unsupported",
91
+ message: "No OpenCode Console workspace is signed in.",
92
+ });
93
+ const { go, budgets, workspace } = body.data;
94
+ const consoleProviders = budgets.some(
95
+ (budget) => budget.coverage === "all" && budget.per === "set",
96
+ )
97
+ ? yield* HttpClient.get("/api/provider", {
98
+ urlParams: { "location[directory]": directory },
99
+ }).pipe(
100
+ Effect.flatMap(HttpClientResponse.filterStatusOk),
101
+ Effect.flatMap(HttpClientResponse.schemaBodyJson(Providers)),
102
+ Effect.map((page) =>
103
+ page.data
104
+ .filter(
105
+ (provider) =>
106
+ provider.integrationID === "opencode" && provider.id !== "opencode-go",
107
+ )
108
+ .map((provider) => provider.id),
109
+ ),
110
+ Effect.orElseSucceed(() => []),
111
+ )
112
+ : [];
113
+ const windows: ServerProviderUsageWindow[] = [];
114
+ if (go) {
115
+ for (const [key, kind, label, duration] of [
116
+ ["rolling", "session", "Session", 300],
117
+ ["weekly", "weekly", "Weekly", 10080],
118
+ ["monthly", "monthly", "Monthly", undefined],
119
+ ] as const) {
120
+ const meter = go[key];
121
+ windows.push({
122
+ id: `go_${key}`,
123
+ kind,
124
+ label: `Go · ${label}`,
125
+ usedPercent: meter.limited ? 100 : clampPercent(meter.percent),
126
+ resetsAt: resetTime(meter.resetsAt),
127
+ ...(duration === undefined ? {} : { windowDurationMins: duration }),
128
+ });
129
+ }
130
+ }
131
+ for (const budget of budgets) {
132
+ const scope = budget.shared || budget.scope === "combined" ? "Shared" : "Individual";
133
+ const covered =
134
+ budget.coverage === "all"
135
+ ? "All spend"
136
+ : budget.models.map((model) => model.name).join(", ") || "Models";
137
+ if (
138
+ budget.per === "model" &&
139
+ budget.coverage === "models" &&
140
+ budget.models.length > 0 &&
141
+ budget.models.every((model) => model.spent !== undefined)
142
+ ) {
143
+ for (const model of budget.models) {
144
+ windows.push({
145
+ id: `budget_${budget.id}_${model.providerID}_${model.modelID}`,
146
+ kind: "other",
147
+ label: `Console · ${scope} · ${model.name}`,
148
+ modelIds: [`${model.providerID}/${model.modelID}`],
149
+ usedPercent: budgetPercent(model.spent ?? budget.spent, budget.limit),
150
+ resetsAt: resetTime(budget.resetsAt),
151
+ });
152
+ }
153
+ } else {
154
+ windows.push({
155
+ id: `budget_${budget.id}`,
156
+ kind: "other",
157
+ label: `Console · ${scope} · ${covered}${budget.per === "model" ? " · Most used model" : ""}`,
158
+ // Aggregate per-model spend cannot identify the exhausted model.
159
+ ...(budget.per === "model"
160
+ ? { modelIds: [] }
161
+ : budget.coverage === "models"
162
+ ? {
163
+ modelIds: budget.models.map((model) => `${model.providerID}/${model.modelID}`),
164
+ }
165
+ : { providerIds: consoleProviders }),
166
+ usedPercent: budgetPercent(budget.spent, budget.limit),
167
+ resetsAt: resetTime(budget.resetsAt),
168
+ });
169
+ }
170
+ }
171
+ const usageURL = URL.parse(workspace.usageURL);
172
+ return {
173
+ ...makeUsageLimits({ checkedAt, windows }),
174
+ ...(usageURL?.protocol === "http:" || usageURL?.protocol === "https:"
175
+ ? { externalUsage: { label: workspace.name?.trim() || workspace.id, url: usageURL.href } }
176
+ : {}),
177
+ };
178
+ }).pipe(
179
+ Effect.timeout("5 seconds"),
180
+ Effect.orElseSucceed(() =>
181
+ makeUnavailableUsageLimits({
182
+ checkedAt,
183
+ reason: "probeFailed",
184
+ message: "OpenCode could not read workspace usage.",
185
+ }),
186
+ ),
187
+ );
188
+});
packages/shared/src/usageLimits.test.ts
+82
-28
@@ -126,34 +126,88 @@ describe("new thread model fallback", () => {
126
).toBeDefined();
127
});
128
it.each([
129
- ["cursor", ["autoPercentUsed"], "claude-opus-5-5", false],
130
- ["cursor", ["autoPercentUsed"], "composer-2.5", false],
131
- ["cursor", ["autoPercentUsed", "apiPercentUsed"], "composer-2.5", true],
132
- ["antigravity", ["gemini-weekly"], "claude-opus-5-5", false],
133
- ["antigravity", ["3p-weekly"], "claude-opus-5-5", true],
134
- ["antigravity", ["gemini-weekly"], "antigravity-default", true],
135
- ["codex", ["individual"], "gpt-5.5", true],
136
- ["opencode", ["go_weekly"], "opencode/big-pickle", false],
137
- ["opencode", ["go_weekly"], "opencode-go/big-pickle", true],
138
- ] as const)("matches %s pools %s to %s", (driver, ids, model, usesFallback) => {
139
- const defaultSelection = { ...selection, model };
140
- expect(
141
- resolveNewThreadModelSelection({
142
- ...defaults,
143
- defaultSelection,
144
- providers: [
145
- provider({
146
- driver: ProviderDriverKind.make(driver),
147
- usageLimits: {
148
- checkedAt: limited.checkedAt,
149
- windows: ids.map((id) => ({ ...window, id, usedPercent: 100 })),
150
- },
151
- }),
152
- available,
153
- ],
154
- }).selection,
155
- ).toEqual(usesFallback ? fallback : defaultSelection);
156
- });
129
+ ["cursor", ["autoPercentUsed"], "claude-opus-5-5", false, undefined, undefined],
130
+ ["cursor", ["autoPercentUsed"], "composer-2.5", false, undefined, undefined],
131
+ ["cursor", ["autoPercentUsed", "apiPercentUsed"], "composer-2.5", true, undefined, undefined],
132
+ ["antigravity", ["gemini-weekly"], "claude-opus-5-5", false, undefined, undefined],
133
+ ["antigravity", ["3p-weekly"], "claude-opus-5-5", true, undefined, undefined],
134
+ ["antigravity", ["gemini-weekly"], "antigravity-default", true, undefined, undefined],
135
+ ["codex", ["individual"], "gpt-5.5", true, undefined, undefined],
136
+ ["opencode", ["go_weekly"], "opencode/big-pickle", false, undefined, undefined],
137
+ ["opencode", ["go_weekly"], "opencode-go/big-pickle", true, undefined, undefined],
138
+ ["opencode", ["budget_model"], "opencode/other", false, ["opencode/limited"], undefined],
139
+ ["opencode", ["budget_model"], "opencode/limited", true, ["opencode/limited"], undefined],
140
+ [
141
+ "opencode",
142
+ ["budget_set"],
143
+ "other/model",
144
+ false,
145
+ ["opencode/limited", "opencode/second"],
146
+ undefined,
147
+ ],
148
+ [
149
+ "opencode",
150
+ ["budget_set"],
151
+ "opencode/second",
152
+ true,
153
+ ["opencode/limited", "opencode/second"],
154
+ undefined,
155
+ ],
156
+ ["opencode", ["budget_empty"], "opencode/other", false, [], undefined],
157
+ [
158
+ "opencode",
159
+ ["budget_all"],
160
+ "anthropic/claude",
161
+ false,
162
+ undefined,
163
+ ["opencode", "console-custom"],
164
+ ],
165
+ [
166
+ "opencode",
167
+ ["budget_all"],
168
+ "opencode-go/model",
169
+ false,
170
+ undefined,
171
+ ["opencode", "console-custom"],
172
+ ],
173
+ ["opencode", ["budget_all"], "opencode/model", true, undefined, ["opencode", "console-custom"]],
174
+ [
175
+ "opencode",
176
+ ["budget_all"],
177
+ "console-custom/model",
178
+ true,
179
+ undefined,
180
+ ["opencode", "console-custom"],
181
+ ],
182
+ ["opencode", ["budget_all"], "opencode/model", false, undefined, []],
183
+ ] as const)(
184
+ "matches %s pools %s to %s",
185
+ (driver, ids, model, usesFallback, modelIds, providerIds) => {
186
+ const defaultSelection = { ...selection, model };
187
+ expect(
188
+ resolveNewThreadModelSelection({
189
+ ...defaults,
190
+ defaultSelection,
191
+ providers: [
192
+ provider({
193
+ driver: ProviderDriverKind.make(driver),
194
+ usageLimits: {
195
+ checkedAt: limited.checkedAt,
196
+ windows: ids.map((id) => ({
197
+ ...window,
198
+ id,
199
+ usedPercent: 100,
200
+ ...(modelIds === undefined ? {} : { modelIds }),
201
+ ...(providerIds === undefined ? {} : { providerIds }),
202
+ })),
203
+ },
204
+ }),
205
+ available,
206
+ ],
207
+ }).selection,
208
+ ).toEqual(usesFallback ? fallback : defaultSelection);
209
+ },
210
+ );
211
});
212
213
describe("pace", () => {
packages/shared/src/usageLimits.ts
+4
@@ -32,6 +32,10 @@ export function exhaustedUsageWindow(
32
const exhausted = windows.filter(
33
(window) =>
34
(window.usedPercent ?? 0) >= 100 &&
35
+ (model === undefined || window.modelIds === undefined || window.modelIds.includes(model)) &&
36
+ (model === undefined ||
37
+ window.providerIds === undefined ||
38
+ window.providerIds.includes(model.split("/")[0] ?? "")) &&
39
(!window.resetsAt ||
40
!Number.isFinite(Date.parse(window.resetsAt)) ||
41
Date.parse(window.resetsAt) > now),