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 {