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(server): stop probing Grok, Cursor, and OpenCode unless turned on (#7459)

Theo Brownee7f6a30caba5
diff --git a/apps/server/src/provider/Layers/GrokProvider.test.ts b/apps/server/src/provider/Layers/GrokProvider.test.ts
index 000243869..1c9bf1f26 100644
--- a/apps/server/src/provider/Layers/GrokProvider.test.ts
+++ b/apps/server/src/provider/Layers/GrokProvider.test.ts
@@ -23,9 +23,19 @@ describe("buildInitialGrokProviderSnapshot", () => {
}),
);
- it.effect("returns a pending snapshot by default", () =>
+ it.effect("returns a disabled snapshot by default — Grok is opt-in", () =>
Effect.gen(function* () {
const snapshot = yield* buildInitialGrokProviderSnapshot(decodeGrokSettings({}));
+ expect(snapshot.enabled).toBe(false);
+ expect(snapshot.status).toBe("disabled");
+ }),
+ );
+
+ it.effect("returns a pending snapshot when enabled", () =>
+ Effect.gen(function* () {
+ const snapshot = yield* buildInitialGrokProviderSnapshot(
+ decodeGrokSettings({ enabled: true }),
+ );
expect(snapshot.enabled).toBe(true);
expect(snapshot.installed).toBe(true);
expect(snapshot.status).toBe("warning");
diff --git a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts
index dcc3ac0b5..a429367bf 100644
--- a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts
+++ b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.test.ts
@@ -223,6 +223,32 @@ describe("ProviderInstanceRegistryLive — multi-instance codex slice", () => {
}).pipe(Effect.provide(testLayer)),
);
+ it.live("treats an explicit in-config enabled:false as disabling despite the envelope", () =>
+ Effect.gen(function* () {
+ // Old settings files can carry both flags with conflicting values.
+ // The explicit false must win so a user's disable is never undone.
+ const staleId = ProviderInstanceId.make("codex_stale");
+ const configMap: ProviderInstanceConfigMap = {
+ [staleId]: {
+ driver: ProviderDriverKind.make("codex"),
+ enabled: true,
+ config: makeCodexConfig({ enabled: false }),
+ },
+ };
+
+ const { registry } = yield* makeProviderInstanceRegistry({
+ drivers: [CodexDriver],
+ configMap,
+ });
+
+ const instance = yield* registry.getInstance(staleId);
+ expect(instance).toBeDefined();
+ expect(instance!.enabled).toBe(false);
+ const snapshot = yield* instance!.snapshot.getSnapshot;
+ expect(snapshot.enabled).toBe(false);
+ }).pipe(Effect.provide(testLayer)),
+ );
+
it.live(
"shadows instances whose driver is not registered in this build without failing boot",
() =>
diff --git a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.ts b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.ts
index b51dc6779..fb75652e3 100644
--- a/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.ts
+++ b/apps/server/src/provider/Layers/ProviderInstanceRegistryLive.ts
@@ -34,6 +34,7 @@
*/
import {
defaultInstanceIdForDriver,
+ providerInstanceConfigEnabledFlag,
ProviderInstanceId,
type ProviderInstanceConfig,
type ProviderInstanceConfigMap,
@@ -93,12 +94,20 @@ interface RegistryState {
const entryEqual = (a: ProviderInstanceConfig, b: ProviderInstanceConfig): boolean =>
Equal.equals(a, b);
-const decodedConfigEnabled = (config: unknown): boolean | undefined => {
- if (!config || typeof config !== "object" || globalThis.Array.isArray(config)) {
- return undefined;
+/**
+ * Resolve an entry's enabled state. An explicit false on either the
+ * envelope or the raw config blob wins (most restrictive) — old settings
+ * files can carry both flags with conflicting values, and a user's disable
+ * must never be silently undone. Otherwise the envelope flag wins, then the
+ * decoded config's flag (which carries the driver schema's default for
+ * built-ins and forks alike), then enabled by default.
+ */
+const resolveEntryEnabled = (entry: ProviderInstanceConfig, typedConfig: unknown): boolean => {
+ const rawConfigEnabled = providerInstanceConfigEnabledFlag(entry.config);
+ if (entry.enabled === false || rawConfigEnabled === false) {
+ return false;
}
- const enabled = (config as { readonly enabled?: unknown }).enabled;
- return typeof enabled === "boolean" ? enabled : undefined;
+ return entry.enabled ?? providerInstanceConfigEnabledFlag(typedConfig) ?? true;
};
/**
@@ -171,7 +180,7 @@ const buildEntry = <R>(input: {
displayName: entry.displayName,
accentColor: entry.accentColor,
environment: entry.environment ?? [],
- enabled: entry.enabled ?? decodedConfigEnabled(typedConfig) ?? true,
+ enabled: resolveEntryEnabled(entry, typedConfig),
config: typedConfig,
})
.pipe(Effect.provideService(Scope.Scope, childScope), Effect.result);
diff --git a/apps/server/src/serverSettings.test.ts b/apps/server/src/serverSettings.test.ts
index d38a30649..35ef5e976 100644
--- a/apps/server/src/serverSettings.test.ts
+++ b/apps/server/src/serverSettings.test.ts
@@ -487,6 +487,65 @@ it.layer(NodeServices.layer)("server settings", (it) => {
}).pipe(Effect.provide(makeServerSettingsLayer())),
);
+ it.effect("folds a legacy in-config enabled flag into the envelope on load", () =>
+ Effect.gen(function* () {
+ const serverConfig = yield* ServerConfig.ServerConfig;
+ const fileSystem = yield* FileSystem.FileSystem;
+ const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
+ // Old settings files can carry both flags with conflicting values.
+ // The explicit false must win so a user's disable sticks.
+ yield* fileSystem.writeFileString(
+ serverConfig.settingsPath,
+ '{"providerInstances":{"grok":{"driver":"grok","enabled":true,"config":{"enabled":false}},"codex_work":{"driver":"codex","config":{"enabled":true,"homePath":"~/.codex"}},"cursor":{"driver":"cursor","config":{"enabled":"nope"}}}}',
+ );
+
+ const settings = yield* serverSettings.getSettings;
+
+ const grokId = ProviderInstanceId.make("grok");
+ const codexWorkId = ProviderInstanceId.make("codex_work");
+ assert.deepEqual(settings.providerInstances[grokId], {
+ driver: ProviderDriverKind.make("grok"),
+ enabled: false,
+ config: {},
+ });
+ // A lone in-config flag is lifted to the envelope and stripped.
+ assert.deepEqual(settings.providerInstances[codexWorkId], {
+ driver: ProviderDriverKind.make("codex"),
+ enabled: true,
+ config: { homePath: "~/.codex" },
+ });
+ // A malformed flag is left alone so driver schema validation can
+ // surface it instead of the fold silently repairing the config.
+ assert.deepEqual(settings.providerInstances[ProviderInstanceId.make("cursor")], {
+ driver: ProviderDriverKind.make("cursor"),
+ config: { enabled: "nope" },
+ });
+ }).pipe(Effect.provide(makeServerSettingsLayer())),
+ );
+
+ it.effect("folds in-config enabled flags arriving through updates", () =>
+ Effect.gen(function* () {
+ const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
+ const grokId = ProviderInstanceId.make("grok");
+
+ const next = yield* serverSettings.updateSettings({
+ providerInstances: {
+ [grokId]: {
+ driver: ProviderDriverKind.make("grok"),
+ enabled: true,
+ config: { enabled: false, binaryPath: "/opt/grok" },
+ },
+ },
+ });
+
+ assert.deepEqual(next.providerInstances[grokId], {
+ driver: ProviderDriverKind.make("grok"),
+ enabled: false,
+ config: { binaryPath: "/opt/grok" },
+ });
+ }).pipe(Effect.provide(makeServerSettingsLayer())),
+ );
+
it.effect("trims provider path settings when updates are applied", () =>
Effect.gen(function* () {
const serverSettings = yield* ServerSettingsModule.ServerSettingsService;
@@ -524,7 +583,8 @@ it.layer(NodeServices.layer)("server settings", (it) => {
launchArgs: "",
});
assert.deepEqual(next.providers.opencode, {
- enabled: true,
+ // OpenCode is disabled by default; this update only touches paths.
+ enabled: false,
binaryPath: "/opt/homebrew/bin/opencode",
serverUrl: "http://127.0.0.1:4096",
serverPassword: "secret-password",
diff --git a/apps/server/src/serverSettings.ts b/apps/server/src/serverSettings.ts
index 2798faf6f..1bf373352 100644
--- a/apps/server/src/serverSettings.ts
+++ b/apps/server/src/serverSettings.ts
@@ -61,11 +61,60 @@ const decodeServerSettings = Schema.decodeUnknownEffect(ServerSettings);
const textEncoder = new TextEncoder();
const textDecoder = new TextDecoder();
+/**
+ * Fold the legacy in-config `enabled` flag into the envelope-level
+ * `ProviderInstanceConfig.enabled` and strip it from the config blob, so
+ * explicit provider instances carry exactly one enabled flag. Old settings
+ * files can hold both flags with conflicting values; an explicit false on
+ * either side wins so a user's disable is never silently undone. Runs on
+ * every load and update — the file converges on the next write.
+ */
+const foldProviderInstanceEnabledFlags = (settings: ServerSettings): ServerSettings => {
+ let changed = false;
+ const providerInstances: Record<string, ProviderInstanceConfig> = {};
+ for (const [instanceId, instance] of Object.entries(settings.providerInstances)) {
+ const config = instance.config;
+ // Only fold boolean flags: a malformed `enabled` (e.g. `"false"`) must
+ // stay in the blob so driver schema validation flags it instead of the
+ // fold silently repairing the config.
+ if (
+ config === null ||
+ typeof config !== "object" ||
+ Array.isArray(config) ||
+ typeof (config as { readonly enabled?: unknown }).enabled !== "boolean"
+ ) {
+ providerInstances[instanceId] = instance;
+ continue;
+ }
+ const { enabled: configEnabled, ...restConfig } = config as Record<string, unknown> & {
+ readonly enabled: boolean;
+ };
+ const resolved =
+ instance.enabled === false || configEnabled === false
+ ? false
+ : (instance.enabled ?? configEnabled);
+ changed = true;
+ providerInstances[instanceId] = {
+ ...instance,
+ enabled: resolved,
+ config: restConfig,
+ } satisfies ProviderInstanceConfig;
+ }
+ if (!changed) {
+ return settings;
+ }
+ return {
+ ...settings,
+ providerInstances: providerInstances as ServerSettings["providerInstances"],
+ };
+};
+
const normalizeServerSettings = (
settings: ServerSettings,
): Effect.Effect<ServerSettings, ServerSettingsError> =>
encodeServerSettings(settings).pipe(
Effect.flatMap(decodeServerSettings),
+ Effect.map(foldProviderInstanceEnabledFlags),
Effect.mapError(
(cause) =>
new ServerSettingsError({
@@ -303,7 +352,7 @@ const make = Effect.gen(function* () {
});
return DEFAULT_SERVER_SETTINGS;
}
- return decoded.value;
+ return foldProviderInstanceEnabledFlags(decoded.value);
});
const settingsCache = yield* Cache.make<typeof cacheKey, ServerSettings, ServerSettingsError>({
diff --git a/apps/web/src/components/settings/ProviderInstanceCard.tsx b/apps/web/src/components/settings/ProviderInstanceCard.tsx
index 11e108e7c..a663aa909 100644
--- a/apps/web/src/components/settings/ProviderInstanceCard.tsx
+++ b/apps/web/src/components/settings/ProviderInstanceCard.tsx
@@ -15,6 +15,7 @@ import * as Result from "effect/Result";
import { useState, type ReactNode } from "react";
import {
isProviderDriverKind,
+ resolveProviderInstanceEnabled,
type ProviderInstanceConfig,
type ProviderInstanceEnvironmentVariable,
type ProviderInstanceId,
@@ -368,12 +369,10 @@ interface ProviderInstanceCardProps {
* notice instead of editable fields, so fork instances round-trip
* without accidentally destroying their config.
* - The enabled Switch writes to the envelope's `instance.enabled`
- * field; the server's registry consults this at `entry.enabled ?? true`
- * before materializing the instance, and the probe also checks its
- * driver-specific `config.enabled`. We treat the envelope flag as the
- * single source of truth from the UI — built-in cards used to write
- * the inner flag, but on the promotion-to-instance path every edit
- * flows through the envelope.
+ * field, which is the single enabled flag: the server folds any legacy
+ * driver-specific `config.enabled` into the envelope on load and both
+ * sides resolve through `resolveProviderInstanceEnabled` (an explicit
+ * false wins, then envelope, then config, then the driver default).
*/
export function ProviderInstanceCard({
instanceId,
@@ -394,7 +393,7 @@ export function ProviderInstanceCard({
onRunUpdate,
isUpdating = false,
}: ProviderInstanceCardProps) {
- const enabled = instance.enabled ?? true;
+ const enabled = resolveProviderInstanceEnabled(instance);
// The server-reported status wins when present; otherwise fall back to
// "disabled"/"warning" based on the local `enabled` flag so the dot
// reflects the persisted intent even before the first probe completes.
diff --git a/apps/web/src/components/settings/ProviderSettingsPanel.tsx b/apps/web/src/components/settings/ProviderSettingsPanel.tsx
index 773463a38..3a38a91e2 100644
--- a/apps/web/src/components/settings/ProviderSettingsPanel.tsx
+++ b/apps/web/src/components/settings/ProviderSettingsPanel.tsx
@@ -12,6 +12,7 @@ import {
ProviderDriverKind,
type ProviderInstanceConfig,
type ProviderInstanceId,
+ resolveProviderInstanceEnabled,
} from "@t3tools/contracts";
import { DEFAULT_UNIFIED_SETTINGS } from "@t3tools/contracts/settings";
import {
@@ -529,15 +530,23 @@ export function EnvironmentProviderSettings({
// instance or a legacy blob there is nothing to render for the slot.
const legacyConfig = legacyProviders[providerSettings.provider];
const defaultLegacyConfig = defaultLegacyProviders[providerSettings.provider];
+ // The envelope is the single enabled flag: keep the legacy in-config
+ // flag out of the synthesized blob, or an explicit `enabled: false`
+ // would keep winning over the envelope and the Switch could never
+ // turn a default-off provider on.
+ const synthesizedInstance = (): ProviderInstanceConfig | undefined => {
+ if (legacyConfig === undefined) {
+ return undefined;
+ }
+ const { enabled: legacyEnabled, ...legacyConfigRest } = legacyConfig;
+ return {
+ driver,
+ enabled: legacyEnabled,
+ config: legacyConfigRest,
+ } satisfies ProviderInstanceConfig;
+ };
const effectiveInstance: ProviderInstanceConfig | undefined =
- explicitInstance ??
- (legacyConfig !== undefined
- ? ({
- driver,
- enabled: legacyConfig.enabled,
- config: legacyConfig,
- } satisfies ProviderInstanceConfig)
- : undefined);
+ explicitInstance ?? synthesizedInstance();
// Only the default slot depends on the legacy blob; custom instances for
// the driver must still render even when the slot has nothing to show.
if (effectiveInstance !== undefined) {
@@ -838,7 +847,7 @@ export function EnvironmentProviderSettings({
}))
}
onUpdate={(next) => {
- const wasEnabled = row.instance.enabled ?? true;
+ const wasEnabled = resolveProviderInstanceEnabled(row.instance);
const isDisabling = next.enabled === false && wasEnabled;
const shouldClearTextGen = isDisabling && textGenInstanceId === row.instanceId;
if (shouldClearTextGen) {
diff --git a/apps/web/src/providerInstances.ts b/apps/web/src/providerInstances.ts
index fd4ca7da9..bb8998970 100644
--- a/apps/web/src/providerInstances.ts
+++ b/apps/web/src/providerInstances.ts
@@ -16,6 +16,7 @@ import {
DEFAULT_MODEL_BY_PROVIDER,
defaultInstanceIdForDriver,
PROVIDER_DISPLAY_NAMES,
+ resolveProviderInstanceEnabled,
type ModelSelection,
type ProviderDriverKind,
ProviderInstanceId,
@@ -220,7 +221,7 @@ export function applyProviderInstanceSettings(
return entries.map((entry) => {
const explicitInstance = settings.providerInstances?.[entry.instanceId];
const enabled = explicitInstance
- ? (explicitInstance.enabled ?? true)
+ ? resolveProviderInstanceEnabled(explicitInstance)
: entry.isDefault
? (legacyProviders[entry.driverKind]?.enabled ?? entry.enabled)
: false;
diff --git a/docs/user/install.md b/docs/user/install.md
index 96776c7ea..15f96e00d 100644
--- a/docs/user/install.md
+++ b/docs/user/install.md
@@ -62,6 +62,9 @@ to use, then authenticate it.
| Grok Build | [Grok Build CLI](https://x.ai/cli) | `grok` | `grok login` |
| OpenCode | [OpenCode](https://opencode.ai) | `opencode` | `opencode auth login` |
+Codex and Claude are on by default. Cursor, Grok Build, and OpenCode are off by default; turn
+them on in **Settings** → the provider's card when you want to use them.
+
Cursor is the one to watch: install Cursor CLI, which provides the `cursor-agent` binary that
T3 Code looks for, but authenticate with `agent login`, not `cursor-agent login`.
diff --git a/packages/contracts/src/settings.test.ts b/packages/contracts/src/settings.test.ts
index 570157292..46a4d25ac 100644
--- a/packages/contracts/src/settings.test.ts
+++ b/packages/contracts/src/settings.test.ts
@@ -1,11 +1,13 @@
import { describe, expect, it } from "vite-plus/test";
import * as Schema from "effect/Schema";
-import { ProviderInstanceId } from "./providerInstance.ts";
+import { ProviderDriverKind, ProviderInstanceId } from "./providerInstance.ts";
import {
ClientSettingsSchema,
ClientSettingsPatch,
DEFAULT_SERVER_SETTINGS,
+ defaultEnabledForDriver,
+ resolveProviderInstanceEnabled,
ServerSettings,
ServerSettingsPatch,
} from "./settings.ts";
@@ -177,6 +179,46 @@ describe("ServerSettings.providerInstances (slice-2 invariant)", () => {
});
});
+describe("provider enabled defaults", () => {
+ it("enables only the stable bindings by default", () => {
+ const decoded = decodeServerSettings({});
+ expect(decoded.providers.codex.enabled).toBe(true);
+ expect(decoded.providers.claudeAgent.enabled).toBe(true);
+ expect(decoded.providers.cursor.enabled).toBe(false);
+ expect(decoded.providers.grok.enabled).toBe(false);
+ expect(decoded.providers.opencode.enabled).toBe(false);
+ });
+
+ it("derives per-driver defaults from the settings schemas", () => {
+ expect(defaultEnabledForDriver(ProviderDriverKind.make("codex"))).toBe(true);
+ expect(defaultEnabledForDriver(ProviderDriverKind.make("grok"))).toBe(false);
+ // Unknown fork drivers stay enabled; their own build decides otherwise.
+ expect(defaultEnabledForDriver(ProviderDriverKind.make("ollama"))).toBe(true);
+ });
+
+ it("resolves instance enabled state with explicit false winning", () => {
+ const grok = ProviderDriverKind.make("grok");
+ const codex = ProviderDriverKind.make("codex");
+ // No flags anywhere: driver default applies.
+ expect(resolveProviderInstanceEnabled({ driver: grok, config: {} })).toBe(false);
+ expect(resolveProviderInstanceEnabled({ driver: codex, config: {} })).toBe(true);
+ // Envelope flag wins over the driver default.
+ expect(resolveProviderInstanceEnabled({ driver: grok, enabled: true, config: {} })).toBe(true);
+ expect(resolveProviderInstanceEnabled({ driver: codex, enabled: false, config: {} })).toBe(
+ false,
+ );
+ // Legacy in-config flag fills in when the envelope is silent.
+ expect(resolveProviderInstanceEnabled({ driver: grok, config: { enabled: true } })).toBe(true);
+ // Conflicting flags: the explicit false wins, whichever side it is on.
+ expect(
+ resolveProviderInstanceEnabled({ driver: grok, enabled: true, config: { enabled: false } }),
+ ).toBe(false);
+ expect(
+ resolveProviderInstanceEnabled({ driver: codex, enabled: false, config: { enabled: true } }),
+ ).toBe(false);
+ });
+});
+
describe("ServerSettings worktree defaults", () => {
it("defaults start-from-origin on for legacy configs", () => {
expect(decodeServerSettings({}).newWorktreesStartFromOrigin).toBe(true);
diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts
index 143087b35..96ee5b85c 100644
--- a/packages/contracts/src/settings.ts
+++ b/packages/contracts/src/settings.ts
@@ -18,7 +18,11 @@ import {
PreviewViewportSetting,
PreviewZoomFactor,
} from "./preview.ts";
-import { ProviderInstanceConfig, ProviderInstanceId } from "./providerInstance.ts";
+import {
+ ProviderInstanceConfig,
+ ProviderInstanceId,
+ type ProviderDriverKind,
+} from "./providerInstance.ts";
// ── Client Settings (local-only) ───────────────────────────────
@@ -403,6 +407,8 @@ export type ClaudeSettings = typeof ClaudeSettings.Type;
export const CursorSettings = makeProviderSettingsSchema(
{
+ // Off by default (like Grok and OpenCode): the binding is not yet
+ // stable enough to probe on every install. Users opt in from Settings.
enabled: Schema.Boolean.pipe(
Schema.withDecodingDefault(Effect.succeed(false)),
Schema.annotateKey({ providerSettingsForm: { hidden: true } }),
@@ -438,8 +444,10 @@ export type CursorSettings = typeof CursorSettings.Type;
export const GrokSettings = makeProviderSettingsSchema(
{
+ // Off by default (like Cursor and OpenCode): the binding is not yet
+ // stable enough to probe on every install. Users opt in from Settings.
enabled: Schema.Boolean.pipe(
- Schema.withDecodingDefault(Effect.succeed(true)),
+ Schema.withDecodingDefault(Effect.succeed(false)),
Schema.annotateKey({ providerSettingsForm: { hidden: true } }),
),
binaryPath: makeBinaryPathSetting("grok").pipe(
@@ -462,8 +470,10 @@ export type GrokSettings = typeof GrokSettings.Type;
export const OpenCodeSettings = makeProviderSettingsSchema(
{
+ // Off by default (like Cursor and Grok): the binding is not yet stable
+ // enough to probe on every install. Users opt in from Settings.
enabled: Schema.Boolean.pipe(
- Schema.withDecodingDefault(Effect.succeed(true)),
+ Schema.withDecodingDefault(Effect.succeed(false)),
Schema.annotateKey({ providerSettingsForm: { hidden: true } }),
),
binaryPath: makeBinaryPathSetting("opencode").pipe(
@@ -667,6 +677,50 @@ export type ServerSettings = typeof ServerSettings.Type;
export const DEFAULT_SERVER_SETTINGS: ServerSettings = Schema.decodeSync(ServerSettings)({});
+/**
+ * Read the legacy `enabled` flag embedded in a provider instance config
+ * blob. The envelope-level `ProviderInstanceConfig.enabled` is the single
+ * flag going forward; this reader exists for legacy `providers.<kind>`
+ * blobs and old settings files that still carry the flag in-config.
+ */
+export const providerInstanceConfigEnabledFlag = (config: unknown): boolean | undefined => {
+ if (config === null || typeof config !== "object" || Array.isArray(config)) {
+ return undefined;
+ }
+ const enabled = (config as { readonly enabled?: unknown }).enabled;
+ return typeof enabled === "boolean" ? enabled : undefined;
+};
+
+/**
+ * Default enabled state for a built-in driver when neither the envelope nor
+ * the config blob carries a flag. Derived from the driver's settings schema
+ * through `DEFAULT_SERVER_SETTINGS`, so the schema's decoding default stays
+ * the single source of truth. Unknown (fork) drivers default to enabled.
+ */
+export const defaultEnabledForDriver = (driver: ProviderDriverKind): boolean => {
+ const legacyDefaults = DEFAULT_SERVER_SETTINGS.providers as Record<
+ string,
+ { readonly enabled?: boolean } | undefined
+ >;
+ return legacyDefaults[driver]?.enabled ?? true;
+};
+
+/**
+ * Resolve whether a configured provider instance is enabled. An explicit
+ * false on either the envelope or the in-config flag wins (most
+ * restrictive), so a user's disable is never silently undone by the other
+ * flag. Otherwise: envelope, then config, then the driver's default.
+ */
+export const resolveProviderInstanceEnabled = (
+ instance: Pick<ProviderInstanceConfig, "driver" | "enabled" | "config">,
+): boolean => {
+ const configEnabled = providerInstanceConfigEnabledFlag(instance.config);
+ if (instance.enabled === false || configEnabled === false) {
+ return false;
+ }
+ return instance.enabled ?? configEnabled ?? defaultEnabledForDriver(instance.driver);
+};
+
export const ServerSettingsOperation = Schema.Literals([
"normalize",
"check-exists",
diff --git a/packages/shared/src/serverSettings.ts b/packages/shared/src/serverSettings.ts
index 21d819a1c..69fc9eaac 100644
--- a/packages/shared/src/serverSettings.ts
+++ b/packages/shared/src/serverSettings.ts
@@ -1,6 +1,7 @@
import {
isProviderDriverKind,
isProviderAvailable,
+ resolveProviderInstanceEnabled,
type ModelSelection,
type ProviderDriverKind,
type ServerProvider,
@@ -36,7 +37,7 @@ export function isModelSelectionProviderEnabled(
): boolean {
const instanceConfig = settings.providerInstances[selection.instanceId];
if (instanceConfig !== undefined) {
- return instanceConfig.enabled ?? true;
+ return resolveProviderInstanceEnabled(instanceConfig);
}
return (