@devries-cameron20 / t3code Mirror · read-only / commits / 807319c276
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 22, 19:30 UTC

fix(opencode): retry failed model catalogs until they recover (#23939)

Yash Singh committed Oct 23, 2026 at 02:13 UTC 807319c276c6831b2c219640e9da5b38019a8f1d
7 files changed +491 -24
packages/provider-core/src/server/managedProvider.test.ts
+75
@@ -13,6 +13,7 @@ import * as Layer from "effect/Layer";
13 import * as PubSub from "effect/PubSub";
14 import * as Ref from "effect/Ref";
15 import * as Stream from "effect/Stream";
16 +import * as TestClock from "effect/testing/TestClock";
17
18 import * as ProviderHost from "./ProviderHost.ts";
19 import { makeManagedServerProvider } from "./managedProvider.ts";
@@ -179,6 +180,80 @@ describe("makeManagedServerProvider", () => {
180 ).pipe(Effect.provide(layerAlwaysRunTest)),
181 );
182
183 + it.effect("skips periodic provider refreshes without foreground provider-status demand", () =>
184 + Effect.scoped(
185 + Effect.gen(function* () {
186 + const checkCalls = yield* Ref.make(0);
187 + const initialCheckDone = yield* Deferred.make<void>();
188 + yield* makeManagedServerProvider<TestSettings>({
189 + resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
190 + getSettings: Effect.succeed({ enabled: true }),
191 + streamSettings: Stream.empty,
192 + haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
193 + refreshOnInterval: () => true,
194 + initialSnapshot: () => Effect.succeed(initialSnapshot),
195 + checkProvider: Ref.updateAndGet(checkCalls, (count) => count + 1).pipe(
196 + Effect.tap((count) =>
197 + count === 1
198 + ? Deferred.succeed(initialCheckDone, undefined).pipe(Effect.ignore)
199 + : Effect.void,
200 + ),
201 + Effect.as(refreshedSnapshot),
202 + ),
203 + refreshInterval: "1 second",
204 + });
205 +
206 + yield* Deferred.await(initialCheckDone);
207 + yield* TestClock.adjust("1 second");
208 + yield* Effect.yieldNow;
209 +
210 + assert.strictEqual(yield* Ref.get(checkCalls), 1);
211 + }),
212 + ).pipe(
213 + Effect.provide(
214 + Layer.mergeAll(layerProviderHost({ runBackgroundWork: false }), TestClock.layer()),
215 + ),
216 + ),
217 + );
218 +
219 + it.effect("stops periodic recovery checks once the snapshot is ready", () =>
220 + Effect.scoped(
221 + Effect.gen(function* () {
222 + const checkCalls = yield* Ref.make(0);
223 + const releaseInitialCheck = yield* Deferred.make<void>();
224 + const failedSnapshot = { ...refreshedSnapshot, status: "error" as const };
225 + const provider = yield* makeManagedServerProvider<TestSettings>({
226 + resolveMaintenance: () => Effect.succeed(maintenanceCapabilities),
227 + getSettings: Effect.succeed({ enabled: true }),
228 + streamSettings: Stream.empty,
229 + haveSettingsChanged: (previous, next) => previous.enabled !== next.enabled,
230 + refreshOnInterval: (snapshot) => snapshot.status === "error",
231 + initialSnapshot: () => Effect.succeed(initialSnapshot),
232 + checkProvider: Deferred.await(releaseInitialCheck).pipe(
233 + Effect.andThen(Ref.updateAndGet(checkCalls, (count) => count + 1)),
234 + Effect.map((count) => (count === 1 ? failedSnapshot : refreshedSnapshot)),
235 + ),
236 + refreshInterval: "1 second",
237 + });
238 + const updates = yield* provider.streamChanges.pipe(
239 + Stream.take(2),
240 + Stream.runCollect,
241 + Effect.forkChild,
242 + );
243 + yield* Effect.yieldNow;
244 + yield* Deferred.succeed(releaseInitialCheck, undefined);
245 + yield* TestClock.adjust("1 second");
246 +
247 + assert.deepStrictEqual(Array.from(yield* Fiber.join(updates)), [
248 + failedSnapshot,
249 + refreshedSnapshot,
250 + ]);
251 + yield* TestClock.adjust("3 seconds");
252 + assert.strictEqual(yield* Ref.get(checkCalls), 2);
253 + }),
254 + ).pipe(Effect.provide(Layer.mergeAll(layerAlwaysRunTest, TestClock.layer()))),
255 + );
256 +
257 it.effect("reruns the provider check when streamed settings change", () =>
258 Effect.scoped(
259 Effect.gen(function* () {
packages/provider-core/src/server/managedProvider.ts
+9 -7
@@ -51,7 +51,7 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
51 readonly publishSnapshot: (snapshot: ServerProvider) => Effect.Effect<void>;
52 }) => Effect.Effect<void>;
53 readonly refreshInterval?: Duration.Input;
54 - readonly refreshOnInterval?: boolean;
54 + readonly refreshOnInterval?: boolean | ((snapshot: ServerProvider) => boolean);
55 readonly checkProviderOnSettingsChange?: (previous: Settings, next: Settings) => boolean;
56 }): Effect.fn.Return<
57 ManagedServerProvider,
@@ -218,11 +218,15 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
218 return yield* applySnapshot(nextSettings, { forceRefresh: true });
219 });
220
221 - const hasProviderStatusDemand = Effect.gen(function* () {
221 + const shouldRefreshOnInterval = Effect.gen(function* () {
222 const state = yield* Ref.get(snapshotStateRef);
223 // A disabled instance has nothing to probe; a periodic check would only
224 // republish a snapshot that differs in checkedAt.
225 - if (!state.snapshot.enabled) {
225 + if (
226 + !state.snapshot.enabled ||
227 + input.refreshOnInterval === false ||
228 + (typeof input.refreshOnInterval === "function" && !input.refreshOnInterval(state.snapshot))
229 + ) {
230 return false;
231 }
232 const instanceId = state.snapshot.instanceId;
@@ -276,10 +280,8 @@ export const makeManagedServerProvider = Effect.fn("makeManagedServerProvider")(
280 Queue.take(refreshIntervalChanges).pipe(Effect.as(false)),
281 ).pipe(
282 Effect.flatMap((intervalElapsed) =>
279 - input.refreshOnInterval !== false &&
280 - intervalElapsed &&
281 - Duration.toMillis(Duration.fromInputUnsafe(refreshInterval)) > 0
282 - ? hasProviderStatusDemand.pipe(
283 + intervalElapsed && Duration.toMillis(Duration.fromInputUnsafe(refreshInterval)) > 0
284 + ? shouldRefreshOnInterval.pipe(
285 Effect.flatMap((shouldRefresh) =>
286 shouldRefresh ? refreshSnapshot().pipe(Effect.asVoid) : Effect.void,
287 ),
packages/provider-opencode/src/server/driver.test.ts
+170
@@ -8,11 +8,16 @@ import { assert, it } from "@effect/vitest";
8 import { ProviderInstanceId } from "@t3tools/contracts";
9 import type { OpenCodeSettings } from "../settings.ts";
10 import * as HostProcess from "@t3tools/shared/HostProcess";
11 +import * as Deferred from "effect/Deferred";
12 import * as Effect from "effect/Effect";
13 import * as Fiber from "effect/Fiber";
14 import * as Layer from "effect/Layer";
15 +import * as Logger from "effect/Logger";
16 +import * as References from "effect/References";
17 +import * as Stream from "effect/Stream";
18 import * as TestClock from "effect/testing/TestClock";
19 import * as HttpClient from "effect/http/HttpClient";
20 +import * as HttpClientResponse from "effect/http/HttpClientResponse";
21 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
22
23 import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
@@ -21,6 +26,7 @@ import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderS
26 import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
27 import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver";
28 import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
29 +import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts";
30 import { OpenCodeDriver, openCodeUpdateFor } from "./driver.ts";
31 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
32
@@ -94,6 +100,170 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
100 yield* Fiber.join(capabilities);
101 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
102 );
103 +
104 + it.effect.each(["probe", "error", "empty"] as const)(
105 + "recovers discovery without a manual refresh after %s",
106 + (initialCatalog) =>
107 + Effect.gen(function* () {
108 + const releaseCatalog = yield* Deferred.make<void>();
109 + const discoveryLogs: Array<Record<string, unknown>> = [];
110 + const logger = Logger.make(({ message, fiber }) => {
111 + if (Array.isArray(message) && message.includes("OpenCode discovery failed")) {
112 + discoveryLogs.push({ ...fiber.getRef(References.CurrentLogAnnotations) });
113 + }
114 + });
115 + let catalogAvailable = false;
116 + let modelReads = 0;
117 + const replies = {
118 + ...OPENCODE_2_RESPONSES,
119 + "/api/provider": {
120 + status: 200,
121 + contentType: "application/json",
122 + body: '{"location":{"directory":"/work"},"data":[]}',
123 + },
124 + "/api/model": {
125 + status: 200,
126 + contentType: "application/json",
127 + body: JSON.stringify({
128 + location: { directory: "/work" },
129 + data: [
130 + {
131 + id: "big-pickle",
132 + modelID: "big-pickle",
133 + providerID: "opencode",
134 + name: "Big Pickle",
135 + package: "@opencode/ai/providers/openai-compatible",
136 + settings: {},
137 + compatibility: {},
138 + capabilities: { tools: true, input: ["text"], output: ["text"] },
139 + variants: [],
140 + time: { released: 1789516800000 },
141 + cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
142 + status: "active",
143 + enabled: true,
144 + limit: { context: 1000000, output: 65536 },
145 + },
146 + ],
147 + }),
148 + },
149 + };
150 + const replay = replayOpenCodeServer(replies, "secret");
151 + const server = HttpClient.make((request) =>
152 + Effect.gen(function* () {
153 + if (initialCatalog === "probe" && !catalogAvailable) {
154 + yield* Deferred.await(releaseCatalog);
155 + return HttpClientResponse.fromWeb(
156 + request,
157 + new Response('{"_tag":"InternalServerError","message":"server starting"}', {
158 + status: 503,
159 + headers: { "content-type": "application/json" },
160 + }),
161 + );
162 + }
163 + if (new URL(request.url).pathname === "/api/model") {
164 + modelReads += 1;
165 + yield* Deferred.await(releaseCatalog);
166 + if (!catalogAvailable) {
167 + return HttpClientResponse.fromWeb(
168 + request,
169 + new Response(
170 + initialCatalog === "error"
171 + ? '{"_tag":"InternalServerError","message":"catalog unavailable"}'
172 + : '{"location":{"directory":"/work"},"data":[]}',
173 + {
174 + status: initialCatalog === "error" ? 500 : 200,
175 + headers: { "content-type": "application/json" },
176 + },
177 + ),
178 + );
179 + }
180 + }
181 + return yield* replay.execute(request);
182 + }),
183 + );
184 + const instance = yield* create(
185 + { serverUrl: "http://127.0.0.1:4096", serverPassword: "secret" },
186 + server,
187 + ).pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: false })));
188 + const initial = yield* instance.snapshot.streamChanges.pipe(
189 + Stream.filter(
190 + (snapshot) =>
191 + snapshot.installed &&
192 + snapshot.status === (initialCatalog === "empty" ? "warning" : "error"),
193 + ),
194 + Stream.take(1),
195 + Stream.runCollect,
196 + Effect.forkChild,
197 + );
198 + yield* Effect.yieldNow;
199 + yield* Deferred.succeed(releaseCatalog, undefined);
200 + yield* TestClock.adjust("5 seconds");
201 + const [failed] = Array.from(yield* Fiber.join(initial));
202 + assert.strictEqual(failed?.auth.status, "unknown");
203 + assert.deepStrictEqual(failed?.models, []);
204 + if (initialCatalog === "probe") assert.strictEqual(failed?.version, null);
205 + assert.strictEqual(discoveryLogs.length, 1);
206 + assert.strictEqual(discoveryLogs[0]?.providerInstanceId, "opencode-test");
207 + assert.strictEqual(discoveryLogs[0]?.serverMode, "external");
208 + assert.strictEqual(
209 + discoveryLogs[0]?.phase,
210 + initialCatalog === "probe" ? "version" : "models",
211 + );
212 +
213 + catalogAvailable = true;
214 + const recovered = yield* instance.snapshot.streamChanges.pipe(
215 + Stream.filter((snapshot) => snapshot.status === "ready"),
216 + Stream.take(1),
217 + Stream.runCollect,
218 + Effect.forkChild,
219 + );
220 + yield* TestClock.adjust("5 minutes");
221 + assert.strictEqual((yield* instance.snapshot.getSnapshot).status, "ready");
222 + const [ready] = Array.from(yield* Fiber.join(recovered));
223 + assert.strictEqual(ready?.auth.status, "authenticated");
224 + assert.deepStrictEqual(
225 + ready?.models.map((model) => model.slug),
226 + ["opencode/big-pickle"],
227 + );
228 +
229 + const readsAfterRecovery = modelReads;
230 + yield* TestClock.adjust("15 minutes");
231 + assert.strictEqual(modelReads, readsAfterRecovery);
232 + assert.strictEqual(discoveryLogs.length, 1);
233 + }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
234 + );
235 +
236 + it.effect("does not retry a rejected server password in the background", () =>
237 + Effect.gen(function* () {
238 + const releaseResponse = yield* Deferred.make<void>();
239 + const requested: Array<string> = [];
240 + const server = replayOpenCodeServer(OPENCODE_2_RESPONSES, "secret", requested);
241 + const instance = yield* create(
242 + { serverUrl: "http://127.0.0.1:4096", serverPassword: "wrong" },
243 + HttpClient.make((request) =>
244 + Deferred.await(releaseResponse).pipe(Effect.andThen(server.execute(request))),
245 + ),
246 + );
247 + // Wait for startup and its maintenance enrichment, both of which probe.
248 + const rejected = yield* instance.snapshot.streamChanges.pipe(
249 + Stream.filter(
250 + (snapshot) => snapshot.status === "error" && snapshot.versionAdvisory !== undefined,
251 + ),
252 + Stream.take(1),
253 + Stream.runCollect,
254 + Effect.forkChild,
255 + );
256 + yield* Effect.yieldNow;
257 + yield* Deferred.succeed(releaseResponse, undefined);
258 + const [snapshot] = Array.from(yield* Fiber.join(rejected));
259 + assert.strictEqual(snapshot?.version, null);
260 + assert.strictEqual(snapshot?.auth.status, "unauthenticated");
261 + const readsAfterRejection = requested.length;
262 +
263 + yield* TestClock.adjust("15 minutes");
264 + assert.strictEqual(requested.length, readsAfterRejection);
265 + }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
266 + );
267 });
268
269 // npm links `<prefix>/bin/opencode` into the package that installed it:
packages/provider-opencode/src/server/driver.ts
+10 -1
@@ -350,6 +350,9 @@ export const OpenCodeDriver: ProviderDriver<
350 host.paths.cwd,
351 runtimeProbe.refresh,
352 loadOpenCode2Models,
353 + ).pipe(
354 + Effect.annotateLogs({ providerInstanceId: instanceId }),
355 + Effect.annotateSpans({ providerInstanceId: instanceId }),
356 ),
357 usageLimits: readOpenCodeGoUsageLimits({
358 enabled: effectiveConfig.enabled,
@@ -440,7 +443,13 @@ export const OpenCodeDriver: ProviderDriver<
443 streamSettings: snapshotSettings.streamSettings,
444 haveSettingsChanged: haveProviderSnapshotSettingsChanged,
445 checkProviderOnSettingsChange: () => false,
443 - refreshOnInterval: false,
446 + // A failed or still-loading catalog must recover without a manual
447 + // refresh. Healthy instances need no recurring server starts.
448 + refreshOnInterval: (snapshot) =>
449 + snapshot.enabled &&
450 + snapshot.installed &&
451 + snapshot.status !== "ready" &&
452 + snapshot.auth.status === "unknown",
453 initialSnapshot: (settings) =>
454 makePendingOpenCodeProvider(settings.provider).pipe(Effect.map(stampIdentity)),
455 checkProvider,
packages/provider-opencode/src/server/status.test.ts
+148
@@ -8,7 +8,9 @@ import * as Effect from "effect/Effect";
8 import * as Fiber from "effect/Fiber";
9 import * as FileSystem from "effect/FileSystem";
10 import * as Layer from "effect/Layer";
11 +import * as Logger from "effect/Logger";
12 import * as Schema from "effect/Schema";
13 +import * as Tracer from "effect/Tracer";
14 import * as HttpClient from "effect/http/HttpClient";
15 import * as HttpClientResponse from "effect/http/HttpClientResponse";
16 import { beforeEach } from "vite-plus/test";
@@ -462,6 +464,110 @@ const checkProvider = Effect.fn("checkProvider")(function* (
464 });
465
466 it.layer(layerTest)("checkOpenCodeProviderStatus", (it) => {
467 + it.effect.each(["version", "inventory", "models", "empty-v1", "empty-v2"] as const)(
468 + "records %s discovery failures in the existing trace and logger",
469 + (failure) =>
470 + Effect.gen(function* () {
471 + const cause = new Error("discovery connection reset");
472 + const v2 = failure === "models" || failure === "empty-v2";
473 + runtimeMock.state.versionStdout = v2 ? "opencode v2.0.18\n" : DEFAULT_VERSION_STDOUT;
474 + if (failure === "version") runtimeMock.state.runVersionError = cause;
475 + if (failure === "inventory") runtimeMock.state.inventoryError = cause;
476 + if (failure === "empty-v1") {
477 + runtimeMock.state.inventory = {
478 + providerList: {
479 + connected: ["openai"],
480 + all: [{ id: "openai", name: "OpenAI", models: {} }],
481 + default: {},
482 + },
483 + agents: [],
484 + skills: [],
485 + };
486 + }
487 + const spans: Array<Tracer.NativeSpan> = [];
488 + yield* checkProvider(
489 + makeOpenCodeSettings({ serverPassword: "private-password" }),
490 + process.cwd(),
491 + undefined,
492 + undefined,
493 + failure === "models"
494 + ? Effect.fail(
495 + new OpenCodeRuntime.OpenCodeRuntimeError({
496 + operation: "model.list",
497 + detail: "model list failed",
498 + cause,
499 + }),
500 + )
501 + : Effect.succeed([]),
502 + ).pipe(
503 + Effect.provideService(
504 + Tracer.Tracer,
505 + Tracer.make({
506 + span: (options) => {
507 + const span = new Tracer.NativeSpan(options);
508 + spans.push(span);
509 + return span;
510 + },
511 + }),
512 + ),
513 + Effect.provide(Logger.layer([Logger.tracerLogger], { mergeWithExisting: false })),
514 + );
515 +
516 + const diagnostics = spans.flatMap((span) =>
517 + span.events
518 + .filter(([name]) => name === "OpenCode discovery failed")
519 + .map((event) => ({ span, event })),
520 + );
521 + NodeAssert.equal(diagnostics.length, 1);
522 + const {
523 + span,
524 + event: [, timestamp, attributes],
525 + } = diagnostics[0]!;
526 + NodeAssert.equal(attributes.provider, "opencode");
527 + NodeAssert.equal(
528 + attributes.phase,
529 + failure.startsWith("empty") ? (v2 ? "models" : "inventory") : failure,
530 + );
531 + NodeAssert.equal(attributes.outcome, failure.startsWith("empty") ? "empty" : "failed");
532 + NodeAssert.equal(attributes.serverMode, "managed");
533 + NodeAssert.equal(attributes["effect.logLevel"], "WARN");
534 + NodeAssert.ok(timestamp >= 0n);
535 + NodeAssert.ok(span.traceId.length > 0);
536 + NodeAssert.equal(span.attributes.get("discovery.outcome"), attributes.outcome);
537 + if (!failure.startsWith("empty")) {
538 + NodeAssert.match(String(attributes["effect.cause"]), /discovery connection reset/);
539 + }
540 + NodeAssert.ok(!JSON.stringify(attributes).includes("private-password"));
541 + }),
542 + );
543 +
544 + it.effect("keeps an empty legacy catalog retryable until connected providers list models", () =>
545 + Effect.gen(function* () {
546 + const upstream = { id: "openai", name: "OpenAI", models: {} };
547 + runtimeMock.state.inventory = {
548 + providerList: { connected: ["openai"], all: [upstream], default: {} },
549 + agents: [],
550 + skills: [],
551 + };
552 + const settings = makeOpenCodeSettings();
553 + const empty = yield* checkProvider(settings);
554 + NodeAssert.equal(empty.status, "warning");
555 + NodeAssert.equal(empty.auth.status, "unknown");
556 + NodeAssert.deepEqual(empty.models, []);
557 +
558 + upstream.models = {
559 + "gpt-5.4": { id: "gpt-5.4", name: "GPT-5.4", variants: {} },
560 + };
561 + const ready = yield* checkProvider(settings);
562 + NodeAssert.equal(ready.status, "ready");
563 + NodeAssert.equal(ready.auth.status, "authenticated");
564 + NodeAssert.deepEqual(
565 + ready.models.map((model) => model.slug),
566 + ["openai/gpt-5.4"],
567 + );
568 + }),
569 + );
570 +
571 it.effect("emits OpenCode variant defaults so trait picker can resolve a visible selection", () =>
572 Effect.gen(function* () {
573 runtimeMock.state.inventory = {
@@ -776,6 +882,48 @@ it.layer(layerTest)("checkOpenCodeProviderStatus", (it) => {
882 });
883
884 it.layer(layerTest)("checkOpenCodeProviderStatus with configured server URL", (it) => {
885 + it.effect.each([
886 + "401 Unauthorized",
887 + "403 Forbidden",
888 + "status=401 body={}",
889 + "status=403 body={}",
890 + "HTTP 401",
891 + "HTTP/1.1 403",
892 + "Response status code: 401",
893 + "Response status code: 403",
894 + "Request failed with status code 401",
895 + "Request failed with status code 403",
896 + ])("keeps explicit authentication rejection actionable: %s", (detail) =>
897 + Effect.gen(function* () {
898 + runtimeMock.state.connectionError = new Error(detail);
899 + const snapshot = yield* checkProvider(
900 + makeOpenCodeSettings({ serverUrl: "http://127.0.0.1:9999" }),
901 + );
902 +
903 + NodeAssert.equal(snapshot.status, "error");
904 + NodeAssert.equal(snapshot.auth.status, "unauthenticated");
905 + NodeAssert.equal(
906 + snapshot.message,
907 + "OpenCode server rejected authentication. Check the server URL and password.",
908 + );
909 + }),
910 + );
911 +
912 + it.effect.each([401, 403, 4010, 4030])("keeps connection failures on port %s retryable", (port) =>
913 + Effect.gen(function* () {
914 + const serverUrl = `http://127.0.0.1:${port}`;
915 + runtimeMock.state.connectionError = new Error(`connect ECONNREFUSED 127.0.0.1:${port}`);
916 + const snapshot = yield* checkProvider(makeOpenCodeSettings({ serverUrl }));
917 +
918 + NodeAssert.equal(snapshot.status, "error");
919 + NodeAssert.equal(snapshot.auth.status, "unknown");
920 + NodeAssert.equal(
921 + snapshot.message,
922 + `Couldn't reach the configured OpenCode server at ${serverUrl}. Check that the server is running and the URL is correct.`,
923 + );
924 + }),
925 + );
926 +
927 it.effect("routes a configured OpenCode 2 server to the 2.x check, never via 1.x", () =>
928 Effect.gen(function* () {
929 const settings = makeOpenCodeSettings({
packages/provider-opencode/src/server/status.ts
+76 -16
@@ -66,19 +66,25 @@ function formatOpenCodeProbeError(input: {
66 readonly isExternalServer: boolean;
67 readonly phase: "version" | "inventory";
68 readonly serverUrl: string;
69 -}): { readonly installed: boolean; readonly message: string } {
69 +}): {
70 + readonly installed: boolean;
71 + readonly message: string;
72 + readonly authStatus?: "unauthenticated";
73 +} {
74 const detail = normalizedErrorMessage(input.cause);
75 const lower = detail?.toLowerCase() ?? "";
76
77 if (input.isExternalServer) {
78 + // Bare auth-code digits can be part of the endpoint's port or path.
79 if (
75 - lower.includes("401") ||
76 - lower.includes("403") ||
77 - lower.includes("unauthorized") ||
78 - lower.includes("forbidden")
80 + /(?:^|\s)(?:status(?:\s+code)?(?:\s*[:=]\s*|\s+)|http(?:\/\d(?:\.\d)?)?\s+)(?:401|403)\b/.test(
81 + lower,
82 + ) ||
83 + /\b(?:unauthorized|forbidden)\b/.test(lower)
84 ) {
85 return {
86 installed: true,
87 + authStatus: "unauthenticated",
88 message: "OpenCode server rejected authentication. Check the server URL and password.",
89 };
90 }
@@ -137,6 +143,32 @@ function formatOpenCodeProbeError(input: {
143 };
144 }
145
146 +// The status check owns the span; keep handled failures visible without adding another span.
147 +const logDiscoveryFailure = Effect.fnUntraced(function* (input: {
148 + readonly phase: "version" | "inventory" | "models";
149 + readonly isExternalServer: boolean;
150 + readonly version?: string;
151 + readonly cause?: Cause.Cause<unknown>;
152 +}) {
153 + const outcome = input.cause ? "failed" : "empty";
154 + const attributes = {
155 + provider: "opencode",
156 + phase: input.phase,
157 + outcome,
158 + serverMode: input.isExternalServer ? "external" : "managed",
159 + ...(input.version === undefined ? {} : { version: input.version }),
160 + };
161 + yield* Effect.annotateCurrentSpan({
162 + "discovery.phase": input.phase,
163 + "discovery.outcome": outcome,
164 + });
165 + yield* (
166 + input.cause
167 + ? Effect.logWarning("OpenCode discovery failed", input.cause)
168 + : Effect.logWarning("OpenCode discovery failed")
169 + ).pipe(Effect.annotateLogs(attributes));
170 +});
171 +
172 function titleCaseSlug(value: string): string {
173 const segments: Array<string> = [];
174 for (const segment of value.split(/[-_/]+/)) {
@@ -592,7 +624,12 @@ const checkOpenCode2 = Effect.fn("checkOpenCode2")(function* (
624 message,
625 });
626 if (result._tag === "Failure") {
595 - yield* Effect.logWarning("OpenCode 2 model list failed", result.cause);
627 + yield* logDiscoveryFailure({
628 + phase: "models",
629 + isExternalServer: settings.serverUrl.trim().length > 0,
630 + version,
631 + cause: result.cause,
632 + });
633 return buildServerProvider({
634 presentation: OPENCODE_2_PRESENTATION,
635 enabled: true,
@@ -606,6 +643,13 @@ const checkOpenCode2 = Effect.fn("checkOpenCode2")(function* (
643 probe: probe("error", "OpenCode could not load its model list."),
644 });
645 }
646 + if (result.value.length === 0) {
647 + yield* logDiscoveryFailure({
648 + phase: "models",
649 + isExternalServer: settings.serverUrl.trim().length > 0,
650 + version,
651 + });
652 + }
653 const models = providerModelsFromSettings(
654 markOpenCodeLegacy(
655 result.value.map((model) => {
@@ -680,7 +724,7 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu
724 installed: failure.installed,
725 version,
726 status: "error",
683 - auth: { status: "unknown" },
727 + auth: { status: failure.authStatus ?? "unknown" },
728 message: failure.message,
729 },
730 });
@@ -715,7 +759,10 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu
759 ),
760 ),
761 );
718 - if (probedExit._tag === "Failure") return fallback(Cause.squash(probedExit.cause));
762 + if (probedExit._tag === "Failure") {
763 + yield* logDiscoveryFailure({ phase: "version", isExternalServer, cause: probedExit.cause });
764 + return fallback(Cause.squash(probedExit.cause));
765 + }
766 const probed = probedExit.value;
767 if (probed.generation === "v2") {
768 return yield* checkOpenCode2(openCodeSettings, probed.version, checkedAt, loadOpenCode2Models);
@@ -777,19 +824,30 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu
824 ),
825 );
826 if (inventoryExit._tag === "Failure") {
827 + yield* logDiscoveryFailure({
828 + phase: "inventory",
829 + isExternalServer,
830 + version,
831 + cause: inventoryExit.cause,
832 + });
833 return {
834 ...fallback(Cause.squash(inventoryExit.cause), version, "inventory"),
835 ...installedVersion,
836 };
837 }
838
839 + const inventoryModels = flattenOpenCodeModels(inventoryExit.value);
840 const models = providerModelsFromSettings(
787 - flattenOpenCodeModels(inventoryExit.value),
841 + inventoryModels,
842 customModels,
843 DEFAULT_OPENCODE_MODEL_CAPABILITIES,
844 );
845 const skills = openCodeSkillsToServerProviderSkills(inventoryExit.value.skills);
846 const connectedCount = inventoryExit.value.providerList.connected.length;
847 + const catalogReady = connectedCount > 0 && inventoryModels.length > 0;
848 + if (connectedCount > 0 && inventoryModels.length === 0) {
849 + yield* logDiscoveryFailure({ phase: "inventory", isExternalServer, version });
850 + }
851 return {
852 ...buildServerProvider({
853 presentation: OPENCODE_PRESENTATION,
@@ -801,17 +859,19 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu
859 probe: {
860 installed: true,
861 version,
804 - status: connectedCount > 0 ? "ready" : "warning",
862 + status: catalogReady ? "ready" : "warning",
863 auth: {
806 - status: connectedCount > 0 ? "authenticated" : "unknown",
864 + status: catalogReady ? "authenticated" : "unknown",
865 type: "opencode",
866 },
867 message:
810 - connectedCount > 0
811 - ? `${connectedCount} upstream provider${connectedCount === 1 ? "" : "s"} connected through ${isExternalServer ? "the configured OpenCode server" : "OpenCode"}.`
812 - : isExternalServer
813 - ? "Connected to the configured OpenCode server, but it did not report any connected upstream providers."
814 - : "OpenCode is available, but it did not report any connected upstream providers.",
868 + connectedCount > 0 && !catalogReady
869 + ? "OpenCode upstream providers are connected, but it did not list any models yet."
870 + : connectedCount > 0
871 + ? `${connectedCount} upstream provider${connectedCount === 1 ? "" : "s"} connected through ${isExternalServer ? "the configured OpenCode server" : "OpenCode"}.`
872 + : isExternalServer
873 + ? "Connected to the configured OpenCode server, but it did not report any connected upstream providers."
874 + : "OpenCode is available, but it did not report any connected upstream providers.",
875 },
876 }),
877 ...installedVersion,
packages/source-control-forgejo/src/server/ForgejoSourceControlProvider.test.ts
+3
@@ -301,6 +301,9 @@ it.effect("reads Forgejo jobs that did not run as finished checks", () =>
301 Effect.provide(
302 Layer.mock(ForgejoCli.ForgejoCli)({
303 api: (input) => {
304 + if (input.path.endsWith("branches/main")) {
305 + return encodeJsonEffect({}).pipe(Effect.orDie, Effect.map(processOutput));
306 + }
307 const status = (context: string, state: string) => ({
308 context,
309 status: state,