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,