@devries-cameron20 / t3code Mirror · read-only / commits / 63d5c6dfe4
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 19:45 UTC

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),