Skip to content

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.tsx
index 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.tsx
index 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 between
diff --git a/apps/mobile/src/features/threads/new-task-flow-provider.tsx b/apps/mobile/src/features/threads/new-task-flow-provider.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.tsx
index 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.tsx
index 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["heal
recovered: "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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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);
+ });
}