Open History to see the last commit
1// @effect-diagnostics nodeBuiltinImport:off
2import * as NodeFS from "node:fs";
3import * as NodeOS from "node:os";
4import * as NodePath from "node:path";
5
6import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
7import * as NodeServices from "@effect/platform-node/NodeServices";
8import { assert, it } from "@effect/vitest";
9import {
10 DEFAULT_SERVER_SETTINGS,
11 ProviderInstanceId,
12 ProviderSessionId,
13 ThreadId,
14} from "@t3tools/contracts";
15import type { OpenCodeSettings } from "../settings.ts";
16import * as HostProcess from "@t3tools/shared/HostProcess";
17import * as Deferred from "effect/Deferred";
18import * as Effect from "effect/Effect";
19import * as Duration from "effect/Duration";
20import * as Fiber from "effect/Fiber";
21import * as FileSystem from "effect/FileSystem";
22import * as Layer from "effect/Layer";
23import * as Logger from "effect/Logger";
24import * as Option from "effect/Option";
25import * as References from "effect/References";
26import * as Stream from "effect/Stream";
27import * as TestClock from "effect/testing/TestClock";
28import * as HttpClient from "effect/http/HttpClient";
29import * as HttpClientResponse from "effect/http/HttpClientResponse";
30import * as FetchHttpClient from "effect/http/FetchHttpClient";
31import * as UrlParams from "effect/http/UrlParams";
32import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
33
34import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
35import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
36import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
37import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
38import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver";
39import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
40import { OpenCodeDriver, isLocalOpenCodeServerUrl, openCodeUpdateFor } from "./driver.ts";
41import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts";
42import {
43 OPENCODE_2_RESPONSES,
44 OPENCODE_2_WORKSPACE_RESPONSES,
45 replayOpenCodeServer,
46} from "./probeResponses.fixture.ts";
47import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
48
49it("only probes a locally configured OpenCode server's installed CLI", () => {
50 assert.isTrue(isLocalOpenCodeServerUrl("http://127.0.0.1:35768"));
51 assert.isTrue(isLocalOpenCodeServerUrl("http://127.255.255.254:4096"));
52 assert.isFalse(isLocalOpenCodeServerUrl("http://127.example.com:4096"));
53 assert.isFalse(isLocalOpenCodeServerUrl("http://128.0.0.1:4096"));
54 assert.isTrue(isLocalOpenCodeServerUrl("http://localhost:4096"));
55 assert.isTrue(isLocalOpenCodeServerUrl("http://[::1]:4096"));
56 assert.isFalse(isLocalOpenCodeServerUrl("https://remote.example.com:4096"));
57 assert.isFalse(isLocalOpenCodeServerUrl(""));
58 assert.isFalse(isLocalOpenCodeServerUrl("file:///tmp/opencode"));
59});
60
61const serverStarts: Array<string> = [];
62const reachedServer = (operation: string) =>
63 Effect.sync(() => serverStarts.push(operation)).pipe(
64 Effect.andThen(
65 Effect.fail(
66 new OpenCodeRuntime.OpenCodeRuntimeError({
67 operation,
68 detail: "reached a 1.x server path",
69 }),
70 ),
71 ),
72 );
73const openCode2Runtime = {
74 runOpenCodeCommand: () => Effect.succeed({ stdout: "opencode v2.0.18\n", stderr: "", code: 0 }),
75 startOpenCodeServerProcess: () => reachedServer("start"),
76 connectToOpenCodeServer: () => reachedServer("connect"),
77} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
78
79const layer = Layer.mergeAll(
80 IdAllocator.layer,
81 McpProviderSessions.layer,
82 ProviderLatestVersions.layer,
83 TestProviderHost.layer(),
84 Layer.succeed(
85 ProviderEventLoggers.ProviderEventLoggers,
86 ProviderEventLoggers.NoOpProviderEventLoggers,
87 ),
88 Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode2Runtime),
89).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
90
91const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient, enabled = true) =>
92 OpenCodeDriver.create({
93 instanceId: ProviderInstanceId.make("opencode-test"),
94 displayName: undefined,
95 environment: [],
96 enabled,
97 config: { ...OpenCodeDriver.defaultConfig(), ...config },
98 }).pipe(Effect.provideService(HttpClient.HttpClient, http));
99
100const noHttp = HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP"));
101
102const openCode2Project = "/work/project-with-config";
103const openCode2Model = (providerID: string, id: string, name: string) => ({
104 id,
105 modelID: id,
106 providerID,
107 name,
108 package: "@opencode/ai/providers/openai-compatible",
109 settings: {},
110 compatibility: {},
111 capabilities: { tools: true, input: ["text"], output: ["text"] },
112 variants: [],
113 time: { released: 1789516800000 },
114 cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
115 status: "active",
116 enabled: true,
117 limit: { context: 1000000, output: 65536 },
118});
119// Serves one machine catalog everywhere plus extra models for the project directory.
120const makeOpenCode2ProjectInstance = (
121 projectCatalog: "listed" | "models-unavailable" | "providers-unavailable",
122) =>
123 Effect.gen(function* () {
124 const machineModels = [openCode2Model("opencode", "big-pickle", "Big Pickle")];
125 const projectModels = [
126 ...machineModels,
127 openCode2Model("uni", "medium-gpt", "Medium GPT"),
128 openCode2Model("uni", "large-gpt", "Large GPT"),
129 ];
130 const replay = replayOpenCodeServer(
131 { ...OPENCODE_2_RESPONSES, ...OPENCODE_2_WORKSPACE_RESPONSES },
132 "secret",
133 );
134 const server = HttpClient.make((request) => {
135 const pathname = new URL(request.url).pathname;
136 if (pathname !== "/api/model" && pathname !== "/api/provider") {
137 return replay.execute(request);
138 }
139 const directory = Option.getOrUndefined(
140 UrlParams.getFirst(request.urlParams, "location[directory]"),
141 );
142 const isProject = directory === openCode2Project;
143 const data = pathname === "/api/provider" ? [] : isProject ? projectModels : machineModels;
144 const unavailable =
145 isProject &&
146 ((pathname === "/api/model" && projectCatalog === "models-unavailable") ||
147 (pathname === "/api/provider" && projectCatalog === "providers-unavailable"));
148 return Effect.succeed(
149 HttpClientResponse.fromWeb(
150 request,
151 new Response(JSON.stringify({ location: { directory }, data }), {
152 status: unavailable ? 503 : 200,
153 headers: { "content-type": "application/json" },
154 }),
155 ),
156 );
157 });
158 const instance = yield* create(
159 { serverUrl: "http://127.0.0.1:4096", serverPassword: "secret" },
160 server,
161 );
162 const ready = yield* instance.snapshot.streamChanges.pipe(
163 Stream.filter((snapshot) => snapshot.status === "ready"),
164 Stream.take(1),
165 Stream.runCollect,
166 Effect.forkChild,
167 );
168 yield* TestClock.adjust("5 seconds");
169 yield* Fiber.join(ready);
170 // Catalog reads repeat until two agree, so let them settle on the test clock.
171 return (cwd: string) =>
172 Effect.gen(function* () {
173 const read = yield* Effect.forkChild(instance.snapshotForCwd!(cwd));
174 yield* TestClock.adjust("5 seconds");
175 return yield* Fiber.join(read);
176 });
177 });
178
179it.live("discovers models through a home-relative OpenCode wrapper", () =>
180 Effect.gen(function* () {
181 const fs = yield* FileSystem.FileSystem;
182 const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-opencode-home with spaces-" });
183 const binaryPath = NodePath.join(home, "opencode");
184 const scriptPath = NodePath.join(home, "opencode.cjs");
185 yield* fs.writeFileString(
186 scriptPath,
187 `if (process.argv.includes('--version')) {
188 console.log('1.18.32');
189 } else {
190 const server = require('node:http').createServer((req, res) => {
191 const route = new URL(req.url, 'http://localhost').pathname;
192 res.setHeader('content-type', 'application/json');
193 res.end(JSON.stringify(route === '/global/health'
194 ? { healthy: true, version: '1.18.32' }
195 : route === '/provider'
196 ? { connected: ['opencode'], default: {}, all: [{
197 id: 'opencode', name: 'OpenCode', models: {
198 'big-pickle': { id: 'big-pickle', name: 'Big Pickle' }
199 }
200 }] }
201 : []));
202 });
203 server.listen(0, '127.0.0.1', () => {
204 console.log('opencode server listening on http://127.0.0.1:' + server.address().port);
205 });
206 }`,
207 );
208 const windows = (yield* HostProcess.Platform) === "win32";
209 const wrapperPath = windows ? `${binaryPath}.cmd` : binaryPath;
210 const node = yield* HostProcess.ExecutablePath;
211 yield* fs.writeFileString(
212 wrapperPath,
213 windows
214 ? `@echo off\r\n"${node}" "${scriptPath}" %*\r\n`
215 : `#!/bin/sh\nexec "${node}" "${scriptPath}" "$@"\n`,
216 );
217 if (!windows) yield* fs.chmod(wrapperPath, 0o755);
218
219 const instance = yield* OpenCodeDriver.create({
220 instanceId: ProviderInstanceId.make("opencode-home"),
221 displayName: undefined,
222 environment: [],
223 enabled: true,
224 config: {
225 ...OpenCodeDriver.defaultConfig(),
226 binaryPath: windows ? "~/opencode.cmd" : "~/opencode",
227 },
228 }).pipe(Effect.provideService(HostProcess.HomeDirectory, home));
229 const snapshot = yield* instance.snapshot.refresh;
230 assert.strictEqual(snapshot.status, "ready");
231 assert.strictEqual(snapshot.version, "1.18.32");
232 assert.isTrue(snapshot.models.some((model) => model.slug === "opencode/big-pickle"));
233 }).pipe(
234 Effect.scoped,
235 Effect.provide(
236 Layer.mergeAll(
237 IdAllocator.layer,
238 McpProviderSessions.layer,
239 ProviderLatestVersions.layer,
240 TestProviderHost.layer({ runBackgroundWork: false }),
241 Layer.succeed(
242 ProviderEventLoggers.ProviderEventLoggers,
243 ProviderEventLoggers.NoOpProviderEventLoggers,
244 ),
245 OpenCodeRuntime.layer.pipe(Layer.provide(OpenCodeServerLedger.layerTest)),
246 ).pipe(
247 Layer.provideMerge(
248 Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, FetchHttpClient.layer),
249 ),
250 ),
251 ),
252 ),
253);
254
255// Under MISE_OFFLINE the shim cannot install OpenCode; a normal run installs 2.x first.
256const lazyMiseShim = {
257 ...openCode2Runtime,
258 runOpenCodeCommand: ({ environment }: { readonly environment?: NodeJS.ProcessEnv }) =>
259 environment?.MISE_OFFLINE === "1"
260 ? Effect.fail(
261 new OpenCodeRuntime.OpenCodeRuntimeError({
262 operation: "runOpenCodeCommand",
263 detail: "mise ERROR Failed to install opencode@latest",
264 }),
265 )
266 : Effect.succeed({ stdout: "opencode v2.0.18\n", stderr: "", code: 0 }),
267} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
268
269it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
270 it.effect("never starts a 1.x server for an OpenCode 2 instance", () =>
271 Effect.gen(function* () {
272 serverStarts.length = 0;
273 const instance = yield* create({}, noHttp);
274 yield* Effect.flip(
275 instance.textGeneration.generateThreadTitle({
276 cwd: process.cwd(),
277 message: "hello",
278 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
279 }),
280 );
281 assert.deepStrictEqual(serverStarts, ["start"]);
282 }).pipe(Effect.scoped),
283 );
284
285 it.effect.each(["2.1.2", null])(
286 "reports the installed CLI version independently of the loopback server (%s)",
287 (installedVersion) =>
288 Effect.gen(function* () {
289 const probeOffline: Array<string | undefined> = [];
290 const runtime = {
291 ...openCode2Runtime,
292 runOpenCodeCommand: (input) =>
293 Effect.sync(() => {
294 probeOffline.push(input.environment?.MISE_OFFLINE);
295 return {
296 stdout:
297 installedVersion === null ? "unrecognized" : `opencode v${installedVersion}\n`,
298 stderr: "",
299 code: 0,
300 };
301 }),
302 } as OpenCodeRuntime.OpenCodeRuntime["Service"];
303 const instance = yield* create(
304 { serverUrl: "http://127.0.0.1:4096" },
305 replayOpenCodeServer(OPENCODE_2_RESPONSES, ""),
306 ).pipe(Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime));
307
308 const snapshot = yield* instance.snapshot.refresh;
309 assert.strictEqual(snapshot.version, "2.0.18");
310 assert.strictEqual(snapshot.installedVersion, installedVersion ?? undefined);
311 const maintenance = yield* instance.snapshot.resolveMaintenance({ fresh: true });
312 assert.strictEqual(maintenance.packageName, "@opencode/cli");
313 assert.isNotEmpty(probeOffline);
314 assert.isTrue(probeOffline.every((offline) => offline === "1"));
315 }).pipe(Effect.scoped),
316 );
317
318 it.effect("skips the installed CLI probe when a localhost provider is disabled", () =>
319 Effect.gen(function* () {
320 const probed: string[] = [];
321 const runtime = {
322 ...openCode2Runtime,
323 runOpenCodeCommand: () =>
324 Effect.sync(() => {
325 probed.push("--version");
326 return { stdout: "opencode v2.1.2\n", stderr: "", code: 0 };
327 }),
328 } as OpenCodeRuntime.OpenCodeRuntime["Service"];
329 const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, noHttp, false).pipe(
330 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
331 );
332
333 const snapshot = yield* instance.snapshot.refresh;
334 assert.isFalse(snapshot.enabled);
335 assert.deepStrictEqual(probed, []);
336 }).pipe(Effect.scoped),
337 );
338
339 it.effect("opens a session through OpenCode 2 that a lazy mise shim installs on first use", () =>
340 Effect.gen(function* () {
341 serverStarts.length = 0;
342 const instance = yield* create({}, noHttp).pipe(
343 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, lazyMiseShim),
344 // The background status check probes offline, which this shim always fails.
345 Effect.provide(TestProviderHost.layer({ runBackgroundWork: false })),
346 );
347
348 yield* instance.orchestrationAdapter
349 .openSession({
350 threadId: ThreadId.make("thread-lazy-mise"),
351 providerSessionId: ProviderSessionId.make("session-lazy-mise"),
352 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
353 runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
354 })
355 .pipe(Effect.scoped, Effect.flip);
356 assert.deepStrictEqual(serverStarts, ["start"], "the OpenCode 2 adapter starts its server");
357 const capabilities = yield* instance.orchestrationAdapter.getCapabilities();
358 assert.isTrue(capabilities.sessions.supportsRuntimeModeSwitchInSession);
359 }).pipe(Effect.scoped),
360 );
361
362 it.effect("does not scan a workspace through a 1.x server it could not probe offline", () =>
363 Effect.gen(function* () {
364 serverStarts.length = 0;
365 const instance = yield* create({}, noHttp).pipe(
366 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, lazyMiseShim),
367 );
368
369 yield* Effect.flip(instance.snapshotForCwd!(process.cwd()));
370 assert.deepStrictEqual(serverStarts, []);
371 }).pipe(Effect.scoped),
372 );
373
374 it.effect.each([
375 "1.18.32",
376 "opencode v2.0.18",
377 "opencode v2.2.4",
378 "opencode v2.2.5",
379 "opencode v2.2.6",
380 ])("advertises native goal support only for supported OpenCode versions: %s", (version) =>
381 Effect.gen(function* () {
382 const fs = yield* FileSystem.FileSystem;
383 const root = yield* fs.makeTempDirectoryScoped({ prefix: "opencode-goal-capability-" });
384 const binaryPath = NodePath.join(
385 root,
386 "lib",
387 "node_modules",
388 "@opencode",
389 "cli",
390 "bin",
391 "opencode",
392 );
393 yield* fs.makeDirectory(NodePath.dirname(binaryPath), { recursive: true });
394 yield* fs.writeFileString(binaryPath, "");
395 const instance = yield* create({ binaryPath }, noHttp).pipe(
396 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, {
397 ...openCode2Runtime,
398 runOpenCodeCommand: () => Effect.succeed({ stdout: version, stderr: "", code: 0 }),
399 }),
400 );
401 yield* instance.snapshot.resolveMaintenance({ fresh: true });
402 const capabilities = yield* instance.orchestrationAdapter.getCapabilities();
403 assert.equal(
404 capabilities.turns.supportsNativeGoals === true,
405 version.endsWith("2.2.5") || version.endsWith("2.2.6"),
406 );
407 }).pipe(Effect.scoped),
408 );
409
410 it.effect("uses the connected OpenCode version for goal support after an upgrade", () =>
411 Effect.gen(function* () {
412 const fs = yield* FileSystem.FileSystem;
413 const root = yield* fs.makeTempDirectoryScoped({ prefix: "opencode-upgraded-goals-" });
414 const binaryPath = NodePath.join(
415 root,
416 "lib",
417 "node_modules",
418 "@opencode",
419 "cli",
420 "bin",
421 "opencode",
422 );
423 yield* fs.makeDirectory(NodePath.dirname(binaryPath), { recursive: true });
424 yield* fs.writeFileString(binaryPath, "");
425 const http = HttpClient.make((request) => {
426 const path = new URL(request.url).pathname;
427 if (path === "/api/info")
428 return Effect.succeed(
429 HttpClientResponse.fromWeb(
430 request,
431 Response.json({
432 ...JSON.parse(OPENCODE_2_RESPONSES["/api/info"].body),
433 version: "2.2.5",
434 }),
435 ),
436 );
437 if (path === "/api/model")
438 return Effect.succeed(
439 HttpClientResponse.fromWeb(
440 request,
441 Response.json({ location: { directory: "/work" }, data: [] }),
442 ),
443 );
444 if (path === "/api/event")
445 return Effect.succeed(
446 HttpClientResponse.fromWeb(
447 request,
448 new Response(new ReadableStream(), {
449 headers: { "content-type": "text/event-stream" },
450 }),
451 ),
452 );
453 return Effect.die(`Unexpected request: ${path}`);
454 });
455 const instance = yield* create({ binaryPath }, http).pipe(
456 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, {
457 ...openCode2Runtime,
458 runOpenCodeCommand: () =>
459 Effect.succeed({ stdout: "opencode v2.2.4", stderr: "", code: 0 }),
460 startOpenCodeServerProcess: ({ verify }) =>
461 Effect.gen(function* () {
462 const url = "http://127.0.0.1:4096";
463 const version = verify ? yield* verify(url) : "2.2.5";
464 return { url, version, isRunning: Effect.succeed(true), exitCode: Effect.never };
465 }),
466 }),
467 );
468 yield* instance.snapshot.resolveMaintenance({ fresh: true });
469 assert.isFalse(
470 (yield* instance.orchestrationAdapter.getCapabilities()).turns.supportsNativeGoals,
471 );
472 const session = yield* instance.orchestrationAdapter.openSession({
473 threadId: ThreadId.make("upgraded-goal"),
474 providerSessionId: ProviderSessionId.make("upgraded-goal"),
475 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
476 runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
477 });
478 assert.isTrue(session.providerSession.capabilities.turns.supportsNativeGoals);
479 assert.isTrue(
480 (yield* instance.orchestrationAdapter.getCapabilities()).turns.supportsNativeGoals,
481 );
482 }).pipe(Effect.scoped),
483 );
484
485 it.effect("answers capability reads without waiting on an unreachable server", () =>
486 Effect.gen(function* () {
487 const hang = HttpClient.make(() => Effect.never);
488 const instance = yield* create({ serverUrl: "http://127.0.0.1:9" }, hang);
489
490 const capabilities = yield* instance.orchestrationAdapter
491 .getCapabilities()
492 .pipe(Effect.forkChild);
493 yield* Effect.yieldNow;
494 assert.isDefined(capabilities.pollUnsafe());
495 yield* Fiber.join(capabilities);
496 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
497 );
498
499 it.effect.each(["/api/debug/location", "/api/event"])(
500 "lists workspace skills from an external OpenCode 2 server whose %s never answers",
501 (stalled) =>
502 Effect.gen(function* () {
503 const answers: Record<string, string> = {
504 "/api/info": OPENCODE_2_RESPONSES["/api/info"].body,
505 "/api/debug/location": "[]",
506 "/api/model": '{"location":{"directory":"/work"},"data":[]}',
507 "/api/provider": '{"location":{"directory":"/work"},"data":[]}',
508 "/api/command": OPENCODE_2_WORKSPACE_RESPONSES["/api/command"].body,
509 "/api/skill": OPENCODE_2_WORKSPACE_RESPONSES["/api/skill"].body,
510 };
511 const http = HttpClient.make((request) => {
512 const path = new URL(request.url).pathname;
513 if (path === stalled) return Effect.never;
514 if (path === "/api/event")
515 return Effect.succeed(
516 HttpClientResponse.fromWeb(
517 request,
518 new Response(new ReadableStream(), {
519 headers: { "content-type": "text/event-stream" },
520 }),
521 ),
522 );
523 const body = answers[path];
524 return body === undefined
525 ? Effect.die(`Unexpected request: ${path}`)
526 : Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(JSON.parse(body))));
527 });
528 const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, http);
529
530 const snapshot = yield* instance.snapshotForCwd!("/work").pipe(Effect.forkChild);
531 yield* TestClock.adjust("30 seconds");
532 const { skills } = yield* Fiber.join(snapshot);
533 assert.include(
534 skills.map((skill) => skill.name),
535 "plum",
536 );
537 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
538 );
539
540 it.effect.each(["probe", "error", "empty"] as const)(
541 "recovers discovery without a manual refresh after %s",
542 (initialCatalog) =>
543 Effect.gen(function* () {
544 const releaseCatalog = yield* Deferred.make<void>();
545 const discoveryLogs: Array<Record<string, unknown>> = [];
546 const logger = Logger.make(({ message, fiber }) => {
547 if (Array.isArray(message) && message.includes("OpenCode discovery failed")) {
548 discoveryLogs.push({ ...fiber.getRef(References.CurrentLogAnnotations) });
549 }
550 });
551 let catalogAvailable = false;
552 let modelReads = 0;
553 const replies = {
554 ...OPENCODE_2_RESPONSES,
555 "/api/provider": {
556 status: 200,
557 contentType: "application/json",
558 body: '{"location":{"directory":"/work"},"data":[]}',
559 },
560 "/api/model": {
561 status: 200,
562 contentType: "application/json",
563 body: JSON.stringify({
564 location: { directory: "/work" },
565 data: [
566 {
567 id: "big-pickle",
568 modelID: "big-pickle",
569 providerID: "opencode",
570 name: "Big Pickle",
571 package: "@opencode/ai/providers/openai-compatible",
572 settings: {},
573 compatibility: {},
574 capabilities: { tools: true, input: ["text"], output: ["text"] },
575 variants: [],
576 time: { released: 1789516800000 },
577 cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
578 status: "active",
579 enabled: true,
580 limit: { context: 1000000, output: 65536 },
581 },
582 ],
583 }),
584 },
585 };
586 const replay = replayOpenCodeServer(replies, "secret");
587 const server = HttpClient.make((request) =>
588 Effect.gen(function* () {
589 if (initialCatalog === "probe" && !catalogAvailable) {
590 yield* Deferred.await(releaseCatalog);
591 return HttpClientResponse.fromWeb(
592 request,
593 new Response('{"_tag":"InternalServerError","message":"server starting"}', {
594 status: 503,
595 headers: { "content-type": "application/json" },
596 }),
597 );
598 }
599 if (new URL(request.url).pathname === "/api/model") {
600 modelReads += 1;
601 yield* Deferred.await(releaseCatalog);
602 if (!catalogAvailable) {
603 return HttpClientResponse.fromWeb(
604 request,
605 new Response(
606 initialCatalog === "error"
607 ? '{"_tag":"InternalServerError","message":"catalog unavailable"}'
608 : '{"location":{"directory":"/work"},"data":[]}',
609 {
610 status: initialCatalog === "error" ? 500 : 200,
611 headers: { "content-type": "application/json" },
612 },
613 ),
614 );
615 }
616 }
617 return yield* replay.execute(request);
618 }),
619 );
620 const instance = yield* create(
621 { serverUrl: "http://127.0.0.1:4096", serverPassword: "secret" },
622 server,
623 ).pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: false })));
624 const initial = yield* instance.snapshot.streamChanges.pipe(
625 Stream.filter(
626 (snapshot) =>
627 snapshot.installed &&
628 snapshot.status === (initialCatalog === "empty" ? "warning" : "error"),
629 ),
630 Stream.take(1),
631 Stream.runCollect,
632 Effect.forkChild,
633 );
634 yield* Effect.yieldNow;
635 yield* Deferred.succeed(releaseCatalog, undefined);
636 yield* TestClock.adjust("5 seconds");
637 const [failed] = Array.from(yield* Fiber.join(initial));
638 assert.strictEqual(failed?.auth.status, "unknown");
639 assert.deepStrictEqual(failed?.models, []);
640 if (initialCatalog === "probe") assert.strictEqual(failed?.version, null);
641 assert.strictEqual(discoveryLogs.length, 1);
642 assert.strictEqual(discoveryLogs[0]?.providerInstanceId, "opencode-test");
643 assert.strictEqual(discoveryLogs[0]?.serverMode, "external");
644 assert.strictEqual(
645 discoveryLogs[0]?.phase,
646 initialCatalog === "probe" ? "version" : "models",
647 );
648
649 catalogAvailable = true;
650 const recovered = yield* instance.snapshot.streamChanges.pipe(
651 Stream.filter((snapshot) => snapshot.status === "ready"),
652 Stream.take(1),
653 Stream.runCollect,
654 Effect.forkChild,
655 );
656 yield* TestClock.adjust("5 minutes");
657 assert.strictEqual((yield* instance.snapshot.getSnapshot).status, "ready");
658 const [ready] = Array.from(yield* Fiber.join(recovered));
659 assert.strictEqual(ready?.auth.status, "authenticated");
660 assert.deepStrictEqual(
661 ready?.models.map((model) => model.slug),
662 ["opencode/big-pickle"],
663 );
664
665 const readsAfterRecovery = modelReads;
666 yield* TestClock.adjust("15 minutes");
667 assert.strictEqual(modelReads, readsAfterRecovery);
668 assert.strictEqual(discoveryLogs.length, 1);
669 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
670 );
671
672 it.effect("lists a project's own opencode.jsonc models in that project's snapshot", () =>
673 Effect.gen(function* () {
674 const snapshotFor = yield* makeOpenCode2ProjectInstance("listed");
675
676 const projectSnapshot = yield* snapshotFor(openCode2Project);
677 assert.deepStrictEqual(projectSnapshot.models.map((entry) => entry.slug).toSorted(), [
678 "opencode/big-pickle",
679 "uni/large-gpt",
680 "uni/medium-gpt",
681 ]);
682 const otherSnapshot = yield* snapshotFor("/work/other-project");
683 assert.deepStrictEqual(
684 otherSnapshot.models.map((entry) => entry.slug),
685 ["opencode/big-pickle"],
686 );
687 assert.strictEqual(otherSnapshot.workspaceModels, undefined);
688 assert.strictEqual(otherSnapshot.workspaceModelsPending, undefined);
689 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
690 );
691
692 it.effect.each(["models-unavailable", "providers-unavailable"] as const)(
693 "reports a project's catalog unknown when its read fails (%s)",
694 (projectCatalog) =>
695 Effect.gen(function* () {
696 const snapshotFor = yield* makeOpenCode2ProjectInstance(projectCatalog);
697
698 const projectSnapshot = yield* snapshotFor(openCode2Project);
699 assert.deepStrictEqual(
700 projectSnapshot.models.map((entry) => entry.slug),
701 ["opencode/big-pickle"],
702 );
703 assert.strictEqual(projectSnapshot.workspaceModels, undefined);
704 assert.strictEqual(projectSnapshot.workspaceModelsPending, true);
705 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
706 );
707
708 it.effect("does not retry a rejected server password in the background", () =>
709 Effect.gen(function* () {
710 const releaseResponse = yield* Deferred.make<void>();
711 const requested: Array<string> = [];
712 const server = replayOpenCodeServer(OPENCODE_2_RESPONSES, "secret", requested);
713 const instance = yield* create(
714 { serverUrl: "http://127.0.0.1:4096", serverPassword: "wrong" },
715 HttpClient.make((request) =>
716 Deferred.await(releaseResponse).pipe(Effect.andThen(server.execute(request))),
717 ),
718 );
719 // Wait for startup and its maintenance enrichment, both of which probe.
720 const rejected = yield* instance.snapshot.streamChanges.pipe(
721 Stream.filter(
722 (snapshot) => snapshot.status === "error" && snapshot.versionAdvisory !== undefined,
723 ),
724 Stream.take(1),
725 Stream.runCollect,
726 Effect.forkChild,
727 );
728 yield* Effect.yieldNow;
729 yield* Deferred.succeed(releaseResponse, undefined);
730 const [snapshot] = Array.from(yield* Fiber.join(rejected));
731 assert.strictEqual(snapshot?.version, null);
732 assert.strictEqual(snapshot?.auth.status, "unauthenticated");
733 const readsAfterRejection = requested.length;
734
735 yield* TestClock.adjust("15 minutes");
736 assert.strictEqual(requested.length, readsAfterRejection);
737 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
738 );
739
740 it.effect.each(
741 [
742 { name: "recovers" },
743 { name: "skips without demand", demand: false },
744 { name: "respects a disabled interval", intervalOff: true },
745 { name: "skips disabled instances", enabled: false },
746 { name: "skips unsupported usage", unsupported: true },
747 ].map((scenario) => ({
748 enabled: true,
749 demand: true,
750 intervalOff: false,
751 unsupported: false,
752 ...scenario,
753 })),
754 )("Go usage recovery $name without restarting a ready catalog", (scenario) =>
755 Effect.gen(function* () {
756 const usageStarted = yield* Deferred.make<void>();
757 let usageReads = 0;
758 let serverStarts = 0;
759 let modelReads = 0;
760 const server = HttpClient.make((request) => {
761 if (request.url === "https://opencode.ai/zen/go/v1/usage") {
762 usageReads += 1;
763 assert.strictEqual(request.headers.authorization, "Bearer test-go-key");
764 if (scenario.unsupported)
765 return Effect.succeed(
766 HttpClientResponse.fromWeb(request, new Response(null, { status: 403 })),
767 );
768 if (usageReads === 1)
769 return Deferred.succeed(usageStarted, undefined).pipe(Effect.andThen(Effect.never));
770 const window = { percent: 10, resetsAt: "2026-11-01T00:00:00.000Z" };
771 return Effect.succeed(
772 HttpClientResponse.fromWeb(
773 request,
774 Response.json({ usage: { rolling: window, weekly: window, monthly: window } }),
775 ),
776 );
777 }
778 const path = new URL(request.url).pathname;
779 if (path === "/api/model") modelReads += 1;
780 const body =
781 path === "/api/info"
782 ? JSON.parse(OPENCODE_2_RESPONSES["/api/info"].body)
783 : {
784 location: { directory: "/work" },
785 data:
786 path === "/api/model"
787 ? [
788 {
789 id: "big-pickle",
790 modelID: "big-pickle",
791 providerID: "opencode",
792 name: "Big Pickle",
793 package: "@opencode/ai/providers/openai-compatible",
794 settings: {},
795 compatibility: {},
796 capabilities: { tools: true, input: ["text"], output: ["text"] },
797 variants: [],
798 time: { released: 1789516800000 },
799 cost: [],
800 status: "active",
801 enabled: true,
802 limit: { context: 1000000, output: 65536 },
803 },
804 ]
805 : [],
806 };
807 return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(body)));
808 });
809 const runtime = {
810 ...openCode2Runtime,
811 startOpenCodeServerProcess: ({
812 verify,
813 }: Parameters<
814 OpenCodeRuntime.OpenCodeRuntime["Service"]["startOpenCodeServerProcess"]
815 >[0]) =>
816 Effect.gen(function* () {
817 serverStarts += 1;
818 const url = "http://127.0.0.1:4096";
819 const version = verify ? yield* verify(url) : "2.0.18";
820 return { url, version, isRunning: Effect.succeed(true), exitCode: Effect.never };
821 }),
822 };
823 const instance = yield* OpenCodeDriver.create({
824 instanceId: ProviderInstanceId.make("opencode-usage-recovery"),
825 displayName: undefined,
826 environment: [
827 {
828 name: "OPENCODE_AUTH_CONTENT",
829 sensitive: true,
830 value: JSON.stringify({
831 "opencode-go": { type: "api", key: "test-go-key" },
832 }),
833 },
834 ],
835 enabled: scenario.enabled,
836 config: OpenCodeDriver.defaultConfig(),
837 }).pipe(
838 Effect.provide(
839 TestProviderHost.layer({
840 runBackgroundWork: scenario.demand,
841 settings: scenario.intervalOff
842 ? {
843 ...DEFAULT_SERVER_SETTINGS,
844 backgroundActivity: {
845 ...DEFAULT_SERVER_SETTINGS.backgroundActivity,
846 profile: "custom",
847 overrides: { providerHealthRefreshInterval: Duration.zero },
848 },
849 }
850 : DEFAULT_SERVER_SETTINGS,
851 }),
852 ),
853 Effect.provideService(HttpClient.HttpClient, server),
854 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
855 );
856 const initial = scenario.enabled
857 ? yield* instance.snapshot.streamChanges.pipe(
858 Stream.filter((snapshot) => snapshot.usageLimits !== undefined),
859 Stream.take(1),
860 Stream.runCollect,
861 Effect.forkChild,
862 )
863 : undefined;
864 if (scenario.enabled && !scenario.unsupported) yield* Deferred.await(usageStarted);
865 yield* TestClock.adjust("5 seconds");
866 const failed = initial
867 ? Array.from(yield* Fiber.join(initial))[0]
868 : yield* instance.snapshot.getSnapshot;
869 if (scenario.enabled) {
870 assert.strictEqual(failed?.status, "ready");
871 assert.strictEqual(failed?.auth.status, "authenticated");
872 }
873 const initialReason =
874 scenario.enabled && !scenario.unsupported ? "probeFailed" : "unsupported";
875 assert.strictEqual(failed?.usageLimits?.unavailable?.reason, initialReason);
876 const catalogReads = modelReads;
877 const starts = serverStarts;
878
879 const shouldRecover =
880 scenario.enabled && scenario.demand && !scenario.intervalOff && !scenario.unsupported;
881 const recovery = shouldRecover
882 ? yield* instance.snapshot.streamChanges.pipe(
883 Stream.filter((snapshot) => snapshot.usageLimits?.windows.length === 3),
884 Stream.take(1),
885 Stream.runCollect,
886 Effect.forkChild,
887 )
888 : undefined;
889 yield* TestClock.adjust("5 minutes");
890 const recovered = yield* instance.snapshot.getSnapshot;
891 const expectedReads = !scenario.enabled ? 0 : shouldRecover ? 2 : 1;
892 assert.strictEqual(usageReads, expectedReads);
893 if (recovery) assert.deepStrictEqual(Array.from(yield* Fiber.join(recovery)), [recovered]);
894 assert.strictEqual(
895 recovered.usageLimits?.unavailable?.reason,
896 shouldRecover ? undefined : initialReason,
897 );
898 assert.deepStrictEqual(
899 recovered.usageLimits?.windows.map((window) => window.kind),
900 shouldRecover ? ["session", "weekly", "monthly"] : [],
901 );
902 assert.strictEqual(modelReads, catalogReads);
903 assert.strictEqual(serverStarts, starts);
904 yield* TestClock.adjust("15 minutes");
905 assert.strictEqual(usageReads, expectedReads);
906 assert.strictEqual(modelReads, catalogReads);
907 assert.strictEqual(serverStarts, starts);
908 }).pipe(Effect.scoped, Effect.provide(TestClock.layer())),
909 );
910});
911
912// npm links into opencode-ai for 1.x and @opencode/cli for 2.x.
913const npmGlobalInstall = (prefix: string, packagePath: ReadonlyArray<string>, bin: string) => {
914 const target = NodePath.join(prefix, "lib", "node_modules", ...packagePath, "bin", bin);
915 NodeFS.mkdirSync(NodePath.dirname(target), { recursive: true });
916 NodeFS.writeFileSync(target, "#!/bin/sh\n");
917 NodeFS.chmodSync(target, 0o755);
918 const link = NodePath.join(prefix, "bin", "opencode");
919 NodeFS.mkdirSync(NodePath.dirname(link), { recursive: true });
920 NodeFS.symlinkSync(target, link);
921 return link;
922};
923const resolveUpdate = (generation: "v1" | "v2", binaryPath: string) =>
924 ProviderMaintenance.resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation), {
925 binaryPath,
926 env: { PATH: "" },
927 }).pipe(
928 Effect.provideService(
929 ChildProcessSpawner.ChildProcessSpawner,
930 ChildProcessSpawner.make(() => Effect.die("resolving an update must not spawn")),
931 ),
932 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
933 );
934
935it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
936 "updates npm-global OpenCode by generation and runs upgrade only for its own installer's path",
937 () =>
938 Effect.gen(function* () {
939 const root = NodeFS.realpathSync(
940 NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-opencode-update-")),
941 );
942 const v2Prefix = NodePath.join(root, "v2");
943 const v1Prefix = NodePath.join(root, "v1");
944 const v2 = yield* resolveUpdate(
945 "v2",
946 npmGlobalInstall(v2Prefix, ["@opencode", "cli"], "opencode.exe"),
947 );
948 assert.deepStrictEqual(v2.update?.args, [
949 "install",
950 "-g",
951 "--prefix",
952 v2Prefix,
953 "--allow-scripts=@opencode/cli",
954 "@opencode/cli@latest",
955 ]);
956 const v1 = yield* resolveUpdate(
957 "v1",
958 npmGlobalInstall(v1Prefix, ["opencode-ai"], "opencode"),
959 );
960 assert.strictEqual(v1.update?.args.at(-1), "opencode-ai@latest");
961 assert.isNull(
962 (yield* resolveUpdate("v2", NodePath.join(v1Prefix, "bin", "opencode"))).update,
963 );
964 assert.isNull(
965 (yield* resolveUpdate("v1", NodePath.join(v2Prefix, "bin", "opencode"))).update,
966 );
967 const executable = (...segments: ReadonlyArray<string>) => {
968 const path = NodePath.join(root, ...segments);
969 NodeFS.mkdirSync(NodePath.dirname(path), { recursive: true });
970 NodeFS.writeFileSync(path, "#!/bin/sh\n");
971 NodeFS.chmodSync(path, 0o755);
972 return path;
973 };
974 const launcher = executable("launcher", "opencode");
975 const native = executable(".opencode", "bin", "opencode");
976 for (const generation of ["v1", "v2"] as const) {
977 assert.isNull((yield* resolveUpdate(generation, launcher)).update);
978 const update = (yield* resolveUpdate(generation, native)).update;
979 assert.deepStrictEqual(update?.args, ["upgrade", "--method", "curl"]);
980 assert.strictEqual(update?.env?.HOME, root);
981 }
982 }),
983);
984
985const versionOutput: { current: string | undefined } = { current: undefined };
986const versionProbes: Array<string> = [];
987const changingRuntime = {
988 runOpenCodeCommand: ({ binaryPath }: { readonly binaryPath: string }) =>
989 Effect.sync(() => versionProbes.push(binaryPath)).pipe(
990 Effect.andThen(
991 versionOutput.current === undefined
992 ? Effect.fail(
993 new OpenCodeRuntime.OpenCodeRuntimeError({
994 operation: "version",
995 detail: "no version",
996 }),
997 )
998 : Effect.succeed({ stdout: versionOutput.current, stderr: "", code: 0 }),
999 ),
1000 ),
1001 startOpenCodeServerProcess: () => reachedServer("start"),
1002 connectToOpenCodeServer: () => reachedServer("connect"),
1003} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
1004const layerUpdate = Layer.mergeAll(
1005 IdAllocator.layer,
1006 McpProviderSessions.layer,
1007 ProviderLatestVersions.layer,
1008 TestProviderHost.layer(),
1009 Layer.succeed(
1010 ProviderEventLoggers.ProviderEventLoggers,
1011 ProviderEventLoggers.NoOpProviderEventLoggers,
1012 ),
1013 Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, changingRuntime),
1014).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
1015
1016const openCode1Provider = (id: string, models: ReadonlyArray<string>) => ({
1017 id,
1018 name: id,
1019 models: Object.fromEntries(
1020 models.map((model) => [model, { id: model, name: model, release_date: "2026-01-01" }]),
1021 ),
1022});
1023const openCode1Project = "/work/project-with-config";
1024const openCode1UnreadableProject = "/work/unreadable-project";
1025const openCode1Providers = (directory: string) => {
1026 const all = [
1027 openCode1Provider("opencode", ["big-pickle"]),
1028 ...(directory === openCode1Project ? [openCode1Provider("uni", ["medium-gpt"])] : []),
1029 ];
1030 return { all, connected: all.map((provider) => provider.id), default: {} };
1031};
1032const openCode1Runtime = {
1033 runOpenCodeCommand: () => Effect.succeed({ stdout: "1.18.18\n", stderr: "", code: 0 }),
1034 startOpenCodeServerProcess: () =>
1035 Effect.succeed({
1036 url: "http://127.0.0.1:4096",
1037 version: "1.18.18",
1038 isRunning: Effect.succeed(true),
1039 exitCode: Effect.never,
1040 }),
1041 createOpenCodeSdkClient: ({ directory }: { readonly directory: string }) => ({
1042 provider: {
1043 list: () =>
1044 directory === openCode1UnreadableProject
1045 ? Promise.reject(new Error("provider list failed"))
1046 : Promise.resolve({ data: openCode1Providers(directory) }),
1047 },
1048 app: { agents: () => Promise.resolve({ data: [] }) },
1049 command: { list: () => Promise.resolve({ data: [] }) },
1050 }),
1051 loadOpenCodeInventory: () =>
1052 Effect.succeed({ providerList: openCode1Providers("/machine"), agents: [], skills: [] }),
1053 loadOpenCodeSkills: () => Effect.succeed([]),
1054} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
1055
1056it.layer(Layer.mergeAll(layer, Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode1Runtime)))(
1057 "OpenCodeDriver on OpenCode 1",
1058 (it) => {
1059 it.effect("lists a project's own opencode.jsonc models in that project's snapshot", () =>
1060 Effect.gen(function* () {
1061 const instance = yield* create({}, noHttp);
1062 const ready = yield* instance.snapshot.streamChanges.pipe(
1063 Stream.filter((snapshot) => snapshot.status === "ready"),
1064 Stream.take(1),
1065 Stream.runCollect,
1066 Effect.forkChild,
1067 );
1068 yield* Fiber.join(ready);
1069 const slugsOf = (snapshot: { readonly models: ReadonlyArray<{ readonly slug: string }> }) =>
1070 snapshot.models.map((model) => model.slug).toSorted();
1071
1072 assert.deepStrictEqual(slugsOf(yield* instance.snapshotForCwd!(openCode1Project)), [
1073 "opencode/big-pickle",
1074 "uni/medium-gpt",
1075 ]);
1076 const otherSnapshot = yield* instance.snapshotForCwd!("/work/other-project");
1077 assert.deepStrictEqual(slugsOf(otherSnapshot), ["opencode/big-pickle"]);
1078 assert.strictEqual(otherSnapshot.workspaceModels, undefined);
1079 assert.strictEqual(otherSnapshot.workspaceModelsPending, undefined);
1080 const unreadable = yield* instance.snapshotForCwd!(openCode1UnreadableProject);
1081 assert.deepStrictEqual(slugsOf(unreadable), ["opencode/big-pickle"]);
1082 assert.strictEqual(unreadable.workspaceModels, undefined);
1083 assert.strictEqual(unreadable.workspaceModelsPending, true);
1084 }).pipe(Effect.scoped),
1085 );
1086 },
1087);
1088
1089it.layer(layerUpdate)("OpenCodeDriver updates", (it) => {
1090 it.effect.skipIf(HostProcess.Platform.defaultValue() === "win32")(
1091 "offers no package update for an unknown version and follows a changed one on a fresh read",
1092 () =>
1093 Effect.gen(function* () {
1094 const root = NodeFS.realpathSync(
1095 NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-opencode-driver-update-")),
1096 );
1097 const binaryPath = npmGlobalInstall(NodePath.join(root, "v1"), ["opencode-ai"], "opencode");
1098 const instance = yield* OpenCodeDriver.create({
1099 instanceId: ProviderInstanceId.make("opencode-update"),
1100 displayName: undefined,
1101 environment: [],
1102 enabled: true,
1103 config: { ...OpenCodeDriver.defaultConfig(), binaryPath },
1104 }).pipe(Effect.provideService(HttpClient.HttpClient, noHttp));
1105
1106 versionOutput.current = undefined;
1107 const unknown = yield* instance.snapshot.resolveMaintenance({ fresh: true });
1108 assert.isNull(unknown.update);
1109 assert.isNull(unknown.packageName);
1110
1111 versionOutput.current = "1.18.32\n";
1112 const v1 = yield* instance.snapshot.resolveMaintenance({ fresh: true });
1113 assert.strictEqual(v1.packageName, "opencode-ai");
1114
1115 versionOutput.current = "opencode v2.0.18\n";
1116 const v2 = yield* instance.snapshot.resolveMaintenance({ fresh: true });
1117 assert.strictEqual(v2.packageName, "@opencode/cli");
1118 assert.isNull(v2.update);
1119 }).pipe(Effect.scoped),
1120 );
1121
1122 it.effect(
1123 "opens sessions through OpenCode 2 after the binary is upgraded in place from 1.x",
1124 () =>
1125 Effect.gen(function* () {
1126 versionOutput.current = "1.18.18\n";
1127 const instance = yield* create({}, noHttp);
1128 // Let the startup status check claim the refresh permit, then wait behind it so it
1129 // cannot probe after the upgrade below.
1130 yield* Effect.yieldNow;
1131 yield* instance.snapshot.refresh;
1132 serverStarts.length = 0;
1133 const openSession = instance.orchestrationAdapter
1134 .openSession({
1135 threadId: ThreadId.make("thread-upgraded"),
1136 providerSessionId: ProviderSessionId.make("session-upgraded"),
1137 modelSelection: { instanceId: instance.instanceId, model: "opencode/big-pickle" },
1138 runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: null },
1139 })
1140 .pipe(Effect.scoped, Effect.flip);
1141
1142 yield* openSession;
1143 assert.deepStrictEqual(serverStarts, ["connect"], "1.x opens through the 1.x adapter");
1144
1145 versionOutput.current = "opencode v2.2.4\n";
1146 serverStarts.length = 0;
1147 yield* openSession;
1148 assert.notInclude(
1149 serverStarts,
1150 "connect",
1151 "after upgrading to 2.x, the next session must not open through the 1.x adapter",
1152 );
1153 assert.include(serverStarts, "start", "the OpenCode 2 adapter starts its server");
1154 }).pipe(Effect.scoped),
1155 );
1156});