lael-labs/t3code

apps/server/src/provider/Drivers/ClaudeDriver.ts+6−1

         checkProvider,
         enrichSnapshot: ({ snapshot, publishSnapshot }) =>
           enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities).pipe(
-            Effect.flatMap(ProviderCompatibility.enrichProviderSnapshotWithCompatibilityAdvisory),
+            Effect.flatMap((snapshot) =>
+              ProviderCompatibility.enrichProviderSnapshotWithTargetedCompatibilityAdvisory(
+                snapshot,
+                maintenanceCapabilities,
+              ),
+            ),
             Effect.provideService(HttpClient.HttpClient, httpClient),
             Effect.provideService(
               ProviderCompatibility.ProviderCompatibilityService,

apps/server/src/provider/Drivers/CodexDriver.ts+6−1

         checkProvider,
         enrichSnapshot: ({ snapshot, publishSnapshot }) =>
           enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities).pipe(
-            Effect.flatMap(ProviderCompatibility.enrichProviderSnapshotWithCompatibilityAdvisory),
+            Effect.flatMap((snapshot) =>
+              ProviderCompatibility.enrichProviderSnapshotWithTargetedCompatibilityAdvisory(
+                snapshot,
+                maintenanceCapabilities,
+              ),
+            ),
             Effect.provideService(HttpClient.HttpClient, httpClient),
             Effect.provideService(
               ProviderCompatibility.ProviderCompatibilityService,

apps/server/src/provider/Drivers/OpenCodeDriver.ts+6−1

         checkProvider,
         enrichSnapshot: ({ snapshot, publishSnapshot }) =>
           enrichProviderSnapshotWithVersionAdvisory(snapshot, maintenanceCapabilities).pipe(
-            Effect.flatMap(ProviderCompatibility.enrichProviderSnapshotWithCompatibilityAdvisory),
+            Effect.flatMap((snapshot) =>
+              ProviderCompatibility.enrichProviderSnapshotWithTargetedCompatibilityAdvisory(
+                snapshot,
+                maintenanceCapabilities,
+              ),
+            ),
             Effect.provideService(HttpClient.HttpClient, httpClient),
             Effect.provideService(
               ProviderCompatibility.ProviderCompatibilityService,

apps/server/src/provider/Layers/CursorProvider.ts+6−1

     snapshot,
     input.maintenanceCapabilities,
   ).pipe(
-    Effect.flatMap(ProviderCompatibility.enrichProviderSnapshotWithCompatibilityAdvisory),
+    Effect.flatMap((enrichedSnapshot) =>
+      ProviderCompatibility.enrichProviderSnapshotWithTargetedCompatibilityAdvisory(
+        enrichedSnapshot,
+        input.maintenanceCapabilities,
+      ),
+    ),
     Effect.provideService(HttpClient.HttpClient, input.httpClient),
     Effect.flatMap((enrichedSnapshot) =>
       publishSnapshot(stampIdentity(enrichedSnapshot)).pipe(Effect.as(enrichedSnapshot)),

apps/server/src/provider/ProviderCompatibility.test.ts+69−11

 import { HttpClient, HttpClientResponse } from "effect/unstable/http";
 import * as ProviderCompatibility from "./ProviderCompatibility.ts";
+import { makeProviderMaintenanceCapabilities } from "./providerMaintenance.ts";
 const codexDriver = ProviderDriverKind.make("codex");
 const claudeDriver = ProviderDriverKind.make("claudeAgent");
   skills: [],
 };
+const codexNpmUpdateCapabilities = makeProviderMaintenanceCapabilities({
+  provider: codexDriver,
+  packageName: "@openai/codex",
+  updateExecutable: "npm",
+  updateArgs: ["install", "-g", "@openai/codex@latest"],
+  updateLockKey: "npm-global",
+});
 function jsonHttpClient(
   responseForUrl: (url: string) => { readonly payload: unknown; readonly status?: number },
 ): HttpClient.HttpClient {
     });
   });
-  it("classifies the initial hosted compatibility policies for T3 Code 0.0.24+", () => {
+  it("adds a targeted compatibility update command when a recommended version is available", () => {
     const document: ProviderCompatibility.ProviderCompatibilityDocument = {
       version: 1,
       policies: [
         {
-          t3CodeRange: ">=0.0.24",
+          t3CodeRange: ">=0.0.0",
+          driver: codexDriver,
+          recommendedRange: ">=0.129.0",
+          recommendedVersion: "0.129.0",
+          ranges: [{ status: "broken", range: "<0.129.0" }],
+        },
+      ],
+    };
+    expect(
+      ProviderCompatibility.createProviderCompatibilityAdvisory({
+        driver: codexDriver,
+        currentVersion: "0.128.0",
+        document,
+        maintenanceCapabilities: codexNpmUpdateCapabilities,
+      }),
+    ).toMatchObject({
+      status: "broken",
+      canUpdate: true,
+      updateCommand: "npm install -g @openai/codex@0.129.0",
+    });
+  });
+  it("does not warn on disabled providers before their version has been probed", () => {
+    const enriched = ProviderCompatibility.applyBundledProviderCompatibilityAdvisory({
+      snapshot: {
+        ...baseProvider,
+        driver: cursorDriver,
+        enabled: false,
+        version: null,
+        status: "disabled",
+      },
+      driver: cursorDriver,
+      currentVersion: null,
+    });
+    expect(enriched.compatibilityAdvisory).toBeUndefined();
+    expect(enriched.status).toBe("disabled");
+  });
+  it("classifies the bundled compatibility policies for current T3 Code builds", () => {
+    const document: ProviderCompatibility.ProviderCompatibilityDocument = {
+      version: 1,
+      policies: [
+        {
+          t3CodeRange: ">=0.0.0",
           driver: codexDriver,
           recommendedRange: ">=0.129.0",
           recommendedVersion: "0.129.0",
           ],
         },
         {
-          t3CodeRange: ">=0.0.24",
+          t3CodeRange: ">=0.0.0",
           driver: claudeDriver,
           recommendedRange: ">=0.2.111",
           recommendedVersion: "0.2.111",
           ranges: [{ status: "supported", range: ">=0.2.111" }],
         },
         {
-          t3CodeRange: ">=0.0.24",
+          t3CodeRange: ">=0.0.0",
           driver: opencodeDriver,
           recommendedRange: ">=1.14.19",
           recommendedVersion: "1.14.19",
           ],
         },
         {
-          t3CodeRange: ">=0.0.24",
+          t3CodeRange: ">=0.0.0",
           driver: cursorDriver,
           recommendedRange: ">=2026.05.09",
           recommendedVersion: "2026.05.09",
         driver,
         currentVersion,
         document,
-        t3CodeVersion: "0.0.24",
+        t3CodeVersion: "0.0.22",
       })?.status;
     expect(classify(codexDriver, "0.129.0")).toBe("supported");
     };
     return Effect.gen(function* () {
-      const enriched = yield* ProviderCompatibility.enrichProviderSnapshotWithCompatibilityAdvisory(
+      const enriched =
-        baseProvider,
+        yield* ProviderCompatibility.enrichProviderSnapshotWithTargetedCompatibilityAdvisory(
-      ).pipe(provideCompatibility(() => ({ payload: remoteDocument })));
+          baseProvider,
+          codexNpmUpdateCapabilities,
+        ).pipe(provideCompatibility(() => ({ payload: remoteDocument })));
       expect(enriched.status).toBe("error");
       expect(enriched.compatibilityAdvisory).toMatchObject({
         status: "broken",
         recommendedVersion: "0.129.0",
+        canUpdate: true,
+        updateCommand: "npm install -g @openai/codex@0.129.0",
       });
     });
   });
         },
       ).pipe(provideCompatibility(() => ({ payload: {}, status: 404 })));
-      expect(enriched.status).toBe("ready");
+      expect(enriched.status).toBe("error");
-      expect(enriched.compatibilityAdvisory).toBeUndefined();
+      expect(enriched.compatibilityAdvisory).toMatchObject({ status: "broken" });
     }),
   );
 });

apps/server/src/provider/ProviderCompatibility.ts+55−9

 import bundledCompatibilityDocumentJson from "../../../../provider-compatibility.v1.json" with { type: "json" };
 import packageJson from "../../package.json" with { type: "json" };
+import {
+  makeTargetedProviderUpdateAction,
+  type ProviderMaintenanceCapabilities,
+} from "./providerMaintenance.ts";
 const T3_CODE_VERSION = packageJson.version;
 const REMOTE_COMPATIBILITY_CACHE_TTL = Duration.minutes(15);
   readonly document: typeof RemoteCompatibilityDocument.Type;
   readonly driver: ProviderDriverKind;
   readonly currentVersion: string | null;
+  readonly maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined;
   readonly t3CodeVersion?: string;
 }): ServerProviderCompatibilityAdvisory | undefined {
   const policy = compatibilityPolicyForDriver({
       : policy.ranges.find((range) => satisfiesSemverRange(currentVersion, range.range));
   const status = matchedRange?.status ?? (currentVersion === null ? "unknown" : "unsupported");
   const recommendedVersion = policy.recommendedVersion ?? null;
+  const targetedUpdateAction = input.maintenanceCapabilities
+    ? makeTargetedProviderUpdateAction(input.maintenanceCapabilities, recommendedVersion)
+    : null;
   return {
     status,
     }),
     recommendedRange: policy.recommendedRange,
     recommendedVersion,
+    updateCommand: targetedUpdateAction?.command ?? null,
+    canUpdate: targetedUpdateAction !== null,
     ranges: [...policy.ranges],
   };
 }
+function shouldSkipCompatibilityAdvisory(input: {
+  readonly snapshot: ProviderCompatibilitySnapshot;
+  readonly currentVersion: string | null;
+}): boolean {
+  return !input.snapshot.enabled && input.currentVersion === null;
+}
 export function createProviderCompatibilityAdvisory(input: {
   readonly driver: ProviderDriverKind;
   readonly currentVersion: string | null;
   readonly document?: typeof RemoteCompatibilityDocument.Type;
+  readonly maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined;
   readonly t3CodeVersion?: string;
 }): ServerProviderCompatibilityAdvisory | undefined {
   return createProviderCompatibilityAdvisoryFromDocument({
     document: input.document ?? bundledProviderCompatibilityDocument,
     driver: input.driver,
     currentVersion: input.currentVersion,
+    maintenanceCapabilities: input.maintenanceCapabilities,
     ...(input.t3CodeVersion ? { t3CodeVersion: input.t3CodeVersion } : {}),
   });
 }
   readonly snapshot: Snapshot;
   readonly driver: ProviderDriverKind;
   readonly currentVersion: string | null;
+  readonly maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined;
 }): Snapshot {
+  if (
+    shouldSkipCompatibilityAdvisory({
+      snapshot: input.snapshot,
+      currentVersion: input.currentVersion,
+    })
+  ) {
+    return removeExistingCompatibilityAdvisory(input.snapshot);
+  }
   return applyCompatibilityAdvisory(
     input.snapshot,
     createProviderCompatibilityAdvisory({
       driver: input.driver,
       currentVersion: input.currentVersion,
+      maintenanceCapabilities: input.maintenanceCapabilities,
     }),
   );
 }
   return yield* compatibility.enrichSnapshot(snapshot);
 });
+export const enrichProviderSnapshotWithTargetedCompatibilityAdvisory = Effect.fn(
+  "enrichProviderSnapshotWithTargetedCompatibilityAdvisory",
+)(function* (snapshot: ServerProvider, maintenanceCapabilities: ProviderMaintenanceCapabilities) {
+  const compatibility = yield* ProviderCompatibilityService;
+  return yield* compatibility.enrichSnapshot(snapshot, maintenanceCapabilities);
+});
 export interface ProviderCompatibilityServiceShape {
   readonly resolveRemoteDocument: Effect.Effect<typeof RemoteCompatibilityDocument.Type | null>;
-  readonly enrichSnapshot: (snapshot: ServerProvider) => Effect.Effect<ServerProvider>;
+  readonly enrichSnapshot: (
+    snapshot: ServerProvider,
+    maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined,
+  ) => Effect.Effect<ServerProvider>;
 }
 export class ProviderCompatibilityService extends Context.Service<
     return {
       resolveRemoteDocument,
-      enrichSnapshot: (snapshot) =>
+      enrichSnapshot: (snapshot, maintenanceCapabilities) =>
         resolveRemoteDocument.pipe(
           Effect.map((remoteDocument) =>
-            applyCompatibilityAdvisory(
+            shouldSkipCompatibilityAdvisory({
               snapshot,
-              createProviderCompatibilityAdvisory({
+              currentVersion: snapshot.version,
-                driver: snapshot.driver,
+            })
-                currentVersion: snapshot.version,
+              ? removeExistingCompatibilityAdvisory(snapshot)
-                ...(remoteDocument ? { document: remoteDocument } : {}),
+              : applyCompatibilityAdvisory(
-              }),
+                  snapshot,
-            ),
+                  createProviderCompatibilityAdvisory({
+                    driver: snapshot.driver,
+                    currentVersion: snapshot.version,
+                    maintenanceCapabilities,
+                    ...(remoteDocument ? { document: remoteDocument } : {}),
+                  }),
+                ),
           ),
         ),
     } satisfies ProviderCompatibilityServiceShape;

apps/server/src/provider/providerMaintenance.test.ts+19−0

@@ -13,6 +13,7 @@ import { · 12 unmodified lines
13	makePackageManagedProviderMaintenanceResolver,	13	makePackageManagedProviderMaintenanceResolver,
14	makeProviderMaintenanceCapabilities,	14	makeProviderMaintenanceCapabilities,
15	makeStaticProviderMaintenanceResolver,	15	makeStaticProviderMaintenanceResolver,
		16	makeTargetedProviderUpdateAction,
16	normalizeCommandPath,	17	normalizeCommandPath,
17	resolveProviderMaintenanceCapabilitiesEffect,	18	resolveProviderMaintenanceCapabilitiesEffect,
18	} from "./providerMaintenance.ts";	19	} from "./providerMaintenance.ts";
@@ -132,6 +133,24 @@ describe("providerMaintenance", () => { · 113 unmodified lines
132	});	133	});
133	});	134	});
134		135
		136	it("targets package install commands that omit an explicit latest suffix", () => {
		137	expect(
		138	makeTargetedProviderUpdateAction(
		139	makeProviderMaintenanceCapabilities({
		140	provider: driver("packageTool"),
		141	packageName: "@example/package-tool",
		142	updateExecutable: "vp",
		143	updateArgs: ["i", "-g", "@example/package-tool"],
		144	updateLockKey: "vite-plus-global",
		145	}),
		146	"1.2.3",
		147	),
		148	).toMatchObject({
		149	command: "vp i -g @example/package-tool@1.2.3",
		150	args: ["i", "-g", "@example/package-tool@1.2.3"],
		151	});
		152	});
		153
135	it.effect(	154	it.effect(
136	"switches package-managed providers to vite-plus updates when the resolved binary lives in vite-plus global bin",	155	"switches package-managed providers to vite-plus updates when the resolved binary lives in vite-plus global bin",
137	() =>	156	() =>

apps/server/src/provider/providerMaintenance.ts+26−0

@@ -108,6 +108,32 @@ export function makeManualOnlyProviderMaintenanceCapabilities(input: { · 107 unmodified lines
108	});	108	});
109	}	109	}
110		110
		111	export function makeTargetedProviderUpdateAction(
		112	capabilities: ProviderMaintenanceCapabilities,
		113	targetVersion: string \| null,
		114	): ProviderMaintenanceCommandAction \| null {
		115	if (!capabilities.update \|\| !capabilities.packageName \|\| !targetVersion) {
		116	return null;
		117	}
		118
		119	const versionedPackageArg = `${capabilities.packageName}@latest`;
		120	const targetPackageArg = `${capabilities.packageName}@${targetVersion}`;
		121	const packageArgIndex = capabilities.update.args.findIndex(
		122	(arg) => arg === versionedPackageArg \|\| arg === capabilities.packageName,
		123	);
		124	if (packageArgIndex < 0) {
		125	return null;
		126	}
		127
		128	const args = [...capabilities.update.args];
		129	args[packageArgIndex] = targetPackageArg;
		130	return {
		131	...capabilities.update,
		132	args,
		133	command: [capabilities.update.executable, ...args].join(" "),
		134	};
		135	}
		136
111	function makeNpmGlobalProviderMaintenanceCapabilities(	137	function makeNpmGlobalProviderMaintenanceCapabilities(
112	definition: PackageManagedProviderMaintenanceDefinition,	138	definition: PackageManagedProviderMaintenanceDefinition,
113	): ProviderMaintenanceCapabilities {	139	): ProviderMaintenanceCapabilities {

apps/server/src/provider/providerMaintenanceRunner.test.ts+30−0

@@ -288,6 +288,36 @@ describe("providerMaintenanceRunner", () => { · 287 unmodified lines
288	);	288	);
289	});	289	});
290		290
		291	it.effect("runs a targeted package update when a target version is supplied", () => {
		292	const calls: Array<{ command: string; args: ReadonlyArray<string> }> = [];
		293	return Effect.gen(function* () {
		294	const { registry } = yield* makeRegistry(baseProvider);
		295	const updater = yield* makeTestRunner(registry);
		296
		297	yield* updater.updateProvider({
		298	provider: CODEX_DRIVER,
		299	targetVersion: "0.129.0",
		300	});
		301
		302	assert.deepStrictEqual(calls, [
		303	{
		304	command: "npm",
		305	args: ["install", "-g", "@openai/codex@0.129.0"],
		306	},
		307	]);
		308	}).pipe(
		309	Effect.provide(
		310	Layer.mergeAll(
		311	latestVersionHttpClient("0.0.0"),
		312	mockSpawnerLayer((command, args) => {
		313	calls.push({ command, args });
		314	return { stdout: "updated" };
		315	}),
		316	),
		317	),
		318	);
		319	});
		320
291	it.effect(	321	it.effect(
292	"runs update commands through Effect ChildProcess when no test runner is injected",	322	"runs update commands through Effect ChildProcess when no test runner is injected",
293	() => {	323	() => {

apps/server/src/provider/providerMaintenanceRunner.ts+9−2

 import { ProviderRegistry } from "./Services/ProviderRegistry.ts";
 import { makeProviderMaintenanceCommandCoordinator } from "./providerMaintenanceCommandCoordinator.ts";
-import { enrichProviderSnapshotWithVersionAdvisory } from "./providerMaintenance.ts";
+import {
+  enrichProviderSnapshotWithVersionAdvisory,
+  makeTargetedProviderUpdateAction,
+} from "./providerMaintenance.ts";
 import type { ProviderMaintenanceCapabilities } from "./providerMaintenance.ts";
 import { collectUint8StreamText } from "../stream/collectUint8StreamText.ts";
 const isServerProviderUpdateError = Schema.is(ServerProviderUpdateError);
       | {
           readonly provider: ProviderDriverKind;
           readonly instanceId?: ProviderInstanceId | undefined;
+          readonly targetVersion?: string | undefined;
         },
   ) => Effect.Effect<ServerProviderUpdatedPayload, ServerProviderUpdateError>;
 }
       typeof target === "string"
         ? defaultInstanceIdForDriver(provider)
         : (target.instanceId ?? defaultInstanceIdForDriver(provider));
+    const targetVersion = typeof target === "string" ? undefined : target.targetVersion;
     const targetKey = `instance:${instanceId}`;
     const capabilities = yield* providerRegistry.getProviderMaintenanceCapabilitiesForInstance(
       instanceId,
       provider,
     );
-    const update = capabilities.update;
+    const update = targetVersion
+      ? makeTargetedProviderUpdateAction(capabilities, targetVersion)
+      : capabilities.update;
     if (!update) {
       return yield* new ServerProviderUpdateError({
         provider,

apps/web/src/components/ChatView.tsx+192−29

@@ -42,7 +42,7 @@ import { useGitStatus } from "~/lib/gitStatusState"; · 41 unmodified lines
42	import { usePrimaryEnvironmentId } from "../environments/primary";	42	import { usePrimaryEnvironmentId } from "../environments/primary";
43	import { readEnvironmentApi } from "../environmentApi";	43	import { readEnvironmentApi } from "../environmentApi";
44	import { isElectron } from "../env";	44	import { isElectron } from "../env";
45	import { readLocalApi } from "../localApi";	45	import { ensureLocalApi, readLocalApi } from "../localApi";
46	import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";	46	import { parseDiffRouteSearch, stripDiffSearchParams } from "../diffRouteSearch";
47	import {	47	import {
48	collapseExpandedComposerCursor,	48	collapseExpandedComposerCursor,
@@ -104,7 +104,14 @@ import { BranchToolbar } from "./BranchToolbar"; · 55 unmodified lines
104	import { resolveShortcutCommand, shortcutLabelForCommand } from "../keybindings";	104	import { resolveShortcutCommand, shortcutLabelForCommand } from "../keybindings";
105	import PlanSidebar from "./PlanSidebar";	105	import PlanSidebar from "./PlanSidebar";
106	import ThreadTerminalDrawer from "./ThreadTerminalDrawer";	106	import ThreadTerminalDrawer from "./ThreadTerminalDrawer";
107	import { ChevronDownIcon, TriangleAlertIcon, WifiOffIcon } from "lucide-react";	107	import {
		108	ChevronDownIcon,
		109	CircleAlertIcon,
		110	DownloadIcon,
		111	LoaderIcon,
		112	TriangleAlertIcon,
		113	WifiOffIcon,
		114	} from "lucide-react";
108	import { cn, randomUUID } from "~/lib/utils";	115	import { cn, randomUUID } from "~/lib/utils";
109	import { stackedThreadToast, toastManager } from "./ui/toast";	116	import { stackedThreadToast, toastManager } from "./ui/toast";
110	import { decodeProjectScriptKeybindingRule } from "~/lib/projectScriptKeybindings";	117	import { decodeProjectScriptKeybindingRule } from "~/lib/projectScriptKeybindings";
@@ -147,7 +154,6 @@ import { ChatHeader } from "./chat/ChatHeader"; · 36 unmodified lines
147	import { type ExpandedImagePreview } from "./chat/ExpandedImagePreview";	154	import { type ExpandedImagePreview } from "./chat/ExpandedImagePreview";
148	import { NoActiveThreadState } from "./NoActiveThreadState";	155	import { NoActiveThreadState } from "./NoActiveThreadState";
149	import { resolveEffectiveEnvMode, resolveEnvironmentOptionLabel } from "./BranchToolbar.logic";	156	import { resolveEffectiveEnvMode, resolveEnvironmentOptionLabel } from "./BranchToolbar.logic";
150	import { ProviderStatusBanner } from "./chat/ProviderStatusBanner";
151	import { ThreadErrorBanner } from "./chat/ThreadErrorBanner";	157	import { ThreadErrorBanner } from "./chat/ThreadErrorBanner";
152	import { ComposerBannerStack, type ComposerBannerStackItem } from "./chat/ComposerBannerStack";	158	import { ComposerBannerStack, type ComposerBannerStackItem } from "./chat/ComposerBannerStack";
153	import {	159	import {
@@ -183,6 +189,11 @@ import { sanitizeThreadErrorMessage } from "~/rpc/transportError"; · 29 unmodified lines
183	import { retainThreadDetailSubscription } from "../environments/runtime/service";	189	import { retainThreadDetailSubscription } from "../environments/runtime/service";
184	import { RightPanelSheet } from "./RightPanelSheet";	190	import { RightPanelSheet } from "./RightPanelSheet";
185	import { Button } from "./ui/button";	191	import { Button } from "./ui/button";
		192	import { Popover, PopoverPopup, PopoverTrigger } from "./ui/popover";
		193	import {
		194	canRunProviderCompatibilityUpdate,
		195	getProviderCompatibilityUpdateCommand,
		196	} from "./settings/providerStatus";
186	import {	197	import {
187	buildVersionMismatchDismissalKey,	198	buildVersionMismatchDismissalKey,
188	dismissVersionMismatch,	199	dismissVersionMismatch,
@@ -197,6 +208,75 @@ const EMPTY_PROPOSED_PLANS: Thread["proposedPlans"] = []; · 8 unmodified lines
197	const EMPTY_PROVIDERS: ServerProvider[] = [];	208	const EMPTY_PROVIDERS: ServerProvider[] = [];
198	const EMPTY_PROVIDER_SKILLS: ServerProvider["skills"] = [];	209	const EMPTY_PROVIDER_SKILLS: ServerProvider["skills"] = [];
199	const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnswer> = {};	210	const EMPTY_PENDING_USER_INPUT_ANSWERS: Record<string, PendingUserInputDraftAnswer> = {};
		211
		212	function stripProviderCompatibilityInstallHint(message: string, recommendedVersion: string \| null) {
		213	if (!recommendedVersion) {
		214	return message;
		215	}
		216	const escapedVersion = recommendedVersion.replace(/[.*+?^${}()\|[\]\\]/g, "\\$&");
		217	return message.replace(new RegExp(`\\sUse\\s+${escapedVersion}\\.?\\s$`, "i"), "").trim();
		218	}
		219
		220	function ProviderCompatibilityBannerAction({
		221	providerLabel,
		222	recommendedVersion,
		223	updateCommand,
		224	canRunUpdate,
		225	updating,
		226	onRunUpdate,
		227	}: {
		228	readonly providerLabel: string;
		229	readonly recommendedVersion: string;
		230	readonly updateCommand: string \| null;
		231	readonly canRunUpdate: boolean;
		232	readonly updating: boolean;
		233	readonly onRunUpdate: () => void;
		234	}) {
		235	return (
		236	<Popover>
		237	<PopoverTrigger
		238	render={
		239	<Button type="button" size="xs" variant="outline">
		240	Install {recommendedVersion}
		241	</Button>
		242	}
		243	/>
		244	<PopoverPopup side="top" align="end" className="w-84">
		245	<div className="grid gap-3">
		246	<div className="grid gap-0.5">
		247	<p className="text-[13px] font-semibold leading-tight text-foreground">
		248	Install compatible {providerLabel}
		249	</p>
		250	<p className="text-xs leading-snug text-muted-foreground">
		251	Install provider harness version {recommendedVersion}.
		252	</p>
		253	</div>
		254	{canRunUpdate ? (
		255	<Button
		256	type="button"
		257	size="xs"
		258	variant="default"
		259	className="w-full"
		260	disabled={updating}
		261	onClick={onRunUpdate}
		262	>
		263	{updating ? <LoaderIcon className="animate-spin" /> : <DownloadIcon />}
		264	{updating ? "Installing" : "Install now"}
		265	</Button>
		266	) : null}
		267	{updateCommand ? (
		268	<div className="rounded-md border border-border/70 bg-muted/40 px-2 py-1.5">
		269	<code className="block overflow-x-auto whitespace-nowrap font-mono text-[11px] text-foreground [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
		270	{updateCommand}
		271	</code>
		272	</div>
		273	) : null}
		274	</div>
		275	</PopoverPopup>
		276	</Popover>
		277	);
		278	}
		279
200	type EnvironmentUnavailableState = {	280	type EnvironmentUnavailableState = {
201	readonly environmentId: EnvironmentId;	281	readonly environmentId: EnvironmentId;
202	readonly label: string;	282	readonly label: string;
@@ -1150,6 +1230,8 @@ export default function ChatView(props: ChatViewProps) { · 947 unmodified lines
1150	const [dismissedVersionMismatchKey, setDismissedVersionMismatchKey] = useState<string \| null>(	1230	const [dismissedVersionMismatchKey, setDismissedVersionMismatchKey] = useState<string \| null>(
1151	null,	1231	null,
1152	);	1232	);
		1233	const [compatibilityUpdatingProviderId, setCompatibilityUpdatingProviderId] =
		1234	useState<ProviderInstanceId \| null>(null);
1153	const versionMismatchDismissed =	1235	const versionMismatchDismissed =
1154	versionMismatchDismissKey === dismissedVersionMismatchKey \|\|	1236	versionMismatchDismissKey === dismissedVersionMismatchKey \|\|
1155	isVersionMismatchDismissed(versionMismatchDismissKey);	1237	isVersionMismatchDismissed(versionMismatchDismissKey);
@@ -1178,8 +1260,112 @@ export default function ChatView(props: ChatViewProps) { · 22 unmodified lines
1178	savedEnvironmentRuntimeById,	1260	savedEnvironmentRuntimeById,
1179	serverConfig?.environment.label,	1261	serverConfig?.environment.label,
1180	]);	1262	]);
		1263	const providerStatuses = serverConfig?.providers ?? EMPTY_PROVIDERS;
		1264	const unlockedSelectedProvider = resolveSelectableProvider(
		1265	providerStatuses,
		1266	selectedProviderByThreadId ?? threadProvider ?? ProviderDriverKind.make("codex"),
		1267	);
		1268	const selectedProvider: ProviderDriverKind = lockedProvider ?? unlockedSelectedProvider;
		1269	// Prefer an instance-id match so a custom Codex instance (e.g.
		1270	// `codex_personal`) surfaces its own status/message in the banner rather
		1271	// than the default Codex's. Falls back to first-match-by-kind when no
		1272	// saved instance id is available or the instance no longer exists.
		1273	const activeProviderInstanceId =
		1274	composerActiveProvider ??
		1275	activeThread?.session?.providerInstanceId ??
		1276	activeThread?.modelSelection.instanceId ??
		1277	activeProject?.defaultModelSelection?.instanceId ??
		1278	null;
		1279	const activeProviderStatus = useMemo(() => {
		1280	if (activeProviderInstanceId) {
		1281	return (
		1282	providerStatuses.find((status) => status.instanceId === activeProviderInstanceId) ?? null
		1283	);
		1284	}
		1285	const defaultInstanceId = defaultInstanceIdForDriver(selectedProvider);
		1286	return providerStatuses.find((status) => status.instanceId === defaultInstanceId) ?? null;
		1287	}, [activeProviderInstanceId, providerStatuses, selectedProvider]);
		1288	const runActiveProviderCompatibilityUpdate = useCallback(async () => {
		1289	const provider = activeProviderStatus;
		1290	const targetVersion = provider?.compatibilityAdvisory?.recommendedVersion ?? null;
		1291	if (!provider \|\| !targetVersion) {
		1292	return;
		1293	}
		1294
		1295	setCompatibilityUpdatingProviderId(provider.instanceId);
		1296	try {
		1297	await ensureLocalApi().server.updateProvider({
		1298	provider: provider.driver,
		1299	instanceId: provider.instanceId,
		1300	targetVersion,
		1301	});
		1302	} catch (error) {
		1303	toastManager.add(
		1304	stackedThreadToast({
		1305	type: "error",
		1306	title: `Could not update ${provider.displayName ?? provider.driver}`,
		1307	description:
		1308	error instanceof Error
		1309	? error.message
		1310	: "The provider update command could not be started.",
		1311	}),
		1312	);
		1313	} finally {
		1314	setCompatibilityUpdatingProviderId((current) =>
		1315	current === provider.instanceId ? null : current,
		1316	);
		1317	}
		1318	}, [activeProviderStatus]);
1181	const composerBannerItems = useMemo<ComposerBannerStackItem[]>(() => {	1319	const composerBannerItems = useMemo<ComposerBannerStackItem[]>(() => {
1182	const items: ComposerBannerStackItem[] = [];	1320	const items: ComposerBannerStackItem[] = [];
		1321	if (
		1322	activeProviderStatus &&
		1323	activeProviderStatus.status !== "ready" &&
		1324	activeProviderStatus.status !== "disabled"
		1325	) {
		1326	const defaultMessage =
		1327	activeProviderStatus.status === "error"
		1328	? "Provider is unavailable."
		1329	: "Provider needs attention.";
		1330	const recommendedVersion =
		1331	activeProviderStatus.compatibilityAdvisory?.recommendedVersion ?? null;
		1332	const compatibilityUpdateCommand =
		1333	getProviderCompatibilityUpdateCommand(activeProviderStatus);
		1334	const canRunCompatibilityUpdate = canRunProviderCompatibilityUpdate(activeProviderStatus);
		1335	const compatibilityUpdating =
		1336	compatibilityUpdatingProviderId === activeProviderStatus.instanceId;
		1337	const hasCompatibilityInstallAction =
		1338	activeProviderStatus.compatibilityAdvisory?.status !== "supported" &&
		1339	recommendedVersion !== null &&
		1340	(canRunCompatibilityUpdate \|\| compatibilityUpdateCommand !== null);
		1341	const rawMessage = activeProviderStatus.message ?? defaultMessage;
		1342	const message = hasCompatibilityInstallAction
		1343	? stripProviderCompatibilityInstallHint(rawMessage, recommendedVersion)
		1344	: rawMessage;
		1345	const providerLabel = activeProviderStatus.displayName ?? activeProviderStatus.driver;
		1346	items.push({
		1347	id: `provider-status:${activeProviderStatus.instanceId}:${activeProviderStatus.status}`,
		1348	variant: activeProviderStatus.status === "error" ? "error" : "warning",
		1349	icon: <CircleAlertIcon />,
		1350	title: `${providerLabel} provider status`,
		1351	description: (
		1352	<span className="line-clamp-3" title={message}>
		1353	{message}
		1354	</span>
		1355	),
		1356	actions:
		1357	hasCompatibilityInstallAction && recommendedVersion ? (
		1358	<ProviderCompatibilityBannerAction
		1359	providerLabel={providerLabel}
		1360	recommendedVersion={recommendedVersion}
		1361	updateCommand={compatibilityUpdateCommand}
		1362	canRunUpdate={canRunCompatibilityUpdate}
		1363	updating={compatibilityUpdating}
		1364	onRunUpdate={() => void runActiveProviderCompatibilityUpdate()}
		1365	/>
		1366	) : undefined,
		1367	});
		1368	}
1183	if (activeEnvironmentUnavailableState) {	1369	if (activeEnvironmentUnavailableState) {
1184	items.push({	1370	items.push({
1185	id: `environment-unavailable:${activeEnvironmentUnavailableState.environmentId}`,	1371	id: `environment-unavailable:${activeEnvironmentUnavailableState.environmentId}`,
@@ -1248,20 +1434,17 @@ export default function ChatView(props: ChatViewProps) { · 62 unmodified lines
1248	return items;	1434	return items;
1249	}, [	1435	}, [
1250	activeEnvironmentUnavailableState,	1436	activeEnvironmentUnavailableState,
		1437	activeProviderStatus,
		1438	compatibilityUpdatingProviderId,
1251	handleReconnectActiveEnvironment,	1439	handleReconnectActiveEnvironment,
1252	navigate,	1440	navigate,
1253	reconnectingEnvironmentId,	1441	reconnectingEnvironmentId,
		1442	runActiveProviderCompatibilityUpdate,
1254	showVersionMismatchBanner,	1443	showVersionMismatchBanner,
1255	versionMismatch,	1444	versionMismatch,
1256	versionMismatchDismissKey,	1445	versionMismatchDismissKey,
1257	versionMismatchServerLabel,	1446	versionMismatchServerLabel,
1258	]);	1447	]);
1259	const providerStatuses = serverConfig?.providers ?? EMPTY_PROVIDERS;
1260	const unlockedSelectedProvider = resolveSelectableProvider(
1261	providerStatuses,
1262	selectedProviderByThreadId ?? threadProvider ?? ProviderDriverKind.make("codex"),
1263	);
1264	const selectedProvider: ProviderDriverKind = lockedProvider ?? unlockedSelectedProvider;
1265	const phase = derivePhase(activeThread?.session ?? null);	1448	const phase = derivePhase(activeThread?.session ?? null);
1266	const threadActivities = activeThread?.activities ?? EMPTY_ACTIVITIES;	1449	const threadActivities = activeThread?.activities ?? EMPTY_ACTIVITIES;
1267	const workLogEntries = useMemo(	1450	const workLogEntries = useMemo(
@@ -1633,24 +1816,6 @@ export default function ChatView(props: ChatViewProps) { · 365 unmodified lines
1633	const gitStatusQuery = useGitStatus({ environmentId, cwd: gitCwd });	1816	const gitStatusQuery = useGitStatus({ environmentId, cwd: gitCwd });
1634	const keybindings = useServerKeybindings();	1817	const keybindings = useServerKeybindings();
1635	const availableEditors = useServerAvailableEditors();	1818	const availableEditors = useServerAvailableEditors();
1636	// Prefer an instance-id match so a custom Codex instance (e.g.
1637	// `codex_personal`) surfaces its own status/message in the banner rather
1638	// than the default Codex's. Falls back to first-match-by-kind when no
1639	// saved instance id is available or the instance no longer exists.
1640	const activeProviderInstanceId =
1641	activeThread?.session?.providerInstanceId ??
1642	activeThread?.modelSelection.instanceId ??
1643	activeProject?.defaultModelSelection?.instanceId ??
1644	null;
1645	const activeProviderStatus = useMemo(() => {
1646	if (activeProviderInstanceId) {
1647	return (
1648	providerStatuses.find((status) => status.instanceId === activeProviderInstanceId) ?? null
1649	);
1650	}
1651	const defaultInstanceId = defaultInstanceIdForDriver(selectedProvider);
1652	return providerStatuses.find((status) => status.instanceId === defaultInstanceId) ?? null;
1653	}, [activeProviderInstanceId, providerStatuses, selectedProvider]);
1654	const activeProjectCwd = activeProject?.cwd ?? null;	1819	const activeProjectCwd = activeProject?.cwd ?? null;
1655	const activeThreadWorktreePath = activeThread?.worktreePath ?? null;	1820	const activeThreadWorktreePath = activeThread?.worktreePath ?? null;
1656	const activeWorkspaceRoot = activeThreadWorktreePath ?? activeProjectCwd ?? undefined;	1821	const activeWorkspaceRoot = activeThreadWorktreePath ?? activeProjectCwd ?? undefined;
@@ -3540,8 +3705,6 @@ export default function ChatView(props: ChatViewProps) { · 1883 unmodified lines
3540	/>	3705	/>
3541	</header>	3706	</header>
3542		3707
3543	{/* Error banner */}
3544	<ProviderStatusBanner status={activeProviderStatus} />
3545	<ThreadErrorBanner	3708	<ThreadErrorBanner
3546	error={activeThread.error}	3709	error={activeThread.error}
3547	onDismiss={() => setThreadError(activeThread.id, null)}	3710	onDismiss={() => setThreadError(activeThread.id, null)}

apps/web/src/components/chat/ChatComposer.tsx+31−5

   isSendBusy: boolean;
   isConnecting: boolean;
   isEnvironmentUnavailable: boolean;
+  isProviderUnavailable: boolean;
   hasSendableContent: boolean;
   preserveComposerFocusOnPointerDown?: boolean;
   onPreviousPendingQuestion: () => void;
         isSendBusy={props.isSendBusy}
         isConnecting={props.isConnecting}
         isEnvironmentUnavailable={props.isEnvironmentUnavailable}
+        isProviderUnavailable={props.isProviderUnavailable}
         isPreparingWorktree={props.isPreparingWorktree}
         hasSendableContent={props.hasSendableContent}
         preserveComposerFocusOnPointerDown={props.preserveComposerFocusOnPointerDown ?? false}
       () => selectedProviderEntry?.snapshot ?? null,
       [selectedProviderEntry],
     );
+    const selectedProviderUnavailableMessage =
+      selectedProviderStatus?.status === "error"
+        ? (selectedProviderStatus.message ?? "Selected provider is unavailable.")
+        : null;
+    const isSelectedProviderUnavailable = selectedProviderUnavailableMessage !== null;
     const selectedProviderModels = useMemo<ReadonlyArray<ServerProvider["models"][number]>>(
       () => selectedProviderEntry?.models ?? [],
       [selectedProviderEntry],
       [activePendingIsResponding, activePendingProgress, activePendingResolvedAnswers],
     );
     const collapsedComposerPrimaryActionDisabled =
-      phase === "running" || isSendBusy || isConnecting || !composerSendState.hasSendableContent;
+      phase === "running" ||
+      isSendBusy ||
+      isConnecting ||
+      isSelectedProviderUnavailable ||
+      !composerSendState.hasSendableContent;
     const collapsedComposerPrimaryActionLabel = "Send message";
     const showMobilePendingAnswerActions =
       isMobileViewport && !isComposerCollapsedMobile && pendingPrimaryAction !== null;
     const submitComposer = useCallback(
       (event?: { preventDefault: () => void }) => {
+        if (isSelectedProviderUnavailable) {
+          event?.preventDefault();
+          return;
+        }
         onSend(event);
         if (shouldBlurMobileComposerOnSubmit()) {
           blurMobileComposerAfterSend();
         }
       },
-      [blurMobileComposerAfterSend, onSend, shouldBlurMobileComposerOnSubmit],
+      [
+        blurMobileComposerAfterSend,
+        isSelectedProviderUnavailable,
+        onSend,
+        shouldBlurMobileComposerOnSubmit,
+      ],
     );
     const expandMobileComposer = useCallback(() => {
       if (composerBlurFrameRef.current !== null) {
                         isSendBusy={isSendBusy}
                         isConnecting={isConnecting}
                         isEnvironmentUnavailable={environmentUnavailable !== null}
+                        isProviderUnavailable={isSelectedProviderUnavailable}
                         isPreparingWorktree={false}
                         hasSendableContent={false}
                         preserveComposerFocusOnPointerDown
                                   ? "connecting"
                                   : "disconnected"
                               }`
-                            : phase === "disconnected"
+                            : selectedProviderUnavailableMessage
-                              ? "Ask for follow-up changes or attach images"
+                              ? selectedProviderUnavailableMessage
-                              : "Ask anything, @tag files/folders, $use skills, or / for commands"
+                              : phase === "disconnected"
+                                ? "Ask for follow-up changes or attach images"
+                                : "Ask anything, @tag files/folders, $use skills, or / for commands"
                   }
                   disabled={
                     isConnecting ||
+                    isSelectedProviderUnavailable ||
                     isComposerApprovalState ||
                     (environmentUnavailable !== null && activePendingProgress === null)
                   }
                       isSendBusy={isSendBusy}
                       isConnecting={isConnecting}
                       isEnvironmentUnavailable={environmentUnavailable !== null}
+                      isProviderUnavailable={isSelectedProviderUnavailable}
                       isPreparingWorktree={false}
                       hasSendableContent={false}
                       preserveComposerFocusOnPointerDown
                     isSendBusy={isSendBusy}
                     isConnecting={isConnecting}
                     isEnvironmentUnavailable={environmentUnavailable !== null}
+                    isProviderUnavailable={isSelectedProviderUnavailable}
                     isPreparingWorktree={isPreparingWorktree}
                     hasSendableContent={composerSendState.hasSendableContent}
                     preserveComposerFocusOnPointerDown={isMobileViewport}

apps/web/src/components/chat/ComposerPrimaryActions.tsx+29−14

   isSendBusy: boolean;
   isConnecting: boolean;
   isEnvironmentUnavailable: boolean;
+  isProviderUnavailable: boolean;
   isPreparingWorktree: boolean;
   hasSendableContent: boolean;
   preserveComposerFocusOnPointerDown?: boolean;
   isSendBusy,
   isConnecting,
   isEnvironmentUnavailable,
+  isProviderUnavailable,
   isPreparingWorktree,
   hasSendableContent,
   preserveComposerFocusOnPointerDown = false,
           {...pointerFocusProps}
           disabled={
             isEnvironmentUnavailable ||
+            isProviderUnavailable ||
             pendingAction.isResponding ||
             (pendingAction.isLastQuestion ? !pendingAction.isComplete : !pendingAction.canAdvance)
           }
           size="sm"
           className={cn("rounded-full", compact ? "h-9 px-3 sm:h-8" : "h-9 px-4 sm:h-8")}
           {...pointerFocusProps}
-          disabled={isSendBusy || isConnecting || isEnvironmentUnavailable}
+          disabled={isSendBusy || isConnecting || isEnvironmentUnavailable || isProviderUnavailable}
         >
           {isConnecting || isSendBusy ? "Sending..." : "Refine"}
         </Button>
           size="sm"
           className="h-9 rounded-l-full rounded-r-none px-4 sm:h-8"
           {...pointerFocusProps}
-          disabled={isSendBusy || isConnecting || isEnvironmentUnavailable}
+          disabled={isSendBusy || isConnecting || isEnvironmentUnavailable || isProviderUnavailable}
         >
           {isConnecting || isSendBusy ? "Sending..." : "Implement"}
         </Button>
                 className="h-9 rounded-l-none rounded-r-full border-l-white/12 px-2 sm:h-8"
                 aria-label="Implementation actions"
                 {...pointerFocusProps}
-                disabled={isSendBusy || isConnecting || isEnvironmentUnavailable}
+                disabled={
+                  isSendBusy || isConnecting || isEnvironmentUnavailable || isProviderUnavailable
+                }
               />
             }
           >
           </MenuTrigger>
           <MenuPopup align="end" side="top">
             <MenuItem
-              disabled={isSendBusy || isConnecting || isEnvironmentUnavailable}
+              disabled={
+                isSendBusy || isConnecting || isEnvironmentUnavailable || isProviderUnavailable
+              }
               onClick={() => void onImplementPlanInNewThread()}
             >
               Implement in a new thread
       type="submit"
       className="flex h-9 w-9 enabled:cursor-pointer items-center justify-center rounded-full bg-primary/90 text-primary-foreground transition-all duration-150 hover:bg-primary hover:scale-105 disabled:pointer-events-none disabled:opacity-30 disabled:hover:scale-100 sm:h-8 sm:w-8"
       {...pointerFocusProps}
-      disabled={isSendBusy || isConnecting || isEnvironmentUnavailable || !hasSendableContent}
+      disabled={
+        isSendBusy ||
+        isConnecting ||
+        isEnvironmentUnavailable ||
+        isProviderUnavailable ||
+        !hasSendableContent
+      }
       aria-label={
-        isEnvironmentUnavailable
+        isProviderUnavailable
-          ? "Environment disconnected"
+          ? "Provider unavailable"
-          : isConnecting
+          : isEnvironmentUnavailable
-            ? "Connecting"
+            ? "Environment disconnected"
-            : isPreparingWorktree
+            : isConnecting
-              ? "Preparing worktree"
+              ? "Connecting"
-              : isSendBusy
+              : isPreparingWorktree
-                ? "Sending"
+                ? "Preparing worktree"
-                : "Send message"
+                : isSendBusy
+                  ? "Sending"
+                  : "Send message"
       }
     >
       {isConnecting || isSendBusy ? (

apps/web/src/components/chat/ProviderStatusBanner.tsx+0−34

@@ -1,34 +0,0 @@
1	import { type ServerProvider } from "@t3tools/contracts";
2	import { memo } from "react";
3	import { Alert, AlertDescription, AlertTitle } from "../ui/alert";
4	import { CircleAlertIcon } from "lucide-react";
5	import { formatProviderDriverKindLabel } from "../../providerModels";
6
7	export const ProviderStatusBanner = memo(function ProviderStatusBanner({
8	status,
9	}: {
10	status: ServerProvider \| null;
11	}) {
12	if (!status \|\| status.status === "ready" \|\| status.status === "disabled") {
13	return null;
14	}
15
16	const providerLabel = status.displayName?.trim() \|\| formatProviderDriverKindLabel(status.driver);
17	const defaultMessage =
18	status.status === "error"
19	? `${providerLabel} provider is unavailable.`
20	: `${providerLabel} provider has limited availability.`;
21	const title = `${providerLabel} provider status`;
22
23	return (
24	<div className="pt-3 mx-auto max-w-3xl">
25	<Alert variant={status.status === "error" ? "error" : "warning"}>
26	<CircleAlertIcon />
27	<AlertTitle>{title}</AlertTitle>
28	<AlertDescription className="line-clamp-3" title={status.message ?? defaultMessage}>
29	{status.message ?? defaultMessage}
30	</AlertDescription>
31	</Alert>
32	</div>
33	);
34	});

apps/web/src/components/chat/ThreadErrorBanner.tsx+3−2

 import { memo } from "react";
-import { Alert, AlertAction, AlertDescription } from "../ui/alert";
 import { CircleAlertIcon, XIcon } from "lucide-react";
+import { Alert, AlertAction, AlertDescription } from "../ui/alert";
 export const ThreadErrorBanner = memo(function ThreadErrorBanner({
   error,
   onDismiss,
 }) {
   if (!error) return null;
   return (
-    <div className="pt-3 mx-auto max-w-3xl">
+    <div className="mx-auto max-w-3xl pt-3">
       <Alert variant="error">
         <CircleAlertIcon />
         <AlertDescription className="line-clamp-3" title={error}>

apps/web/src/components/settings/ProviderInstanceCard.tsx+203−128

@@ -39,6 +39,7 @@ import { ProviderModelsSection } from "./ProviderModelsSection"; · 38 unmodified lines
39	import { ProviderInstanceIcon } from "../chat/ProviderInstanceIcon";	39	import { ProviderInstanceIcon } from "../chat/ProviderInstanceIcon";
40	import { RedactedSensitiveText } from "./RedactedSensitiveText";	40	import { RedactedSensitiveText } from "./RedactedSensitiveText";
41	import {	41	import {
		42	getProviderCompatibilityUpdateCommand,
42	getProviderVersionAdvisoryPresentation,	43	getProviderVersionAdvisoryPresentation,
43	PROVIDER_STATUS_STYLES,	44	PROVIDER_STATUS_STYLES,
44	getProviderCompatibilityAdvisoryPresentation,	45	getProviderCompatibilityAdvisoryPresentation,
@@ -57,6 +58,8 @@ const PROVIDER_ACCENT_SWATCHES = [ · 12 unmodified lines
57	] as const;	58	] as const;
58		59
59	const ENVIRONMENT_VARIABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;	60	const ENVIRONMENT_VARIABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
		61	const ADVISORY_ICON_CLUSTER_CLASS = "-my-0.5 inline-flex h-5 shrink-0 items-center gap-2";
		62	const ADVISORY_ICON_SLOT_CLASS = "inline-flex size-5 shrink-0 items-center justify-center";
60		63
61	let environmentVariableDraftId = 0;	64	let environmentVariableDraftId = 0;
62	const nextEnvironmentVariableDraftId = () => `provider-env-${environmentVariableDraftId++}`;	65	const nextEnvironmentVariableDraftId = () => `provider-env-${environmentVariableDraftId++}`;
@@ -422,6 +425,8 @@ interface ProviderInstanceCardProps { · 359 unmodified lines
422	readonly onModelOrderChange: (next: ReadonlyArray<string>) => void;	425	readonly onModelOrderChange: (next: ReadonlyArray<string>) => void;
423	readonly onRunUpdate?: (() => void) \| undefined;	426	readonly onRunUpdate?: (() => void) \| undefined;
424	readonly isUpdating?: boolean \| undefined;	427	readonly isUpdating?: boolean \| undefined;
		428	readonly onRunCompatibilityUpdate?: (() => void) \| undefined;
		429	readonly isCompatibilityUpdating?: boolean \| undefined;
425	}	430	}
426		431
427	/**	432	/**
@@ -466,6 +471,8 @@ export function ProviderInstanceCard({ · 38 unmodified lines
466	onModelOrderChange,	471	onModelOrderChange,
467	onRunUpdate,	472	onRunUpdate,
468	isUpdating = false,	473	isUpdating = false,
		474	onRunCompatibilityUpdate,
		475	isCompatibilityUpdating = false,
469	}: ProviderInstanceCardProps) {	476	}: ProviderInstanceCardProps) {
470	const enabled = instance.enabled ?? true;	477	const enabled = instance.enabled ?? true;
471	// The server-reported status wins when present; otherwise fall back to	478	// The server-reported status wins when present; otherwise fall back to
@@ -487,7 +494,9 @@ export function ProviderInstanceCard({ · 15 unmodified lines
487	liveProvider?.compatibilityAdvisory,	494	liveProvider?.compatibilityAdvisory,
488	);	495	);
489	const versionAdvisory = getProviderVersionAdvisoryPresentation(liveProvider?.versionAdvisory);	496	const versionAdvisory = getProviderVersionAdvisoryPresentation(liveProvider?.versionAdvisory);
		497	const hasProviderAdvisoryIcons = compatibilityAdvisory !== null \|\| versionAdvisory !== null;
490	const updateCommand = versionAdvisory?.updateCommand ?? null;	498	const updateCommand = versionAdvisory?.updateCommand ?? null;
		499	const compatibilityUpdateCommand = getProviderCompatibilityUpdateCommand(liveProvider);
491	const FallbackIconComponent = driverOption?.icon;	500	const FallbackIconComponent = driverOption?.icon;
492	const displayName =	501	const displayName =
493	instance.displayName?.trim() \|\| driverOption?.label \|\| String(instance.driver);	502	instance.displayName?.trim() \|\| driverOption?.label \|\| String(instance.driver);
@@ -681,134 +690,200 @@ export function ProviderInstanceCard({ · 187 unmodified lines
681	<div className="min-w-0 flex-1 space-y-1">	690	<div className="min-w-0 flex-1 space-y-1">
682	<div className="flex min-w-0 flex-wrap items-center gap-2">	691	<div className="flex min-w-0 flex-wrap items-center gap-2">
683	{titleHeadNode}	692	{titleHeadNode}
684	{versionCodeNode}	693	{versionCodeNode \|\| hasProviderAdvisoryIcons ? (
685	{compatibilityAdvisory ? (	694	<span className={ADVISORY_ICON_CLUSTER_CLASS}>
686	<Popover>	695	{versionCodeNode}
687	<PopoverTrigger	696	{compatibilityAdvisory ? (
688	render={	697	<span className={ADVISORY_ICON_SLOT_CLASS}>
689	<Button	698	<Popover>
690	type="button"	699	<PopoverTrigger
691	size="icon-xs"	700	render={
692	variant="ghost"	701	<Button
693	className={cn(	702	type="button"
694	"size-5 rounded-sm p-0",	703	size="icon-xs"
695	compatibilityAdvisory.emphasis === "strong"	704	variant="ghost"
696	? "text-destructive hover:text-destructive"	705	className={cn(
697	: "text-warning hover:text-warning",	706	"size-5 rounded-sm p-0",
698	)}	707	compatibilityAdvisory.emphasis === "strong"
699	aria-label={`${compatibilityAdvisory.title} — view details`}	708	? "text-destructive hover:text-destructive"
700	>	709	: "text-warning hover:text-warning",
701	<AlertTriangleIcon className="size-3.5" />	710	)}
702	</Button>	711	aria-label={`${compatibilityAdvisory.title} — view details`}
703	}	712	>
704	/>	713	<AlertTriangleIcon className="size-3.5" />
705	<PopoverPopup side="bottom" align="start" className="w-84">	714	</Button>
706	<div className="grid gap-1">	715	}
707	<p className="text-[13px] font-semibold leading-tight text-foreground">	716	/>
708	{compatibilityAdvisory.title}	717	<PopoverPopup side="bottom" align="start" className="w-84">
709	</p>	718	<div className="grid gap-3">
710	<p	719	<div className="grid gap-0.5">
711	className={cn(	720	<p className="text-[13px] font-semibold leading-tight text-foreground">
712	"text-xs leading-snug",	721	{compatibilityAdvisory.title}
713	compatibilityAdvisory.emphasis === "strong"	722	</p>
714	? "text-destructive"	723	<p
715	: "text-warning",	724	className={cn(
716	)}	725	"text-xs leading-snug",
717	>	726	compatibilityAdvisory.emphasis === "strong"
718	{compatibilityAdvisory.detail}	727	? "text-destructive"
719	</p>	728	: "text-warning",
720	</div>	729	)}
721	</PopoverPopup>	730	>
722	</Popover>	731	{compatibilityAdvisory.detail}
723	) : null}	732	</p>
724	{versionAdvisory ? (	733	</div>
725	<Popover>	734	{onRunCompatibilityUpdate ? (
726	<PopoverTrigger	735	<Button
727	render={	736	type="button"
728	<Button	737	size="xs"
729	type="button"	738	variant="default"
730	size="icon-xs"	739	className="w-full"
731	variant="ghost"	740	disabled={isCompatibilityUpdating}
732	className={cn(	741	onClick={onRunCompatibilityUpdate}
733	"size-5 rounded-sm p-0",	742	>
734	versionAdvisory.emphasis === "strong"	743	{isCompatibilityUpdating ? (
735	? "text-warning hover:text-warning"	744	<LoaderIcon className="animate-spin" />
736	: "text-primary hover:text-primary",	745	) : (
737	)}	746	<DownloadIcon />
738	aria-label="Update available — view details"	747	)}
739	>	748	{isCompatibilityUpdating ? "Updating" : "Update now"}
740	<ArrowUpCircleIcon className="size-3.5 [animation:bounce_2.4s_ease-in-out_infinite] motion-reduce:animate-none" />	749	</Button>
741	</Button>	750	) : null}
742	}	751	{onRunCompatibilityUpdate && compatibilityUpdateCommand ? (
743	/>	752	<div className="flex items-center gap-2 text-[10px] font-medium uppercase tracking-wider text-muted-foreground">
744	<PopoverPopup side="bottom" align="start" className="w-84">	753	<span aria-hidden className="h-px flex-1 bg-border" />
745	<div className="grid gap-3">	754	or, update manually using
746	<div className="grid gap-0.5">	755	<span aria-hidden className="h-px flex-1 bg-border" />
747	<p className="text-[13px] font-semibold leading-tight text-foreground">	756	</div>
748	Update available	757	) : null}
749	</p>	758	{compatibilityUpdateCommand ? (
750	<p	759	<div className="flex items-center gap-1 rounded-md border border-border/70 bg-muted/40 py-0.5 pr-0.5 pl-2">
751	className={cn(	760	<code className="min-w-0 flex-1 overflow-x-auto whitespace-nowrap font-mono text-[11px] text-foreground [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
752	"text-xs leading-snug",	761	{compatibilityUpdateCommand}
753	versionAdvisory.emphasis === "strong"	762	</code>
754	? "text-warning"	763	<Tooltip>
755	: "text-muted-foreground",	764	<TooltipTrigger
756	)}	765	render={
757	>	766	<Button
758	{versionAdvisory.detail}	767	type="button"
759	</p>	768	size="icon-xs"
760	</div>	769	variant="ghost"
761	{onRunUpdate ? (	770	className="size-6 shrink-0 rounded-sm p-0 text-muted-foreground hover:text-foreground"
762	<Button	771	onClick={() =>
763	type="button"	772	copyToClipboard(compatibilityUpdateCommand, {
764	size="xs"	773	providerName: displayName,
765	variant="default"	774	})
766	className="w-full"	775	}
767	disabled={isUpdating}	776	aria-label="Copy compatibility update command"
768	onClick={onRunUpdate}	777	>
769	>	778	<CopyIcon className="size-3" />
770	{isUpdating ? <LoaderIcon className="animate-spin" /> : <DownloadIcon />}	779	</Button>
771	{isUpdating ? "Updating" : "Update now"}	780	}
772	</Button>	781	/>
773	) : null}	782	<TooltipPopup side="top">Copy command</TooltipPopup>
774	{onRunUpdate && updateCommand ? (	783	</Tooltip>
775	<div className="flex items-center gap-2 text-[10px] font-medium uppercase tracking-wider text-muted-foreground">	784	</div>
776	<span aria-hidden className="h-px flex-1 bg-border" />	785	) : null}
777	or, update manually using	786	</div>
778	<span aria-hidden className="h-px flex-1 bg-border" />	787	</PopoverPopup>
779	</div>	788	</Popover>
780	) : null}	789	</span>
781	{updateCommand ? (	790	) : null}
782	<div className="flex items-center gap-1 rounded-md border border-border/70 bg-muted/40 py-0.5 pr-0.5 pl-2">	791	{versionAdvisory ? (
783	<code className="min-w-0 flex-1 overflow-x-auto whitespace-nowrap font-mono text-[11px] text-foreground [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">	792	<span className={ADVISORY_ICON_SLOT_CLASS}>
784	{updateCommand}	793	<Popover>
785	</code>	794	<PopoverTrigger
786	<Tooltip>	795	render={
787	<TooltipTrigger	796	<Button
788	render={	797	type="button"
789	<Button	798	size="icon-xs"
790	type="button"	799	variant="ghost"
791	size="icon-xs"	800	className={cn(
792	variant="ghost"	801	"size-5 rounded-sm p-0",
793	className="size-6 shrink-0 rounded-sm p-0 text-muted-foreground hover:text-foreground"	802	versionAdvisory.emphasis === "strong"
794	onClick={() =>	803	? "text-warning hover:text-warning"
795	copyToClipboard(updateCommand, {	804	: "text-primary hover:text-primary",
796	providerName: displayName,	805	)}
797	})	806	aria-label="Update available — view details"
798	}	807	>
799	aria-label="Copy update command"	808	<ArrowUpCircleIcon className="size-3.5 [animation:bounce_2.4s_ease-in-out_infinite] motion-reduce:animate-none" />
800	>	809	</Button>
801	<CopyIcon className="size-3" />	810	}
802	</Button>	811	/>
803	}	812	<PopoverPopup side="bottom" align="start" className="w-84">
804	/>	813	<div className="grid gap-3">
805	<TooltipPopup side="top">Copy command</TooltipPopup>	814	<div className="grid gap-0.5">
806	</Tooltip>	815	<p className="text-[13px] font-semibold leading-tight text-foreground">
807	</div>	816	Update available
808	) : null}	817	</p>
809	</div>	818	<p
810	</PopoverPopup>	819	className={cn(
811	</Popover>	820	"text-xs leading-snug",
		821	versionAdvisory.emphasis === "strong"
		822	? "text-warning"
		823	: "text-muted-foreground",
		824	)}
		825	>
		826	{versionAdvisory.detail}
		827	</p>
		828	</div>
		829	{onRunUpdate ? (
		830	<Button
		831	type="button"
		832	size="xs"
		833	variant="default"
		834	className="w-full"
		835	disabled={isUpdating}
		836	onClick={onRunUpdate}
		837	>
		838	{isUpdating ? (
		839	<LoaderIcon className="animate-spin" />
		840	) : (
		841	<DownloadIcon />
		842	)}
		843	{isUpdating ? "Updating" : "Update now"}
		844	</Button>
		845	) : null}
		846	{onRunUpdate && updateCommand ? (
		847	<div className="flex items-center gap-2 text-[10px] font-medium uppercase tracking-wider text-muted-foreground">
		848	<span aria-hidden className="h-px flex-1 bg-border" />
		849	or, update manually using
		850	<span aria-hidden className="h-px flex-1 bg-border" />
		851	</div>
		852	) : null}
		853	{updateCommand ? (
		854	<div className="flex items-center gap-1 rounded-md border border-border/70 bg-muted/40 py-0.5 pr-0.5 pl-2">
		855	<code className="min-w-0 flex-1 overflow-x-auto whitespace-nowrap font-mono text-[11px] text-foreground [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
		856	{updateCommand}
		857	</code>
		858	<Tooltip>
		859	<TooltipTrigger
		860	render={
		861	<Button
		862	type="button"
		863	size="icon-xs"
		864	variant="ghost"
		865	className="size-6 shrink-0 rounded-sm p-0 text-muted-foreground hover:text-foreground"
		866	onClick={() =>
		867	copyToClipboard(updateCommand, {
		868	providerName: displayName,
		869	})
		870	}
		871	aria-label="Copy update command"
		872	>
		873	<CopyIcon className="size-3" />
		874	</Button>
		875	}
		876	/>
		877	<TooltipPopup side="top">Copy command</TooltipPopup>
		878	</Tooltip>
		879	</div>
		880	) : null}
		881	</div>
		882	</PopoverPopup>
		883	</Popover>
		884	</span>
		885	) : null}
		886	</span>
812	) : null}	887	) : null}
813	{titleTailNode}	888	{titleTailNode}
814	</div>	889	</div>

apps/web/src/components/settings/SettingsPanels.browser.tsx+58−1

@@ -255,7 +255,7 @@ function createOutdatedProvider(driver: string): ServerProvider { · 254 unmodified lines
255	latestVersion: "1.1.0",	255	latestVersion: "1.1.0",
256	message: "Update available.",	256	message: "Update available.",
257	checkedAt: "2026-05-04T10:00:00.000Z",	257	checkedAt: "2026-05-04T10:00:00.000Z",
258	updateCommand: "npm install -g openai/codex@latest",	258	updateCommand: "npm install -g @openai/codex@latest",
259	canUpdate: true,	259	canUpdate: true,
260	},	260	},
261	};	261	};
@@ -1155,6 +1155,63 @@ describe("GeneralSettingsPanel observability", () => { · 893 unmodified lines
1155	instanceId: ProviderInstanceId.make("codex"),	1155	instanceId: ProviderInstanceId.make("codex"),
1156	});	1156	});
1157	});	1157	});
		1158
		1159	it("runs targeted compatibility updates from the provider card", async () => {
		1160	const updateProvider = vi.fn<LocalApi["server"]["updateProvider"]>().mockResolvedValue({
		1161	providers: [],
		1162	});
		1163	window.nativeApi = {
		1164	persistence: {
		1165	getClientSettings: vi.fn().mockResolvedValue(null),
		1166	setClientSettings: vi.fn().mockResolvedValue(undefined),
		1167	},
		1168	server: {
		1169	updateProvider,
		1170	},
		1171	} as unknown as LocalApi;
		1172	const incompatibleProvider: ServerProvider = {
		1173	...createOutdatedProvider("codex"),
		1174	version: "0.128.0",
		1175	status: "error",
		1176	message:
		1177	"This provider harness version 0.128.0 is known to be incompatible with this T3 Code release. Use 0.129.0.",
		1178	compatibilityAdvisory: {
		1179	status: "broken",
		1180	severity: "error",
		1181	currentVersion: "0.128.0",
		1182	message:
		1183	"This provider harness version 0.128.0 is known to be incompatible with this T3 Code release. Use 0.129.0.",
		1184	recommendedRange: ">=0.129.0",
		1185	recommendedVersion: "0.129.0",
		1186	ranges: [{ status: "broken", range: "<0.129.0" }],
		1187	},
		1188	};
		1189
		1190	setServerConfigSnapshot({
		1191	...createBaseServerConfig(),
		1192	providers: [incompatibleProvider],
		1193	});
		1194
		1195	mounted = await render(
		1196	<AppAtomRegistryProvider>
		1197	<ProviderSettingsPanel />
		1198	</AppAtomRegistryProvider>,
		1199	);
		1200
		1201	await page
		1202	.getByRole("button", { name: "Incompatible provider version — view details" })
		1203	.click();
		1204	await expect
		1205	.element(page.getByText("npm install -g @openai/codex@0.129.0"))
		1206	.toBeInTheDocument();
		1207	await page.getByRole("button", { name: "Update now" }).click();
		1208
		1209	expect(updateProvider).toHaveBeenCalledWith({
		1210	provider: ProviderDriverKind.make("codex"),
		1211	instanceId: ProviderInstanceId.make("codex"),
		1212	targetVersion: "0.129.0",
		1213	});
		1214	});
1158	});	1215	});
1159		1216
1160	describe("SourceControlSettingsPanel discovery states", () => {	1217	describe("SourceControlSettingsPanel discovery states", () => {

apps/web/src/components/settings/SettingsPanels.tsx+83−0

@@ -10,6 +10,7 @@ import { · 9 unmodified lines
10	type ProviderInstanceConfig,	10	type ProviderInstanceConfig,
11	type ProviderInstanceId,	11	type ProviderInstanceId,
12	type ScopedThreadRef,	12	type ScopedThreadRef,
		13	type ServerProvider,
13	} from "@t3tools/contracts";	14	} from "@t3tools/contracts";
14	import { scopeThreadRef } from "@t3tools/client-runtime";	15	import { scopeThreadRef } from "@t3tools/client-runtime";
15	import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";	16	import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";
@@ -63,6 +64,10 @@ import { · 47 unmodified lines
63	type ProviderUpdateCandidate,	64	type ProviderUpdateCandidate,
64	} from "../ProviderUpdateLaunchNotification.logic";	65	} from "../ProviderUpdateLaunchNotification.logic";
65	import { ProviderInstanceCard } from "./ProviderInstanceCard";	66	import { ProviderInstanceCard } from "./ProviderInstanceCard";
		67	import {
		68	canRunProviderCompatibilityUpdate,
		69	getProviderCompatibilityUpdateCommand,
		70	} from "./providerStatus";
66	import { DRIVER_OPTIONS, getDriverOption } from "./providerDriverMeta";	71	import { DRIVER_OPTIONS, getDriverOption } from "./providerDriverMeta";
67	import {	72	import {
68	buildProviderInstanceUpdatePatch,	73	buildProviderInstanceUpdatePatch,
@@ -1010,6 +1015,55 @@ export function ProviderSettingsPanel() { · 941 unmodified lines
1010	}	1015	}
1011	}, []);	1016	}, []);
1012		1017
		1018	const runProviderCompatibilityUpdate = useCallback(async (provider: ServerProvider) => {
		1019	const targetVersion = provider.compatibilityAdvisory?.recommendedVersion ?? null;
		1020	if (!targetVersion) {
		1021	return;
		1022	}
		1023
		1024	let started = false;
		1025	setUpdatingProviderDrivers((previous) => {
		1026	if (previous.has(provider.driver)) {
		1027	return previous;
		1028	}
		1029	started = true;
		1030	const next = new Set(previous);
		1031	next.add(provider.driver);
		1032	return next;
		1033	});
		1034	if (!started) {
		1035	return;
		1036	}
		1037
		1038	try {
		1039	await ensureLocalApi().server.updateProvider({
		1040	provider: provider.driver,
		1041	instanceId: provider.instanceId,
		1042	targetVersion,
		1043	});
		1044	} catch (error) {
		1045	toastManager.add(
		1046	stackedThreadToast({
		1047	type: "error",
		1048	title: `Could not update ${PROVIDER_DISPLAY_NAMES[provider.driver] ?? provider.driver}`,
		1049	description:
		1050	error instanceof Error
		1051	? error.message
		1052	: "The provider update command could not be started.",
		1053	}),
		1054	);
		1055	} finally {
		1056	setUpdatingProviderDrivers((previous) => {
		1057	if (!previous.has(provider.driver)) {
		1058	return previous;
		1059	}
		1060	const next = new Set(previous);
		1061	next.delete(provider.driver);
		1062	return next;
		1063	});
		1064	}
		1065	}, []);
		1066
1013	interface InstanceRow {	1067	interface InstanceRow {
1014	readonly instanceId: ProviderInstanceId;	1068	readonly instanceId: ProviderInstanceId;
1015	readonly instance: ProviderInstanceConfig;	1069	readonly instance: ProviderInstanceConfig;
@@ -1245,6 +1299,22 @@ export function ProviderSettingsPanel() { · 229 unmodified lines
1245	updateCandidate !== undefined &&	1299	updateCandidate !== undefined &&
1246	canOneClickUpdateProviderCandidate(updateCandidate, serverProviders) &&	1300	canOneClickUpdateProviderCandidate(updateCandidate, serverProviders) &&
1247	!updatingProviderDrivers.has(updateCandidate.driver);	1301	!updatingProviderDrivers.has(updateCandidate.driver);
		1302	const compatibilityUpdateCommand = getProviderCompatibilityUpdateCommand(liveProvider);
		1303	const showInlineCompatibilityUpdateButton =
		1304	canRunProviderCompatibilityUpdate(liveProvider) &&
		1305	compatibilityUpdateCommand !== null &&
		1306	Boolean(liveProvider?.compatibilityAdvisory?.recommendedVersion);
		1307	const isCompatibilityUpdateRunning =
		1308	liveProvider !== undefined &&
		1309	(updatingProviderDrivers.has(liveProvider.driver) \|\|
		1310	serverProviders.some(
		1311	(provider) =>
		1312	provider.driver === liveProvider.driver && isProviderUpdateActive(provider),
		1313	));
		1314	const canRunInlineCompatibilityUpdate =
		1315	showInlineCompatibilityUpdateButton &&
		1316	liveProvider !== undefined &&
		1317	!updatingProviderDrivers.has(liveProvider.driver);
1248	const modelPreferences = settings.providerModelPreferences?.[row.instanceId] ?? {	1318	const modelPreferences = settings.providerModelPreferences?.[row.instanceId] ?? {
1249	hiddenModels: [],	1319	hiddenModels: [],
1250	modelOrder: [],	1320	modelOrder: [],
@@ -1318,6 +1388,19 @@ export function ProviderSettingsPanel() { · 67 unmodified lines
1318	: undefined	1388	: undefined
1319	}	1389	}
1320	isUpdating={showInlineUpdateButton ? isDriverUpdateRunning : undefined}	1390	isUpdating={showInlineUpdateButton ? isDriverUpdateRunning : undefined}
		1391	onRunCompatibilityUpdate={
		1392	showInlineCompatibilityUpdateButton && liveProvider
		1393	? () => {
		1394	if (!canRunInlineCompatibilityUpdate) {
		1395	return;
		1396	}
		1397	void runProviderCompatibilityUpdate(liveProvider);
		1398	}
		1399	: undefined
		1400	}
		1401	isCompatibilityUpdating={
		1402	showInlineCompatibilityUpdateButton ? isCompatibilityUpdateRunning : undefined
		1403	}
1321	/>	1404	/>
1322	);	1405	);
1323	})}	1406	})}

apps/web/src/components/settings/providerStatus.test.ts+31−1

@@ -1,6 +1,9 @@
1	import { describe, expect, it } from "vitest";	1	import { describe, expect, it } from "vitest";
2		2
3	import { getProviderCompatibilityAdvisoryPresentation } from "./providerStatus";	3	import {
		4	getProviderCompatibilityAdvisoryPresentation,
		5	getProviderCompatibilityUpdateCommand,
		6	} from "./providerStatus";
4		7
5	describe("getProviderCompatibilityAdvisoryPresentation", () => {	8	describe("getProviderCompatibilityAdvisoryPresentation", () => {
6	it("hides supported compatibility advisories", () => {	9	it("hides supported compatibility advisories", () => {
@@ -29,7 +32,34 @@ describe("getProviderCompatibilityAdvisoryPresentation", () => { · 22 unmodified lines
29	).toEqual({	32	).toEqual({
30	title: "Incompatible provider version",	33	title: "Incompatible provider version",
31	detail: "Known incompatible.",	34	detail: "Known incompatible.",
		35	updateCommand: null,
		36	canUpdate: false,
32	emphasis: "strong",	37	emphasis: "strong",
33	});	38	});
34	});	39	});
		40
		41	it("derives targeted compatibility update commands from package install commands", () => {
		42	expect(
		43	getProviderCompatibilityUpdateCommand({
		44	compatibilityAdvisory: {
		45	status: "broken",
		46	severity: "error",
		47	currentVersion: "0.128.0",
		48	message: "Known incompatible.",
		49	recommendedRange: ">=0.129.0",
		50	recommendedVersion: "0.129.0",
		51	ranges: [],
		52	},
		53	versionAdvisory: {
		54	status: "behind_latest",
		55	currentVersion: "0.128.0",
		56	latestVersion: "0.130.0",
		57	checkedAt: "2026-05-13T00:00:00.000Z",
		58	message: "Update available.",
		59	updateCommand: "vp i -g @openai/codex",
		60	canUpdate: true,
		61	},
		62	}),
		63	).toBe("vp i -g @openai/codex@0.129.0");
		64	});
35	});	65	});

apps/web/src/components/settings/providerStatus.ts+56−0

@@ -120,11 +120,65 @@ export function getProviderVersionAdvisoryPresentation( · 119 unmodified lines
120	};	120	};
121	}	121	}
122		122
		123	function makeTargetedUpdateCommand(input: {
		124	readonly updateCommand: string \| null \| undefined;
		125	readonly recommendedVersion: string \| null \| undefined;
		126	}): string \| null {
		127	if (!input.updateCommand \|\| !input.recommendedVersion) {
		128	return null;
		129	}
		130	if (!input.updateCommand.includes("@latest")) {
		131	const packageNameMatch = input.updateCommand.match(
		132	/(?:^\|\s)(@[^\s]+\/[^\s@]+\|[^\s@]+)(?=\s*$)/,
		133	);
		134	if (!packageNameMatch?.[1]) {
		135	return null;
		136	}
		137	return input.updateCommand.replace(
		138	packageNameMatch[1],
		139	`${packageNameMatch[1]}@${input.recommendedVersion}`,
		140	);
		141	}
		142	return input.updateCommand.replace("@latest", `@${input.recommendedVersion}`);
		143	}
		144
		145	export function getProviderCompatibilityUpdateCommand(
		146	provider: Pick<ServerProvider, "compatibilityAdvisory" \| "versionAdvisory"> \| null \| undefined,
		147	): string \| null {
		148	const compatibilityAdvisory = provider?.compatibilityAdvisory;
		149	if (!compatibilityAdvisory \|\| compatibilityAdvisory.status === "supported") {
		150	return null;
		151	}
		152	return (
		153	compatibilityAdvisory.updateCommand ??
		154	makeTargetedUpdateCommand({
		155	updateCommand: provider.versionAdvisory?.updateCommand,
		156	recommendedVersion: compatibilityAdvisory.recommendedVersion,
		157	})
		158	);
		159	}
		160
		161	export function canRunProviderCompatibilityUpdate(
		162	provider: Pick<ServerProvider, "compatibilityAdvisory" \| "versionAdvisory"> \| null \| undefined,
		163	): boolean {
		164	const compatibilityAdvisory = provider?.compatibilityAdvisory;
		165	if (!compatibilityAdvisory \|\| compatibilityAdvisory.status === "supported") {
		166	return false;
		167	}
		168	return (
		169	compatibilityAdvisory.canUpdate === true \|\|
		170	(provider?.versionAdvisory?.canUpdate === true &&
		171	getProviderCompatibilityUpdateCommand(provider) !== null)
		172	);
		173	}
		174
123	export function getProviderCompatibilityAdvisoryPresentation(	175	export function getProviderCompatibilityAdvisoryPresentation(
124	advisory: ServerProviderCompatibilityAdvisory \| undefined,	176	advisory: ServerProviderCompatibilityAdvisory \| undefined,
125	): {	177	): {
126	readonly title: string;	178	readonly title: string;
127	readonly detail: string;	179	readonly detail: string;
		180	readonly updateCommand: string \| null;
		181	readonly canUpdate: boolean;
128	readonly emphasis: "normal" \| "strong";	182	readonly emphasis: "normal" \| "strong";
129	} \| null {	183	} \| null {
130	if (!advisory \|\| advisory.status === "supported") {	184	if (!advisory \|\| advisory.status === "supported") {
@@ -142,6 +196,8 @@ export function getProviderCompatibilityAdvisoryPresentation( · 11 unmodified lines
142	title:	196	title:
143	advisory.status === "broken" ? "Incompatible provider version" : "Provider version warning",	197	advisory.status === "broken" ? "Incompatible provider version" : "Provider version warning",
144	detail: advisory.message ?? fallback,	198	detail: advisory.message ?? fallback,
		199	updateCommand: advisory.updateCommand ?? null,
		200	canUpdate: advisory.canUpdate === true,
145	emphasis: advisory.severity === "error" ? "strong" : "normal",	201	emphasis: advisory.severity === "error" ? "strong" : "normal",
146	};	202	};
147	}	203	}

packages/contracts/src/server.ts+3−0

   message: Schema.NullOr(TrimmedNonEmptyString),
   recommendedRange: Schema.NullOr(TrimmedNonEmptyString),
   recommendedVersion: Schema.optionalKey(Schema.NullOr(TrimmedNonEmptyString)),
+  updateCommand: Schema.optionalKey(Schema.NullOr(TrimmedNonEmptyString)),
+  canUpdate: Schema.optionalKey(Schema.Boolean),
   ranges: Schema.Array(ServerProviderCompatibilityRange).pipe(
     Schema.withDecodingDefault(Effect.succeed([])),
   ),
 export const ServerProviderUpdateInput = Schema.Struct({
   provider: ProviderDriverKind,
   instanceId: Schema.optionalKey(ProviderInstanceId),
+  targetVersion: Schema.optionalKey(TrimmedNonEmptyString),
 });
 export type ServerProviderUpdateInput = typeof ServerProviderUpdateInput.Type;

provider-compatibility.v1.json+4−4

@@ -2,7 +2,7 @@ · 1 unmodified line
2	"version": 1,	2	"version": 1,
3	"policies": [	3	"policies": [
4	{	4	{
5	"t3CodeRange": ">=0.0.24",	5	"t3CodeRange": ">=0.0.0",
6	"driver": "codex",	6	"driver": "codex",
7	"recommendedRange": ">=0.129.0",	7	"recommendedRange": ">=0.129.0",
8	"recommendedVersion": "0.129.0",	8	"recommendedVersion": "0.129.0",
@@ -20,7 +20,7 @@ · 11 unmodified lines
20	]	20	]
21	},	21	},
22	{	22	{
23	"t3CodeRange": ">=0.0.24",	23	"t3CodeRange": ">=0.0.0",
24	"driver": "claudeAgent",	24	"driver": "claudeAgent",
25	"recommendedRange": ">=0.2.111",	25	"recommendedRange": ">=0.2.111",
26	"recommendedVersion": "0.2.111",	26	"recommendedVersion": "0.2.111",
@@ -33,7 +33,7 @@ · 6 unmodified lines
33	]	33	]
34	},	34	},
35	{	35	{
36	"t3CodeRange": ">=0.0.24",	36	"t3CodeRange": ">=0.0.0",
37	"driver": "opencode",	37	"driver": "opencode",
38	"recommendedRange": ">=1.14.19",	38	"recommendedRange": ">=1.14.19",
39	"recommendedVersion": "1.14.19",	39	"recommendedVersion": "1.14.19",
@@ -51,7 +51,7 @@ · 11 unmodified lines
51	]	51	]
52	},	52	},
53	{	53	{
54	"t3CodeRange": ">=0.0.24",	54	"t3CodeRange": ">=0.0.0",
55	"driver": "cursor",	55	"driver": "cursor",
56	"recommendedRange": ">=2026.05.09",	56	"recommendedRange": ">=2026.05.09",
57	"recommendedVersion": "2026.05.09",	57	"recommendedVersion": "2026.05.09",

Add targeted provider compatibility updates

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code