@devries-cameron20 / t3code-1 / commits / 4ae66e2e86
Fork 0

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

fix(opencode): project-defined models appear in that project's picker (#24585)

Julius Marminge committed Nov 11, 2026 at 18:28 UTC 4ae66e2e86deb303cc1728cece1b5a68f1073721
27 files changed +861 -166
apps/mobile/src/features/settings/ScheduledTaskPickerScreens.tsx
+1
@@ -67,6 +67,7 @@ export function ScheduledTaskModelPickerRouteScreen() {
67 <ThreadSettingsPickerScreen
68 environmentId={editor.environmentId}
69 projectId={projectId}
70 + cwd={null}
71 providerGroups={providerGroups}
72 selectedModel={selectedModel}
73 prompt={editor.draft.prompt}
apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
+2 -6
@@ -368,10 +368,6 @@ export function NewTaskDraftScreen(props: {
368 };
369 const cycleEnvironmentCommands = environments.length > 1 ? (["cycleHost"] as const) : [];
370 useHardwareKeyboardCommand(cycleEnvironmentCommands, cycleEnvironment);
371 - const composerWorkspaceCwd =
372 - (flow.workspaceMode === "worktree"
373 - ? selectedProject?.workspaceRoot
374 - : (flow.selectedWorktreePath ?? selectedProject?.workspaceRoot)) || null;
371 const preventRemove =
372 (isIncomingShareHoldingRoute && !isProjectPickerReturnActive) || flow.submitting;
373 usePreventRemove(preventRemove, () => undefined);
@@ -971,7 +967,7 @@ export function NewTaskDraftScreen(props: {
967 <ThreadScreenBinding
968 environmentId={selectedProject.environmentId}
969 header={
974 - <DraftThreadHeader thread={thread} project={selectedProject} cwd={composerWorkspaceCwd} />
970 + <DraftThreadHeader thread={thread} project={selectedProject} cwd={flow.workspaceCwd} />
971 }
972 draftMode={{
973 content: heroViewport,
@@ -1012,7 +1008,7 @@ export function NewTaskDraftScreen(props: {
1008 onCancelQueuedRunEdit={() => {}}
1009 onRemoveQueuedEditAttachment={() => {}}
1010 projectWorkspaceRoot={selectedProject.workspaceRoot}
1015 - threadCwd={composerWorkspaceCwd}
1011 + threadCwd={flow.workspaceCwd}
1012 selectedThreadQueueCount={0}
1013 queuedMessages={[]}
1014 dispatchingMessageId={null}
apps/mobile/src/features/threads/ThreadComposer.tsx
+6 -2
@@ -86,7 +86,11 @@ import {
86 composerStripAttachments,
87 type DraftComposerFileAttachment,
88 } from "../../lib/composerImages";
89 -import { buildModelOptions, isModelSelectionUnavailable } from "../../lib/modelOptions";
89 +import {
90 + buildModelOptions,
91 + isModelSelectionUnavailable,
92 + serverConfigForCwd,
93 +} from "../../lib/modelOptions";
94 import { useScaledTextRole, type ScaledTextRole } from "../settings/appearance/useScaledTextRole";
95 import type { RemoteClientConnectionState } from "../../lib/connection";
96 import { MOBILE_TYPOGRAPHY } from "../../lib/typography";
@@ -715,7 +719,7 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
719 ? undefined
720 : currentModelSelection.instanceId;
721 const modelOptions = buildModelOptions(
718 - props.serverConfig,
722 + serverConfigForCwd(props.serverConfig, props.projectCwd),
723 currentModelSelection,
724 lockedProviderInstanceId,
725 props.selectedThread.projectId,
apps/mobile/src/features/threads/ThreadSettingsSheet.tsx
+64 -11
@@ -5,7 +5,7 @@ import {
5 import * as Dialog from "../../components/ui/Dialog";
6 import { createV5StackNavigator as createNativeStackNavigator } from "../../native/createV5StackNavigator";
7 import { useSheetStackOptions } from "../layout/nested-stacks";
8 -import { DEFAULT_SERVER_SETTINGS } from "@t3tools/contracts";
8 +import { DEFAULT_SERVER_SETTINGS, ProviderInstanceId } from "@t3tools/contracts";
9 import {
10 modelPreferencesMigrationPatch,
11 resolveModelPreferences,
@@ -14,7 +14,6 @@ import type {
14 EnvironmentId,
15 ModelSelection,
16 ProjectId,
17 - ProviderInstanceId,
17 ProviderOptionDescriptor,
18 ProviderOptionSelection,
19 RuntimeMode,
@@ -22,7 +21,7 @@ import type {
21 ThreadId,
22 } from "@t3tools/contracts";
23 import type { LegendListRenderItemProps } from "@legendapp/list/react-native";
25 -import { RegistryContext, useAtomValue } from "@effect/atom-react";
24 +import { RegistryContext, useAtomMount, useAtomValue } from "@effect/atom-react";
25 import { AnimatedLegendList } from "@legendapp/list/reanimated";
26 import {
27 getProviderOptionCurrentLabel,
@@ -65,6 +64,7 @@ import { useReduceMotionEnabled } from "../../lib/appState";
64 import {
65 buildModelOptions,
66 groupByProvider,
67 + serverConfigForCwd,
68 type ModelOption,
69 type ProviderGroup,
70 } from "../../lib/modelOptions";
@@ -89,6 +89,8 @@ import { useQuietThreadStructure } from "../../state/use-thread-detail";
89 import { activeComposerDraftKey, useQueuedRunEdit } from "../../state/queued-run-edit";
90 import { selectThreadModel } from "../../state/thread-model-selection";
91 import { useThreadSelection } from "../../state/use-thread-selection";
92 +import { useSelectedThreadWorktree } from "../../state/use-selected-thread-worktree";
93 +import { providerWorkspaceSnapshotRefresh } from "../../state/provider-workspace-snapshot-refresh";
94 import { threadAllowsProviderSwitch } from "../../state/thread-provider-switching";
95 import { environmentServerConfigsAtom, serverEnvironment } from "../../state/server";
96 import { mobilePreferencesAtom } from "../../state/preferences";
@@ -257,6 +259,7 @@ type ThreadSettingsSubmenuPage =
259 type ThreadSettingsSessionProps = {
260 readonly environmentId: EnvironmentId | null;
261 readonly projectId: ProjectId | null;
262 + readonly cwd: string | null;
263 readonly providerInstanceId?: ProviderInstanceId;
264 readonly lockedProviderInstanceId?: ProviderInstanceId;
265 readonly providerGroups: ReadonlyArray<ProviderGroup>;
@@ -312,6 +315,8 @@ type ThreadSettingsSessionValue = {
315 readonly setSearchQuery: (query: string) => void;
316 readonly setShowLegacy: (showLegacy: boolean) => void;
317 readonly toggleProvider: (providerKey: string) => void;
318 + /** The provider whose catalog for this folder the picker keeps fresh. */
319 + readonly workspaceScan: { readonly instanceId: ProviderInstanceId; readonly cwd: string } | null;
320 };
321
322 const ThreadSettingsSessionContext = createContext<ThreadSettingsSessionValue | null>(null);
@@ -338,7 +343,7 @@ function ThreadSettingsSessionProvider(
343 manageHidden && config
344 ? groupByProvider(
345 buildModelOptions(
341 - config,
346 + serverConfigForCwd(config, props.cwd),
347 props.selectedModel,
348 props.lockedProviderInstanceId,
349 props.projectId,
@@ -589,8 +594,17 @@ function ThreadSettingsSessionProvider(
594 );
595 };
596
597 + const environmentId = props.environmentId;
598 + // Like the web picker's open tab: scanning every provider would spawn a probe per provider.
599 + const scannedInstanceId =
600 + providerFilter !== null && providerFilter !== FAVORITES_PROVIDER_FILTER
601 + ? ProviderInstanceId.make(providerFilter)
602 + : props.providerInstanceId;
603 + const workspaceScan =
604 + props.cwd && scannedInstanceId ? { instanceId: scannedInstanceId, cwd: props.cwd } : null;
605 +
606 const value = {
593 - environmentId: props.environmentId,
607 + environmentId,
608 providerInstanceId: props.providerInstanceId,
609 providerGroups,
610 manageHidden,
@@ -622,15 +636,34 @@ function ThreadSettingsSessionProvider(
636 setShowLegacy: setShowLegacyToggle,
637 toggleProvider,
638 toggleFavorite,
639 + workspaceScan,
640 } satisfies ThreadSettingsSessionValue;
641
642 return (
643 <ThreadSettingsSessionContext.Provider value={value}>
644 + {environmentId && workspaceScan ? (
645 + <ProviderWorkspaceSnapshotScan
646 + key={workspaceScan.instanceId}
647 + environmentId={environmentId}
648 + instanceId={workspaceScan.instanceId}
649 + cwd={workspaceScan.cwd}
650 + />
651 + ) : null}
652 {props.children}
653 </ThreadSettingsSessionContext.Provider>
654 );
655 }
656
657 +/** A project's own provider config can add models only its workspace scan lists. */
658 +function ProviderWorkspaceSnapshotScan(props: {
659 + readonly environmentId: EnvironmentId;
660 + readonly instanceId: ProviderInstanceId;
661 + readonly cwd: string;
662 +}) {
663 + useAtomMount(providerWorkspaceSnapshotRefresh(props));
664 + return null;
665 +}
666 +
667 function useThreadSettingsSession() {
668 const value = use(ThreadSettingsSessionContext);
669 if (!value) {
@@ -927,11 +960,25 @@ function ThreadSettingsMainContent(props: {
960 const refreshProviders = () => {
961 if (!session.environmentId || isRefreshingProviders) return;
962 setIsRefreshingProviders(true);
930 - void refreshProviderCatalog(session.environmentId).then((result) => {
931 - setIsRefreshingProviders(false);
932 - const error = providerCatalogRefreshError(result);
933 - if (error) Dialog.alert("Could not refresh models", error);
934 - });
963 + const environmentId = session.environmentId;
964 + const workspaceScan = session.workspaceScan;
965 + void refreshProviderCatalog(environmentId)
966 + .then(async (result) => {
967 + // A project's own models are read per folder, so the machine refresh alone keeps them stale.
968 + // A failed folder read keeps its previous models and retries, so only the machine result alerts.
969 + if (result._tag === "Success" && workspaceScan) {
970 + await refreshProvidersCommand({
971 + environmentId,
972 + input: { ...workspaceScan, fresh: true },
973 + });
974 + }
975 + return result;
976 + })
977 + .then((result) => {
978 + setIsRefreshingProviders(false);
979 + const error = providerCatalogRefreshError(result);
980 + if (error) Dialog.alert("Could not refresh models", error);
981 + });
982 };
983 const [listLoaded, setListLoaded] = useState(false);
984 // Android can drop the first frame of a reduced-motion fade, leaving rows invisible.
@@ -1313,6 +1360,7 @@ export function ExistingThreadSettingsRouteScreen({
1360 // Reads the same environmentId/threadId params as the Thread route beneath it.
1361 const { selectedThread, selectedThreadDetailRef, selectedEnvironmentRuntime } =
1362 useThreadSelection();
1363 + const { selectedThreadCwd } = useSelectedThreadWorktree();
1364 // Streamed text would otherwise re-render the whole model picker on every delta.
1365 const structure = useQuietThreadStructure(selectedThreadDetailRef);
1366 const reportedModelSelection = useThreadReportedModelSelection(selectedThreadDetailRef);
@@ -1327,7 +1375,10 @@ export function ExistingThreadSettingsRouteScreen({
1375 return <View className="flex-1 bg-sheet" />;
1376 }
1377
1330 - const serverConfig = selectedEnvironmentRuntime?.serverConfig ?? null;
1378 + const serverConfig = serverConfigForCwd(
1379 + selectedEnvironmentRuntime?.serverConfig ?? null,
1380 + selectedThreadCwd,
1381 + );
1382 const modelSelection = draftSettings.modelSelection ?? selectedThread.modelSelection;
1383 const lockedProviderInstanceId = threadAllowsProviderSwitch({
1384 thread: selectedThread,
@@ -1354,6 +1405,7 @@ export function ExistingThreadSettingsRouteScreen({
1405 <ThreadSettingsPickerScreen
1406 environmentId={selectedThread.environmentId}
1407 projectId={selectedThread.projectId}
1408 + cwd={selectedThreadCwd}
1409 providerInstanceId={modelSelection.instanceId}
1410 {...(lockedProviderInstanceId ? { lockedProviderInstanceId } : {})}
1411 providerGroups={groupByProvider(modelOptions)}
@@ -1391,6 +1443,7 @@ export function NewTaskThreadSettingsRouteScreen() {
1443 <ThreadSettingsPickerScreen
1444 environmentId={flow.selectedEnvironmentId}
1445 projectId={flow.selectedProject?.id ?? null}
1446 + cwd={flow.workspaceCwd}
1447 {...(flow.selectedModel ? { providerInstanceId: flow.selectedModel.instanceId } : {})}
1448 providerGroups={flow.providerGroups}
1449 selectedModel={flow.selectedModel}
apps/mobile/src/features/threads/new-task-flow-provider.tsx
+13 -1
@@ -32,6 +32,7 @@ import {
32 resolveDefaultableModelSelection,
33 resolveNewTaskModelSelection,
34 resolveSelectableModelSelection,
35 + serverConfigForCwd,
36 } from "../../lib/modelOptions";
37 import { scopedProjectKey } from "../../lib/scopedEntities";
38 import { useAtomValue } from "@effect/atom-react";
@@ -137,6 +138,8 @@ type NewTaskFlowContextValue = {
138 readonly canChooseWorkspace: boolean;
139 readonly selectedBranchName: string | null;
140 readonly selectedWorktreePath: string | null;
141 + /** Where the draft's agent will run: the selected worktree, else the project root. */
142 + readonly workspaceCwd: string | null;
143 readonly resolveWorkspaceSelection: (
144 selection: ComposerDraftWorkspaceSelection | undefined,
145 ) => ComposerDraftWorkspaceSelection;
@@ -324,7 +327,6 @@ export function NewTaskFlowProvider(
327 const storedStickyModelSelection = useStickyComposerModelSelection();
328 const modelSelectionNow = useNowMinuteMs();
329 const projectDefaults = useNewTaskProjectDefaults(selectedProject);
327 - const selectedEnvironmentServerConfig = projectDefaults.serverConfig;
330 const isScratchDraft = projectDefaults.isScratch;
331 const serverConfigs = useServerConfigs();
332 const { connectedEnvironments } = useRemoteConnectionStatus();
@@ -404,6 +406,15 @@ export function NewTaskFlowProvider(
406 const workspaceMode = workspaceSelection.mode;
407 const selectedBranchName = workspaceSelection.branch;
408 const selectedWorktreePath = workspaceSelection.worktreePath;
409 + // A new worktree does not exist yet, so the project root stands in for it.
410 + const workspaceCwd =
411 + (workspaceMode === "worktree"
412 + ? selectedProject?.workspaceRoot
413 + : (selectedWorktreePath ?? selectedProject?.workspaceRoot)) || null;
414 + const selectedEnvironmentServerConfig = serverConfigForCwd(
415 + projectDefaults.serverConfig,
416 + workspaceCwd,
417 + );
418 // Keep the user's explicit choice separate from the resolved display value:
419 // only the explicit flag is ever written back to the draft, so the resolved
420 // value keeps tracking the server setting when the config loads late.
@@ -831,6 +842,7 @@ export function NewTaskFlowProvider(
842 canChooseWorkspace,
843 selectedBranchName,
844 selectedWorktreePath,
845 + workspaceCwd,
846 resolveWorkspaceSelection,
847 startFromOrigin,
848 draftKey: selectedProjectDraftKey,
apps/mobile/src/features/threads/use-composer-command-menu.ts
+1 -7
@@ -41,7 +41,6 @@ import {
41 scoreQueryMatch,
42 } from "@t3tools/shared/searchRanking";
43 import {
44 - createProviderWorkspaceSnapshotRefreshAtomFamily,
44 dedupeProviderSkillsByName,
45 getProviderSkillsForSlashMenu,
46 getProviderSlashCommandsForSlashMenu,
@@ -58,7 +57,7 @@ import { Atom } from "effect/reactivity";
57 import { useEffect, useState } from "react";
58
59 import type { ComposerEditorSelection } from "../../components/ComposerEditor";
61 -import { serverEnvironment } from "../../state/server";
60 +import { providerWorkspaceSnapshotRefresh } from "../../state/provider-workspace-snapshot-refresh";
61 import {
62 useComposerPathSearch,
63 useComposerPullRequestSearch,
@@ -68,11 +67,6 @@ import type { ModelOption } from "../../lib/modelOptions";
67 import type { ComposerCommandItem } from "./ComposerCommandPopover";
68 import { matchesSlashSkillQuery } from "./composerSlashSkillSearch";
69
71 -const providerWorkspaceSnapshotRefresh = createProviderWorkspaceSnapshotRefreshAtomFamily({
72 - providers: serverEnvironment.providersValueAtom,
73 - refreshProviders: serverEnvironment.refreshProviders,
74 -});
75 -
70 const idleWorkspaceSnapshotRefreshAtom: Atom.Atom<unknown> = Atom.make<void>(undefined).pipe(
71 Atom.withLabel("mobile:provider-workspace-snapshot-refresh:idle"),
72 );
apps/mobile/src/lib/modelOptions.ts
+11
@@ -22,6 +22,7 @@ import {
22 getProviderOptionDescriptors,
23 } from "@t3tools/shared/model";
24 import { resolveModelShortName } from "@t3tools/client-runtime/provider-clients";
25 +import { resolveProvidersForCwd } from "@t3tools/client-runtime/providerSkills";
26
27 export type ModelOption = {
28 readonly key: string;
@@ -159,6 +160,16 @@ function normalizeSelectionOptions(
160 };
161 }
162
163 +/** The config as a project at `cwd` sees it, with that project's own provider models. */
164 +export function serverConfigForCwd<C extends T3ServerConfig | null | undefined>(
165 + config: C,
166 + cwd: string | null,
167 +): C {
168 + if (!config) return config;
169 + const providers = resolveProvidersForCwd(config.providers, cwd);
170 + return providers === config.providers ? config : { ...config, providers };
171 +}
172 +
173 /** Require explicit projectId or null so omissions cannot bypass project provider disablement. */
174 export function isModelSelectionUnavailable(
175 config: T3ServerConfig | null | undefined,
apps/mobile/src/state/provider-workspace-snapshot-refresh.ts new
+9
@@ -0,0 +1,9 @@
1 +import { createProviderWorkspaceSnapshotRefreshAtomFamily } from "@t3tools/client-runtime/providerSkills";
2 +
3 +import { serverEnvironment } from "./server";
4 +
5 +/** Shared by the composer and the model picker so one cwd scans once. */
6 +export const providerWorkspaceSnapshotRefresh = createProviderWorkspaceSnapshotRefreshAtomFamily({
7 + providers: serverEnvironment.providersValueAtom,
8 + refreshProviders: serverEnvironment.refreshProviders,
9 +});
apps/server/src/provider/ProviderRegistry.test.ts
+187
@@ -615,6 +615,60 @@ it.layer(
615 });
616
617 describe("ProviderRegistry.layer", () => {
618 + it("marks folder catalogs pending when a machine refresh changes the machine models", () => {
619 + const machineModel = {
620 + slug: "opencode/big-pickle",
621 + name: "Big Pickle",
622 + isCustom: false,
623 + capabilities: null,
624 + } satisfies ServerProvider["models"][number];
625 + const projectModel = { ...machineModel, slug: "uni/medium-gpt", name: "Medium GPT" };
626 + const addedModel = { ...machineModel, slug: "opencode/new", name: "New" };
627 + const provider = {
628 + instanceId: ProviderInstanceId.make("opencode"),
629 + driver: ProviderDriverKind.make("opencode"),
630 + status: "ready",
631 + enabled: true,
632 + installed: true,
633 + auth: { status: "authenticated" },
634 + checkedAt: "2026-03-25T00:00:00.000Z",
635 + version: "2.0.0",
636 + models: [machineModel],
637 + slashCommands: [],
638 + skills: [],
639 + } satisfies ServerProvider;
640 + const withCatalog = ProviderRegistry.upsertProviderWorkspaceSnapshot(
641 + ProviderRegistry.upsertProviderWorkspaceSnapshot(provider, "/project", {
642 + ...provider,
643 + workspaceModels: [machineModel, projectModel],
644 + }),
645 + "/plain",
646 + provider,
647 + );
648 +
649 + const unchanged = ProviderRegistry.mergeProviderSnapshot(withCatalog, provider);
650 + assert.deepStrictEqual(
651 + unchanged.workspaceSnapshots?.map((snapshot) => snapshot.cwd),
652 + ["/project", "/plain"],
653 + );
654 + const changed = ProviderRegistry.mergeProviderSnapshot(withCatalog, {
655 + ...provider,
656 + models: [machineModel, addedModel],
657 + });
658 + assert.deepStrictEqual(
659 + changed.workspaceSnapshots?.map(({ cwd, models, modelsPending }) => ({
660 + cwd,
661 + models,
662 + modelsPending,
663 + })),
664 + [
665 + { cwd: "/project", models: [machineModel, projectModel], modelsPending: true },
666 + // Its folder may define a model the machine catalog just dropped.
667 + { cwd: "/plain", models: undefined, modelsPending: true },
668 + ],
669 + );
670 + });
671 +
672 it("stores workspace skills, commands and options without changing machine metadata", () => {
673 const provider = {
674 instanceId: ProviderInstanceId.make("codex"),
@@ -629,11 +683,15 @@ it.layer(
683 slashCommands: [{ name: "global" }],
684 skills: [{ name: "global", path: "/global/SKILL.md", enabled: true }],
685 } satisfies ServerProvider;
686 + const projectModels = [
687 + { slug: "project-model", name: "Project Model", isCustom: false, capabilities: null },
688 + ] satisfies ServerProvider["models"];
689 const scopedSnapshot = {
690 ...provider,
691 checkedAt: "2026-03-25T00:01:00.000Z",
692 slashCommands: [{ name: "project" }],
693 skills: [{ name: "project", path: "/project/SKILL.md", enabled: true }],
694 + workspaceModels: projectModels,
695 optionDescriptors: [
696 {
697 id: "agent",
@@ -661,6 +719,7 @@ it.layer(
719 slashCommands: scopedSnapshot.slashCommands,
720 skills: scopedSnapshot.skills,
721 optionDescriptors: scopedSnapshot.optionDescriptors,
722 + models: projectModels,
723 },
724 ]);
725
@@ -668,6 +727,7 @@ it.layer(
727 ...scopedSnapshot,
728 slashCommands: [COMPACT_SLASH_COMMAND],
729 slashCommandsPending: true,
730 + workspaceModelsPending: true,
731 } satisfies ProviderWorkspaceSnapshot;
732 const partial = ProviderRegistry.upsertProviderWorkspaceSnapshot(
733 result,
@@ -676,6 +736,8 @@ it.layer(
736 );
737 assert.deepStrictEqual(partial.workspaceSnapshots?.[0]?.slashCommands, [{ name: "project" }]);
738 assert.strictEqual(partial.workspaceSnapshots?.[0]?.slashCommandsPending, true);
739 + assert.deepStrictEqual(partial.workspaceSnapshots?.[0]?.models, projectModels);
740 + assert.strictEqual(partial.workspaceSnapshots?.[0]?.modelsPending, true);
741 const otherProject = ProviderRegistry.upsertProviderWorkspaceSnapshot(
742 partial,
743 "/other-project",
@@ -693,6 +755,14 @@ it.layer(
755 { name: "replacement" },
756 ]);
757 assert.strictEqual(recovered.workspaceSnapshots?.[0]?.slashCommandsPending, undefined);
758 + assert.deepStrictEqual(recovered.workspaceSnapshots?.[0]?.models, projectModels);
759 + assert.strictEqual(recovered.workspaceSnapshots?.[0]?.modelsPending, undefined);
760 + const withoutModels = ProviderRegistry.upsertProviderWorkspaceSnapshot(
761 + recovered,
762 + "/project",
763 + { ...scopedSnapshot, workspaceModels: undefined },
764 + );
765 + assert.strictEqual(withoutModels.workspaceSnapshots?.[0]?.models, undefined);
766
767 const { optionDescriptors, ...failedSnapshot } = scopedSnapshot;
768 const firstFailure = ProviderRegistry.upsertProviderWorkspaceSnapshot(
@@ -2092,6 +2162,123 @@ it.layer(
2162 }),
2163 );
2164
2165 + it.effect("rescans a folder whose model catalog could not be read before its TTL", () =>
2166 + Effect.gen(function* () {
2167 + const driver = ProviderDriverKind.make("opencode");
2168 + const instanceId = ProviderInstanceId.make("opencode");
2169 + const machineModel = {
2170 + slug: "opencode/big-pickle",
2171 + name: "Big Pickle",
2172 + isCustom: false,
2173 + capabilities: null,
2174 + } satisfies ServerProvider["models"][number];
2175 + const projectModel = { ...machineModel, slug: "uni/medium-gpt", name: "Medium GPT" };
2176 + const provider = {
2177 + instanceId,
2178 + driver,
2179 + status: "ready",
2180 + enabled: true,
2181 + installed: true,
2182 + auth: { status: "authenticated" },
2183 + checkedAt: "2026-06-10T00:00:00.000Z",
2184 + version: "2.0.0",
2185 + models: [machineModel],
2186 + slashCommands: [],
2187 + skills: [],
2188 + } as const satisfies ServerProvider;
2189 + const machineProvider = yield* Ref.make<ServerProvider>(provider);
2190 + const scanResult = yield* Ref.make<ProviderWorkspaceSnapshot>({
2191 + ...provider,
2192 + slashCommandsPending: false,
2193 + workspaceModelsPending: true,
2194 + });
2195 + const instance: ProviderInstance = {
2196 + instanceId,
2197 + driverKind: driver,
2198 + continuationIdentity: {
2199 + driverKind: driver,
2200 + continuationKey: "opencode:instance:opencode",
2201 + },
2202 + displayName: undefined,
2203 + enabled: true,
2204 + snapshot: {
2205 + resolveMaintenance: () =>
2206 + Effect.succeed(
2207 + makeManualOnlyProviderMaintenanceCapabilities({
2208 + provider: driver,
2209 + packageName: null,
2210 + }),
2211 + ),
2212 + getSnapshot: Ref.get(machineProvider),
2213 + refresh: Ref.get(machineProvider),
2214 + streamChanges: Stream.empty,
2215 + applyUsageLimits: () => Effect.void,
2216 + },
2217 + snapshotForCwd: () => Ref.get(scanResult),
2218 + orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
2219 + textGeneration: {} as ProviderInstance["textGeneration"],
2220 + };
2221 + const layerInstanceRegistry = Layer.succeed(
2222 + ProviderInstanceRegistry.ProviderInstanceRegistry,
2223 + {
2224 + getInstance: (requestedId) =>
2225 + Effect.succeed(requestedId === instanceId ? instance : undefined),
2226 + listInstances: Effect.succeed([instance]),
2227 + listUnavailable: Effect.succeed([]),
2228 + streamChanges: Stream.empty,
2229 + subscribeChanges: Effect.flatMap(PubSub.unbounded<void>(), PubSub.subscribe),
2230 + },
2231 + );
2232 + const scope = yield* Scope.make();
2233 + yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void));
2234 + const runtimeServices = yield* Layer.build(
2235 + ProviderRegistry.layer.pipe(
2236 + Layer.provide(layerUnusedMutator),
2237 + Layer.provideMerge(layerInstanceRegistry),
2238 + Layer.provideMerge(
2239 + ServerConfig.layerTest(process.cwd(), {
2240 + prefix: "t3-provider-registry-pending-workspace-models-",
2241 + }),
2242 + ),
2243 + Layer.provideMerge(NodeServices.layer),
2244 + ),
2245 + ).pipe(Scope.provide(scope));
2246 +
2247 + yield* Effect.gen(function* () {
2248 + const registry = yield* ProviderRegistry.ProviderRegistry;
2249 + const workspaceOf = Effect.map(
2250 + registry.getProviders,
2251 + (providers) => providers[0]?.workspaceSnapshots?.[0],
2252 + );
2253 + yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/project" });
2254 + const unread = yield* workspaceOf;
2255 + assert.strictEqual(unread?.models, undefined);
2256 + assert.strictEqual(unread?.modelsPending, true);
2257 +
2258 + const workspaceModels = [machineModel, projectModel];
2259 + yield* Ref.set(scanResult, { ...provider, slashCommandsPending: false, workspaceModels });
2260 + yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/project" });
2261 + const recovered = yield* workspaceOf;
2262 + assert.deepStrictEqual(recovered?.models, workspaceModels);
2263 + assert.strictEqual(recovered?.modelsPending, undefined);
2264 +
2265 + // A fresh refresh whose machine models change still publishes the folder read it ran.
2266 + const addedModel = { ...machineModel, slug: "opencode/new", name: "New" };
2267 + const nextWorkspaceModels = [machineModel, addedModel, projectModel];
2268 + yield* Ref.set(machineProvider, { ...provider, models: [machineModel, addedModel] });
2269 + yield* Ref.set(scanResult, {
2270 + ...provider,
2271 + slashCommandsPending: false,
2272 + workspaceModels: nextWorkspaceModels,
2273 + });
2274 + yield* registry.refreshWorkspaceSnapshot({ instanceId, cwd: "/project", fresh: true });
2275 + const rescanned = yield* workspaceOf;
2276 + assert.deepStrictEqual(rescanned?.models, nextWorkspaceModels);
2277 + assert.strictEqual(rescanned?.modelsPending, undefined);
2278 + }).pipe(Effect.provide(runtimeServices));
2279 + }),
2280 + );
2281 +
2282 it.effect("shares one in-flight pass between concurrent untargeted refreshes", () =>
2283 Effect.gen(function* () {
2284 const driver = ProviderDriverKind.make("codex");
apps/server/src/provider/ProviderRegistry.ts
+36 -9
@@ -1,6 +1,7 @@
1 import {
2 defaultInstanceIdForDriver,
3 isProviderWorkspaceSnapshotCurrent,
4 + isProviderWorkspaceSnapshotPending,
5 ProviderDriverKind,
6 type ProviderInstanceId,
7 type ServerProvider,
@@ -157,6 +158,9 @@ export function upsertProviderWorkspaceSnapshot(
158 ): ServerProvider {
159 const previousSnapshot = provider.workspaceSnapshots?.find((snapshot) => snapshot.cwd === cwd);
160 const optionDescriptors = scopedSnapshot.optionDescriptors ?? previousSnapshot?.optionDescriptors;
161 + const models = scopedSnapshot.workspaceModelsPending
162 + ? previousSnapshot?.models
163 + : scopedSnapshot.workspaceModels;
164 const workspaceSnapshot = {
165 cwd,
166 checkedAt: scopedSnapshot.checkedAt,
@@ -166,6 +170,8 @@ export function upsertProviderWorkspaceSnapshot(
170 ...(scopedSnapshot.slashCommandsPending ? { slashCommandsPending: true } : {}),
171 skills: scopedSnapshot.skills,
172 ...(optionDescriptors === undefined ? {} : { optionDescriptors }),
173 + ...(models === undefined ? {} : { models }),
174 + ...(scopedSnapshot.workspaceModelsPending ? { modelsPending: true } : {}),
175 } satisfies NonNullable<ServerProvider["workspaceSnapshots"]>[number];
176 return {
177 ...provider,
@@ -296,14 +302,22 @@ export const mergeProviderSnapshot = (
302 }
303 const savedAccount = carrySavedAntigravityAccount(previousProvider, nextProvider);
304 const { message: _uncheckedMessage, ...nextWithoutMessage } = nextProvider;
305 + const models = mergeProviderModels(nextProvider, previousProvider.models, nextProvider.models);
306 + // Folder catalogs were compared with the old machine catalog, so every folder rescans.
307 + const previousWorkspaceSnapshots = Equal.equals(models, previousProvider.models)
308 + ? previousProvider.workspaceSnapshots
309 + : previousProvider.workspaceSnapshots?.map((snapshot) => ({
310 + ...snapshot,
311 + modelsPending: true,
312 + }));
313 return {
314 ...(savedAccount?.status === "ready" ? nextWithoutMessage : nextProvider),
315 ...savedAccount,
302 - models: mergeProviderModels(nextProvider, previousProvider.models, nextProvider.models),
316 + models,
317 ...(nextProvider.workspaceSnapshots !== undefined
318 ? { workspaceSnapshots: nextProvider.workspaceSnapshots }
305 - : previousProvider.workspaceSnapshots !== undefined
306 - ? { workspaceSnapshots: previousProvider.workspaceSnapshots }
319 + : previousWorkspaceSnapshots !== undefined
320 + ? { workspaceSnapshots: previousWorkspaceSnapshots }
321 : {}),
322 ...(shouldRetainMissingOpenCodeMetadata(nextProvider)
323 ? {
@@ -1003,7 +1017,7 @@ export const layer = Layer.effect(
1017 !provider.enabled ||
1018 (!input.fresh &&
1019 scannedFrom &&
1006 - !scannedFrom.slashCommandsPending &&
1020 + !isProviderWorkspaceSnapshotPending(scannedFrom) &&
1021 isProviderWorkspaceSnapshotCurrent(scannedFrom, DateTime.toEpochMillis(now)))
1022 ) {
1023 return providers;
@@ -1011,17 +1025,30 @@ export const layer = Layer.effect(
1025 // Use scan start for TTL, not checkedAt inherited from the machine health check.
1026 const scannedAt = DateTime.formatIso(now);
1027 const instance = yield* instanceRegistry.getInstance(input.instanceId);
1014 - if (!instance?.snapshotForCwd) return providers;
1028 + const snapshotForCwd = instance?.snapshotForCwd;
1029 + if (!instance || !snapshotForCwd) return providers;
1030 const token = yield* Deferred.make<void>();
1031 + // A machine refresh can change this cwd's snapshot, so the scan publishes against the result.
1032 const refreshMachineSnapshot = input.fresh
1033 ? (instance.invalidateCaches ?? Effect.void).pipe(
1034 Effect.andThen(refreshInstance(input.instanceId)),
1035 + Effect.andThen(Ref.get(providersRef)),
1036 + Effect.map((current) =>
1037 + workspaceSnapshotOf(
1038 + current.find((candidate) => candidate.instanceId === input.instanceId),
1039 + ),
1040 + ),
1041 )
1020 - : Effect.void;
1042 + : Effect.succeed(scannedFrom);
1043 const runScan = refreshMachineSnapshot.pipe(
1022 - Effect.andThen(instance.snapshotForCwd(input.scanCwd ?? input.cwd)),
1044 + Effect.flatMap((scanBase) =>
1045 + Effect.map(snapshotForCwd(input.scanCwd ?? input.cwd), (scopedSnapshot) => ({
1046 + scanBase,
1047 + scopedSnapshot,
1048 + })),
1049 + ),
1050 // Scans fail on error; returned inventory remains valid even when provider health reports an error.
1024 - Effect.flatMap((scopedSnapshot) =>
1051 + Effect.flatMap(({ scanBase, scopedSnapshot }) =>
1052 instanceRegistry.getInstance(input.instanceId).pipe(
1053 Effect.flatMap((currentInstance) => {
1054 if (currentInstance !== instance) return Ref.get(providersRef);
@@ -1032,7 +1059,7 @@ export const layer = Layer.effect(
1059 }
1060 return currentProviders.map((candidate) =>
1061 candidate.instanceId === input.instanceId &&
1035 - Equal.equals(workspaceSnapshotOf(candidate), scannedFrom)
1062 + Equal.equals(workspaceSnapshotOf(candidate), scanBase)
1063 ? upsertProviderWorkspaceSnapshot(candidate, input.cwd, {
1064 ...scopedSnapshot,
1065 checkedAt: scannedAt,
apps/web/src/components/ChatView.tsx
+14 -9
@@ -241,7 +241,10 @@ import { useEnvironmentScope } from "~/state/session";
241 import { primaryServerKeybindingsAtom, serverEnvironment } from "../state/server";
242 import { hostEnvironmentIdAtom } from "../state/primaryEnvironment";
243 import { threadEnvironment } from "../state/threads";
244 -import { resolveProviderSkillsForCwd } from "@t3tools/client-runtime/providerSkills";
244 +import {
245 + resolveProviderSkillsForCwd,
246 + resolveProvidersForCwd,
247 +} from "@t3tools/client-runtime/providerSkills";
248 import { chatGitStatusAtom, NO_CHAT_GIT_STATUS_ATOM, vcsEnvironment } from "../state/vcs";
249 import {
250 type EnvironmentPresentation,
@@ -1221,10 +1224,18 @@ export default function ChatView(props: ChatViewProps) {
1224 : (primaryEnvironment?.serverConfig ?? null);
1225 const providerEnvironmentId = (activeThread ? activeEnvironment : primaryEnvironment)
1226 ?.environmentId;
1224 - const providerStatuses =
1227 + const gitCwd = activeProject
1228 + ? projectScriptCwd({
1229 + project: { cwd: activeProject.workspaceRoot },
1230 + worktreePath: activeThread?.worktreePath ?? null,
1231 + })
1232 + : null;
1233 + const providerStatuses = resolveProvidersForCwd(
1234 (providerEnvironmentId === undefined
1235 ? undefined
1227 - : providersByEnvironment.get(providerEnvironmentId)) ?? EMPTY_PROVIDERS;
1236 + : providersByEnvironment.get(providerEnvironmentId)) ?? EMPTY_PROVIDERS,
1237 + gitCwd,
1238 + );
1239 const selectedProviderByThreadId = composerActiveProvider ?? null;
1240 const threadProvider =
1241 activeThread?.modelSelection.instanceId ??
@@ -1601,12 +1612,6 @@ export default function ChatView(props: ChatViewProps) {
1612 turnDiffSummaries.at(-1)?.completedAt ?? null,
1613 );
1614
1604 - const gitCwd = activeProject
1605 - ? projectScriptCwd({
1606 - project: { cwd: activeProject.workspaceRoot },
1607 - worktreePath: activeThread?.worktreePath ?? null,
1608 - })
1609 - : null;
1615 const gitStatusCwd = activeThread?.worktreePath ?? gitCwd;
1616 const gitStatusAtom =
1617 gitStatusCwd === null
apps/web/src/components/chat/ChatComposer.tsx
+1
@@ -2404,6 +2404,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
2404 const composerControls = (
2405 <ComposerControlsBar
2406 environmentId={environmentId}
2407 + workspaceCwd={gitCwd}
2408 routeKind={routeKind}
2409 routeThreadRef={routeThreadRef}
2410 draftId={draftId}
apps/web/src/components/chat/ComposerControlsBar.tsx
+2
@@ -41,6 +41,7 @@ const MODEL_TRIGGER_STATES = "data-popup-open:bg-accent data-popup-open:text-for
41
42 export function ComposerControlsBar(props: {
43 environmentId: EnvironmentId;
44 + workspaceCwd: string | null;
45 routeKind: ChatComposerProps["routeKind"];
46 routeThreadRef: ChatComposerProps["routeThreadRef"];
47 draftId: ChatComposerProps["draftId"];
@@ -183,6 +184,7 @@ export function ComposerControlsBar(props: {
184 const composerModelPicker = (
185 <ComposerModelPicker
186 environmentId={environmentId}
187 + workspaceCwd={props.workspaceCwd}
188 compact={false}
189 isComposerOwned
190 // The trigger grows away from this edge when its model or effort label changes.
apps/web/src/components/chat/ModelPickerContent.tsx
+11 -1
@@ -24,6 +24,7 @@ import {
24 } from "react";
25 import { ModelListRow } from "./ModelListRow";
26 import { ModelPickerSidebar } from "./ModelPickerSidebar";
27 +import { useProviderWorkspaceSnapshotRefresh } from "./useProviderWorkspaceSnapshotRefresh";
28 import { getProviderStatusMessage, hasProviderSetup } from "./ProviderStatusBanner";
29 import {
30 modelPickerLegacySectionKey,
@@ -323,6 +324,8 @@ function WindowKeyDownListener({ onKeyDown }: { onKeyDown: (event: KeyboardEvent
324
325 export const ModelPickerContent = memo(function ModelPickerContent(props: {
326 environmentId: EnvironmentId | null;
327 + /** Keeps the open provider tab's catalog fresh for this directory. */
328 + workspaceCwd?: string | null;
329 activeInstanceId: ProviderInstanceId;
330 model: string;
331 selectedModels?: ReadonlyArray<{ instanceId: ProviderInstanceId; model: string }>;
@@ -435,6 +438,11 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: {
438 return hasPickableFavorite ? "favorites" : props.activeInstanceId;
439 },
440 );
441 + const { scanning: workspaceModelsScanning } = useProviderWorkspaceSnapshotRefresh({
442 + environmentId: props.environmentId,
443 + gitCwd: props.workspaceCwd ?? null,
444 + instanceId: selectedInstanceId === "favorites" ? undefined : selectedInstanceId,
445 + });
446 const favoritesSet = new Set(favorites.map((fav) => providerModelKey(fav.provider, fav.model)));
447 const [expandedLegacyInstances, setExpandedLegacyInstances] = useState(
448 () =>
@@ -1063,7 +1071,9 @@ export const ModelPickerContent = memo(function ModelPickerContent(props: {
1071 emptyLabel={
1072 selectedInstanceId === "favorites" && !isSearching
1073 ? "No favorites yet"
1066 - : "No models found"
1074 + : workspaceModelsScanning
1075 + ? "Searching project models..."
1076 + : "No models found"
1077 }
1078 onRequestClose={onRequestClose}
1079 onOpenProviderSetup={onOpenProviderSetup}
apps/web/src/components/chat/ProviderModelPicker.tsx
+2
@@ -88,6 +88,7 @@ export const DockedPickerContext = createContext<{ modelLabel: string }>({ model
88
89 export const ProviderModelPicker = memo(function ProviderModelPicker(props: {
90 environmentId: EnvironmentId | null;
91 + workspaceCwd?: string | null;
92 activeInstanceId: ProviderInstanceId;
93 model: string;
94 selectedModels?: ReadonlyArray<{ instanceId: ProviderInstanceId; model: string }>;
@@ -280,6 +281,7 @@ export const ProviderModelPicker = memo(function ProviderModelPicker(props: {
281 <ModelPickerContent
282 searchInputRef={searchInputRef}
283 environmentId={props.environmentId}
284 + workspaceCwd={props.workspaceCwd ?? null}
285 activeInstanceId={activeInstanceId}
286 model={props.model}
287 {...(props.selectedModels !== undefined ? { selectedModels: props.selectedModels } : {})}
apps/web/src/components/chat/useProviderWorkspaceSnapshotRefresh.ts
+5 -5
@@ -19,18 +19,18 @@ const idleRefreshAtom: Atom.Atom<ProviderWorkspaceSnapshotRefreshState | undefin
19 >(undefined).pipe(Atom.withLabel("provider-workspace-snapshot-refresh:idle"));
20
21 /**
22 - * Keeps the selected provider's workspace snapshot fresh for the composer's
23 - * cwd while mounted. Returns a check to run when the user types, and whether
24 - * the cwd's skills are still being scanned.
22 + * Keeps a provider's workspace snapshot fresh for the composer's cwd while
23 + * mounted. Returns a check to run when the user types, and whether the cwd's
24 + * skills are still being scanned.
25 */
26 export function useProviderWorkspaceSnapshotRefresh(input: {
27 - readonly environmentId: EnvironmentId;
27 + readonly environmentId: EnvironmentId | null;
28 readonly gitCwd: string | null;
29 readonly instanceId: ProviderInstanceId | undefined;
30 }): { readonly refresh: () => void; readonly scanning: boolean } {
31 const { environmentId, gitCwd, instanceId } = input;
32 const atom =
33 - gitCwd && instanceId
33 + environmentId && gitCwd && instanceId
34 ? providerWorkspaceSnapshotRefresh({ environmentId, instanceId, cwd: gitCwd })
35 : idleRefreshAtom;
36 return {
docs/user/providers-opencode.md
+4
@@ -75,5 +75,9 @@ refreshes or text-generation work, then refresh again to reload the files. Repea
75 refreshes keep the helper alive. An external server may need its own reload or
76 restart before T3 Code can see configuration changes.
77
78 +Models defined in a project's own `opencode.json` appear only in that project's
79 +model picker, after T3 Code reads the project's catalog the first time the picker
80 +opens there.
81 +
82 Existing threads keep their selected model and options even when it disappears
83 from the catalog. If OpenCode rejects that model, select an available one and retry.
packages/client-runtime/src/providerSkills.test.ts
+41
@@ -15,6 +15,7 @@ import {
15 isProviderWorkspaceSnapshotScanning,
16 resolveProviderSkillsForCwd,
17 resolveProviderSlashCommandsForCwd,
18 + resolveProvidersForCwd,
19 } from "./providerSkills.ts";
20
21 const provider = {
@@ -120,6 +121,30 @@ describe("workspace provider snapshots", () => {
121 expect(hasCompleteProviderWorkspaceSnapshot(undefined, "/workspace/project-a")).toBe(false);
122 expect(hasCompleteProviderWorkspaceSnapshot(provider, null)).toBe(false);
123 });
124 +
125 + it("lists a project's own models only for that project", () => {
126 + const projectModel = {
127 + slug: "uni/medium-gpt",
128 + name: "Medium GPT",
129 + isCustom: false,
130 + capabilities: null,
131 + } satisfies ServerProvider["models"][number];
132 + const withProjectModels = {
133 + ...provider,
134 + workspaceSnapshots: provider.workspaceSnapshots.map((snapshot) => ({
135 + ...snapshot,
136 + models: [projectModel],
137 + })),
138 + } satisfies ServerProvider;
139 + const providers = [provider, withProjectModels];
140 +
141 + expect(resolveProvidersForCwd(providers, "/workspace/project-a").map((p) => p.models)).toEqual([
142 + [],
143 + [projectModel],
144 + ]);
145 + expect(resolveProvidersForCwd(providers, "/workspace/project-a")[0]).toBe(provider);
146 + expect(resolveProvidersForCwd(providers, "/workspace/project-b")).toBe(providers);
147 + });
148 });
149
150 describe("provider workspace snapshot refresh atom", () => {
@@ -273,6 +298,22 @@ describe("provider workspace snapshot refresh atom", () => {
298 expect(vi.getTimerCount()).toBe(0);
299 });
300
301 + it("rescans a current snapshot whose commands are complete but models are pending", () => {
302 + vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
303 + const [current] = withSnapshot("2026-01-01T00:00:00.000Z");
304 + const { run, unmount } = setup([
305 + {
306 + ...current!,
307 + workspaceSnapshots: current!.workspaceSnapshots!.map((snapshot) => ({
308 + ...snapshot,
309 + modelsPending: true,
310 + })),
311 + },
312 + ]);
313 + expect(run).toHaveBeenCalledTimes(1);
314 + unmount();
315 + });
316 +
317 it("stops retrying after three failed scans until the TTL lapses", async () => {
318 vi.useFakeTimers({ now: Date.parse("2026-01-01T00:00:00.000Z") });
319 const { registry, atom, run, unmount } = setup(withSnapshot("2026-01-01T00:00:00.000Z", true));
packages/client-runtime/src/providerSkills.ts
+26 -5
@@ -1,6 +1,7 @@
1 import {
2 type EnvironmentId,
3 isProviderWorkspaceSnapshotCurrent,
4 + isProviderWorkspaceSnapshotPending,
5 PROVIDER_WORKSPACE_SNAPSHOT_TTL_MS,
6 type ProviderInstanceId,
7 type ServerProvider,
@@ -102,7 +103,7 @@ export function hasCompleteProviderWorkspaceSnapshot(
103 cwd: string | null | undefined,
104 ): boolean {
105 const snapshot = provider && resolveProviderWorkspaceSnapshot(provider, cwd);
105 - return Boolean(snapshot && !snapshot.slashCommandsPending);
106 + return Boolean(snapshot && !isProviderWorkspaceSnapshotPending(snapshot));
107 }
108
109 function hasCurrentProviderWorkspaceSnapshot(
@@ -113,7 +114,7 @@ function hasCurrentProviderWorkspaceSnapshot(
114 const snapshot = provider && resolveProviderWorkspaceSnapshot(provider, cwd);
115 return Boolean(
116 snapshot &&
116 - !snapshot.slashCommandsPending &&
117 + !isProviderWorkspaceSnapshotPending(snapshot) &&
118 isProviderWorkspaceSnapshotCurrent(snapshot, nowMs),
119 );
120 }
@@ -132,6 +133,26 @@ export function resolveProviderSlashCommandsForCwd(
133 return resolveProviderWorkspaceSnapshot(provider, cwd)?.slashCommands ?? provider.slashCommands;
134 }
135
136 +/** A project's own provider config can add models that only its workspace snapshot lists. */
137 +function resolveProviderModelsForCwd(
138 + provider: ServerProvider,
139 + cwd: string | null | undefined,
140 +): ServerProvider["models"] {
141 + return resolveProviderWorkspaceSnapshot(provider, cwd)?.models ?? provider.models;
142 +}
143 +
144 +/** Providers keep their identity unless the cwd has its own catalog. */
145 +export function resolveProvidersForCwd<P extends ServerProvider>(
146 + providers: ReadonlyArray<P>,
147 + cwd: string | null | undefined,
148 +): ReadonlyArray<P> {
149 + const resolved = providers.map((provider) => {
150 + const models = resolveProviderModelsForCwd(provider, cwd);
151 + return models === provider.models ? provider : { ...provider, models };
152 + });
153 + return resolved.every((provider, index) => provider === providers[index]) ? providers : resolved;
154 +}
155 +
156 const WORKSPACE_SNAPSHOT_RETRY_COOLDOWN_MS = 10_000;
157 // A cwd that never scans, such as a deleted worktree, would otherwise retry forever.
158 const WORKSPACE_SNAPSHOT_MAX_ATTEMPTS = 3;
@@ -175,8 +196,8 @@ function planProviderWorkspaceSnapshotRefresh(
196 readonly recheckAt: number | null;
197 } {
198 const hasSnapshot = hasCompleteProviderWorkspaceSnapshot(provider, cwd);
178 - const pending =
179 - (provider && resolveProviderWorkspaceSnapshot(provider, cwd)?.slashCommandsPending) === true;
199 + const snapshot = provider && resolveProviderWorkspaceSnapshot(provider, cwd);
200 + const pending = Boolean(snapshot && isProviderWorkspaceSnapshotPending(snapshot));
201 // Losing a snapshot (the server dropped it) lifts both the TTL and the retry
202 // cooldown so the scan happens at once.
203 const lost = previous.hadSnapshot && !hasSnapshot;
@@ -252,7 +273,7 @@ function resolveWorkspaceSnapshotStatus(
273 ): WorkspaceSnapshotStatus {
274 const snapshot = provider && resolveProviderWorkspaceSnapshot(provider, cwd);
275 if (!snapshot) return "absent";
255 - return snapshot.slashCommandsPending ? "pending" : "complete";
276 + return isProviderWorkspaceSnapshotPending(snapshot) ? "pending" : "complete";
277 }
278
279 interface ProviderWorkspaceSnapshotRefreshTarget {
packages/client-runtime/src/state/server.ts
+1
@@ -680,6 +680,7 @@ type ServerProviderEntry = ServerConfig["providers"][number];
680 const snapshotBasis = (provider: ServerProviderEntry | undefined) =>
681 provider && {
682 enabled: provider.enabled,
683 + models: provider.models,
684 slashCommands: provider.slashCommands,
685 skills: provider.skills,
686 };
packages/contracts/src/server.ts
+10
@@ -129,6 +129,9 @@ export const ServerProviderWorkspaceSnapshot = Schema.Struct({
129 slashCommandsPending: Schema.optional(Schema.Boolean),
130 skills: Schema.Array(ServerProviderSkill),
131 optionDescriptors: Schema.optional(Schema.Array(ProviderOptionDescriptor)),
132 + // Absent means the provider's machine `models`, which keeps most snapshots small.
133 + models: Schema.optional(Schema.Array(ServerProviderModel)),
134 + modelsPending: Schema.optional(Schema.Boolean),
135 });
136 export type ServerProviderWorkspaceSnapshot = typeof ServerProviderWorkspaceSnapshot.Type;
137
@@ -141,6 +144,13 @@ export function isProviderWorkspaceSnapshotCurrent(
144 return nowMs - Date.parse(snapshot.checkedAt) < PROVIDER_WORKSPACE_SNAPSHOT_TTL_MS;
145 }
146
147 +/** A pending snapshot keeps what it found before and is rescanned before its TTL. */
148 +export function isProviderWorkspaceSnapshotPending(
149 + snapshot: Pick<ServerProviderWorkspaceSnapshot, "slashCommandsPending" | "modelsPending">,
150 +): boolean {
151 + return snapshot.slashCommandsPending === true || snapshot.modelsPending === true;
152 +}
153 +
154 /** Unavailable snapshots must set installed and enabled false. */
155 export const ServerProviderAvailability = Schema.Literals(["available", "unavailable"]);
156 export type ServerProviderAvailability = typeof ServerProviderAvailability.Type;
packages/provider-core/src/server/driver.ts
+6 -1
@@ -30,7 +30,12 @@ export interface ProviderDriverMetadata {
30 }
31
32 export type ProviderWorkspaceSnapshot = ServerProvider &
33 - Pick<ServerProviderWorkspaceSnapshot, "slashCommandsPending" | "optionDescriptors">;
33 + Pick<ServerProviderWorkspaceSnapshot, "slashCommandsPending" | "optionDescriptors"> & {
34 + /** Set only when the directory's catalog differs from the machine snapshot's. */
35 + readonly workspaceModels?: ServerProviderWorkspaceSnapshot["models"];
36 + /** The directory's catalog could not be read, so keep the models found before. */
37 + readonly workspaceModelsPending?: boolean;
38 + };
39
40 export interface ProviderInstance {
41 readonly instanceId: ProviderInstanceId;
packages/provider-opencode/src/server/OpenCodeRuntime.ts
+32 -24
@@ -226,6 +226,36 @@ export const loadOpenCodeCommands = (client: OpencodeClient) =>
226 ),
227 );
228
229 +const loadOpenCodeProviders = (client: OpencodeClient) =>
230 + runOpenCodeSdk("provider.list", (signal) => client.provider.list(undefined, { signal })).pipe(
231 + Effect.filterMapOrFail(
232 + (list) =>
233 + list.data
234 + ? Result.succeed(list.data)
235 + : Result.fail(
236 + new OpenCodeRuntimeError({
237 + operation: "provider.list",
238 + detail: "OpenCode provider list was empty.",
239 + }),
240 + ),
241 + (result) => result,
242 + ),
243 + );
244 +
245 +const loadOpenCodeAgents = (client: OpencodeClient) =>
246 + runOpenCodeSdk("app.agents", (signal) => client.app.agents(undefined, { signal })).pipe(
247 + Effect.map((result): ReadonlyArray<Agent> => result.data ?? []),
248 + );
249 +
250 +/** The providers and agents OpenCode resolves for the client's directory. Fails if either read does. */
251 +export const loadOpenCodeProviderCatalog = Effect.fn("OpenCodeRuntime.loadOpenCodeProviderCatalog")(
252 + (client: OpencodeClient) =>
253 + Effect.all(
254 + { providerList: loadOpenCodeProviders(client), agents: loadOpenCodeAgents(client) },
255 + { concurrency: "unbounded" },
256 + ),
257 +);
258 +
259 export interface ParsedOpenCodeModelSlug {
260 readonly providerID: string;
261 readonly modelID: string;
@@ -801,28 +831,6 @@ const makeOpenCodeRuntime = Effect.gen(function* () {
831 );
832 };
833
804 - const loadProviders = (client: OpencodeClient) =>
805 - runOpenCodeSdk("provider.list", (signal) => client.provider.list(undefined, { signal })).pipe(
806 - Effect.filterMapOrFail(
807 - (list) =>
808 - list.data
809 - ? Result.succeed(list.data)
810 - : Result.fail(
811 - new OpenCodeRuntimeError({
812 - operation: "provider.list",
813 - detail: "OpenCode provider list was empty.",
814 - }),
815 - ),
816 - (result) => result,
817 - ),
818 - );
819 -
820 - const loadAgents = (client: OpencodeClient) =>
821 - runOpenCodeSdk("app.agents", (signal) => client.app.agents(undefined, { signal })).pipe(
822 - Effect.map((result) => result.data ?? []),
823 - Effect.orElseSucceed((): ReadonlyArray<Agent> => []),
824 - );
825 -
834 const loadOpenCodeSkills: OpenCodeRuntime["Service"]["loadOpenCodeSkills"] = (client) =>
835 runOpenCodeSdk("app.skills", (signal) => client.app.skills(undefined, { signal })).pipe(
836 Effect.map((result) =>
@@ -839,8 +847,8 @@ const makeOpenCodeRuntime = Effect.gen(function* () {
847 const loadOpenCodeInventory: OpenCodeRuntime["Service"]["loadOpenCodeInventory"] = (client) =>
848 Effect.all(
849 [
842 - loadProviders(client),
843 - loadAgents(client),
850 + loadOpenCodeProviders(client),
851 + loadOpenCodeAgents(client).pipe(Effect.orElseSucceed((): ReadonlyArray<Agent> => [])),
852 loadSkills(client),
853 loadOpenCodeCommands(client).pipe(Effect.orElseSucceed(() => [])),
854 ],
packages/provider-opencode/src/server/driver.test.ts
+190
@@ -21,12 +21,14 @@ import * as Fiber from "effect/Fiber";
21 import * as FileSystem from "effect/FileSystem";
22 import * as Layer from "effect/Layer";
23 import * as Logger from "effect/Logger";
24 +import * as Option from "effect/Option";
25 import * as References from "effect/References";
26 import * as Stream from "effect/Stream";
27 import * as TestClock from "effect/testing/TestClock";
28 import * as HttpClient from "effect/http/HttpClient";
29 import * as HttpClientResponse from "effect/http/HttpClientResponse";
30 import * as FetchHttpClient from "effect/http/FetchHttpClient";
31 +import * as UrlParams from "effect/http/UrlParams";
32 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
33
34 import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
@@ -97,6 +99,83 @@ const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient,
99
100 const noHttp = HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP"));
101
102 +const openCode2Project = "/work/project-with-config";
103 +const 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.
120 +const 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 +
179 it.live("discovers models through a home-relative OpenCode wrapper", () =>
180 Effect.gen(function* () {
181 const fs = yield* FileSystem.FileSystem;
@@ -424,6 +503,8 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
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 };
@@ -588,6 +669,42 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
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>();
@@ -896,6 +1013,79 @@ const layerUpdate = Layer.mergeAll(
1013 Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, changingRuntime),
1014 ).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
1015
1016 +const 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 +});
1023 +const openCode1Project = "/work/project-with-config";
1024 +const openCode1UnreadableProject = "/work/unreadable-project";
1025 +const 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 +};
1032 +const 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 +
1056 +it.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 +
1089 it.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",
packages/provider-opencode/src/server/driver.ts
+73 -24
@@ -1,9 +1,14 @@
1 -import { ProviderDriverKind, settingsSecretLiteral } from "@t3tools/contracts";
1 +import {
2 + ProviderDriverKind,
3 + settingsSecretLiteral,
4 + type ServerProviderModel,
5 +} from "@t3tools/contracts";
6 import { OpenCodeSettings } from "../settings.ts";
7 import * as Digest from "effect/crypto/Digest";
8 import * as SecureRandom from "effect/crypto/SecureRandom";
9 import * as Deferred from "effect/Deferred";
10 import * as Effect from "effect/Effect";
11 +import * as Equal from "effect/Equal";
12 import * as Option from "effect/Option";
13 import * as FileSystem from "effect/FileSystem";
14 import * as Path from "effect/Path";
@@ -26,16 +31,19 @@ import type { ProviderTextGeneration } from "@t3tools/provider-core/server/textG
31 import { ProviderDriverError } from "@t3tools/provider-core/server/errors";
32 import { openCodeUsageReader, type OpenCodeUsageReaderEnv } from "./usage.ts";
33 import { readOpenCodeGoUsageLimits } from "./usageLimits.ts";
29 -import { loadOpenCode2Catalog } from "./openCode2Catalog.ts";
34 +import { loadOpenCode2Catalog, loadOpenCode2DirectoryCatalog } from "./openCode2Catalog.ts";
35 import {
36 checkOpenCodeProviderStatus,
37 loadOpenCode2Workspace,
38 makeOpenCode2ModelLoader,
39 makePendingOpenCodeProvider,
40 openCode2CommandsToServerProviderSlashCommands,
41 + openCode2ProviderModels,
42 openCode2SkillsToServerProviderSkills,
43 openCodeSkillsToServerProviderSkills,
44 openCodeCommandsToServerProviderSlashCommands,
45 + openCodeProviderModels,
46 + readSettledOpenCode2Catalog,
47 } from "./status.ts";
48 import { makeManagedServerProvider } from "@t3tools/provider-core/server/managedProvider";
49 import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
@@ -138,6 +146,17 @@ function byOpenCodeRuntime<A, E, R, PE>(
146 );
147 }
148
149 +// An unread catalog keeps what the registry found before rather than the machine catalog.
150 +function workspaceModelsFor(
151 + machineModels: ReadonlyArray<ServerProviderModel>,
152 + cwdModels: Option.Option<ReadonlyArray<ServerProviderModel>>,
153 +) {
154 + if (Option.isNone(cwdModels)) return { workspaceModelsPending: true };
155 + return Equal.equals(cwdModels.value, machineModels)
156 + ? {}
157 + : { models: cwdModels.value, workspaceModels: cwdModels.value };
158 +}
159 +
160 // Hot reads use the last successful probe; session opens await it to select the correct protocol.
161 function selectOpenCodeRuntimeAdapter(input: {
162 readonly probe: OpenCodeRuntimeProbe;
@@ -504,11 +523,22 @@ export const OpenCodeDriver: ProviderDriver<
523 slashCommandsPending: undefined,
524 })),
525 ),
526 + // A project's opencode.jsonc can define its own providers.
527 + models: OpenCodeRuntime.loadOpenCodeProviderCatalog(client).pipe(
528 + Effect.timeoutOption("10 seconds"),
529 + Effect.map(
530 + Option.flatMapNullishOr((catalog) =>
531 + openCodeProviderModels(effectiveConfig, catalog),
532 + ),
533 + ),
534 + Effect.orElseSucceed(() => Option.none<ReadonlyArray<ServerProviderModel>>()),
535 + ),
536 },
537 { concurrency: "unbounded" },
538 ).pipe(
510 - Effect.map(({ skills, commandInventory }) => ({
539 + Effect.map(({ skills, commandInventory, models }) => ({
540 skills,
541 + models,
542 ...commandInventory,
543 })),
544 );
@@ -613,23 +643,39 @@ export const OpenCodeDriver: ProviderDriver<
643 ),
644 Effect.flatMap((probed) =>
645 byOpenCodeRuntime(Effect.succeed(probed), {
616 - v2: Effect.all([
617 - snapshot.getSnapshot,
618 - listOpenCode2Workspace(cwd).pipe(
619 - Effect.timeout("20 seconds"),
620 - Effect.mapError(
621 - (cause) =>
622 - new ProviderDriverError({
623 - driver: DRIVER_KIND,
624 - instanceId,
625 - detail: `Failed to list OpenCode commands and skills for '${cwd}'`,
626 - cause,
627 - }),
646 + v2: Effect.all(
647 + [
648 + snapshot.getSnapshot,
649 + // A project's opencode.jsonc can define its own providers.
650 + readSettledOpenCode2Catalog(
651 + openCode2Server.withConnection(({ client }) =>
652 + loadOpenCode2DirectoryCatalog(client, cwd),
653 + ),
654 + ).pipe(
655 + Effect.map(
656 + Option.map((catalog) =>
657 + openCode2ProviderModels(effectiveConfig, catalog),
658 + ),
659 + ),
660 ),
629 - ),
630 - ]).pipe(
631 - Effect.map(([machineSnapshot, { skills, commands }]) => ({
661 + listOpenCode2Workspace(cwd).pipe(
662 + Effect.timeout("20 seconds"),
663 + Effect.mapError(
664 + (cause) =>
665 + new ProviderDriverError({
666 + driver: DRIVER_KIND,
667 + instanceId,
668 + detail: `Failed to list OpenCode commands and skills for '${cwd}'`,
669 + cause,
670 + }),
671 + ),
672 + ),
673 + ],
674 + { concurrency: "unbounded" },
675 + ).pipe(
676 + Effect.map(([machineSnapshot, cwdModels, { skills, commands }]) => ({
677 ...machineSnapshot,
678 + ...workspaceModelsFor(machineSnapshot.models, cwdModels),
679 skills: openCode2SkillsToServerProviderSkills(skills),
680 slashCommands: openCode2CommandsToServerProviderSlashCommands(commands),
681 // A finished scan lists at least the built-ins. None means it
@@ -641,12 +687,15 @@ export const OpenCodeDriver: ProviderDriver<
687 snapshot.getSnapshot,
688 loadWorkspaceForCwd(cwd).pipe(Effect.timeout("20 seconds")),
689 ]).pipe(
644 - Effect.map(([machineSnapshot, { skills, commands, slashCommandsPending }]) => ({
645 - ...machineSnapshot,
646 - skills: openCodeSkillsToServerProviderSkills(skills),
647 - slashCommands: openCodeCommandsToServerProviderSlashCommands(commands),
648 - slashCommandsPending,
649 - })),
690 + Effect.map(
691 + ([machineSnapshot, { skills, models, commands, slashCommandsPending }]) => ({
692 + ...machineSnapshot,
693 + ...workspaceModelsFor(machineSnapshot.models, models),
694 + skills: openCodeSkillsToServerProviderSkills(skills),
695 + slashCommands: openCodeCommandsToServerProviderSlashCommands(commands),
696 + slashCommandsPending,
697 + }),
698 + ),
699 Effect.mapError(
700 (cause) =>
701 new ProviderDriverError({
packages/provider-opencode/src/server/openCode2Catalog.ts
+27 -19
@@ -1,6 +1,5 @@
1 import type { OpenCodeClient } from "@opencode/client/effect";
2 import * as Effect from "effect/Effect";
3 -import * as Option from "effect/Option";
3
4 import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
5 import type { OpenCode2Model } from "./status.ts";
@@ -8,28 +7,23 @@ import type { OpenCode2Model } from "./status.ts";
7 // Cold catalogs take seconds; model reads already retry empty catalogs.
8 const PROVIDER_NAME_TIMEOUT = "3 seconds";
9
11 -/** Provider names are optional decoration; bound their read so models cannot stall. */
12 -export const loadOpenCode2Catalog = (
10 +const listProviders = (client: OpenCodeClient, directory: string) =>
11 + client.provider.list({ location: { directory } }).pipe(
12 + Effect.timeout(PROVIDER_NAME_TIMEOUT),
13 + Effect.map((list) => list.data),
14 + );
15 +
16 +const readCatalog = <E>(
17 client: OpenCodeClient,
18 directory: string,
15 -): Effect.Effect<ReadonlyArray<OpenCode2Model>, OpenCodeRuntime.OpenCodeRuntimeError> => {
16 - const location = { directory };
17 - return Effect.all(
18 - {
19 - models: client.model.list({ location }),
20 - providers: client.provider
21 - .list({ location })
22 - .pipe(Effect.timeout(PROVIDER_NAME_TIMEOUT), Effect.option),
23 - },
19 + providers: Effect.Effect<ReadonlyArray<{ readonly id: string; readonly name: string }>, E>,
20 +): Effect.Effect<ReadonlyArray<OpenCode2Model>, OpenCodeRuntime.OpenCodeRuntimeError> =>
21 + Effect.all(
22 + { models: client.model.list({ location: { directory } }), providers },
23 { concurrency: "unbounded" },
24 ).pipe(
25 Effect.map(({ models, providers }) => {
27 - const providerNames = new Map(
28 - (Option.getOrUndefined(providers)?.data ?? []).map((provider) => [
29 - provider.id,
30 - provider.name,
31 - ]),
32 - );
26 + const providerNames = new Map(providers.map((provider) => [provider.id, provider.name]));
27 return models.data.map((model) => {
28 const providerName = providerNames.get(model.providerID);
29 return {
@@ -53,4 +47,18 @@ export const loadOpenCode2Catalog = (
47 }),
48 ),
49 );
56 -};
50 +
51 +/** Provider names are optional decoration; bound their read so models cannot stall. */
52 +export const loadOpenCode2Catalog = (client: OpenCodeClient, directory: string) =>
53 + readCatalog(
54 + client,
55 + directory,
56 + listProviders(client, directory).pipe(Effect.orElseSucceed(() => [])),
57 + );
58 +
59 +/** Missing provider names would relabel every model, so a directory read needs them. */
60 +export const loadOpenCode2DirectoryCatalog = Effect.fn(
61 + "OpenCodeRuntime.loadOpenCode2DirectoryCatalog",
62 +)((client: OpenCodeClient, directory: string) =>
63 + readCatalog(client, directory, listProviders(client, directory)),
64 +);
packages/provider-opencode/src/server/status.ts
+86 -42
@@ -10,6 +10,7 @@ import * as Cause from "effect/Cause";
10 import * as Schema from "effect/Schema";
11 import * as DateTime from "effect/DateTime";
12 import * as Effect from "effect/Effect";
13 +import * as Option from "effect/Option";
14 import * as Schedule from "effect/Schedule";
15
16 import { createModelCapabilities } from "@t3tools/shared/model";
@@ -314,7 +315,7 @@ function markOpenCodeLegacy(
315 }
316
317 function flattenOpenCodeModels(
317 - input: OpenCodeRuntime.OpenCodeInventory,
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 }> = [];
@@ -357,6 +358,21 @@ function flattenOpenCodeModels(
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. */
362 +export 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 +
376 function trimOptional(value: string | null | undefined): string | undefined {
377 const trimmed = value?.trim();
378 return trimmed && trimmed.length > 0 ? trimmed : undefined;
@@ -482,27 +498,42 @@ const catalogFingerprint = (models: ReadonlyArray<OpenCode2Model>) =>
498 .join("\n");
499
500 /** A cold server can list a partial catalog; two agreeing reads reduce that startup race. */
501 +const 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 +
517 +const OPENCODE_2_CATALOG_SETTLE_TIMEOUT = "5 seconds";
518 +
519 export const makeOpenCode2ModelLoader = <E>(
520 list: Effect.Effect<ReadonlyArray<OpenCode2Model>, E>,
521 ) =>
522 Effect.sync(() => {
523 let lastLoaded: ReadonlyArray<OpenCode2Model> = [];
524 return Effect.suspend(() => {
491 - let previous: string | undefined;
525 let latest: ReadonlyArray<OpenCode2Model> = [];
493 - return list.pipe(
494 - Effect.repeat({
495 - until: (models) => {
496 - if (models.length > 0) latest = models;
497 - const fingerprint = models.length > 0 ? catalogFingerprint(models) : undefined;
498 - const settled = fingerprint !== undefined && fingerprint === previous;
499 - previous = fingerprint;
500 - return settled;
501 - },
502 - schedule: Schedule.spaced("250 millis"),
503 - }),
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))),
505 - Effect.timeoutOption("5 seconds"),
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;
@@ -513,6 +544,15 @@ export const makeOpenCode2ModelLoader = <E>(
544 });
545 });
546
547 +/** None when the reads fail or never agree, so a partial catalog never passes for a settled one. */
548 +export 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 +
556 export interface OpenCode2Workspace {
557 readonly skills: ReadonlyArray<{
558 readonly id: string;
@@ -608,6 +648,31 @@ function openCode2ModelCapabilities(model: OpenCode2Model): ModelCapabilities {
648 });
649 }
650
651 +export 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 +
676 const checkOpenCode2 = Effect.fn("checkOpenCode2")(function* (
677 settings: OpenCodeSettings,
678 version: string,
@@ -649,30 +714,11 @@ const checkOpenCode2 = Effect.fn("checkOpenCode2")(function* (
714 version,
715 });
716 }
652 - const models = providerModelsFromSettings(
653 - markOpenCodeLegacy(
654 - result.value.map((model) => {
655 - const subProvider = subProviderLabelFor(model);
656 - return {
657 - model: {
658 - slug: `${model.providerID}/${model.id}`,
659 - name: model.name,
660 - ...(subProvider ? { subProvider } : {}),
661 - isCustom: false,
662 - capabilities: openCode2ModelCapabilities(model),
663 - },
664 - release: model,
665 - };
666 - }),
667 - ).toSorted((left, right) => left.name.localeCompare(right.name)),
668 - settings.customModels,
669 - DEFAULT_OPENCODE_MODEL_CAPABILITIES,
670 - );
717 return buildServerProvider({
718 presentation: OPENCODE_2_PRESENTATION,
719 enabled: true,
720 checkedAt,
675 - models,
721 + models: openCode2ProviderModels(settings, result.value),
722 slashCommands: [COMPACT_SLASH_COMMAND],
723 probe:
724 result.value.length > 0
@@ -835,16 +881,14 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu
881 };
882 }
883
838 - const inventoryModels = flattenOpenCodeModels(inventoryExit.value);
839 - const models = providerModelsFromSettings(
840 - inventoryModels,
841 - customModels,
842 - DEFAULT_OPENCODE_MODEL_CAPABILITIES,
843 - );
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;
846 - const catalogReady = connectedCount > 0 && inventoryModels.length > 0;
847 - if (connectedCount > 0 && inventoryModels.length === 0) {
890 + const catalogReady = connectedCount > 0 && catalogModels !== undefined;
891 + if (connectedCount > 0 && catalogModels === undefined) {
892 yield* logDiscoveryFailure({ phase: "inventory", isExternalServer, version });
893 }
894 return {