Open History to see the last commit
1import {
2 type ModelCapabilities,
3 type ServerProviderModel,
4 type ServerProviderSkill,
5 type ServerProviderSlashCommand,
6 settingsSecretLiteral,
7} from "@t3tools/contracts";
8import type { OpenCodeSettings } from "../settings.ts";
9import * as Cause from "effect/Cause";
10import * as Schema from "effect/Schema";
11import * as DateTime from "effect/DateTime";
12import * as Effect from "effect/Effect";
13import * as Option from "effect/Option";
14import * as Schedule from "effect/Schedule";
15
16import { createModelCapabilities } from "@t3tools/shared/model";
17import { compareSemverVersions } from "@t3tools/shared/semver";
18import {
19 buildServerProvider,
20 COMPACT_SLASH_COMMAND,
21 nonEmptyTrimmed,
22 providerModelsFromSettings,
23 type ServerProviderDraft,
24} from "@t3tools/provider-core/server/snapshotProbe";
25import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
26import type { ProbedOpenCode } from "./versionProbe.ts";
27import type { Agent, ProviderListResponse } from "@opencode-ai/sdk/v2";
28import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
29
30const OPENCODE_PRESENTATION = {
31 displayName: "OpenCode",
32 showInteractionModeToggle: false,
33} as const;
34
35class OpenCodeProbeError extends Schema.TaggedError<OpenCodeProbeError>()("OpenCodeProbeError", {
36 cause: Schema.optional(Schema.Defect()),
37 detail: Schema.String,
38}) {}
39
40const isOpenCodeProbeError = Schema.is(OpenCodeProbeError);
41
42function normalizeProbeMessage(message: string): string | undefined {
43 const trimmed = message.trim();
44 if (trimmed.length === 0) {
45 return undefined;
46 }
47 if (
48 trimmed === "An error occurred in Effect.tryPromise" ||
49 trimmed === "An error occurred in Effect.try"
50 ) {
51 return undefined;
52 }
53 return trimmed;
54}
55
56function normalizedErrorMessage(cause: unknown): string | undefined {
57 if (isOpenCodeProbeError(cause)) {
58 return normalizeProbeMessage(cause.detail);
59 }
60
61 if (!(cause instanceof Error)) {
62 return undefined;
63 }
64
65 return normalizeProbeMessage(cause.message);
66}
67
68function formatOpenCodeProbeError(input: {
69 readonly cause: unknown;
70 readonly isExternalServer: boolean;
71 readonly phase: "version" | "inventory";
72 readonly serverUrl: string;
73}): {
74 readonly installed: boolean;
75 readonly message: string;
76 readonly authStatus?: "unauthenticated";
77} {
78 const detail = normalizedErrorMessage(input.cause);
79 const lower = detail?.toLowerCase() ?? "";
80
81 if (input.isExternalServer) {
82 // Bare auth-code digits can be part of the endpoint's port or path.
83 if (
84 /(?:^|\s)(?:status(?:\s+code)?(?:\s*[:=]\s*|\s+)|http(?:\/\d(?:\.\d)?)?\s+)(?:401|403)\b/.test(
85 lower,
86 ) ||
87 /\b(?:unauthorized|forbidden)\b/.test(lower)
88 ) {
89 return {
90 installed: true,
91 authStatus: "unauthenticated",
92 message: "OpenCode server rejected authentication. Check the server URL and password.",
93 };
94 }
95
96 if (
97 lower.includes("econnrefused") ||
98 lower.includes("enotfound") ||
99 lower.includes("fetch failed") ||
100 lower.includes("networkerror") ||
101 lower.includes("timed out") ||
102 lower.includes("timeout") ||
103 lower.includes("socket hang up")
104 ) {
105 return {
106 installed: true,
107 message: `Couldn't reach the configured OpenCode server at ${input.serverUrl}. Check that the server is running and the URL is correct.`,
108 };
109 }
110
111 return {
112 installed: true,
113 message: detail ?? "Failed to connect to the configured OpenCode server.",
114 };
115 }
116
117 if (lower.includes("enoent") || lower.includes("notfound")) {
118 return {
119 installed: false,
120 message: "OpenCode CLI (`opencode`) is not installed or not on PATH.",
121 };
122 }
123
124 if (lower.includes("quarantine")) {
125 return {
126 installed: true,
127 message:
128 "macOS is blocking the OpenCode binary (quarantine). Run `xattr -d com.apple.quarantine $(which opencode)` to fix this.",
129 };
130 }
131
132 if (lower.includes("invalid code signature") || lower.includes("corrupted")) {
133 return {
134 installed: true,
135 message:
136 "macOS killed the OpenCode process due to an invalid code signature. The binary may be corrupted. Try reinstalling OpenCode.",
137 };
138 }
139
140 const failureLabel =
141 input.phase === "inventory"
142 ? "Failed to load OpenCode provider inventory"
143 : "Failed to execute OpenCode CLI health check";
144 return {
145 installed: true,
146 message: detail ? `${failureLabel}: ${detail}` : `${failureLabel}.`,
147 };
148}
149
150// The status check owns the span; keep handled failures visible without adding another span.
151const logDiscoveryFailure = Effect.fnUntraced(function* (input: {
152 readonly phase: "version" | "inventory" | "models";
153 readonly isExternalServer: boolean;
154 readonly version?: string;
155 readonly cause?: Cause.Cause<unknown>;
156}) {
157 const outcome = input.cause ? "failed" : "empty";
158 const attributes = {
159 provider: "opencode",
160 phase: input.phase,
161 outcome,
162 serverMode: input.isExternalServer ? "external" : "managed",
163 ...(input.version === undefined ? {} : { version: input.version }),
164 };
165 yield* Effect.annotateCurrentSpan({
166 "discovery.phase": input.phase,
167 "discovery.outcome": outcome,
168 });
169 yield* (
170 input.cause
171 ? Effect.logWarning("OpenCode discovery failed", input.cause)
172 : Effect.logWarning("OpenCode discovery failed")
173 ).pipe(Effect.annotateLogs(attributes));
174});
175
176function titleCaseSlug(value: string): string {
177 const segments: Array<string> = [];
178 for (const segment of value.split(/[-_/]+/)) {
179 if (segment.length > 0) {
180 segments.push(segment.charAt(0).toUpperCase() + segment.slice(1));
181 }
182 }
183 return segments.join(" ");
184}
185
186function inferDefaultVariant(
187 providerID: string,
188 variants: ReadonlyArray<string>,
189): string | undefined {
190 if (variants.length === 1) {
191 return variants[0];
192 }
193 if (providerID === "anthropic" || providerID.startsWith("google")) {
194 return variants.includes("high") ? "high" : undefined;
195 }
196 if (providerID === "openai" || providerID === "opencode") {
197 return variants.includes("medium") ? "medium" : variants.includes("high") ? "high" : undefined;
198 }
199 return undefined;
200}
201
202function inferDefaultAgent(agents: ReadonlyArray<Agent>): string | undefined {
203 return agents.find((agent) => agent.name === "build")?.name ?? agents[0]?.name ?? undefined;
204}
205
206const DEFAULT_OPENCODE_MODEL_CAPABILITIES: ModelCapabilities = createModelCapabilities({
207 optionDescriptors: [
208 {
209 id: "variant",
210 label: "Reasoning",
211 type: "select",
212 options: [
213 { id: "low", label: "Low" },
214 { id: "medium", label: "Medium", isDefault: true },
215 { id: "high", label: "High" },
216 { id: "xhigh", label: "Extra High" },
217 ],
218 currentValue: "medium",
219 },
220 {
221 id: "agent",
222 label: "Agent",
223 type: "select",
224 options: [
225 { id: "build", label: "Build", isDefault: true },
226 { id: "plan", label: "Plan" },
227 ],
228 currentValue: "build",
229 },
230 ],
231});
232
233function openCodeCapabilitiesForModel(input: {
234 readonly providerID: string;
235 readonly model: ProviderListResponse["all"][number]["models"][string];
236 readonly agents: ReadonlyArray<Agent>;
237}): ModelCapabilities {
238 const variantValues = Object.keys(input.model.variants ?? {});
239 const defaultVariant = inferDefaultVariant(input.providerID, variantValues);
240 const variantOptions = variantValues.map((value) =>
241 defaultVariant === value
242 ? { id: value, label: titleCaseSlug(value), isDefault: true as const }
243 : { id: value, label: titleCaseSlug(value) },
244 );
245 const primaryAgents = input.agents.filter(
246 (agent) => !agent.hidden && (agent.mode === "primary" || agent.mode === "all"),
247 );
248 const defaultAgent = inferDefaultAgent(primaryAgents);
249 const agentOptions = primaryAgents.map((agent) =>
250 defaultAgent === agent.name
251 ? { id: agent.name, label: titleCaseSlug(agent.name), isDefault: true as const }
252 : { id: agent.name, label: titleCaseSlug(agent.name) },
253 );
254 return createModelCapabilities({
255 optionDescriptors: [
256 ...(variantOptions.length > 0
257 ? [
258 {
259 id: "variant",
260 label: "Reasoning",
261 type: "select" as const,
262 options: variantOptions,
263 ...(defaultVariant ? { currentValue: defaultVariant } : {}),
264 },
265 ]
266 : []),
267 ...(agentOptions.length > 0
268 ? [
269 {
270 id: "agent",
271 label: "Agent",
272 type: "select" as const,
273 options: agentOptions,
274 ...(defaultAgent ? { currentValue: defaultAgent } : {}),
275 },
276 ]
277 : []),
278 ],
279 });
280}
281
282interface OpenCodeRelease {
283 readonly providerID: string;
284 readonly family?: string | undefined;
285 readonly released?: number | undefined;
286 readonly deprecated?: boolean | undefined;
287}
288
289/**
290 * OpenCode catalogs keep every release of a family, such as Claude Opus 4.5
291 * through 5.5. Only the newest active release of each family within a
292 * sub-provider stays current; older releases and deprecated models are legacy.
293 */
294function markOpenCodeLegacy(
295 entries: ReadonlyArray<{
296 readonly model: ServerProviderModel;
297 readonly release: OpenCodeRelease;
298 }>,
299): Array<ServerProviderModel> {
300 const familyKey = ({ providerID, family }: OpenCodeRelease) =>
301 family ? `${providerID}/${family}` : undefined;
302 const newest = new Map<string, number>();
303 for (const { release } of entries) {
304 const key = familyKey(release);
305 if (key === undefined || release.released === undefined || release.deprecated) continue;
306 newest.set(key, Math.max(newest.get(key) ?? release.released, release.released));
307 }
308 return entries.map(({ model, release }) => {
309 const key = familyKey(release);
310 const latest = key === undefined ? undefined : newest.get(key);
311 const superseded =
312 latest !== undefined && release.released !== undefined && release.released < latest;
313 return release.deprecated || superseded ? { ...model, isLegacy: true } : model;
314 });
315}
316
317function flattenOpenCodeModels(
318 input: Pick<OpenCodeRuntime.OpenCodeInventory, "providerList" | "agents">,
319): ReadonlyArray<ServerProviderModel> {
320 const connected = new Set(input.providerList.connected);
321 const entries: Array<{ model: ServerProviderModel; release: OpenCodeRelease }> = [];
322
323 for (const provider of input.providerList.all) {
324 if (!connected.has(provider.id)) {
325 continue;
326 }
327
328 for (const model of Object.values(provider.models)) {
329 const name = nonEmptyTrimmed(model.name);
330 if (!name) {
331 continue;
332 }
333
334 const subProvider = nonEmptyTrimmed(provider.name);
335 const released = Date.parse(model.release_date);
336 entries.push({
337 model: {
338 slug: `${provider.id}/${model.id}`,
339 name,
340 ...(subProvider ? { subProvider } : {}),
341 isCustom: false,
342 capabilities: openCodeCapabilitiesForModel({
343 providerID: provider.id,
344 model,
345 agents: input.agents,
346 }),
347 },
348 release: {
349 providerID: provider.id,
350 family: model.family,
351 released: Number.isNaN(released) ? undefined : released,
352 deprecated: model.status === "deprecated",
353 },
354 });
355 }
356 }
357
358 return markOpenCodeLegacy(entries).toSorted((left, right) => left.name.localeCompare(right.name));
359}
360
361/** Undefined when OpenCode lists no models, so callers can keep the catalog they have. */
362export function openCodeProviderModels(
363 settings: Pick<OpenCodeSettings, "customModels">,
364 catalog: Pick<OpenCodeRuntime.OpenCodeInventory, "providerList" | "agents">,
365): ReadonlyArray<ServerProviderModel> | undefined {
366 const models = flattenOpenCodeModels(catalog);
367 return models.length === 0
368 ? undefined
369 : providerModelsFromSettings(
370 models,
371 settings.customModels,
372 DEFAULT_OPENCODE_MODEL_CAPABILITIES,
373 );
374}
375
376function trimOptional(value: string | null | undefined): string | undefined {
377 const trimmed = value?.trim();
378 return trimmed && trimmed.length > 0 ? trimmed : undefined;
379}
380
381export function openCodeSkillsToServerProviderSkills(
382 input: OpenCodeRuntime.OpenCodeInventory["skills"] | undefined,
383): ReadonlyArray<ServerProviderSkill> {
384 const skills: ServerProviderSkill[] = [];
385 for (const skill of input ?? []) {
386 const name = trimOptional(skill.name);
387 const path = trimOptional(skill.location);
388 if (!name || !path) {
389 continue;
390 }
391
392 const description = trimOptional(skill.description);
393 skills.push({
394 name,
395 path,
396 enabled: true,
397 ...(description ? { description, shortDescription: description } : {}),
398 });
399 }
400
401 return skills.toSorted((left, right) => left.name.localeCompare(right.name));
402}
403
404export function openCodeCommandsToServerProviderSlashCommands(
405 input: OpenCodeRuntime.OpenCodeInventory["commands"],
406): ReadonlyArray<ServerProviderSlashCommand> {
407 const commands: ServerProviderSlashCommand[] = [COMPACT_SLASH_COMMAND];
408 const names = new Set([COMPACT_SLASH_COMMAND.name]);
409 for (const command of input ?? []) {
410 const name = trimOptional(command.name);
411 if (!name || names.has(name) || command.source === "skill") continue;
412 names.add(name);
413 const description = trimOptional(command.description);
414 const hint = trimOptional(command.hints.join(" "));
415 commands.push({
416 name,
417 ...(description ? { description } : {}),
418 ...(hint ? { input: { hint } } : {}),
419 });
420 }
421 return commands;
422}
423
424export const makePendingOpenCodeProvider = Effect.fn(
425 "OpencodeProviderStatus.makePendingOpenCodeProvider",
426)(function* (openCodeSettings: OpenCodeSettings): Effect.fn.Return<ServerProviderDraft> {
427 const checkedAt = yield* Effect.map(DateTime.now, DateTime.formatIso);
428 const models = providerModelsFromSettings(
429 [],
430 openCodeSettings.customModels,
431 DEFAULT_OPENCODE_MODEL_CAPABILITIES,
432 );
433
434 if (!openCodeSettings.enabled) {
435 return buildServerProvider({
436 presentation: OPENCODE_PRESENTATION,
437 enabled: false,
438 checkedAt,
439 models,
440 probe: {
441 installed: false,
442 version: null,
443 status: "warning",
444 auth: { status: "unknown" },
445 message:
446 openCodeSettings.serverUrl.trim().length > 0
447 ? "OpenCode is disabled in T3 Code settings. A server URL is configured."
448 : "OpenCode is disabled in T3 Code settings.",
449 },
450 });
451 }
452
453 return buildServerProvider({
454 presentation: OPENCODE_PRESENTATION,
455 enabled: true,
456 checkedAt,
457 models,
458 probe: {
459 installed: false,
460 version: null,
461 status: "warning",
462 auth: { status: "unknown" },
463 message: "OpenCode provider status has not been checked in this session yet.",
464 },
465 });
466});
467
468export interface OpenCode2Model extends OpenCodeRelease {
469 readonly id: string;
470 readonly name: string;
471 readonly providerName?: string;
472 readonly variants: ReadonlyArray<{ readonly id: string }>;
473}
474
475// Sub-provider names distinguish overlapping catalog entries.
476function subProviderLabelFor(input: {
477 readonly providerID: string;
478 readonly providerName?: string;
479}): string | undefined {
480 const label = nonEmptyTrimmed(input.providerName) ?? input.providerID;
481 return label.toLowerCase() === OPENCODE_PRESENTATION.displayName.toLowerCase()
482 ? undefined
483 : label;
484}
485
486const catalogFingerprint = (models: ReadonlyArray<OpenCode2Model>) =>
487 models
488 .map((model) =>
489 JSON.stringify([
490 model.providerID,
491 model.id,
492 model.name,
493 model.providerName,
494 model.variants.map((variant) => variant.id).toSorted(),
495 ]),
496 )
497 .toSorted()
498 .join("\n");
499
500/** A cold server can list a partial catalog; two agreeing reads reduce that startup race. */
501const settleOpenCode2Catalog = <E>(list: Effect.Effect<ReadonlyArray<OpenCode2Model>, E>) =>
502 Effect.suspend(() => {
503 let previous: string | undefined;
504 return list.pipe(
505 Effect.repeat({
506 until: (models) => {
507 const fingerprint = models.length > 0 ? catalogFingerprint(models) : undefined;
508 const settled = fingerprint !== undefined && fingerprint === previous;
509 previous = fingerprint;
510 return settled;
511 },
512 schedule: Schedule.spaced("250 millis"),
513 }),
514 );
515 });
516
517const OPENCODE_2_CATALOG_SETTLE_TIMEOUT = "5 seconds";
518
519export const makeOpenCode2ModelLoader = <E>(
520 list: Effect.Effect<ReadonlyArray<OpenCode2Model>, E>,
521) =>
522 Effect.sync(() => {
523 let lastLoaded: ReadonlyArray<OpenCode2Model> = [];
524 return Effect.suspend(() => {
525 let latest: ReadonlyArray<OpenCode2Model> = [];
526 return settleOpenCode2Catalog(
527 list.pipe(
528 Effect.tap((models) =>
529 Effect.sync(() => {
530 if (models.length > 0) latest = models;
531 }),
532 ),
533 ),
534 ).pipe(
535 Effect.catch((error) => (latest.length > 0 ? Effect.succeed(latest) : Effect.fail(error))),
536 Effect.timeoutOption(OPENCODE_2_CATALOG_SETTLE_TIMEOUT),
537 Effect.map((loaded) => {
538 // Fresh progress may still be partial, but a warm cache must not freeze slow catalogs.
539 if (loaded._tag === "Some") lastLoaded = loaded.value;
540 else if (latest.length > 0) lastLoaded = latest;
541 return lastLoaded;
542 }),
543 );
544 });
545 });
546
547/** None when the reads fail or never agree, so a partial catalog never passes for a settled one. */
548export const readSettledOpenCode2Catalog = <E>(
549 list: Effect.Effect<ReadonlyArray<OpenCode2Model>, E>,
550) =>
551 settleOpenCode2Catalog(list).pipe(
552 Effect.timeoutOption(OPENCODE_2_CATALOG_SETTLE_TIMEOUT),
553 Effect.orElseSucceed(() => Option.none<ReadonlyArray<OpenCode2Model>>()),
554 );
555
556export interface OpenCode2Workspace {
557 readonly skills: ReadonlyArray<{
558 readonly id: string;
559 readonly name: string;
560 readonly path: string;
561 readonly description?: string | undefined;
562 }>;
563 readonly commands: ReadonlyArray<{
564 readonly name: string;
565 readonly description?: string | undefined;
566 }>;
567}
568
569/**
570 * Reading a location the server has not loaded boots its scan, and only reads after the scan's
571 * `command.updated` plus `skill.updated` are complete; `scanned` must listen before `read`. A
572 * loaded location listing no commands is still scanning. OpenCode exposes no readiness signal,
573 * so one another caller booted moments earlier can still read partial.
574 */
575export const loadOpenCode2Workspace = Effect.fn("OpencodeProviderStatus.loadOpenCode2Workspace")(
576 function* <E>(
577 read: Effect.Effect<OpenCode2Workspace, E>,
578 scanned: Effect.Effect<void>,
579 loaded: Effect.Effect<boolean>,
580 ) {
581 const wasLoaded = yield* loaded;
582 const first = yield* read;
583 if (wasLoaded && first.commands.length > 0) return first;
584 yield* scanned.pipe(Effect.timeoutOption("10 seconds"));
585 return yield* read;
586 },
587);
588
589export function openCode2SkillsToServerProviderSkills(
590 skills: OpenCode2Workspace["skills"],
591): ReadonlyArray<ServerProviderSkill> {
592 return skills
593 .map((skill) => {
594 const description = trimOptional(skill.description);
595 return {
596 name: skill.id,
597 path: skill.path,
598 enabled: true,
599 ...(skill.name === skill.id ? {} : { displayName: skill.name }),
600 ...(description ? { description, shortDescription: description } : {}),
601 };
602 })
603 .toSorted((left, right) => left.name.localeCompare(right.name));
604}
605
606export function openCode2CommandsToServerProviderSlashCommands(
607 commands: OpenCode2Workspace["commands"],
608): ReadonlyArray<ServerProviderSlashCommand> {
609 const slashCommands: ServerProviderSlashCommand[] = [COMPACT_SLASH_COMMAND];
610 const names = new Set([COMPACT_SLASH_COMMAND.name]);
611 for (const command of commands) {
612 const name = trimOptional(command.name);
613 if (!name || names.has(name)) continue;
614 names.add(name);
615 const description = trimOptional(command.description);
616 slashCommands.push({ name, ...(description ? { description } : {}) });
617 }
618 return slashCommands;
619}
620
621// OpenCode has no reviewer; Auto asks like Supervised.
622const OPENCODE_2_PRESENTATION = {
623 ...OPENCODE_PRESENTATION,
624 showInteractionModeToggle: true,
625 supportedRuntimeModes: ["approval-required", "auto-accept-edits", "auto", "full-access"],
626} as const;
627
628function openCode2ModelCapabilities(model: OpenCode2Model): ModelCapabilities {
629 const variants = model.variants.map((variant) => variant.id);
630 const defaultVariant = inferDefaultVariant(model.providerID, variants);
631 return createModelCapabilities({
632 optionDescriptors:
633 variants.length === 0
634 ? []
635 : [
636 {
637 id: "variant",
638 label: "Reasoning",
639 type: "select",
640 options: variants.map((id) => ({
641 id,
642 label: titleCaseSlug(id),
643 ...(id === defaultVariant ? { isDefault: true } : {}),
644 })),
645 ...(defaultVariant === undefined ? {} : { currentValue: defaultVariant }),
646 },
647 ],
648 });
649}
650
651export function openCode2ProviderModels(
652 settings: Pick<OpenCodeSettings, "customModels">,
653 catalog: ReadonlyArray<OpenCode2Model>,
654): ReadonlyArray<ServerProviderModel> {
655 return providerModelsFromSettings(
656 markOpenCodeLegacy(
657 catalog.map((model) => {
658 const subProvider = subProviderLabelFor(model);
659 return {
660 model: {
661 slug: `${model.providerID}/${model.id}`,
662 name: model.name,
663 ...(subProvider ? { subProvider } : {}),
664 isCustom: false,
665 capabilities: openCode2ModelCapabilities(model),
666 },
667 release: model,
668 };
669 }),
670 ).toSorted((left, right) => left.name.localeCompare(right.name)),
671 settings.customModels,
672 DEFAULT_OPENCODE_MODEL_CAPABILITIES,
673 );
674}
675
676const checkOpenCode2 = Effect.fn("checkOpenCode2")(function* (
677 settings: OpenCodeSettings,
678 version: string,
679 checkedAt: string,
680 loadModels: Effect.Effect<ReadonlyArray<OpenCode2Model>, OpenCodeRuntime.OpenCodeRuntimeError>,
681) {
682 const result = yield* Effect.exit(loadModels);
683 const probe = (status: "ready" | "warning" | "error", message: string) => ({
684 installed: true,
685 version,
686 status,
687 auth: { status: status === "ready" ? ("authenticated" as const) : ("unknown" as const) },
688 message,
689 });
690 if (result._tag === "Failure") {
691 yield* logDiscoveryFailure({
692 phase: "models",
693 isExternalServer: settings.serverUrl.trim().length > 0,
694 version,
695 cause: result.cause,
696 });
697 return buildServerProvider({
698 presentation: OPENCODE_2_PRESENTATION,
699 enabled: true,
700 checkedAt,
701 models: providerModelsFromSettings(
702 [],
703 settings.customModels,
704 DEFAULT_OPENCODE_MODEL_CAPABILITIES,
705 ),
706 slashCommands: [COMPACT_SLASH_COMMAND],
707 probe: probe("error", "OpenCode could not load its model list."),
708 });
709 }
710 if (result.value.length === 0) {
711 yield* logDiscoveryFailure({
712 phase: "models",
713 isExternalServer: settings.serverUrl.trim().length > 0,
714 version,
715 });
716 }
717 return buildServerProvider({
718 presentation: OPENCODE_2_PRESENTATION,
719 enabled: true,
720 checkedAt,
721 models: openCode2ProviderModels(settings, result.value),
722 slashCommands: [COMPACT_SLASH_COMMAND],
723 probe:
724 result.value.length > 0
725 ? probe(
726 "ready",
727 `OpenCode ${version} lists ${result.value.length} model${result.value.length === 1 ? "" : "s"}.`,
728 )
729 : probe("warning", "OpenCode 2 is running, but it did not list any models yet."),
730 });
731});
732
733export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatus")(function* (
734 openCodeSettings: OpenCodeSettings,
735 cwd: string,
736 probeRuntime: Effect.Effect<ProbedOpenCode, OpenCodeRuntime.OpenCodeRuntimeError>,
737 loadOpenCode2Models: Effect.Effect<
738 ReadonlyArray<OpenCode2Model>,
739 OpenCodeRuntime.OpenCodeRuntimeError
740 >,
741): Effect.fn.Return<
742 ServerProviderDraft,
743 never,
744 OpenCodeRuntime.OpenCodeRuntime | OpenCodeServerOwner.OpenCodeServerOwner
745> {
746 const openCodeRuntime = yield* OpenCodeRuntime.OpenCodeRuntime;
747 const serverOwner = yield* OpenCodeServerOwner.OpenCodeServerOwner;
748 const checkedAt = DateTime.formatIso(yield* DateTime.now);
749 const customModels = openCodeSettings.customModels;
750 const isExternalServer = openCodeSettings.serverUrl.trim().length > 0;
751
752 const fallback = (
753 cause: unknown,
754 version: string | null = null,
755 phase: "version" | "inventory" = "version",
756 ) => {
757 const failure = formatOpenCodeProbeError({
758 cause,
759 isExternalServer,
760 phase,
761 serverUrl: openCodeSettings.serverUrl,
762 });
763 return buildServerProvider({
764 presentation: OPENCODE_PRESENTATION,
765 enabled: openCodeSettings.enabled,
766 checkedAt,
767 models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES),
768 probe: {
769 installed: failure.installed,
770 version,
771 status: "error",
772 auth: { status: failure.authStatus ?? "unknown" },
773 message: failure.message,
774 },
775 });
776 };
777
778 if (!openCodeSettings.enabled) {
779 return buildServerProvider({
780 presentation: OPENCODE_PRESENTATION,
781 enabled: false,
782 checkedAt,
783 models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES),
784 probe: {
785 installed: false,
786 version: null,
787 status: "warning",
788 auth: { status: "unknown" },
789 message: isExternalServer
790 ? "OpenCode is disabled in T3 Code settings. A server URL is configured."
791 : "OpenCode is disabled in T3 Code settings.",
792 },
793 });
794 }
795
796 const probedExit = yield* Effect.exit(
797 probeRuntime.pipe(
798 Effect.mapError(
799 (cause) =>
800 new OpenCodeProbeError({
801 cause,
802 detail: OpenCodeRuntime.openCodeRuntimeErrorDetail(cause),
803 }),
804 ),
805 ),
806 );
807 if (probedExit._tag === "Failure") {
808 yield* logDiscoveryFailure({ phase: "version", isExternalServer, cause: probedExit.cause });
809 return fallback(Cause.squash(probedExit.cause));
810 }
811 const probed = probedExit.value;
812 if (probed.generation === "v2") {
813 return yield* checkOpenCode2(openCodeSettings, probed.version, checkedAt, loadOpenCode2Models);
814 }
815 if (compareSemverVersions(probed.version, OpenCodeRuntime.MINIMUM_OPENCODE_VERSION) < 0) {
816 return buildServerProvider({
817 presentation: OPENCODE_PRESENTATION,
818 enabled: openCodeSettings.enabled,
819 checkedAt,
820 models: providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES),
821 probe: {
822 installed: true,
823 version: probed.version,
824 status: "error",
825 auth: { status: "unknown" },
826 message: `OpenCode v${probed.version} is too old. Upgrade to v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`,
827 },
828 });
829 }
830
831 const installedVersion = isExternalServer ? {} : { installedVersion: probed.version };
832 let version = probed.version;
833 const loadInventory = Effect.fnUntraced(function* (server: {
834 readonly url: string;
835 readonly serverPassword?: string;
836 readonly version: string;
837 }) {
838 // Preserve the helper's version even when its inventory request fails.
839 version = server.version;
840 return yield* openCodeRuntime.loadOpenCodeInventory(
841 openCodeRuntime.createOpenCodeSdkClient({
842 baseUrl: server.url,
843 directory: cwd,
844 ...(server.serverPassword !== undefined ? { serverPassword: server.serverPassword } : {}),
845 }),
846 );
847 });
848 const inventoryEffect = isExternalServer
849 ? openCodeRuntime
850 .connectToOpenCodeServer({
851 binaryPath: openCodeSettings.binaryPath,
852 directory: cwd,
853 serverUrl: openCodeSettings.serverUrl,
854 ...(settingsSecretLiteral(openCodeSettings.serverPassword)
855 ? { serverPassword: settingsSecretLiteral(openCodeSettings.serverPassword) }
856 : {}),
857 })
858 .pipe(Effect.flatMap(loadInventory), Effect.scoped)
859 : serverOwner.withServer(loadInventory);
860 const inventoryExit = yield* Effect.exit(
861 inventoryEffect.pipe(
862 Effect.mapError(
863 (cause) =>
864 new OpenCodeProbeError({
865 cause,
866 detail: OpenCodeRuntime.openCodeRuntimeErrorDetail(cause),
867 }),
868 ),
869 ),
870 );
871 if (inventoryExit._tag === "Failure") {
872 yield* logDiscoveryFailure({
873 phase: "inventory",
874 isExternalServer,
875 version,
876 cause: inventoryExit.cause,
877 });
878 return {
879 ...fallback(Cause.squash(inventoryExit.cause), version, "inventory"),
880 ...installedVersion,
881 };
882 }
883
884 const catalogModels = openCodeProviderModels(openCodeSettings, inventoryExit.value);
885 const models =
886 catalogModels ??
887 providerModelsFromSettings([], customModels, DEFAULT_OPENCODE_MODEL_CAPABILITIES);
888 const skills = openCodeSkillsToServerProviderSkills(inventoryExit.value.skills);
889 const connectedCount = inventoryExit.value.providerList.connected.length;
890 const catalogReady = connectedCount > 0 && catalogModels !== undefined;
891 if (connectedCount > 0 && catalogModels === undefined) {
892 yield* logDiscoveryFailure({ phase: "inventory", isExternalServer, version });
893 }
894 return {
895 ...buildServerProvider({
896 presentation: OPENCODE_PRESENTATION,
897 enabled: true,
898 checkedAt,
899 models,
900 skills,
901 slashCommands: openCodeCommandsToServerProviderSlashCommands(inventoryExit.value.commands),
902 probe: {
903 installed: true,
904 version,
905 status: catalogReady ? "ready" : "warning",
906 auth: {
907 status: catalogReady ? "authenticated" : "unknown",
908 type: "opencode",
909 },
910 message:
911 connectedCount > 0 && !catalogReady
912 ? "OpenCode upstream providers are connected, but it did not list any models yet."
913 : connectedCount > 0
914 ? `${connectedCount} upstream provider${connectedCount === 1 ? "" : "s"} connected through ${isExternalServer ? "the configured OpenCode server" : "OpenCode"}.`
915 : isExternalServer
916 ? "Connected to the configured OpenCode server, but it did not report any connected upstream providers."
917 : "OpenCode is available, but it did not report any connected upstream providers.",
918 },
919 }),
920 ...installedVersion,
921 };
922});