The best way to control Claude Code, Codex and more from any computer or phone

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