@devries-cameron20 / t3code Mirror · read-only / commits / 3ec8347a69
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

fix(opencode): a slow OpenCode 2 server start no longer leaves the model list empty (#35049)

Julius Marminge committed Nov 12, 2026 at 02:31 UTC 3ec8347a695f2d752fe2391a62e36555b57d5406
4 files changed +63 -14
packages/provider-opencode/src/server/openCode2Catalog.test.ts
+13
@@ -1,6 +1,8 @@
1 import { assert, it } from "@effect/vitest";
2 import * as Effect from "effect/Effect";
3 +import * as Fiber from "effect/Fiber";
4 import * as Layer from "effect/Layer";
5 +import * as TestClock from "effect/testing/TestClock";
6 import { HttpClient, HttpClientResponse } from "effect/http";
7 import { describe } from "vite-plus/test";
8
@@ -84,6 +86,17 @@ describe("loadOpenCode2Catalog", () => {
86 }),
87 );
88
89 + it.effect("lists no models yet when the model list does not answer", () =>
90 + Effect.gen(function* () {
91 + const fiber = yield* Effect.forkChild(
92 + readCatalog({ "/api/provider": PROVIDERS_BODY }, ["/api/model"]),
93 + );
94 + yield* TestClock.adjust("5 seconds");
95 +
96 + assert.deepStrictEqual(yield* Fiber.join(fiber), []);
97 + }),
98 + );
99 +
100 // regression: #17424 only the provider list is optional; a model-list failure fails the read
101 it.effect("fails the read when the model list fails", () =>
102 Effect.gen(function* () {
packages/provider-opencode/src/server/openCode2Catalog.ts
+10 -2
@@ -6,6 +6,8 @@ import type { OpenCode2Model } from "./status.ts";
6
7 // Cold catalogs take seconds; model reads already retry empty catalogs.
8 const PROVIDER_NAME_TIMEOUT = "3 seconds";
9 +// Bounds the request alone (server start has its own bounds); a slow list reads as not listed yet.
10 +const MODEL_LIST_TIMEOUT = "5 seconds";
11
12 const listProviders = (client: OpenCodeClient, directory: string) =>
13 client.provider.list({ location: { directory } }).pipe(
@@ -19,12 +21,18 @@ const readCatalog = <E>(
21 providers: Effect.Effect<ReadonlyArray<{ readonly id: string; readonly name: string }>, E>,
22 ): Effect.Effect<ReadonlyArray<OpenCode2Model>, OpenCodeRuntime.OpenCodeRuntimeError> =>
23 Effect.all(
22 - { models: client.model.list({ location: { directory } }), providers },
24 + {
25 + models: client.model.list({ location: { directory } }).pipe(
26 + Effect.timeoutOption(MODEL_LIST_TIMEOUT),
27 + Effect.map((list) => (list._tag === "Some" ? list.value.data : [])),
28 + ),
29 + providers,
30 + },
31 { concurrency: "unbounded" },
32 ).pipe(
33 Effect.map(({ models, providers }) => {
34 const providerNames = new Map(providers.map((provider) => [provider.id, provider.name]));
27 - return models.data.map((model) => {
35 + return models.map((model) => {
36 const providerName = providerNames.get(model.providerID);
37 return {
38 providerID: model.providerID,
packages/provider-opencode/src/server/status.test.ts
+19
@@ -12,6 +12,7 @@ import * as Layer from "effect/Layer";
12 import * as Logger from "effect/Logger";
13 import * as Schema from "effect/Schema";
14 import * as Tracer from "effect/Tracer";
15 +import * as TestClock from "effect/testing/TestClock";
16 import * as HttpClient from "effect/http/HttpClient";
17 import * as HttpClientResponse from "effect/http/HttpClientResponse";
18 import { beforeEach } from "vite-plus/test";
@@ -24,6 +25,7 @@ import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
25 import {
26 checkOpenCodeProviderStatus,
27 loadOpenCode2Workspace,
28 + makeOpenCode2ModelLoader,
29 type OpenCode2Model,
30 type OpenCode2Workspace,
31 } from "./status.ts";
@@ -1160,3 +1162,20 @@ it.effect("reads an already loaded OpenCode 2 directory once without waiting for
1162 NodeAssert.deepEqual(calls, ["read"]);
1163 }),
1164 );
1165 +
1166 +it.effect("lists a catalog whose cold server start outlasts the settle budget", () =>
1167 + Effect.gen(function* () {
1168 + const catalog: ReadonlyArray<OpenCode2Model> = [
1169 + { providerID: "opencode", id: "big-pickle", name: "Big Pickle", variants: [] },
1170 + ];
1171 + let reads = 0;
1172 + // The loader's read includes spawning the server; a loaded host can take 6s to start it.
1173 + const read = Effect.suspend(() =>
1174 + reads++ === 0 ? Effect.sleep("6 seconds").pipe(Effect.as(catalog)) : Effect.succeed(catalog),
1175 + );
1176 + const load = yield* makeOpenCode2ModelLoader(read);
1177 + const fiber = yield* Effect.forkChild(load);
1178 + yield* TestClock.adjust("10 seconds");
1179 + NodeAssert.deepEqual(yield* Fiber.join(fiber), catalog);
1180 + }),
1181 +);
packages/provider-opencode/src/server/status.ts
+21 -12
@@ -498,10 +498,13 @@ const catalogFingerprint = (models: ReadonlyArray<OpenCode2Model>) =>
498 .join("\n");
499
500 /** A cold server can list a partial catalog; two agreeing reads reduce that startup race. */
501 -const settleOpenCode2Catalog = <E>(list: Effect.Effect<ReadonlyArray<OpenCode2Model>, E>) =>
501 +const settleOpenCode2Catalog = <E>(
502 + list: Effect.Effect<ReadonlyArray<OpenCode2Model>, E>,
503 + first?: ReadonlyArray<OpenCode2Model>,
504 +) =>
505 Effect.suspend(() => {
503 - let previous: string | undefined;
504 - return list.pipe(
506 + let previous = first && first.length > 0 ? catalogFingerprint(first) : undefined;
507 + return (first ? Effect.delay(list, "250 millis") : list).pipe(
508 Effect.repeat({
509 until: (models) => {
510 const fingerprint = models.length > 0 ? catalogFingerprint(models) : undefined;
@@ -523,17 +526,23 @@ export const makeOpenCode2ModelLoader = <E>(
526 let lastLoaded: ReadonlyArray<OpenCode2Model> = [];
527 return Effect.suspend(() => {
528 let latest: ReadonlyArray<OpenCode2Model> = [];
526 - return settleOpenCode2Catalog(
527 - list.pipe(
528 - Effect.tap((models) =>
529 - Effect.sync(() => {
530 - if (models.length > 0) latest = models;
531 - }),
529 + const tracked = list.pipe(
530 + Effect.tap((models) =>
531 + Effect.sync(() => {
532 + if (models.length > 0) latest = models;
533 + }),
534 + ),
535 + );
536 + // The first read can include a cold server start, so only settling shares the budget.
537 + return tracked.pipe(
538 + Effect.flatMap((first) =>
539 + settleOpenCode2Catalog(tracked, first).pipe(
540 + Effect.timeoutOption(OPENCODE_2_CATALOG_SETTLE_TIMEOUT),
541 ),
542 ),
534 - ).pipe(
535 - Effect.catch((error) => (latest.length > 0 ? Effect.succeed(latest) : Effect.fail(error))),
536 - Effect.timeoutOption(OPENCODE_2_CATALOG_SETTLE_TIMEOUT),
543 + Effect.catch((error) =>
544 + latest.length > 0 ? Effect.succeedSome(latest) : Effect.fail(error),
545 + ),
546 Effect.map((loaded) => {
547 // Fresh progress may still be partial, but a warm cache must not freeze slow catalogs.
548 if (loaded._tag === "Some") lastLoaded = loaded.value;