Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(providers): hide disconnected providers (#257)
Leo705eb65e64c2
diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsxindex b9b9196d2..d653f1735 100644--- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx+++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx@@ -648,6 +648,7 @@ export function NewTaskDraftScreen(props: {resolveSelectableModelSelection(selectedEnvironmentServerConfig,draft.modelSelection ?? null,+ flow.subscriptionStatuses,) ?? flow.selectedModel;const workspaceMode = draft.workspaceSelection?.mode ?? flow.workspaceMode;const selectedBranchName = draft.workspaceSelection?.branch ?? flow.selectedBranchName;diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsxindex 305f6fc87..f1a49f6d6 100644--- a/apps/mobile/src/features/threads/ThreadComposer.tsx+++ b/apps/mobile/src/features/threads/ThreadComposer.tsx@@ -67,6 +67,8 @@ import {import { resolveProviderOptionDescriptors } from "../../lib/providerOptions";import { useComposerPathSearch } from "../../state/use-composer-path-search";import { botEnvironment, environmentBotsAtom } from "../../state/bots";+import { serverEnvironment } from "../../state/server";+import { useEnvironmentQuery } from "../../state/query";import { useAtomCommand } from "../../state/use-atom-command";import { ComposerCommandPopover, type ComposerCommandItem } from "./ComposerCommandPopover";import { matchesSlashSkillQuery } from "./composerSlashSkillSearch";@@ -288,6 +290,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer});const settingsRoutePresentation = useExistingThreadSettingsRoutePresentation();const bots = useAtomValue(environmentBotsAtom(props.environmentId));+ const subscriptionAuth = useEnvironmentQuery(+ serverEnvironment.subscriptionAuth({ environmentId: props.environmentId, input: {} }),+ );+ const subscriptionStatuses = subscriptionAuth.data?.providers;const bot = bots.find((candidate) => candidate.id === props.selectedThread.botId);const updateBot = useAtomCommand(botEnvironment.update, { reportFailure: false });const settingsRoutePresentedRef = useRef(false);@@ -611,8 +617,8 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer// ── Model menu ───────────────────────────────────────────const modelOptions = useMemo(- () => buildModelOptions(props.serverConfig, currentModelSelection),- [props.serverConfig, currentModelSelection],+ () => buildModelOptions(props.serverConfig, currentModelSelection, subscriptionStatuses),+ [props.serverConfig, currentModelSelection, subscriptionStatuses],);const providerGroups = useMemo(() => groupByProvider(modelOptions), [modelOptions]);// An existing thread is bound to its harness: sessions can't move betweendiff --git a/apps/mobile/src/features/threads/new-task-flow-provider.tsx b/apps/mobile/src/features/threads/new-task-flow-provider.tsxindex 535271439..2b752b59c 100644--- a/apps/mobile/src/features/threads/new-task-flow-provider.tsx+++ b/apps/mobile/src/features/threads/new-task-flow-provider.tsx@@ -8,6 +8,7 @@ import type {ProviderOptionSelection,RuntimeMode,ServerProviderSkill,+ SubscriptionProviderStatus,} from "@t3tools/contracts";import {CommandId,@@ -53,6 +54,7 @@ import {} from "../../state/use-composer-drafts";import { useDebouncedValue, usePaginatedBranches } from "../../state/queries";import { vcsEnvironment } from "../../state/vcs";+import { serverEnvironment } from "../../state/server";import {flattenQueuedThreadMessages,threadOutboxManager,@@ -153,6 +155,7 @@ type NewTaskFlowContextValue = {readonly modelOptions: ReadonlyArray<ModelOption>;readonly selectedModel: ModelSelection | null;readonly selectedModelOption: ModelOption | null;+ readonly subscriptionStatuses: ReadonlyArray<SubscriptionProviderStatus> | undefined;readonly selectedProviderSkills: ReadonlyArray<ServerProviderSkill>;readonly providerGroups: ReadonlyArray<ProviderGroup>;readonly filteredBranches: ReadonlyArray<VcsRef>;@@ -218,6 +221,12 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {projects.some((project) => project.environmentId === selectedEnvironmentIdOverride)? selectedEnvironmentIdOverride: (projects[0]?.environmentId ?? null);+ const subscriptionAuth = useEnvironmentQuery(+ selectedEnvironmentId === null+ ? null+ : serverEnvironment.subscriptionAuth({ environmentId: selectedEnvironmentId, input: {} }),+ );+ const subscriptionStatuses = subscriptionAuth.data?.providers;const [selectedProjectKey, setSelectedProjectKey] = useState<string | null>(null);const [submitting, setSubmitting] = useState(false);const [branchQuery, setBranchQuery] = useState("");@@ -416,18 +425,26 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {const draftModelSelection = resolveSelectableModelSelection(selectedEnvironmentServerConfig,selectedProjectDraft.modelSelection ?? null,+ subscriptionStatuses,);const projectDefaultModelSelection = resolveDefaultableModelSelection(selectedEnvironmentServerConfig,selectedProject?.defaultModelSelection ?? null,+ subscriptionStatuses,);const modelOptions = useMemo(() =>buildModelOptions(selectedEnvironmentServerConfig,draftModelSelection ?? projectDefaultModelSelection,+ subscriptionStatuses,),- [selectedEnvironmentServerConfig, draftModelSelection, projectDefaultModelSelection],+ [+ selectedEnvironmentServerConfig,+ draftModelSelection,+ projectDefaultModelSelection,+ subscriptionStatuses,+ ],);const selectedModel =@@ -1034,6 +1051,7 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {modelOptions,selectedModel,selectedModelOption,+ subscriptionStatuses,selectedProviderSkills,providerGroups,filteredBranches,@@ -1095,6 +1113,7 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {selectedModel,selectedModelKey,selectedModelOption,+ subscriptionStatuses,selectedProjectDraftKey,selectedProviderSkills,setSelectedModelOptions,diff --git a/apps/mobile/src/lib/modelOptions.test.ts b/apps/mobile/src/lib/modelOptions.test.tsindex 8a9dabbe0..18f30b6b9 100644--- a/apps/mobile/src/lib/modelOptions.test.ts+++ b/apps/mobile/src/lib/modelOptions.test.ts@@ -51,6 +51,48 @@ describe("mobile model options", () => {]);});+ it("does not offer host-detected models for disconnected subscriptions", () => {+ const config = {+ providers: [+ {+ instanceId: "codex",+ driver: "codex",+ enabled: true,+ installed: true,+ auth: { status: "authenticated" },+ models: [{ slug: "gpt-5.6-sol", name: "GPT-5.6 Sol", capabilities: null }],+ },+ {+ instanceId: "grok",+ driver: "grok",+ enabled: true,+ installed: true,+ auth: { status: "unknown" },+ models: [{ slug: "grok-build", name: "Grok Build", capabilities: null }],+ },+ ],+ } as unknown as ServerConfig;++ const options = buildModelOptions(config, null, [+ {+ provider: "openai-codex",+ connected: false,+ health: "missing",+ dependentBots: [],+ dependentRoutines: [],+ },+ {+ provider: "xai",+ connected: true,+ health: "detected",+ dependentBots: [],+ dependentRoutines: [],+ },+ ]);++ expect(options.map((option) => option.key)).toEqual(["grok:grok-build"]);+ });+it("normalizes a legacy fallback selection against current capabilities", () => {const config = {providers: [diff --git a/apps/mobile/src/lib/modelOptions.ts b/apps/mobile/src/lib/modelOptions.tsindex cb7a8c419..6cddab790 100644--- a/apps/mobile/src/lib/modelOptions.ts+++ b/apps/mobile/src/lib/modelOptions.ts@@ -2,7 +2,9 @@ import type {ModelCapabilities,ModelSelection,ServerConfig as T3ServerConfig,+ SubscriptionProviderStatus,} from "@t3tools/contracts";+import { filterProvidersBySubscriptionConnection } from "@t3tools/client-runtime/provider-auth";import {buildProviderOptionSelectionsFromDescriptors,getProviderOptionDescriptors,@@ -69,13 +71,15 @@ function normalizeSelectionOptions(export function resolveSelectableModelSelection(config: T3ServerConfig | null | undefined,selection: ModelSelection | null,+ subscriptionStatuses?: ReadonlyArray<SubscriptionProviderStatus>,): ModelSelection | null {if (!selection || !config) {return selection;}- const provider = config.providers.find(- (candidate) => candidate.instanceId === selection.instanceId,- );+ const providers = subscriptionStatuses+ ? filterProvidersBySubscriptionConnection(config.providers, subscriptionStatuses)+ : config.providers;+ const provider = providers.find((candidate) => candidate.instanceId === selection.instanceId);return provider &&provider.enabled &&provider.installed &&@@ -94,8 +98,9 @@ export function resolveSelectableModelSelection(export function resolveDefaultableModelSelection(config: T3ServerConfig | null | undefined,selection: ModelSelection | null,+ subscriptionStatuses?: ReadonlyArray<SubscriptionProviderStatus>,): ModelSelection | null {- const usable = resolveSelectableModelSelection(config, selection);+ const usable = resolveSelectableModelSelection(config, selection, subscriptionStatuses);if (!usable || !config) {return usable;}@@ -107,10 +112,14 @@ export function resolveDefaultableModelSelection(export function buildModelOptions(config: T3ServerConfig | null | undefined,fallbackModelSelection: ModelSelection | null,+ subscriptionStatuses?: ReadonlyArray<SubscriptionProviderStatus>,): ReadonlyArray<ModelOption> {const options = new Map<string, ModelOption>();- for (const provider of config?.providers ?? []) {+ const providers = subscriptionStatuses+ ? filterProvidersBySubscriptionConnection(config?.providers ?? [], subscriptionStatuses)+ : (config?.providers ?? []);+ for (const provider of providers) {if (!provider.enabled || !provider.installed || provider.auth.status === "unauthenticated") {continue;}@@ -139,7 +148,11 @@ export function buildModelOptions(}}- if (fallbackModelSelection) {+ if (+ fallbackModelSelection &&+ (!subscriptionStatuses ||+ providers.some((provider) => provider.instanceId === fallbackModelSelection.instanceId))+ ) {const key = `${fallbackModelSelection.instanceId}:${fallbackModelSelection.model}`;const existing = options.get(key);if (existing) {diff --git a/apps/server/src/subscription-auth/runtime.test.ts b/apps/server/src/subscription-auth/runtime.test.tsindex 07a3f52df..75caae12b 100644--- a/apps/server/src/subscription-auth/runtime.test.ts+++ b/apps/server/src/subscription-auth/runtime.test.ts@@ -2,15 +2,32 @@import * as NodeFS from "node:fs";import * as NodeOS from "node:os";import * as NodePath from "node:path";+import {+ DEFAULT_SERVER_SETTINGS,+ defaultInstanceIdForDriver,+ ProviderDriverKind,+ type SubscriptionProviderStatus,+} from "@t3tools/contracts";import { afterEach, describe, expect, it, vi } from "vite-plus/test";import { SubscriptionAuthService } from "./service.ts";import {mergeSubscriptionInstanceEnvironment,+ subscriptionProviderSettingsPatch,subscriptionRequestUrl,subscriptionRuntimeEnvironment,withExplicitEnvironmentKeys,} from "./runtime.ts";+const subscriptionStatus = (+ provider: SubscriptionProviderStatus["provider"],+ connected: boolean,+): SubscriptionProviderStatus => ({+ provider,+ connected,+ dependentBots: [],+ dependentRoutines: [],+});+const directories: string[] = [];function fixture() {const secretsDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "akeru-runtime-auth-"));@@ -23,6 +40,51 @@ afterEach(() => {});describe("subscription runtime credentials", () => {+ it("aligns default provider enablement with Akeru subscription connections", () => {+ expect(+ subscriptionProviderSettingsPatch(DEFAULT_SERVER_SETTINGS, [+ subscriptionStatus("openai-codex", false),+ subscriptionStatus("anthropic", false),+ subscriptionStatus("cursor", true),+ subscriptionStatus("xai", true),+ subscriptionStatus("kimi-for-coding", false),+ subscriptionStatus("opencode-go", false),+ ]),+ ).toEqual({+ providers: {+ codex: { enabled: false },+ claudeAgent: { enabled: false },+ cursor: { enabled: true },+ grok: { enabled: true },+ kimi: { enabled: false },+ opencodeGo: { enabled: false },+ },+ });+ });++ it("leaves explicitly configured default instances under instance control", () => {+ const grok = ProviderDriverKind.make("grok");+ const instanceId = defaultInstanceIdForDriver(grok);+ expect(+ subscriptionProviderSettingsPatch(+ {+ ...DEFAULT_SERVER_SETTINGS,+ providerInstances: {+ [instanceId]: { driver: grok, enabled: false, config: {} },+ },+ },+ [subscriptionStatus("xai", true)],+ ),+ ).toEqual({+ providers: {+ codex: { enabled: false },+ claudeAgent: { enabled: false },+ kimi: { enabled: false },+ opencodeGo: { enabled: false },+ },+ });+ });+it.each([["anthropic", "ANTHROPIC_API_KEY", "instance-key"],["anthropic", "ANTHROPIC_API_KEY", ""],diff --git a/apps/server/src/subscription-auth/runtime.ts b/apps/server/src/subscription-auth/runtime.tsindex e4a89d579..2ab69324d 100644--- a/apps/server/src/subscription-auth/runtime.ts+++ b/apps/server/src/subscription-auth/runtime.ts@@ -1,4 +1,12 @@-import type { ProviderInstanceConfig, ProviderInstanceEnvironment } from "@t3tools/contracts";+import {+ defaultInstanceIdForDriver,+ type ProviderInstanceConfig,+ type ProviderInstanceEnvironment,+ ProviderDriverKind,+ type ServerSettings,+ type ServerSettingsPatch,+ type SubscriptionProviderStatus,+} from "@t3tools/contracts";import * as Schema from "effect/Schema";import { mergeProviderInstanceEnvironment } from "../provider/ProviderInstanceEnvironment.ts";@@ -13,6 +21,38 @@ type SubscriptionEnvironment = NodeJS.ProcessEnv & {readonly [explicitEnvironmentKeys]?: ReadonlySet<string>;};+const subscriptionProviderDrivers = [+ ["codex", "openai-codex"],+ ["claudeAgent", "anthropic"],+ ["cursor", "cursor"],+ ["grok", "xai"],+ ["kimi", "kimi-for-coding"],+ ["opencodeGo", "opencode-go"],+] as const;++/**+ * Subscription connections own the enabled state of Akeru's default provider+ * instances. Explicit instances keep their own switch because they may carry+ * separate credentials or isolation settings.+ */+export function subscriptionProviderSettingsPatch(+ settings: ServerSettings,+ statuses: ReadonlyArray<SubscriptionProviderStatus>,+): ServerSettingsPatch | null {+ const connected = new Map(statuses.map((status) => [status.provider, status.connected]));+ const providers: NonNullable<ServerSettingsPatch["providers"]> = {};++ for (const [driver, subscriptionProvider] of subscriptionProviderDrivers) {+ const driverKind = ProviderDriverKind.make(driver);+ if (Object.hasOwn(settings.providerInstances, defaultInstanceIdForDriver(driverKind))) continue;+ const enabled = connected.get(subscriptionProvider) ?? false;+ if (settings.providers[driver].enabled === enabled) continue;+ Object.assign(providers, { [driver]: { enabled } });+ }++ return Object.keys(providers).length > 0 ? { providers } : null;+}+/** The symbol survives environment spreads without becoming a child-process variable. */export function mergeSubscriptionInstanceEnvironment(environment: ProviderInstanceEnvironment | undefined,diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.tsindex 9f06c3141..34fb0d77f 100644--- a/apps/server/src/ws.ts+++ b/apps/server/src/ws.ts@@ -80,6 +80,7 @@ import {import { resolveServerBackgroundActivitySettings } from "@t3tools/shared/backgroundActivitySettings";import { SubscriptionAuthService } from "./subscription-auth/service.ts";import { makeApiKeySessionReset } from "./subscription-auth/sessionReset.ts";+import { subscriptionProviderSettingsPatch } from "./subscription-auth/runtime.ts";import { deriveProviderInstanceConfigMap } from "./provider/Layers/ProviderInstanceRegistryHydration.ts";import {buildProviderAccessCapabilities,@@ -542,6 +543,18 @@ const makeWsRpcLayer = (const botInbox = BotInboxService.forSecretsDir(config.secretsDir);const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents;const serverSettings = yield* ServerSettings.ServerSettingsService;+ const syncSubscriptionProviderSettings = Effect.gen(function* () {+ const settings = yield* serverSettings.getSettings;+ const patch = subscriptionProviderSettingsPatch(settings, subscriptionAuth.statuses());+ if (patch) yield* serverSettings.updateSettings(patch);+ }).pipe(+ Effect.catch((cause) =>+ Effect.logWarning("Failed to align provider settings with subscription connections", {+ detail: cause.message,+ }),+ ),+ );+ yield* syncSubscriptionProviderSettings;const resetChangedApiKeySessions = makeApiKeySessionReset(subscriptionAuth,agentController,@@ -702,6 +715,7 @@ const makeWsRpcLayer = (const getAccessHealthSnapshot = Effect.fn("getAccessHealthSnapshot")(function* () {subscriptionAuth.reload();botInbox.reload();+ yield* syncSubscriptionProviderSettings;const [providers, bots, snapshot] = yield* Effect.all([providerRegistry.getProviders,projectionBots@@ -2509,7 +2523,10 @@ const makeWsRpcLayer = (new SubscriptionAuthError({reason: cause instanceof Error ? cause.message : String(cause),}),- }).pipe(resetChangedApiKeySessions),+ }).pipe(+ resetChangedApiKeySessions,+ Effect.tap(() => syncSubscriptionProviderSettings),+ ),{ "rpc.aggregate": "server" },),[WS_METHODS.subscriptionAuthComplete]: ({ loginId, code }) =>@@ -2521,7 +2538,10 @@ const makeWsRpcLayer = (new SubscriptionAuthError({reason: cause instanceof Error ? cause.message : String(cause),}),- }).pipe(resetChangedApiKeySessions),+ }).pipe(+ resetChangedApiKeySessions,+ Effect.tap(() => syncSubscriptionProviderSettings),+ ),{ "rpc.aggregate": "server" },),[WS_METHODS.subscriptionAuthCancel]: ({ loginId }) =>diff --git a/apps/web/src/components/settings/ProvidersPanel.test.tsx b/apps/web/src/components/settings/ProvidersPanel.test.tsxindex 5e06feeb1..91fdb1230 100644--- a/apps/web/src/components/settings/ProvidersPanel.test.tsx+++ b/apps/web/src/components/settings/ProvidersPanel.test.tsx@@ -62,6 +62,8 @@ describe("subscription providers", () => {expect(markup).toContain("Reconnect key");expect(markup).toContain("Use OAuth");expect(markup).toContain("Disconnect Claude");+ expect(markup).toContain("Connected");+ expect(markup).not.toContain("Detected");expect(markup).not.toContain(SUBSCRIPTION_PROVIDERS[1]!.description);});diff --git a/apps/web/src/components/settings/ProvidersPanel.tsx b/apps/web/src/components/settings/ProvidersPanel.tsxindex 46791badb..597cc20b6 100644--- a/apps/web/src/components/settings/ProvidersPanel.tsx+++ b/apps/web/src/components/settings/ProvidersPanel.tsx@@ -54,6 +54,19 @@ const healthLabels: Readonly<Record<NonNullable<SubscriptionProviderStatus["healrecovered: "Recovered",};+function providerBadgeLabel(status: SubscriptionProviderStatus | undefined): string {+ if (status?.connected !== true) return "Missing";+ if (+ status.health === "expired" ||+ status.health === "revoked" ||+ status.health === "failed" ||+ status.health === "failed-first-request"+ ) {+ return healthLabels[status.health];+ }+ return "Connected";+}+function healthBadgeVariant(health: SubscriptionProviderStatus["health"] | undefined) {if (health === "healthy" || health === "recovered") return "success" as const;if (@@ -111,7 +124,7 @@ export function ProviderLoginCard({)}{definition.label}<Badge variant={healthBadgeVariant(status?.health)} className="h-4 px-1.5 text-[10px]">- {status?.health ? healthLabels[status.health] : connected ? "Detected" : "Missing"}+ {providerBadgeLabel(status)}</Badge></span>}diff --git a/apps/web/src/providerInstances.test.ts b/apps/web/src/providerInstances.test.tsindex b58069109..58e85802c 100644--- a/apps/web/src/providerInstances.test.ts+++ b/apps/web/src/providerInstances.test.ts@@ -129,18 +129,31 @@ describe("isProviderInstancePickerSelectable", () => {});describe("isProviderInstancePickerVisible", () => {- it("keeps enabled instances in the rail and removes disabled instances", () => {- const [enabledEntry, disabledEntry] = deriveProviderInstanceEntries([- provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),- provider({- provider: ProviderDriverKind.make("claudeAgent"),- instanceId: "claudeAgent",- enabled: false,- }),- ]);+ it("keeps selectable instances in the rail and removes inactive instances", () => {+ const [enabledEntry, disabledEntry, missingEntry, signedOutEntry] =+ deriveProviderInstanceEntries([+ provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),+ provider({+ provider: ProviderDriverKind.make("claudeAgent"),+ instanceId: "claudeAgent",+ enabled: false,+ }),+ provider({+ provider: ProviderDriverKind.make("kimi"),+ instanceId: "kimi",+ installed: false,+ }),+ provider({+ provider: ProviderDriverKind.make("opencodeGo"),+ instanceId: "opencodeGo",+ authStatus: "unauthenticated",+ }),+ ]);expect(enabledEntry && isProviderInstancePickerVisible(enabledEntry)).toBe(true);expect(disabledEntry && isProviderInstancePickerVisible(disabledEntry)).toBe(false);+ expect(missingEntry && isProviderInstancePickerVisible(missingEntry)).toBe(false);+ expect(signedOutEntry && isProviderInstancePickerVisible(signedOutEntry)).toBe(false);});});diff --git a/apps/web/src/providerInstances.ts b/apps/web/src/providerInstances.tsindex 08af444ff..25f635827 100644--- a/apps/web/src/providerInstances.ts+++ b/apps/web/src/providerInstances.ts@@ -93,9 +93,9 @@ export function isProviderInstancePickerSelectable(entry: ProviderInstanceEntry));}-/** Picker rails contain configured, enabled instances only. */+/** Picker rails contain only instances that can contribute selectable models. */export function isProviderInstancePickerVisible(entry: ProviderInstanceEntry): boolean {- return entry.enabled;+ return isProviderInstancePickerSelectable(entry);}/**diff --git a/apps/web/src/state/server.ts b/apps/web/src/state/server.tsindex 1071d8209..cf6f80358 100644--- a/apps/web/src/state/server.ts+++ b/apps/web/src/state/server.ts@@ -9,6 +9,7 @@ import {} from "@t3tools/contracts";import { createServerEnvironmentAtoms } from "@t3tools/client-runtime/state/server";import { createEnvironmentServerConfigsAtom } from "@t3tools/client-runtime/state/shell";+import { filterProvidersBySubscriptionConnection } from "@t3tools/client-runtime/provider-auth";import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";import * as Option from "effect/Option";import { AsyncResult, Atom } from "effect/unstable/reactivity";@@ -75,10 +76,15 @@ export const primaryServerSettingsAtom = Atom.make((get): ServerSettings => get(primaryServerConfigAtom)?.settings ?? DEFAULT_SERVER_SETTINGS,).pipe(Atom.withLabel("web-primary-server-settings"));-export const primaryServerProvidersAtom = Atom.make(- (get): ReadonlyArray<ServerProvider> =>- get(primaryServerConfigAtom)?.providers ?? EMPTY_SERVER_PROVIDERS,-).pipe(Atom.withLabel("web-primary-server-providers"));+export const primaryServerProvidersAtom = Atom.make((get): ReadonlyArray<ServerProvider> => {+ const environmentId = get(primaryEnvironmentIdAtom);+ const providers = get(primaryServerConfigAtom)?.providers ?? EMPTY_SERVER_PROVIDERS;+ if (environmentId === null) return EMPTY_SERVER_PROVIDERS;+ const statuses = Option.getOrUndefined(+ AsyncResult.value(get(serverEnvironment.subscriptionAuth({ environmentId, input: {} }))),+ );+ return filterProvidersBySubscriptionConnection(providers, statuses?.providers);+}).pipe(Atom.withLabel("web-primary-server-providers"));export const primaryServerKeybindingsAtom = Atom.make((get): ServerConfig["keybindings"] =>diff --git a/packages/client-runtime/src/providerAuth.test.ts b/packages/client-runtime/src/providerAuth.test.tsindex 7d1b99dcb..4b2f30875 100644--- a/packages/client-runtime/src/providerAuth.test.ts+++ b/packages/client-runtime/src/providerAuth.test.ts@@ -1,8 +1,14 @@import { describe, expect, it } from "vite-plus/test";-import type { SubscriptionProviderStatus } from "@t3tools/contracts";+import {+ ProviderDriverKind,+ ProviderInstanceId,+ type ServerProvider,+ type SubscriptionProviderStatus,+} from "@t3tools/contracts";import {apiKeyStartInput,apiKeyValidationError,+ filterProvidersBySubscriptionConnection,PROVIDER_CONNECTIONS,providerConnectionLabel,providerUsesApiKey,@@ -73,7 +79,7 @@ describe("provider API key forms", () => {it("does not claim a saved key passed a health check", () => {expect(providerConnectionLabel({ ...status, authMode: "api-key", health: "detected" })).toBe(- "API key saved · detected",+ "API key saved",);expect(providerConnectionLabel({ ...status, connected: false })).toBe("Not connected");expect(providerConnectionLabel(status)).toBe("OAuth connected");@@ -85,3 +91,51 @@ describe("provider API key forms", () => {expect(providerUsesApiKey({ ...status, provider: "opencode-go" })).toBe(true);});});++describe("filterProvidersBySubscriptionConnection", () => {+ const provider = (driver: string, instanceId = driver): ServerProvider => ({+ instanceId: ProviderInstanceId.make(instanceId),+ driver: ProviderDriverKind.make(driver),+ enabled: true,+ installed: true,+ version: null,+ status: "ready",+ auth: { status: "authenticated" },+ checkedAt: "2026-09-13T00:00:00.000Z",+ models: [],+ slashCommands: [],+ skills: [],+ });++ it("keeps only connected built-in subscription providers", () => {+ const providers = [+ provider("codex"),+ provider("claudeAgent"),+ provider("grok"),+ provider("opencode"),+ ];+ const statuses: SubscriptionProviderStatus[] = [+ { ...status, provider: "openai-codex", connected: false, health: "missing" },+ { ...status, provider: "anthropic", connected: false, health: "missing" },+ { ...status, provider: "xai", connected: true, health: "detected" },+ ];++ expect(+ filterProvidersBySubscriptionConnection(providers, statuses).map(+ (candidate) => candidate.instanceId,+ ),+ ).toEqual(["grok", "opencode"]);+ });++ it("preserves custom instances that own their connection", () => {+ const custom = provider("codex", "codex_work");++ expect(filterProvidersBySubscriptionConnection([custom], [])).toEqual([custom]);+ });++ it("preserves configured providers until connection status is available", () => {+ const providers = [provider("codex"), provider("claudeAgent")];++ expect(filterProvidersBySubscriptionConnection(providers, undefined)).toEqual(providers);+ });+});diff --git a/packages/client-runtime/src/providerAuth.ts b/packages/client-runtime/src/providerAuth.tsindex d37010ad6..8ebffb5e4 100644--- a/packages/client-runtime/src/providerAuth.ts+++ b/packages/client-runtime/src/providerAuth.ts@@ -1,4 +1,6 @@import {+ defaultInstanceIdForDriver,+ type ServerProvider,SubscriptionBaseUrl,type SubscriptionAuthStartInput,type SubscriptionProviderId,@@ -45,7 +47,36 @@ export function apiKeyStartInput(export function providerConnectionLabel(status: SubscriptionProviderStatus): string {if (!status.connected) return "Not connected";- const mode = providerUsesApiKey(status) ? "API key saved" : "OAuth connected";- const health = status.health?.replaceAll("-", " ");- return health ? `${mode} · ${health}` : mode;+ return providerUsesApiKey(status) ? "API key saved" : "OAuth connected";+}++const SUBSCRIPTION_PROVIDER_BY_DRIVER: Readonly<Record<string, SubscriptionProviderId>> = {+ codex: "openai-codex",+ claudeAgent: "anthropic",+ cursor: "cursor",+ grok: "xai",+ kimi: "kimi-for-coding",+ opencodeGo: "opencode-go",+};++/**+ * Keep default built-in provider instances aligned with the connections the+ * user made inside Akeru. Host CLI credentials are intentionally not enough+ * to make an unconnected account appear in model pickers. Custom instances+ * remain governed by their own configured environment and provider probe.+ */+export function filterProvidersBySubscriptionConnection(+ providers: ReadonlyArray<ServerProvider>,+ statuses: ReadonlyArray<SubscriptionProviderStatus> | undefined,+): ReadonlyArray<ServerProvider> {+ if (!statuses) return providers;+ const connected = new Set(+ statuses.filter((status) => status.connected).map((status) => status.provider),+ );+ return providers.filter((provider) => {+ const subscriptionProvider = SUBSCRIPTION_PROVIDER_BY_DRIVER[String(provider.driver)];+ if (!subscriptionProvider) return true;+ if (provider.instanceId !== defaultInstanceIdForDriver(provider.driver)) return true;+ return connected.has(subscriptionProvider);+ });}