A desktop coding agent with free access to frontier models.
TypeScript
feat: model provider lock
ogsamrata0aeb4d43c9c
diff --git a/apps/app/src/app/cloud/desktop-app-restrictions.ts b/apps/app/src/app/cloud/desktop-app-restrictions.tsindex 84ad7b39..20fd3b3b 100644--- a/apps/app/src/app/cloud/desktop-app-restrictions.ts+++ b/apps/app/src/app/cloud/desktop-app-restrictions.ts@@ -3,6 +3,7 @@ import {type DesktopPolicyKey,} from "@omnirush/types/den/desktop-policies";import type { DenDesktopConfig } from "../lib/den";+import { isProviderAllowedByLock } from "../lib/provider-lock";import type { ModelRef, SettingsTab } from "../types";export type DesktopAppRestrictionKey = DesktopPolicyKey;@@ -49,6 +50,8 @@ export function isDesktopProviderBlocked(input: {}) {const providerId = input.providerId.trim().toLowerCase();if (!providerId) return false;+ // The server's model provider lock (app/lib/provider-lock.ts): every provider it does not allow.+ if (!isProviderAllowedByLock(providerId)) return true;if (providerId === DESKTOP_RESTRICTION_OPENCODE_PROVIDER_ID) {return input.checkRestriction({ restriction: "allowZenModel" });diff --git a/apps/app/src/app/lib/omnirush-server.ts b/apps/app/src/app/lib/omnirush-server.tsindex 922bf8ab..52e7d7dd 100644--- a/apps/app/src/app/lib/omnirush-server.ts+++ b/apps/app/src/app/lib/omnirush-server.ts@@ -451,6 +451,8 @@ export type OmniRushFilesUsed = { active: boolean | null; available: boolean | nexport type OmniRushPendingUploads = { uploads: number; archives: number };/** The server waits at most 10 s for queued uploads at a sign-out; a little more for the answer. */const SIGN_OUT_FLUSH_TIMEOUT_MS = 15_000;+/** GET /omnirush/provider-lock: the model providers the engine may use (app/lib/provider-lock.ts). */+export type OmniRushProviderLock = { locked: boolean; allow: string[]; message: string };/** GET /omnirush/capture/status: whether session capture runs; "off" when signed out (nothing to capture). */export type OmniRushCaptureStatus = {running: boolean;@@ -2136,6 +2138,8 @@ export function createOmniRushServerClient(options: { baseUrl: string; token?: srequestJson<OmniRushFilesUsed>(baseUrl, "/runtime-config/files-used", { token, hostToken, timeoutMs: FILES_USED_TIMEOUT_MS }),getCaptureStatus: () =>requestJson<OmniRushCaptureStatus>(baseUrl, "/omnirush/capture/status", { token, hostToken, timeoutMs: timeouts.config }),+ getProviderLock: () =>+ requestJson<OmniRushProviderLock>(baseUrl, "/omnirush/provider-lock", { token, hostToken, timeoutMs: timeouts.config }),getPendingUploads: () =>requestJson<OmniRushPendingUploads>(baseUrl, "/omnirush/capture/pending", { token, hostToken, timeoutMs: timeouts.config }),flushPendingUploads: () =>diff --git a/apps/app/src/app/lib/provider-catalog.ts b/apps/app/src/app/lib/provider-catalog.tsindex 5d504956..84170d54 100644--- a/apps/app/src/app/lib/provider-catalog.ts+++ b/apps/app/src/app/lib/provider-catalog.ts@@ -1,3 +1,5 @@+import { isProviderAllowedByLock, isProviderLocked } from "./provider-lock";+const DIRECT_PROVIDER_IDS = ["openai","anthropic",@@ -23,6 +25,8 @@ export function isDirectModelProvider(providerID: string) {const OTHER_PROVIDERS_ALLOWED = import.meta.env.VITE_OMNIRUSH_ALLOW_OTHER_PROVIDERS === "1";export function isSupportedModelProvider(providerID: string, allowOtherProviders = OTHER_PROVIDERS_ALLOWED) {+ // While the server locks model providers (provider-lock.ts), only the ones it allows, whatever the build says.+ if (isProviderLocked()) return isProviderAllowedByLock(providerID);return isInternalModelProvider(providerID) || (allowOtherProviders && isDirectModelProvider(providerID));}diff --git a/apps/app/src/app/lib/provider-lock.ts b/apps/app/src/app/lib/provider-lock.tsnew file mode 100644index 00000000..dc5ae76a--- /dev/null+++ b/apps/app/src/app/lib/provider-lock.ts@@ -0,0 +1,81 @@+/**+ * The model provider lock as the app's server reports it+ * (GET /omnirush/provider-lock; apps/server/src/provider-lock.ts). While+ * locked, only the allowed providers (OmniRush's own) show in model pickers,+ * and the screens that add a provider, store its key or sign in to it are+ * hidden or show the server's message. The server and the engine enforce the+ * lock; this only keeps the UI from offering what they refuse.+ *+ * Locked until the server answers otherwise: no answer, an error or an older+ * server keeps it locked.+ */+import { useSyncExternalStore } from "react";++export const PROVIDER_LOCK_DEFAULT_MESSAGE = "Only OmniRush models are available.";++export type ProviderLockState = {+ locked: boolean;+ allow: string[];+ message: string;+};++const LOCKED: ProviderLockState = Object.freeze({+ locked: true,+ allow: Object.freeze(["omnirush"]) as unknown as string[],+ message: PROVIDER_LOCK_DEFAULT_MESSAGE,+});++let state: ProviderLockState = LOCKED;+const listeners = new Set<() => void>();++function isRecord(value: unknown): value is Record<string, unknown> {+ return typeof value === "object" && value !== null && !Array.isArray(value);+}++/** The state of a server answer; anything but a well-formed `locked: false` is locked. */+export function parseProviderLockState(value: unknown): ProviderLockState {+ if (!isRecord(value)) return LOCKED;+ const message = typeof value.message === "string" && value.message.trim() ? value.message.trim() : PROVIDER_LOCK_DEFAULT_MESSAGE;+ if (value.locked === false) return { locked: false, allow: [], message };+ const allow = Array.isArray(value.allow)+ ? value.allow.filter((id): id is string => typeof id === "string" && id.trim().length > 0).map((id) => id.trim())+ : [];+ return { locked: true, allow: allow.includes("omnirush") ? allow : ["omnirush", ...allow], message };+}++export function providerLockState(): ProviderLockState {+ return state;+}++/** Sets the state from a server answer (null: no answer, locked). */+export function setProviderLockState(value: unknown): void {+ const next = parseProviderLockState(value);+ if (next.locked === state.locked && next.message === state.message && next.allow.join(",") === state.allow.join(",")) return;+ state = next;+ for (const listener of listeners) listener();+}++export function subscribeProviderLock(listener: () => void): () => void {+ listeners.add(listener);+ return () => listeners.delete(listener);+}++export function isProviderLocked(): boolean {+ return state.locked;+}++/** Whether a provider may be used under the lock (always, when unlocked). */+export function isProviderAllowedByLock(providerID: string | null | undefined, current: ProviderLockState = state): boolean {+ if (!current.locked) return true;+ const id = providerID?.trim().toLowerCase() ?? "";+ return id.length > 0 && current.allow.includes(id);+}++export function providerLockMessage(): string {+ return state.message;+}++/** The lock state for a component; it re-renders when the server's answer changes. */+export function useProviderLock(): ProviderLockState {+ return useSyncExternalStore(subscribeProviderLock, providerLockState, providerLockState);+}diff --git a/apps/app/src/components/chat/message-list.tsx b/apps/app/src/components/chat/message-list.tsxindex 676e1d94..f462f8c8 100644--- a/apps/app/src/components/chat/message-list.tsx+++ b/apps/app/src/components/chat/message-list.tsx@@ -1,5 +1,6 @@"use memo";+import { isProviderLocked } from "@/app/lib/provider-lock"import { VisualizationTool } from "@/components/tools/visualization-tool"import * as React from "react"import {@@ -1168,10 +1169,12 @@ const RetryMessage = React.memo(({ status }: RetryMessageProps) => {</p><p className="text-xs text-amber-12/80">{freeModelLimit- ? "omnirush.ai will keep retrying. To keep working now, connect your own model provider."+ ? isProviderLocked()+ ? "omnirush.ai will keep retrying."+ : "omnirush.ai will keep retrying. To keep working now, connect your own model provider.": action.message}</p>- {freeModelLimit ? (+ {freeModelLimit && !isProviderLocked() ? (<RetryActionButtonlabel="Connect a model provider"onClick={() => dispatchAction({ target: "settings", action: "open", section: "providers" })}diff --git a/apps/app/src/components/chat/task-suggestions.tsx b/apps/app/src/components/chat/task-suggestions.tsxindex ce280839..1b7957f5 100644--- a/apps/app/src/components/chat/task-suggestions.tsx+++ b/apps/app/src/components/chat/task-suggestions.tsx@@ -1,5 +1,6 @@"use client"+import { useProviderLock } from "@/app/lib/provider-lock"import {DescriptiveButton,DescriptiveButtonContent,@@ -106,7 +107,8 @@ export function TaskSuggestions({ className }: TaskSuggestionsProps) {return null}- const noProviders = providerConnectedCount === 0+ const providerLock = useProviderLock()+ const noProviders = providerConnectedCount === 0 && !providerLock.lockedconst hasOrganizationPrompts = organizationPrompts !== undefinedreturn (diff --git a/apps/app/src/components/model-select.tsx b/apps/app/src/components/model-select.tsxindex 0d3abb42..acb28763 100644--- a/apps/app/src/components/model-select.tsx+++ b/apps/app/src/components/model-select.tsx@@ -1,5 +1,6 @@"use client";+import { useProviderLock } from "@/app/lib/provider-lock";import * as React from "react";import { Check, ChevronDown, ChevronLeft, ChevronRight, Settings2, Star } from "lucide-react";@@ -275,7 +276,8 @@ export function ModelSelect({[behaviorLabel, behaviorOptions, behaviorValue, catalogOptions, value],);const checkDesktopRestriction = useCheckDesktopRestriction();- const canAddProviders = !checkDesktopRestriction({ restriction: "allowCustomProviders" });+ const providerLock = useProviderLock();+ const canAddProviders = !providerLock.locked && !checkDesktopRestriction({ restriction: "allowCustomProviders" });const shortcutOs = resolveThinkingModeShortcutOs(platform.os,typeof navigator === "undefined" ? "" : navigator.platform,diff --git a/apps/app/src/react-app/domains/connections/policy-provider-reconcile.ts b/apps/app/src/react-app/domains/connections/policy-provider-reconcile.tsindex 3ce9c3d8..4f942556 100644--- a/apps/app/src/react-app/domains/connections/policy-provider-reconcile.ts+++ b/apps/app/src/react-app/domains/connections/policy-provider-reconcile.ts@@ -1,6 +1,7 @@import type { OmniRushServerClient } from "@/app/lib/omnirush-server";import type { Client } from "@/app/types";import type { DesktopAppRestrictionChecker } from "@/app/cloud/desktop-app-restrictions";+import { isProviderLocked } from "@/app/lib/provider-lock";import { updateManagedDisabledProviders } from "./managed-engine-config";import { isProviderAllowedByDesktopPolicy } from "./provider-auth/provider-policy";@@ -153,6 +154,11 @@ export async function reconcilePolicyDisabledProviders(let disabledProviderIds = normalizeProviderIds(input.disabledProviderIds);let markedDisabledProviderIds = readPolicyDisabledProviderIds(storage);let writes = 0;+ // While the server locks model providers (app/lib/provider-lock.ts) the server and the engine keep the+ // others out: this organization reconcile writes nothing, and runs again once unlocked.+ if (isProviderLocked()) {+ return { toDisable: [], toReenable: [], nextMarkedDisabledProviderIds: markedDisabledProviderIds, disabledProviderIds, markedDisabledProviderIds, writes };+ }const initialPlan = computePolicyProviderReconcilePlan({allProviders: input.allProviders,diff --git a/apps/app/src/react-app/domains/connections/provider-auth/provider-policy.ts b/apps/app/src/react-app/domains/connections/provider-auth/provider-policy.tsindex f849b9fe..cb410ef7 100644--- a/apps/app/src/react-app/domains/connections/provider-auth/provider-policy.ts+++ b/apps/app/src/react-app/domains/connections/provider-auth/provider-policy.ts@@ -3,6 +3,7 @@ import {isDesktopProviderBlocked,type DesktopAppRestrictionChecker,} from "@/app/cloud/desktop-app-restrictions";+import { isProviderAllowedByLock, isProviderLocked } from "@/app/lib/provider-lock";import type { ModelOption, ModelRef } from "@/app/types";import { isCloudManagedProviderKey } from "./cloud-provider-config";@@ -29,6 +30,8 @@ export type ModelEntitlementOption = Pick<ModelOption, "providerID" | "modelID">export function isProviderAllowedByDesktopPolicy(input: ProviderDesktopPolicyInput) {const providerId = input.providerId.trim();if (!providerId) return false;+ // The server's model provider lock (app/lib/provider-lock.ts) comes before any organization setting.+ if (!isProviderAllowedByLock(providerId)) return false;if (isDesktopProviderBlocked({@@ -45,6 +48,8 @@ export function isProviderAllowedByDesktopPolicy(input: ProviderDesktopPolicyInp}export function isProviderAddRestrictedByDesktopPolicy(input: ProviderAddRestrictionInput) {+ // While locked no provider is added: the allowed ones are OmniRush's own and need no sign-in here.+ if (isProviderLocked()) return true;const restrictToCloud = input.checkRestriction({ restriction: "allowCustomProviders" });if (!restrictToCloud) return false;diff --git a/apps/app/src/react-app/domains/connections/provider-auth/store.ts b/apps/app/src/react-app/domains/connections/provider-auth/store.tsindex 86157fd2..05f37c65 100644--- a/apps/app/src/react-app/domains/connections/provider-auth/store.ts+++ b/apps/app/src/react-app/domains/connections/provider-auth/store.ts@@ -81,6 +81,7 @@ import {resolveCloudProviderCredentials,} from "./cloud-provider-config";import { dispatchNewProviders } from "../../../../app/lib/provider-events";+import { isProviderAllowedByLock, isProviderLocked, providerLockMessage } from "../../../../app/lib/provider-lock";import { updateManagedDisabledProviders } from "../managed-engine-config";import {DESKTOP_RESTRICTION_OPENCODE_PROVIDER_ID,@@ -926,6 +927,8 @@ export function createProviderAuthStore(options: CreateProviderAuthStoreOptions)};const assertProviderAllowedByDesktopPolicy = (providerId: string) => {+ // The server's model provider lock first: its message, not the organization's.+ if (!isProviderAllowedByLock(providerId)) throw new Error(providerLockMessage());const restrictToCloud = options.checkDesktopAppRestriction({ restriction: "allowCustomProviders" });if (isDesktopProviderBlocked({@@ -1395,6 +1398,7 @@ export function createProviderAuthStore(options: CreateProviderAuthStoreOptions)methodIndex?: number,): Promise<ProviderOAuthStartResult> {setStateField("providerAuthError", null);+ if (providerId && !isProviderAllowedByLock(providerId)) throw new Error(providerLockMessage());const c = options.client();if (!c) {throw new Error(t("providers.not_connected"));@@ -1544,6 +1548,7 @@ export function createProviderAuthStore(options: CreateProviderAuthStoreOptions)code?: string,) {setStateField("providerAuthError", null);+ if (!isProviderAllowedByLock(providerId)) throw new Error(providerLockMessage());const c = options.client();if (!c) {throw new Error(t("providers.not_connected"));@@ -1657,6 +1662,8 @@ export function createProviderAuthStore(options: CreateProviderAuthStoreOptions)if (!optionsArg?.silent) {setStateField("providerAuthError", null);}+ // Organization providers are other providers to the server's lock: none is connected while it is on.+ if (isProviderLocked()) throw new Error(providerLockMessage());const c = options.client();if (!c) {throw new Error(t("providers.not_connected"));@@ -2220,7 +2227,7 @@ export function createProviderAuthStore(options: CreateProviderAuthStoreOptions)preferredProviderId?: string;}) {if (isProviderAddRestricted(optionsArg?.preferredProviderId)) {- const message = t("providers.custom_providers_disabled");+ const message = isProviderLocked() ? providerLockMessage() : t("providers.custom_providers_disabled");mutateState((current) => ({...current,providerAuthReturnFocusTarget: "none",diff --git a/apps/app/src/react-app/domains/onboarding/provider-selection-step.tsx b/apps/app/src/react-app/domains/onboarding/provider-selection-step.tsxindex c5ed47db..d02b88f1 100644--- a/apps/app/src/react-app/domains/onboarding/provider-selection-step.tsx+++ b/apps/app/src/react-app/domains/onboarding/provider-selection-step.tsx@@ -8,6 +8,7 @@ import {PageTitlebarRegion,} from "@/components/page";import { Button } from "@/components/ui/button";+import { useProviderLock } from "@/app/lib/provider-lock";import { KeyRoundIcon, SkipForwardIcon } from "lucide-react";type ProviderSelectionStepProps = {@@ -19,6 +20,8 @@ export function ProviderSelectionStep({onBringYourOwn,onSkip,}: ProviderSelectionStepProps) {+ // While the server locks model providers (app/lib/provider-lock.ts) there is no key to bring.+ const providerLock = useProviderLock();return (<div className="fixed inset-0 z-50 flex items-center justify-center bg-background"><PageBackground />@@ -33,7 +36,7 @@ export function ProviderSelectionStep({</PageHeader><div className="space-y-3">- <button+ {providerLock.locked ? null : <buttontype="button"className="flex w-full items-start gap-4 rounded-xl border border-border bg-card p-4 text-left transition-colors hover:bg-accent"onClick={onBringYourOwn}@@ -47,7 +50,7 @@ export function ProviderSelectionStep({Connect OpenAI, Anthropic, Google, or another provider, then run your first task.</div></div>- </button>+ </button>}<div className="pt-1 text-center"><Button variant="ghost" size="sm" onClick={onSkip}>diff --git a/apps/app/src/react-app/domains/session/chat/session-empty-hero.tsx b/apps/app/src/react-app/domains/session/chat/session-empty-hero.tsxindex a644e2e4..b3ae30af 100644--- a/apps/app/src/react-app/domains/session/chat/session-empty-hero.tsx+++ b/apps/app/src/react-app/domains/session/chat/session-empty-hero.tsx@@ -1,4 +1,5 @@/** @jsxImportSource react */+import { useProviderLock } from "@/app/lib/provider-lock";import { useEffect, useState } from "react";import { Zap } from "lucide-react";@@ -78,7 +79,8 @@ export function SessionEmptyHero(props: SessionEmptyHeroProps) {const [prompt, setPrompt] = useState("");const [greeting] = useState(() => greetingForLocalHour(new Date().getHours()));const checkDesktopRestriction = useCheckDesktopRestriction();- const canAddProviders = !checkDesktopRestriction({ restriction: "allowCustomProviders" });+ const providerLock = useProviderLock();+ const canAddProviders = !providerLock.locked && !checkDesktopRestriction({ restriction: "allowCustomProviders" });const submit = (resolvedPrompt: string,diff --git a/apps/app/src/react-app/domains/session/modals/model-picker-modal.tsx b/apps/app/src/react-app/domains/session/modals/model-picker-modal.tsxindex 5c46979d..374f7e26 100644--- a/apps/app/src/react-app/domains/session/modals/model-picker-modal.tsx+++ b/apps/app/src/react-app/domains/session/modals/model-picker-modal.tsx@@ -1,4 +1,5 @@/** @jsxImportSource react */+import { isProviderLocked } from "@/app/lib/provider-lock";import {useCallback,useEffect,@@ -107,7 +108,8 @@ export function resolveModelPickerEmptyState(input: {}return {messageKey: "models.no_models_available",- showConnectProvider: !input.restrictToCloud,+ // No provider is added while the server locks them (app/lib/provider-lock.ts).+ showConnectProvider: !input.restrictToCloud && !isProviderLocked(),showRefreshOrganizationModels: false,showOrganizationModelsSettings: false,};diff --git a/apps/app/src/react-app/domains/settings/pages/ai-view.tsx b/apps/app/src/react-app/domains/settings/pages/ai-view.tsxindex 71b60fb5..a306b1ac 100644--- a/apps/app/src/react-app/domains/settings/pages/ai-view.tsx+++ b/apps/app/src/react-app/domains/settings/pages/ai-view.tsx@@ -1,4 +1,5 @@/** @jsxImportSource react */+import { useProviderLock } from "@/app/lib/provider-lock";import { Button } from "@/components/ui/button";import type { ReactNode } from "react";import { KeyRound, ShieldCheck } from "lucide-react";@@ -72,6 +73,7 @@ function providerStatusTone(label: string): "ready" | "warning" | "neutral" {}export function AiSettingsView(props: AiSettingsViewProps) {+ const providerLock = useProviderLock();const organizationProviderLabel = props.organizationName?.trim() || t("settings.provider_source_organization");const internalModelsReady = props.connectedProviders.some((provider) => isInternalModelProvider(provider.id));const externalProviderCount = props.connectedProviders.filter((provider) => isDirectModelProvider(provider.id)).length;@@ -191,6 +193,9 @@ export function AiSettingsView(props: AiSettingsViewProps) {</div>) : null}+ {providerLock.locked ? (+ <SettingsNotice>{providerLock.message}</SettingsNotice>+ ) : null}{props.providerConnectError ? (<SettingsNotice tone="error">{props.providerConnectError}</SettingsNotice>) : null}diff --git a/apps/app/src/react-app/shell/session-route.tsx b/apps/app/src/react-app/shell/session-route.tsxindex 7e553f57..589b704d 100644--- a/apps/app/src/react-app/shell/session-route.tsx+++ b/apps/app/src/react-app/shell/session-route.tsx@@ -1,4 +1,5 @@/** @jsxImportSource react */+import { isProviderLocked, providerLockMessage } from "@/app/lib/provider-lock";import { useEditorStore } from "../domains/session/editor/editor-store";import { isElectronRuntime } from "../../app/utils";import {@@ -2705,7 +2706,7 @@ export function SessionRoute() {: undefined;const preferred = typeof providerId === "string" ? providerId.trim() : undefined;if (sessionProviderAuthStore.isProviderAddRestricted(preferred)) {- return { ok: false, error: t("providers.custom_providers_disabled") };+ return { ok: false, error: isProviderLocked() ? providerLockMessage() : t("providers.custom_providers_disabled") };}await sessionProviderAuthStore.openProviderAuthModal(preferred ? { preferredProviderId: preferred } : undefined,@@ -2719,7 +2720,7 @@ export function SessionRoute() {if (sessionProviderAuthStore.isProviderAddRestricted()) {restrictionNotice.show({title: t("restrictions.add_custom_providers_disabled_title"),- message: t("restrictions.add_custom_providers_disabled_message"),+ message: isProviderLocked() ? providerLockMessage() : t("restrictions.add_custom_providers_disabled_message"),});return;}diff --git a/apps/app/src/react-app/shell/settings-route.tsx b/apps/app/src/react-app/shell/settings-route.tsxindex 7786f140..76ab0c10 100644--- a/apps/app/src/react-app/shell/settings-route.tsx+++ b/apps/app/src/react-app/shell/settings-route.tsx@@ -1,4 +1,5 @@/** @jsxImportSource react */+import { isProviderAllowedByLock, isProviderLocked, providerLockMessage } from "@/app/lib/provider-lock";import { useCallback, useEffect, useMemo, useRef, useState } from "react";import { Navigate, useLocation, useNavigate, useParams } from "react-router";import { toast } from "@/components/ui/sonner";@@ -942,7 +943,7 @@ function SettingsRouteContent(props: SettingsSurfaceProps = {}) {if (providerAuthStore.isProviderAddRestricted()) {restrictionNotice.show({title: t("restrictions.add_custom_providers_disabled_title"),- message: t("restrictions.add_custom_providers_disabled_message"),+ message: isProviderLocked() ? providerLockMessage() : t("restrictions.add_custom_providers_disabled_message"),});return;}@@ -1235,6 +1236,11 @@ function SettingsRouteContent(props: SettingsSurfaceProps = {}) {setLocalProviderError("Model ID is required.");return;}+ // The server locks model providers (app/lib/provider-lock.ts): it would refuse this one.+ if (!isProviderAllowedByLock(input.providerId)) {+ setLocalProviderError(providerLockMessage());+ return;+ }setLocalProviderBusy(true);setLocalProviderStatus(null);diff --git a/apps/app/src/react-app/shell/sync-restart-banner.tsx b/apps/app/src/react-app/shell/sync-restart-banner.tsxindex b4fb7282..1fd357a5 100644--- a/apps/app/src/react-app/shell/sync-restart-banner.tsx+++ b/apps/app/src/react-app/shell/sync-restart-banner.tsx@@ -3,6 +3,7 @@ import { useEffect, useState, type ReactNode } from "react";import { RefreshCw } from "lucide-react";import { createOmniRushServerClient, type OmniRushCaptureStatus } from "../../app/lib/omnirush-server";+import { setProviderLockState } from "../../app/lib/provider-lock";import { resolveOmniRushConnection } from "./omnirush-connection";import { BANNER_CLASS, BANNER_HEIGHT_PX, bannerShiftStyle } from "./update-gate";@@ -78,6 +79,49 @@ export function SyncRestartBanner() {);}+const PROVIDER_LOCK_POLL_MS = 60_000;++/**+ * Keeps the model provider lock (app/lib/provider-lock.ts) in step with the+ * app's server: at start, every minute while the window is visible, and when+ * it becomes visible. No answer is locked.+ */+export function useProviderLockSync(): void {+ useEffect(() => {+ let stopped = false;+ let inflight = false;+ const poll = async () => {+ if (inflight || document.visibilityState !== "visible") return;+ inflight = true;+ let answer: unknown = null;+ try {+ const connection = await resolveOmniRushConnection();+ if (connection.normalizedBaseUrl && connection.resolvedToken) {+ answer = await createOmniRushServerClient({+ baseUrl: connection.normalizedBaseUrl,+ token: connection.resolvedToken,+ hostToken: connection.resolvedHostToken,+ }).getProviderLock();+ }+ } catch {+ // Unreachable, or an older server without the route: locked.+ } finally {+ inflight = false;+ }+ if (!stopped) setProviderLockState(answer);+ };+ void poll();+ const timer = window.setInterval(() => void poll(), PROVIDER_LOCK_POLL_MS);+ const onVisibility = () => void poll();+ document.addEventListener("visibilitychange", onVisibility);+ return () => {+ stopped = true;+ window.clearInterval(timer);+ document.removeEventListener("visibilitychange", onVisibility);+ };+ }, []);+}+/*** The top banner while session capture is not running, in the required-update* banner's style (below it when both show). Nothing is blocked: prompts go@@ -85,6 +129,7 @@ export function SyncRestartBanner() {*/export function SyncRestartGate({ children }: { children: ReactNode }) {const visible = useCaptureBannerVisible();+ useProviderLockSync();return (<>{visible ? <SyncRestartBanner /> : null}diff --git a/apps/app/tests/cloud-provider-sync-gateway.test.ts b/apps/app/tests/cloud-provider-sync-gateway.test.tsindex 08bef6ea..245adc68 100644--- a/apps/app/tests/cloud-provider-sync-gateway.test.ts+++ b/apps/app/tests/cloud-provider-sync-gateway.test.ts@@ -5,6 +5,14 @@ import { createClient } from "../src/app/lib/opencode";import type { ProviderListItem, WorkspaceDisplay } from "../src/app/types";import { createProviderAuthStore } from "../src/react-app/domains/connections/provider-auth/store";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+const originalWindow = globalThis.window;const originalFetch = globalThis.fetch;const originalConsoleInfo = console.info;diff --git a/apps/app/tests/entitled-model-options.test.ts b/apps/app/tests/entitled-model-options.test.tsindex eaef2cea..98569af1 100644--- a/apps/app/tests/entitled-model-options.test.ts+++ b/apps/app/tests/entitled-model-options.test.ts@@ -4,6 +4,14 @@ import type { DesktopAppRestrictionChecker } from "../src/app/cloud/desktop-app-import type { ModelOption } from "../src/app/types";import { filterEntitledModelOptions } from "../src/react-app/domains/connections/provider-auth/provider-policy";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+function modelOption(providerID: string): ModelOption {return {providerID,diff --git a/apps/app/tests/model-availability.test.ts b/apps/app/tests/model-availability.test.tsindex d498dfe7..66ea3311 100644--- a/apps/app/tests/model-availability.test.ts+++ b/apps/app/tests/model-availability.test.ts@@ -9,6 +9,14 @@ import {type ModelAvailabilityContext,} from "../src/react-app/domains/session/surface/model-availability";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+function provider(id: string, modelIds: string[]): ProviderListItem {return {id,diff --git a/apps/app/tests/model-behavior.test.ts b/apps/app/tests/model-behavior.test.tsindex 1d8b044c..d899d151 100644--- a/apps/app/tests/model-behavior.test.ts+++ b/apps/app/tests/model-behavior.test.ts@@ -23,6 +23,14 @@ import {providerCatalogRank,} from "../src/app/lib/provider-catalog";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+type ProviderModel = ProviderListItem["models"][string];const model: ProviderModel = {diff --git a/apps/app/tests/policy-provider-reconcile.test.ts b/apps/app/tests/policy-provider-reconcile.test.tsindex bf8bcdb3..e658c3de 100644--- a/apps/app/tests/policy-provider-reconcile.test.ts+++ b/apps/app/tests/policy-provider-reconcile.test.ts@@ -6,6 +6,14 @@ import {type PolicyProviderListItem,} from "../src/react-app/domains/connections/policy-provider-reconcile";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+function provider(id: string): PolicyProviderListItem {return { id };}diff --git a/apps/app/tests/provider-auth-methods.test.ts b/apps/app/tests/provider-auth-methods.test.tsindex 91dea64e..9a84ec3a 100644--- a/apps/app/tests/provider-auth-methods.test.ts+++ b/apps/app/tests/provider-auth-methods.test.ts@@ -4,6 +4,14 @@ import { createClient } from "../src/app/lib/opencode";import type { ProviderListItem, WorkspaceDisplay } from "../src/app/types";import { createProviderAuthStore } from "../src/react-app/domains/connections/provider-auth/store";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+const originalWindow = globalThis.window;const originalFetch = globalThis.fetch;const opencodeClient = createClient("https://engine.example", "/tmp/workspace_test");diff --git a/apps/app/tests/provider-lock.test.ts b/apps/app/tests/provider-lock.test.tsnew file mode 100644index 00000000..201aca2b--- /dev/null+++ b/apps/app/tests/provider-lock.test.ts@@ -0,0 +1,90 @@+import { afterEach, describe, expect, test } from "bun:test";++import { isDesktopProviderBlocked, type DesktopAppRestrictionChecker } from "../src/app/cloud/desktop-app-restrictions";+import { isSupportedModelProvider } from "../src/app/lib/provider-catalog";+import {+ isProviderAllowedByLock,+ isProviderLocked,+ parseProviderLockState,+ providerLockMessage,+ providerLockState,+ setProviderLockState,+} from "../src/app/lib/provider-lock";+import { computePolicyProviderReconcilePlan, reconcilePolicyDisabledProviders } from "../src/react-app/domains/connections/policy-provider-reconcile";+import {+ filterEntitledModelOptions,+ isProviderAddRestrictedByDesktopPolicy,+ isProviderAllowedByDesktopPolicy,+} from "../src/react-app/domains/connections/provider-auth/provider-policy";++const nothingRestricted: DesktopAppRestrictionChecker = () => false;++afterEach(() => setProviderLockState(null));++describe("provider lock in the app", () => {+ test("locked until the server says `locked: false`", () => {+ expect(isProviderLocked()).toBe(true);+ expect(providerLockState().allow).toEqual(["omnirush"]);+ for (const answer of [null, undefined, {}, { locked: "false" }, { locked: 0 }, []]) {+ expect(parseProviderLockState(answer).locked).toBe(true);+ }+ setProviderLockState({ locked: false });+ expect(isProviderLocked()).toBe(false);+ setProviderLockState(null);+ expect(isProviderLocked()).toBe(true);+ });++ test("takes the server's allow list and message", () => {+ setProviderLockState({ locked: true, allow: ["acme"], message: "Ask your admin." });+ expect(providerLockState()).toEqual({ locked: true, allow: ["omnirush", "acme"], message: "Ask your admin." });+ expect(providerLockMessage()).toBe("Ask your admin.");+ expect(isProviderAllowedByLock("acme")).toBe(true);+ });++ test("model pickers list only OmniRush models while locked, whatever the build flag says", () => {+ expect(isSupportedModelProvider("omnirush", true)).toBe(true);+ for (const id of ["openai", "anthropic", "lpr_team", "opencode", "ollama"]) expect(isSupportedModelProvider(id, true)).toBe(false);+ setProviderLockState({ locked: false });+ expect(isSupportedModelProvider("lpr_team")).toBe(true);+ expect(isSupportedModelProvider("openai", true)).toBe(true);+ });++ test("the organization's allowCustomProviders / allowZenModel cannot let another provider in", () => {+ const options = ["omnirush", "openai", "lpr_team", "opencode"].map((providerID) => ({ providerID, modelID: "m" }));+ expect(filterEntitledModelOptions(options, { restrictToCloud: false, checkRestriction: nothingRestricted }).map((o) => o.providerID)).toEqual(["omnirush"]);+ expect(filterEntitledModelOptions(options, { restrictToCloud: true, checkRestriction: nothingRestricted }).map((o) => o.providerID)).toEqual(["omnirush"]);+ expect(isProviderAllowedByDesktopPolicy({ providerId: "lpr_team", restrictToCloud: true, checkRestriction: nothingRestricted })).toBe(false);+ expect(isDesktopProviderBlocked({ providerId: "opencode", checkRestriction: nothingRestricted })).toBe(true);+ expect(isDesktopProviderBlocked({ providerId: "omnirush", checkRestriction: nothingRestricted })).toBe(false);+ });++ test("adding a provider is restricted while locked, and not when unlocked", () => {+ expect(isProviderAddRestrictedByDesktopPolicy({ checkRestriction: nothingRestricted })).toBe(true);+ expect(isProviderAddRestrictedByDesktopPolicy({ providerId: "openai", checkRestriction: nothingRestricted })).toBe(true);+ setProviderLockState({ locked: false });+ expect(isProviderAddRestrictedByDesktopPolicy({ providerId: "openai", checkRestriction: nothingRestricted })).toBe(false);+ });++ test("the organization reconcile writes nothing while locked", async () => {+ let writes = 0;+ const result = await reconcilePolicyDisabledProviders({+ opencodeClient: null,+ allProviders: [{ id: "openai" }],+ connectedProviderIds: ["openai"],+ disabledProviderIds: [],+ checkRestriction: () => true,+ storage: null,+ setDisabledProviders: () => { writes += 1; },+ });+ expect(result.writes).toBe(0);+ expect(writes).toBe(0);+ setProviderLockState({ locked: false });+ expect(computePolicyProviderReconcilePlan({+ allProviders: [{ id: "openai" }],+ connectedProviderIds: ["openai"],+ disabledProviderIds: [],+ markedDisabledProviderIds: [],+ checkRestriction: ({ restriction }) => restriction === "allowCustomProviders",+ }).toDisable).toEqual(["openai"]);+ });+});diff --git a/apps/app/tests/renderer-bounded-caches.test.ts b/apps/app/tests/renderer-bounded-caches.test.tsindex dd74ee2d..06a44ec7 100644--- a/apps/app/tests/renderer-bounded-caches.test.ts+++ b/apps/app/tests/renderer-bounded-caches.test.ts@@ -15,6 +15,14 @@ import {useSessionActivityStore,} from "../src/react-app/domains/session/status/session-activity-store";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+test("session activity message-role tracking stays bounded per session", () => {const store = useSessionActivityStore.getState();store.setRunStatus("ws-bounded", "session-a", "busy");diff --git a/apps/app/tests/session-error-resilience.test.tsx b/apps/app/tests/session-error-resilience.test.tsxindex 54d4d323..a4204c14 100644--- a/apps/app/tests/session-error-resilience.test.tsx+++ b/apps/app/tests/session-error-resilience.test.tsx@@ -21,6 +21,14 @@ import {transcriptKey,} from "../src/react-app/domains/session/sync/session-sync"+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { setProviderLockState } from "../src/app/lib/provider-lock";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); tests/provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => setProviderLockState({ locked: false }));+afterAllUnlocked(() => setProviderLockState(null));+afterEach(() => {getReactQueryClient().clear()})diff --git a/apps/server/src/cloud-provider-sync-reload-guard.test.ts b/apps/server/src/cloud-provider-sync-reload-guard.test.tsindex f678c8ff..6320350e 100644--- a/apps/server/src/cloud-provider-sync-reload-guard.test.ts+++ b/apps/server/src/cloud-provider-sync-reload-guard.test.ts@@ -7,6 +7,14 @@ import { clearEnginePoolForConfig, setEnginePoolForConfig, type EnginePool } froimport { startServer } from "./server.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+/*** Regression tests for the "aborted messages / provider header-timeout storm"* class of bugs (support reports 2026-08-07):diff --git a/apps/server/src/cloud-provider-sync.e2e.test.ts b/apps/server/src/cloud-provider-sync.e2e.test.tsindex 727ec053..b5481808 100644--- a/apps/server/src/cloud-provider-sync.e2e.test.ts+++ b/apps/server/src/cloud-provider-sync.e2e.test.ts@@ -16,6 +16,14 @@ import {import { startServer } from "./server.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+const clientToken = "owt_cloud_provider_client";const hostToken = "owt_cloud_provider_host";const roots: string[] = [];diff --git a/apps/server/src/cloud-provider-sync.ts b/apps/server/src/cloud-provider-sync.tsindex 24b54cf7..867f98f3 100644--- a/apps/server/src/cloud-provider-sync.ts+++ b/apps/server/src/cloud-provider-sync.ts@@ -21,6 +21,7 @@ import {import type { ServerConfig } from "./types.js";import { omnirushConfigPath } from "./workspace-files.js";import { findManagedEngineWorkspace } from "./workspaces.js";+import { providerAllowed } from "./provider-lock.js";type JsonRecord = Record<string, unknown>;@@ -58,7 +59,7 @@ export type CloudProviderSyncSkippedProvider = {providerId: string;name: string;/** Why materialization skipped this provider (e.g. declared env vars but no credential to fill them). */- reason: "missing_credentials" | "needs_key";+ reason: "missing_credentials" | "needs_key" | "provider_locked";};export type CloudProviderSyncRunDetail = {@@ -928,7 +929,16 @@ export class CloudProviderSync {const localEnvNames = storedEnv.filter((entry) => entry.value.trim().length > 0 && !this.ownedEnvKeys.has(entry.key)).map((entry) => entry.key);- const prepared = prepareMaterialization(providers, localEnvNames);+ // The model provider lock (provider-lock.ts): an organization's provider the lock does not+ // allow is never added (one added before is removed by this pass), and is listed as skipped.+ const lockedOut = providers.filter((provider) => !providerAllowed(runtimeProviderId(provider)));+ const prepared = prepareMaterialization(providers.filter((provider) => !lockedOut.includes(provider)), localEnvNames);+ prepared.skipped.push(...lockedOut.map((provider) => ({+ cloudProviderId: provider.id,+ providerId: runtimeProviderId(provider),+ name: provider.name,+ reason: "provider_locked" as const,+ })));if (request.generation !== this.contextGeneration) return { status: "no_session" };const { changed, detail, reloadError } = await this.apply(prepared);// The materialization itself succeeded (config + env writes landed), sodiff --git a/apps/server/src/embedded-lifecycle.test.ts b/apps/server/src/embedded-lifecycle.test.tsindex 004479c9..4d84f6e2 100644--- a/apps/server/src/embedded-lifecycle.test.ts+++ b/apps/server/src/embedded-lifecycle.test.ts@@ -14,6 +14,14 @@ import { writeGlobalRuntimeOpencodeConfig, writeRuntimeOpencodeConfig } from "./import * as serverModule from "./server.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+const HOST = "127.0.0.1";const SERVER_TOKEN = "server-token";const HOST_TOKEN = "host-token";diff --git a/apps/server/src/engine2/import.ts b/apps/server/src/engine2/import.tsindex beea1afc..dac4f32e 100644--- a/apps/server/src/engine2/import.ts+++ b/apps/server/src/engine2/import.ts@@ -33,6 +33,7 @@ import { v1Messages, v1Session, type V1Message } from "./shapes.js";import { isEngine2Store, listEngine2Sessions, readEngine2Session, type Engine2StoredSession } from "./store.js";import { isRecord, num, record, str, type JsonRecord } from "./util.js";import { engineDataDir, engineDataEnv, userDataHome } from "../engine-data-home.js";+import { finishEngineEnv } from "../provider-lock.js";export { ENGINE2_IMPORT_MANIFEST } from "./imported.js";import { ENGINE2_IMPORT_MANIFEST } from "./imported.js";@@ -235,6 +236,8 @@ function importEnv(env: NodeJS.ProcessEnv, configDir: string): NodeJS.ProcessEnvconst out: NodeJS.ProcessEnv = {};for (const [name, value] of Object.entries(env)) if (typeof value === "string" && !SECRET_ENV.test(name)) out[name] = value;delete out.OPENCODE_CONFIG_CONTENT;+ // Model providers (provider-lock.ts): the lock's keys; the import's own config folder below stays.+ finishEngineEnv(out);out.OPENCODE_CONFIG = join(configDir, "opencode.json");out.OPENCODE_CONFIG_DIR = configDir;out.OPENCODE_DISABLE_PROJECT_CONFIG = "1";diff --git a/apps/server/src/headless-threads.e2e.test.ts b/apps/server/src/headless-threads.e2e.test.tsindex d285e371..045fd5c0 100644--- a/apps/server/src/headless-threads.e2e.test.ts+++ b/apps/server/src/headless-threads.e2e.test.ts@@ -8,6 +8,14 @@ import { createHeadlessThreadClient } from "@omnirush/headless-threads";import { startServer } from "./server.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+// These tests dispatch prompts through a local workspace without an omnirush.ai// account. The server's sign-in gate refuses that unless both development// flags are set; the gate itself is covered by session-uploader.server.e2e.test.ts.diff --git a/apps/server/src/local-workflows.test.ts b/apps/server/src/local-workflows.test.tsindex 1b96d930..2881485e 100644--- a/apps/server/src/local-workflows.test.ts+++ b/apps/server/src/local-workflows.test.ts@@ -7,6 +7,14 @@ import { ApiError } from "./errors.js";import { LocalWorkflowService, type LocalWorkflowPromptBody, type LocalWorkflowPromptDispatcher } from "./local-workflows.js";import type { ServerConfig, WorkspaceInfo } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+/*** A workflow step is a prompt dispatch: it must reach the engine only through* the injected dispatcher (the server's gated, captured engine proxy), neverdiff --git a/apps/server/src/local-workflows.ts b/apps/server/src/local-workflows.tsindex 927aa190..b0450789 100644--- a/apps/server/src/local-workflows.ts+++ b/apps/server/src/local-workflows.ts@@ -10,6 +10,7 @@ import type { Actor, ServerConfig, WorkspaceInfo } from "./types.js";import { managedDesktopPolicy } from "./managed-desktop-policy.js";import type { createOpencodeClient } from "@opencode-ai/sdk/v2/client";import { writeFileAtomic } from "./atomic-write.js";+import { assertProviderAllowed, providerAllowed } from "./provider-lock.js";type Engine = ReturnType<typeof createOpencodeClient>;type EngineFactory = (config: ServerConfig, workspace: WorkspaceInfo, options?: { sessionId?: string }) => Engine;@@ -136,7 +137,7 @@ export class LocalWorkflowService {if (result.error || !result.data) throw new Error("Model catalog unavailable");const all = result.data.all;const connected = new Set(result.data.connected); const output: LocalAvailableModel[] = [];- for (const provider of all) if (connected.has(provider.id)) for (const [modelID, model] of Object.entries(provider.models ?? {})) output.push({ providerID: provider.id, modelID, name: typeof model.name === "string" ? model.name : modelID, providerName: provider.name });+ for (const provider of all) if (connected.has(provider.id) && providerAllowed(provider.id)) for (const [modelID, model] of Object.entries(provider.models ?? {})) output.push({ providerID: provider.id, modelID, name: typeof model.name === "string" ? model.name : modelID, providerName: provider.name });const value = { models: output.sort((a, b) => `${a.providerName}${a.modelID}`.localeCompare(`${b.providerName}${b.modelID}`)), error: null };this.modelCache.set(workspace.id, { at: Date.now(), value });return value;@@ -244,6 +245,8 @@ export class LocalWorkflowService {this.checkActive(active);await managedDesktopPolicy(this.config).assert("sync");await managedDesktopPolicy(this.config).assert("model", { ...decision.model });+ // The model provider lock (provider-lock.ts): only the allowed providers' models.+ assertProviderAllowed(decision.model.providerID);this.checkActive(active);await this.updateStep(workspace, run.id, index, { decision });// The gate can close mid-run (sign-out); check again before creating a session it would orphan.diff --git a/apps/server/src/managed-opencode-v2.ts b/apps/server/src/managed-opencode-v2.tsindex 7998a1bd..61f76be8 100644--- a/apps/server/src/managed-opencode-v2.ts+++ b/apps/server/src/managed-opencode-v2.ts@@ -11,6 +11,8 @@ export { installOpencodeV2Binary } from "./opencode-v2-binary.js";import { loopbackFetch } from "./server-fetch.js";import { writeFileAtomic } from "./atomic-write.js";+import { currentProviderLockPolicy, providerAllowed } from "./provider-lock.js";+import { providerLockEnv } from "./provider-lock/provider-lock.mjs";export interface OpencodeV2ModelSpec {id: string;@@ -86,7 +88,9 @@ export async function createManagedOpencodeV2Server(const username = "opencode";let url = "";const providers = new Map<string, OpencodeV2ProviderSpec>();- const opencodeModelsUrl = (options.env?.OPENCODE_MODELS_URL ?? process.env.OPENCODE_MODELS_URL)?.replace(/\/+$/, "");+ // Model providers (provider-lock.ts): while locked no model list source and the lock's keys.+ const providerLock = currentProviderLockPolicy();+ const opencodeModelsUrl = providerLock.locked ? undefined : (options.env?.OPENCODE_MODELS_URL ?? process.env.OPENCODE_MODELS_URL)?.replace(/\/+$/, "");const disableModelsFetch = options.env?.OPENCODE_DISABLE_MODELS_FETCH ?? process.env.OPENCODE_DISABLE_MODELS_FETCH;// The engine needs OS paths and locale settings, not the server's provider,// cloud, database, or control-plane credentials. Unknown keys stay private.@@ -123,6 +127,7 @@ export async function createManagedOpencodeV2Server(OPENCODE_AUTO_SHARE: "false",...(opencodeModelsUrl === undefined ? {} : { OPENCODE_MODELS_URL: opencodeModelsUrl }),...(disableModelsFetch === undefined ? {} : { OPENCODE_DISABLE_MODELS_FETCH: disableModelsFetch }),+ ...providerLockEnv(providerLock).set,},stdio: ["ignore", "pipe", "pipe"],});@@ -186,6 +191,8 @@ export async function createManagedOpencodeV2Server(async function writeProviders(): Promise<void> {const providerConfig: Record<string, unknown> = {};for (const provider of providers.values()) {+ // Only the providers the lock allows (provider-lock.ts) reach the v2 engine.+ if (!providerAllowed(provider.id)) continue;const models: Record<string, unknown> = {};for (const model of provider.models) {const config = model.config ?? {};diff --git a/apps/server/src/managed-opencode.ts b/apps/server/src/managed-opencode.tsindex a891cc27..a19c98de 100644--- a/apps/server/src/managed-opencode.ts+++ b/apps/server/src/managed-opencode.ts@@ -3,6 +3,8 @@ import { realpathSync } from "node:fs";import net from "node:net";import { randomUUID } from "node:crypto";import { globalOpencodeConfigDir } from "@omnirush/paths";+import { currentProviderLockPolicy, finishEngineEnv } from "./provider-lock.js";+import { providerLockEnv, withProviderLockEnv } from "./provider-lock/provider-lock.mjs";import { engineDataEnv } from "./engine-data-home.js";import { repairEngineStoreBeforeStart } from "./engine-store-repair.js";import { engineInstallLogEnv } from "./install-log-host.js";@@ -220,12 +222,17 @@ async function startManagedOpencodeServer(// OmniRush.ai's engine build keeps its own global config in// ~/.config/omnirush; the app's global skills, agents and config live in// the opencode global config directory, so the engine reads that one too.- const baseEnv = { ...process.env, ...options.env };+ // Model providers (provider-lock.ts): while locked, the inherited+ // environment loses its config injection keys first (the app's own values+ // below stay), and the engine gets the lock's keys last.+ const providerLock = currentProviderLockPolicy();+ const inheritedEnv = withProviderLockEnv(process.env, providerLock);+ const baseEnv = { ...inheritedEnv, ...options.env };if (!baseEnv.OPENCODE_CONFIG_DIR?.trim()) engineEnvDefaults.OPENCODE_CONFIG_DIR = globalOpencodeConfigDir({ env: baseEnv });// The desktop's engine keeps its sessions apart from the CLI's (engine-data-home.ts).const dataEnv = engineDataEnv(baseEnv) ?? {};- const env: NodeJS.ProcessEnv = {- ...process.env,+ const env: NodeJS.ProcessEnv = finishEngineEnv({+ ...inheritedEnv,...engineEnvDefaults,...options.env,...dataEnv,@@ -237,7 +244,7 @@ async function startManagedOpencodeServer(OPENCODE_AUTO_SHARE: "false",OPENCODE_SERVER_USERNAME: username,OPENCODE_SERVER_PASSWORD: password,- };+ }, providerLock);// The managed engine needs its own provider environment, but never the key// that decrypts OmniRush.ai-owned OAuth credentials.delete env.OMNIRUSH_ENCRYPTION_KEY;@@ -248,10 +255,11 @@ async function startManagedOpencodeServer(...engineEnvDefaults,...(options.env ?? {}),...dataEnv,+ ...providerLockEnv(providerLock).set,OPENCODE_SERVER_USERNAME: username,OPENCODE_SERVER_PASSWORD: password,})- .filter((entry): entry is [string, string] => entry[0] !== "OPENCODE_PURE" && typeof entry[1] === "string")+ .filter((entry): entry is [string, string] => entry[0] !== "OPENCODE_PURE" && typeof entry[1] === "string" && env[entry[0]] === entry[1]).map(([name, value]) => ({name,value: SECRET_ENV_PATTERN.test(name) ? "<redacted>" : value,diff --git a/apps/server/src/managed-provider-auth.test.ts b/apps/server/src/managed-provider-auth.test.tsindex 22d4518f..6981007a 100644--- a/apps/server/src/managed-provider-auth.test.ts+++ b/apps/server/src/managed-provider-auth.test.ts@@ -13,6 +13,14 @@ import { resetManagedProviderAuthCache, syncManagedProviderAuth } from "./manageimport { ENGINE_GLOBAL_RUNTIME_CONFIG_ID, writeRuntimeOpencodeConfig } from "./runtime-opencode-config-store.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+type Call = { method: string; url: string; body: unknown; authorization: string | null };const PROVIDER = "lpr_01kyhvcrn0eshb3rp2dt10z29j";diff --git a/apps/server/src/managed-provider-auth.ts b/apps/server/src/managed-provider-auth.tsindex 85ad9be4..7544bad3 100644--- a/apps/server/src/managed-provider-auth.ts+++ b/apps/server/src/managed-provider-auth.ts@@ -5,6 +5,7 @@ import { resolveWorkspaceOpencodeConnection } from "./opencode-connection.js";import { readGlobalRuntimeOpencodeConfig, runtimeProviderMap } from "./runtime-opencode-config-store.js";import type { ServerConfig } from "./types.js";import { findManagedEngineWorkspace } from "./workspaces.js";+import { providerAllowed } from "./provider-lock.js";/*** Deliver server-managed provider credentials to the engine.@@ -60,7 +61,7 @@ export type ManagedProviderAuthResult = {rotated: string[];unchanged: string[];removed: string[];- skipped: Array<{ providerId: string; reason: "no_env_names" | "no_stored_credential" }>;+ skipped: Array<{ providerId: string; reason: "no_env_names" | "no_stored_credential" | "provider_locked" }>;failed: Array<{ providerId: string; status: number | null }>;};@@ -271,10 +272,15 @@ async function reconcileManagedProviderAuth(input: ManagedProviderAuthInput): Prconst headers: Record<string, string> = { "content-type": "application/json" };if (target.authHeader) headers.authorization = target.authHeader;- const managedIds = new Set(Object.keys(providers));+ const managedIds = new Set(Object.keys(providers).filter((providerId) => providerAllowed(providerId)));for (const [providerId, entry] of Object.entries(providers)) {if (!isCurrent()) return result;+ // The model provider lock (provider-lock.ts): no key reaches the engine for a provider it does not allow.+ if (!providerAllowed(providerId)) {+ result.skipped.push({ providerId, reason: "provider_locked" });+ continue;+ }const envNames = readEnvNames(entry);if (envNames.length === 0) {result.skipped.push({ providerId, reason: "no_env_names" });diff --git a/apps/server/src/omnirush-gateway-broker.ts b/apps/server/src/omnirush-gateway-broker.tsindex 265bccd9..205d8e26 100644--- a/apps/server/src/omnirush-gateway-broker.ts+++ b/apps/server/src/omnirush-gateway-broker.ts@@ -1686,6 +1686,8 @@ export class OmniRushGatewayBroker {...(isRecord(payload.web_search) ? { web_search: payload.web_search } : {}),// Computer use (computer-use/desktop.ts reads it; absent is off)....(isRecord(payload.computer_use) ? { computer_use: payload.computer_use } : {}),+ // The model provider lock (provider-lock.ts reads it; absent is locked).+ ...(isRecord(payload.providers) ? { providers: payload.providers } : {}),};} catch {return null;diff --git a/apps/server/src/omnirush-runtime-config.ts b/apps/server/src/omnirush-runtime-config.tsindex 1d2934bb..82ae3769 100644--- a/apps/server/src/omnirush-runtime-config.ts+++ b/apps/server/src/omnirush-runtime-config.ts@@ -59,6 +59,7 @@ import {} from "./omnirush-model-catalog.js";import { writeFileAtomic } from "./atomic-write.js";import { webSearchSetting, type WebSearchSwitch } from "./web-search.js";+import { currentProviderLockPolicy, lockEngineConfig, type ProviderLockPolicy } from "./provider-lock.js";import { boxServiceFor } from "./box/desktop.js";import { engineConfig as withBoxEngineConfig } from "./box/launch.js";import {@@ -231,6 +232,7 @@ export function buildOmniRushRuntimeConfigObjectFromSnapshot(bestPracticesDir?: string,webSearch: WebSearchSwitch | null = null,userSkillPaths: string[] = [],+ providerLock: ProviderLockPolicy = currentProviderLockPolicy(),): Record<string, unknown> {const disabledProviders = runtimeDisabledProviderList(runtimeConfig);// OMNIRUSH_APPROVALS in the server environment wins over the persisted setting.@@ -258,15 +260,17 @@ export function buildOmniRushRuntimeConfigObjectFromSnapshot(: {}),};const ownProviders = Object.keys(provider).filter((id) => /^(?:lpr_|omnirush$)/i.test(id));- // Signed in, the model picker lists only omnirush.ai (and org-assigned)- // models: the engine would otherwise also load providers from the user's- // own opencode config, whose models bypass the gateway and whose errors- // name upstream relays. OMNIRUSH_ALLOW_OTHER_PROVIDERS=1 or an org policy- // with allowCustomProviders: true lets them back in.+ // Only when the server unlocked providers (provider-lock.ts): signed in,+ // the model picker lists only omnirush.ai (and org-assigned) models: the+ // engine would otherwise also load providers from the user's own opencode+ // config, whose models bypass the gateway and whose errors name upstream+ // relays. OMNIRUSH_ALLOW_OTHER_PROVIDERS=1 or an org policy with+ // allowCustomProviders: true lets them back in. While locked, none of them+ // does: lockEngineConfig() below keeps only the allowed providers.const onlyOwnProviders = ownProviders.length > 0&& env.OMNIRUSH_ALLOW_OTHER_PROVIDERS !== "1"&& runtimeConfig.managedPolicy?.allowCustomProviders !== true;- return {+ return withoutEmptyProviderMap(lockEngineConfig({...engineConfig,...(internalGateway? { model: `${INTERNAL_PROVIDER_ID}/${omnirushDefaultModelId(catalog)}` }@@ -340,7 +344,14 @@ export function buildOmniRushRuntimeConfigObjectFromSnapshot(...(disabledProviders.length ? { disabled_providers: disabledProviders } : {}),...(lsp ? { lsp } : {}),...(Object.keys(provider).length ? { provider } : {}),- };+ }, providerLock).config);+}++/** A provider map the lock emptied is left out, as when there was none. */+function withoutEmptyProviderMap(config: Record<string, unknown>): Record<string, unknown> {+ if (!isRecord(config.provider) || Object.keys(config.provider).length) return config;+ const { provider: _provider, ...rest } = config;+ return rest;}function isRecord(value: unknown): value is Record<string, unknown> {diff --git a/apps/server/src/omnirush-ui-mcp-guard.e2e.test.ts b/apps/server/src/omnirush-ui-mcp-guard.e2e.test.tsindex 0afa1c5d..e7248be6 100644--- a/apps/server/src/omnirush-ui-mcp-guard.e2e.test.ts+++ b/apps/server/src/omnirush-ui-mcp-guard.e2e.test.ts@@ -8,6 +8,7 @@ import { omnirushRuntimeConfigFilePath, writeOmniRushRuntimeConfigFile } from ".import {ENGINE_GLOBAL_RUNTIME_CONFIG_ID,readEffectiveRuntimeOpencodeConfig,+ readGlobalRuntimeOpencodeConfig,readRuntimeOpencodeConfig,runtimeDbPath,writeRuntimeOpencodeConfig,@@ -218,10 +219,13 @@ describe("MCP allowlist at the HTTP and runtime boundaries", () => {expect(await response.json()).toMatchObject({ code: "mcp_config_patch" });expect((await readRuntimeOpencodeConfig(config, "ws_1")).mcp).toBeUndefined();+ // Another model provider is refused too while the server locks them (provider-lock.ts).const provider = await call("PATCH", "/workspace/ws_1/config", {opencode: { provider: { "user-provider": { npm: "@ai-sdk/openai" } } },});- expect(provider.status).toBe(200);+ expect(provider.status).toBe(403);+ expect(await provider.json()).toMatchObject({ code: "provider_locked", message: "Only OmniRush models are available." });+ expect((await readGlobalRuntimeOpencodeConfig(config)).provider).toBeUndefined();});test("enabling a stored registry launch is refused and not pushed", async () => {diff --git a/apps/server/src/opencode-models-url.test.ts b/apps/server/src/opencode-models-url.test.tsindex be26e9dd..619b6697 100644--- a/apps/server/src/opencode-models-url.test.ts+++ b/apps/server/src/opencode-models-url.test.ts@@ -4,6 +4,14 @@ import { join } from "node:path";import { describe, expect, test } from "bun:test";import { resolveOpencodeModelsEnv, resolveOpencodeModelsUrl } from "./opencode-models-url.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+function restoreProcessEnv(name: string, value: string | undefined): void {if (value === undefined) {delete process.env[name];diff --git a/apps/server/src/provider-lock.test.ts b/apps/server/src/provider-lock.test.tsnew file mode 100644index 00000000..f53bf191--- /dev/null+++ b/apps/server/src/provider-lock.test.ts@@ -0,0 +1,259 @@+import { afterEach, describe, expect, test } from "bun:test";+import { chmod, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";+import { tmpdir } from "node:os";+import { join } from "node:path";++import { createManagedOpencodeServer } from "./managed-opencode.js";+import { OmniRushGatewayBroker } from "./omnirush-gateway-broker.js";+import { buildOmniRushRuntimeConfigObjectFromSnapshot } from "./omnirush-runtime-config.js";+import { builtinOmniRushModelCatalog } from "./omnirush-model-catalog.js";+import {+ applyProviderLockAnswer,+ assertConfigWithinProviderLock,+ assertProxiedEngineRequestWithinProviderLock,+ currentProviderLockPolicy,+ engineRequestProviderLockDenial,+ lockedEngineEnv,+ providerAllowed,+ providerLockConfigViolations,+ resetProviderLock,+ watchProviderLock,+} from "./provider-lock.js";+import { providerLockPolicy } from "./provider-lock/provider-lock.mjs";++const UNLOCKED = { providers: { locked: false, message: "Any provider." } };+const LOCKED = providerLockPolicy({ providers: { locked: true, allow: ["omnirush"], message: "Only OmniRush models are available." } });+const roots: string[] = [];++afterEach(async () => {+ resetProviderLock();+ while (roots.length) await rm(roots.pop()!, { recursive: true, force: true });+});++describe("provider lock: fails closed", () => {+ test("locked at start, and for every answer that is not a clear `locked: false`", () => {+ expect(currentProviderLockPolicy()).toMatchObject({ locked: true, allow: ["omnirush"] });+ for (const answer of [null, undefined, {}, { schema_versions: [1, 2] }, { providers: null }, { providers: { locked: "false" } }, { providers: { locked: 0 } }, { providers: [] }]) {+ applyProviderLockAnswer(answer);+ expect(currentProviderLockPolicy().locked).toBe(true);+ }+ });++ test("a `locked: false` answer unlocks in memory; the next failed read locks again", () => {+ expect(applyProviderLockAnswer(UNLOCKED)).toBe(true);+ expect(currentProviderLockPolicy().locked).toBe(false);+ expect(applyProviderLockAnswer(UNLOCKED)).toBe(false);+ expect(applyProviderLockAnswer(null)).toBe(true);+ expect(currentProviderLockPolicy().locked).toBe(true);+ });++ test("the server's allow list and message are taken, omnirush always first", () => {+ applyProviderLockAnswer({ providers: { locked: true, allow: ["acme", "BAD ID", 7], message: "Ask your admin." } });+ expect(currentProviderLockPolicy()).toMatchObject({ locked: true, allow: ["omnirush", "acme"], message: "Ask your admin." });+ expect(providerAllowed("acme")).toBe(true);+ expect(providerAllowed("openai")).toBe(false);+ });++ test("the watcher re-reads, applies a change, and locks on a failed read", async () => {+ const answers: Array<() => Promise<unknown>> = [async () => UNLOCKED, async () => UNLOCKED, async () => { throw new Error("offline"); }];+ let applied = 0;+ const stop = watchProviderLock({ read: () => (answers.shift() ?? (async () => null))(), apply: async () => { applied += 1; }, everyMs: 5 });+ try {+ for (let i = 0; i < 100 && applied < 2; i += 1) await Bun.sleep(5);+ } finally {+ stop();+ }+ expect(applied).toBe(2);+ expect(currentProviderLockPolicy().locked).toBe(true);+ });+});++describe("provider lock: gateway broker", () => {+ test("passes the server's providers block on (a field-by-field rebuild would drop it)", async () => {+ const broker = new OmniRushGatewayBroker({+ credentials: { gatewayUrl: "https://gateway.example/omnirush/v1", accessToken: "a", refreshToken: "r" },+ engineToken: "local-engine-token",+ fetch: async () => Response.json({ schema_versions: [1, 2, 3], canonical_trace: true, providers: { locked: false, allow: [], message: "x" } }),+ });+ const capabilities = await broker.sessionUploadCapabilities({ strict: true });+ expect(capabilities.providers).toEqual({ locked: false, allow: [], message: "x" });+ expect(applyProviderLockAnswer(capabilities)).toBe(true);+ expect(currentProviderLockPolicy().locked).toBe(false);+ });++ test("signed out the strict read throws, which is locked", async () => {+ const broker = new OmniRushGatewayBroker({ engineToken: "t", fetch: async () => Response.json({}) });+ const answer = await broker.sessionUploadCapabilities({ strict: true }).catch(() => null);+ applyProviderLockAnswer(answer);+ expect(currentProviderLockPolicy().locked).toBe(true);+ });+});++describe("provider lock: engine config", () => {+ const gateway = { baseUrl: "http://127.0.0.1:1/omnirush-gateway/v1" };+ const userProviders = {+ openai: { npm: "@ai-sdk/openai", options: { apiKey: "sk-fake" }, models: { "gpt-x": {} } },+ lpr_org1: { npm: "@ai-sdk/openai-compatible", options: { baseURL: "https://org.example" }, models: { m: {} } },+ opencode: { models: {} },+ };++ function build(runtime: Record<string, unknown>, env: NodeJS.ProcessEnv = {}, signedIn = true) {+ return buildOmniRushRuntimeConfigObjectFromSnapshot(runtime, signedIn ? gateway : undefined, env, builtinOmniRushModelCatalog());+ }++ test("a signed-in user without other providers gets the same config locked and unlocked", () => {+ const locked = build({});+ applyProviderLockAnswer(UNLOCKED);+ const unlocked = build({});+ expect(JSON.stringify(locked)).toBe(JSON.stringify(unlocked));+ expect(locked.enabled_providers).toEqual(["omnirush"]);+ expect(Object.keys(locked.provider as object)).toEqual(["omnirush"]);+ });++ test("locked: only the allowed providers, whatever env, org policy, zen or org providers say", () => {+ const cases: Array<[Record<string, unknown>, NodeJS.ProcessEnv]> = [+ [{ provider: userProviders }, {}],+ [{ provider: userProviders }, { OMNIRUSH_ALLOW_OTHER_PROVIDERS: "1" }],+ [{ provider: userProviders, managedPolicy: { allowCustomProviders: true } }, {}],+ [{ provider: userProviders, managedPolicy: { allowCustomProviders: false, allowZenModel: true } }, {}],+ [{ provider: userProviders, disabled_providers: ["anthropic"], model: "openai/gpt-x", small_model: "openai/gpt-x", command: { c: { model: "openai/gpt-x", template: "t" } } }, {}],+ ];+ for (const [runtime, env] of cases) {+ const config = build(runtime, env);+ expect(config.enabled_providers).toEqual(["omnirush"]);+ expect(Object.keys(config.provider as object)).toEqual(["omnirush"]);+ expect(config).not.toHaveProperty("disabled_providers");+ expect(String(config.model)).toStartWith("omnirush/");+ expect(config).not.toHaveProperty("small_model");+ expect(providerLockConfigViolations(config, LOCKED)).toEqual([]);+ }+ });++ test("locked and signed out: still only the allowed providers, and no other provider's map", () => {+ const config = build({ provider: userProviders }, { OMNIRUSH_ALLOW_OTHER_PROVIDERS: "1" }, false);+ expect(config.enabled_providers).toEqual(["omnirush"]);+ expect(config).not.toHaveProperty("provider");+ });++ test("unlocked by the server: the earlier behaviour (org and env switches apply)", () => {+ applyProviderLockAnswer(UNLOCKED);+ expect(build({ provider: userProviders }).enabled_providers).toEqual(["lpr_org1", "omnirush"]);+ expect(build({ provider: userProviders }, { OMNIRUSH_ALLOW_OTHER_PROVIDERS: "1" })).not.toHaveProperty("enabled_providers");+ expect(build({ provider: userProviders, managedPolicy: { allowCustomProviders: true } })).not.toHaveProperty("enabled_providers");+ expect(build({ provider: userProviders, managedPolicy: { allowCustomProviders: false } }).enabled_providers).toEqual(["lpr_org1", "omnirush", "opencode"]);+ expect(Object.keys(build({ provider: userProviders }).provider as object).sort()).toEqual(["lpr_org1", "omnirush", "openai", "opencode"]);+ });+});++describe("provider lock: engine environment", () => {+ test("inherited config injection is removed, the app's own config folder stays, the lock is set", () => {+ const env = lockedEngineEnv(+ { OPENCODE_CONFIG_CONTENT: "{}", OPENCODE_CONFIG_DIR: "/user/dir", OPENCODE_MODELS_URL: "https://x", OPENCODE_MODELS_PATH: "/m.json", HOME: "/h" },+ { OPENCODE_CONFIG_DIR: "/app/dir", OPENCODE_MODELS_URL: "http://localhost:8791/models" },+ );+ expect(env).toMatchObject({+ HOME: "/h",+ OPENCODE_CONFIG_DIR: "/app/dir",+ OMNIRUSH_PROVIDER_LOCK: "1",+ OMNIRUSH_PROVIDER_ALLOW: "omnirush",+ OMNIRUSH_PROVIDER_LOCK_MESSAGE: "Only OmniRush models are available.",+ OPENCODE_DISABLE_MODELS_FETCH: "1",+ });+ for (const key of ["OPENCODE_CONFIG_CONTENT", "OPENCODE_MODELS_URL", "OPENCODE_MODELS_PATH"]) expect(env).not.toHaveProperty(key);+ });++ test("unlocked: the environment as it was", () => {+ applyProviderLockAnswer(UNLOCKED);+ expect(lockedEngineEnv({ OPENCODE_CONFIG_CONTENT: "{}" }, { A: "1" })).toEqual({ OPENCODE_CONFIG_CONTENT: "{}", A: "1" });+ });++ test("every managed engine spawn gets the lock, also over the caller's and the user's values", async () => {+ const root = await mkdtemp(join(tmpdir(), "omnirush-provider-lock-"));+ roots.push(root);+ const dumpPath = join(root, "env.json");+ const bin = join(root, "dump-env.mjs");+ await writeFile(bin, [+ "#!/usr/bin/env bun",+ "import { writeFileSync } from 'node:fs';",+ "const port = Number(process.argv[process.argv.indexOf('--port') + 1]);",+ "const keys = ['OMNIRUSH_PROVIDER_LOCK', 'OMNIRUSH_PROVIDER_ALLOW', 'OPENCODE_DISABLE_MODELS_FETCH', 'OPENCODE_MODELS_URL', 'OPENCODE_CONFIG_CONTENT', 'OPENCODE_CONFIG_DIR'];",+ "writeFileSync(process.env.ENV_DUMP_PATH, JSON.stringify(Object.fromEntries(keys.map((k) => [k, process.env[k] ?? null]))));",+ "const server = Bun.serve({ hostname: '127.0.0.1', port, fetch: () => Response.json({ ok: true }) });",+ "console.log(`opencode server listening on http://127.0.0.1:${server.port}`);",+ "process.on('SIGTERM', () => { server.stop(true); process.exit(0); });",+ ].join("\n"));+ await chmod(bin, 0o755);+ const previous = { content: process.env.OPENCODE_CONFIG_CONTENT, dir: process.env.OPENCODE_CONFIG_DIR };+ process.env.OPENCODE_CONFIG_CONTENT = '{"provider":{"openai":{}}}';+ process.env.OPENCODE_CONFIG_DIR = join(root, "user-config");+ try {+ const managed = await createManagedOpencodeServer({+ bin,+ cwd: root,+ env: { ENV_DUMP_PATH: dumpPath, OPENCODE_MODELS_URL: "https://models.example", OPENCODE_DISABLE_MODELS_FETCH: "0" },+ });+ try {+ const dumped = JSON.parse(await readFile(dumpPath, "utf8"));+ expect(dumped).toMatchObject({+ OMNIRUSH_PROVIDER_LOCK: "1",+ OMNIRUSH_PROVIDER_ALLOW: "omnirush",+ OPENCODE_DISABLE_MODELS_FETCH: "1",+ OPENCODE_MODELS_URL: null,+ OPENCODE_CONFIG_CONTENT: null,+ });+ expect(dumped.OPENCODE_CONFIG_DIR).not.toBe(join(root, "user-config"));+ } finally {+ await managed.close();+ }+ } finally {+ if (previous.content === undefined) delete process.env.OPENCODE_CONFIG_CONTENT; else process.env.OPENCODE_CONFIG_CONTENT = previous.content;+ if (previous.dir === undefined) delete process.env.OPENCODE_CONFIG_DIR; else process.env.OPENCODE_CONFIG_DIR = previous.dir;+ }+ });+});++describe("provider lock: refusals", () => {+ test("engine requests: other providers' keys, sign-ins, config and models are refused", () => {+ const refused: Array<[string, string, Record<string, unknown>]> = [+ ["PUT", "/auth/openai", { type: "api", key: "sk-fake" }],+ ["POST", "/provider/anthropic/oauth/authorize", { method: 0 }],+ ["POST", "/provider/anthropic/oauth/callback", { method: 0, code: "c" }],+ ["PATCH", "/config", { provider: { openai: { options: { apiKey: "sk-fake" } } } }],+ ["PATCH", "/global/config", { model: "anthropic/claude-x" }],+ ["PATCH", "/config", { agent: { build: { model: "openai/gpt-x" } } }],+ ["POST", "/session/ses_1/prompt_async", { model: { providerID: "openai", modelID: "gpt-x" }, parts: [] }],+ ["POST", "/session/ses_1/message", { providerID: "openai", modelID: "gpt-x", parts: [] }],+ ["POST", "/session/ses_1/command", { command: "c", model: "openai/gpt-x" }],+ ["POST", "/api/session/ses_1/prompt", { model: { providerID: "opencode", modelID: "zen" } }],+ ["POST", "/session", { model: { providerID: "lpr_org1", id: "m" } }],+ ];+ for (const [method, path, body] of refused) expect([method, path, engineRequestProviderLockDenial(method, path, body)]).toEqual([method, path, "Only OmniRush models are available."]);+ const allowed: Array<[string, string, Record<string, unknown>]> = [+ ["GET", "/provider", {}],+ ["DELETE", "/auth/openai", {}],+ ["PUT", "/auth/omnirush", { type: "api", key: "k" }],+ ["PATCH", "/config", { disabled_providers: ["openai"], share: "disabled" }],+ ["POST", "/session/ses_1/prompt_async", { model: { providerID: "omnirush", modelID: "gpt-5" }, parts: [] }],+ ["POST", "/session/ses_1/prompt_async", { parts: [{ type: "text", text: "use openai/gpt-x" }] }],+ ];+ for (const [method, path, body] of allowed) expect([method, path, engineRequestProviderLockDenial(method, path, body)]).toEqual([method, path, null]);+ applyProviderLockAnswer(UNLOCKED);+ for (const [method, path, body] of refused) expect(engineRequestProviderLockDenial(method, path, body)).toBeNull();+ });++ test("a proxied request is read from a clone and refused with 403 provider_locked", async () => {+ const request = new Request("http://x/opencode/session/s/prompt_async", { method: "POST", body: JSON.stringify({ model: { providerID: "openai", modelID: "m" } }) });+ const error = await assertProxiedEngineRequestWithinProviderLock(request, "/opencode/session/s/prompt_async").catch((e) => e);+ expect(error).toMatchObject({ status: 403, code: "provider_locked", message: "Only OmniRush models are available." });+ expect(await request.json()).toEqual({ model: { providerID: "openai", modelID: "m" } });+ const ok = new Request("http://x/opencode/session/s/prompt_async", { method: "POST", body: JSON.stringify({ model: { providerID: "omnirush", modelID: "m" } }) });+ await assertProxiedEngineRequestWithinProviderLock(ok, "/opencode/session/s/prompt_async");+ });++ test("config writes that add another provider or its model are refused", () => {+ expect(() => assertConfigWithinProviderLock({ provider: { ollama: {} } })).toThrow("Only OmniRush models are available.");+ expect(() => assertConfigWithinProviderLock({ enabled_providers: ["openai"] })).toThrow();+ expect(() => assertConfigWithinProviderLock({ $schema: "x", mcp: {}, disabled_providers: ["openai"] })).not.toThrow();+ expect(() => assertConfigWithinProviderLock(null)).not.toThrow();+ });+});diff --git a/apps/server/src/provider-lock.ts b/apps/server/src/provider-lock.tsnew file mode 100644index 00000000..04277045--- /dev/null+++ b/apps/server/src/provider-lock.ts@@ -0,0 +1,250 @@+/**+ * Model providers the managed engine may use: only OmniRush's own provider+ * (the account gateway) unless the server says otherwise. The shared rules+ * are provider-lock/provider-lock.mjs (the same file as the CLI's); this is+ * the desktop's side of them.+ *+ * The server's switch is GET /collect/capabilities `providers`+ * ({ locked, allow, message }), read through the gateway broker at start and+ * again every few minutes while the app runs. It is kept in memory only: the+ * app starts LOCKED and stays locked until an answer from the server says+ * `locked: false`; a failed read, no account, an older server or a malformed+ * block is locked again. Nothing on this computer unlocks it: no environment+ * variable (OMNIRUSH_ALLOW_OTHER_PROVIDERS), no organization setting+ * (allowCustomProviders, allowZenModel), no remembered answer.+ *+ * While locked:+ * - the engine runs with the lock environment (withProviderLockEnv) and+ * drops every other provider itself;+ * - the engine config the app writes lists only the allowed providers+ * (omnirush-runtime-config.ts, lockEngineConfig);+ * - the app's routes that add a provider, store its key or sign in to it,+ * and engine requests that name another provider's model, answer 403+ * `provider_locked` with the server's message.+ */+import { parse as parseJsonc } from "jsonc-parser";++import { ApiError } from "./errors.js";+import {+ lockEngineConfig,+ lockedProviderPolicy,+ modelRefAllowed,+ providerLockEnv,+ providerLockPolicy,+ withProviderLockEnv,+ type ProviderLockPolicy,+} from "./provider-lock/provider-lock.mjs";++export type { ProviderLockPolicy } from "./provider-lock/provider-lock.mjs";+export { lockEngineConfig, modelRefAllowed, providerLockPolicy, withProviderLockEnv } from "./provider-lock/provider-lock.mjs";++export const PROVIDER_LOCKED_CODE = "provider_locked";++let current: ProviderLockPolicy = lockedProviderPolicy("default");++/** The policy in force: locked until the server's answer says otherwise. */+export function currentProviderLockPolicy(): ProviderLockPolicy {+ return current;+}++function samePolicy(left: ProviderLockPolicy, right: ProviderLockPolicy): boolean {+ return left.locked === right.locked && left.message === right.message && left.allow.join(",") === right.allow.join(",");+}++/**+ * Takes the policy of a /collect/capabilities answer (null/undefined: no+ * answer, which is locked). Whether the policy in force changed.+ */+export function applyProviderLockAnswer(capabilities: unknown): boolean {+ const next = providerLockPolicy(capabilities ?? null);+ const changed = !samePolicy(current, next);+ current = next;+ return changed;+}++/** Back to the locked start state (tests, sign-out). */+export function resetProviderLock(): void {+ current = lockedProviderPolicy("default");+}++/** Whether `providerId` may be used under `policy`. */+export function providerAllowed(providerId: unknown, policy: ProviderLockPolicy = current): boolean {+ if (!policy.locked) return true;+ return typeof providerId === "string" && policy.allow.includes(providerId);+}++export function providerLockedError(policy: ProviderLockPolicy = current): ApiError {+ return new ApiError(403, PROVIDER_LOCKED_CODE, policy.message);+}++/** Throws 403 provider_locked unless `providerId` is allowed. */+export function assertProviderAllowed(providerId: unknown, policy: ProviderLockPolicy = current): void {+ if (!providerAllowed(providerId, policy)) throw providerLockedError(policy);+}++/** Throws 403 provider_locked while locked (routes that only ever add another provider). */+export function assertProvidersUnlocked(policy: ProviderLockPolicy = current): void {+ if (policy.locked) throw providerLockedError(policy);+}++/**+ * The engine environment for a spawn: the lock applied to the inherited+ * environment (its config injection keys removed), then the app's own+ * values, then the lock's keys again so nothing the app or the user passed+ * turns the model list fetch or another config source back on.+ */+export function lockedEngineEnv<T extends Record<string, string | undefined>>(+ inherited: T,+ app: Record<string, string | undefined>,+ policy: ProviderLockPolicy = current,+): Record<string, string | undefined> {+ const env: Record<string, string | undefined> = { ...withProviderLockEnv(inherited, policy), ...app };+ return finishEngineEnv(env, policy);+}++/**+ * The last step of an engine environment built elsewhere: while locked, no+ * inline config, no model list source, and the lock's keys. The app's own+ * OPENCODE_CONFIG_DIR stays (it was set after the inherited value was taken+ * out).+ */+export function finishEngineEnv<T extends Record<string, string | undefined>>(env: T, policy: ProviderLockPolicy = current): T {+ const { set, remove } = providerLockEnv(policy);+ for (const key of remove) if (key !== "OPENCODE_CONFIG_DIR") delete env[key];+ return Object.assign(env, set);+}++function isRecord(value: unknown): value is Record<string, unknown> {+ return typeof value === "object" && value !== null && !Array.isArray(value);+}++/**+ * What an engine config (a file's content, a config PATCH) would bring in+ * past the lock: other providers' definitions and model references+ * ("provider:<id>", "model", "agent.<name>.model", ...). Empty when unlocked+ * or when nothing does. A list that only disables providers is fine.+ */+export function providerLockConfigViolations(config: unknown, policy: ProviderLockPolicy = current): string[] {+ if (!policy.locked || !isRecord(config)) return [];+ const removed = lockEngineConfig(config, policy).removed.filter((item) => item !== "disabled_providers");+ if (Array.isArray(config.enabled_providers)) {+ for (const id of config.enabled_providers) if (!policy.allow.includes(String(id))) removed.push(`enabled_providers:${String(id)}`);+ }+ return removed;+}++/** An engine config file's content (JSON with comments) as an object; null when it is not one. */+export function parseJsoncContent(content: string): Record<string, unknown> | null {+ try {+ const value: unknown = parseJsonc(content, [], { allowTrailingComma: true, disallowComments: false });+ return isRecord(value) ? value : null;+ } catch {+ return null;+ }+}++/** Throws 403 provider_locked when the config would bring in another provider. */+export function assertConfigWithinProviderLock(config: unknown, policy: ProviderLockPolicy = current): void {+ if (providerLockConfigViolations(config, policy).length) throw providerLockedError(policy);+}++function modelProviderOf(value: unknown): string | null | undefined {+ if (typeof value === "string") {+ const slash = value.indexOf("/");+ return slash > 0 ? value.slice(0, slash) : null;+ }+ if (isRecord(value) && typeof value.providerID === "string") return value.providerID;+ return undefined;+}++/**+ * Why an engine request (path without the /opencode prefix, parsed JSON+ * body) breaks the lock, or null. Refused: provider sign-in and API key+ * routes of other providers, config writes that add another provider or its+ * models, and session/prompt requests naming another provider's model.+ */+export function engineRequestProviderLockDenial(+ method: string,+ enginePath: string,+ body: Record<string, unknown>,+ policy: ProviderLockPolicy = current,+): string | null {+ if (!policy.locked) return null;+ const verb = method.toUpperCase();+ if (["GET", "HEAD", "OPTIONS", "DELETE"].includes(verb)) return null;+ const path = enginePath.replace(/^\/api(?=\/)/, "");+ const auth = path.match(/^\/auth\/([^/]+)\/?$/);+ if (auth) return providerAllowed(decodeURIComponent(auth[1] ?? ""), policy) ? null : policy.message;+ const oauth = path.match(/^\/provider\/([^/]+)\/oauth(?:\/|$)/);+ if (oauth) return providerAllowed(decodeURIComponent(oauth[1] ?? ""), policy) ? null : policy.message;+ if (/^\/(?:global\/)?config\/?$/.test(path)) {+ return providerLockConfigViolations(body, policy).length ? policy.message : null;+ }+ if (/^\/session(?:\/|$)/.test(path)) {+ for (const value of [body.model, body.providerID === undefined ? undefined : { providerID: body.providerID }]) {+ const provider = modelProviderOf(value);+ if (provider !== undefined && provider !== null && !providerAllowed(provider, policy)) return policy.message;+ }+ }+ return null;+}++/** Throws 403 provider_locked for engineRequestProviderLockDenial(). */+export function assertEngineRequestWithinProviderLock(method: string, enginePath: string, body: Record<string, unknown>, policy: ProviderLockPolicy = current): void {+ const denial = engineRequestProviderLockDenial(method, enginePath, body, policy);+ if (denial) throw new ApiError(403, PROVIDER_LOCKED_CODE, denial);+}++/**+ * Reads the proxied engine request's JSON body (a clone; the request itself+ * is forwarded untouched) and applies engineRequestProviderLockDenial(). A+ * body that is not a JSON object carries no model and passes here.+ */+export async function assertProxiedEngineRequestWithinProviderLock(request: Request, path: string, policy: ProviderLockPolicy = current): Promise<void> {+ if (!policy.locked || ["GET", "HEAD", "OPTIONS", "DELETE"].includes(request.method)) return;+ let decoded = path;+ try {+ decoded = decodeURIComponent(path);+ } catch {+ /* the raw path */+ }+ const enginePath = decoded.replace(/^\/opencode2?(?=\/|$)/, "");+ let body: Record<string, unknown> = {};+ if (request.body) {+ const text = await request.clone().text().catch(() => "");+ if (text.trim()) {+ try {+ const value: unknown = JSON.parse(text);+ if (isRecord(value)) body = value;+ } catch {+ /* not JSON: no model in it */+ }+ }+ }+ assertEngineRequestWithinProviderLock(request.method, enginePath, body, policy);+}++/**+ * Reads the server's switch again every `everyMs` while the app runs, and+ * calls `apply` when the policy in force changed (an answer flipped it, or a+ * failed read locked it again). One read at a time. Returns the stop.+ */+export function watchProviderLock({ read, apply, everyMs }: { read: () => Promise<unknown>; apply: () => Promise<unknown>; everyMs: number }): () => void {+ let busy = false;+ const timer = setInterval(() => {+ if (busy) return;+ busy = true;+ void read()+ .catch(() => null)+ .then((capabilities) => (applyProviderLockAnswer(capabilities) ? apply() : undefined))+ .catch(() => undefined)+ .finally(() => { busy = false; });+ }, everyMs);+ timer.unref?.();+ return () => clearInterval(timer);+}++/** The policy for the app's UI (GET /omnirush/provider-lock). */+export function providerLockStatus(policy: ProviderLockPolicy = current): { locked: boolean; allow: string[]; message: string; source: string } {+ return { locked: policy.locked, allow: [...policy.allow], message: policy.message, source: policy.source };+}diff --git a/apps/server/src/provider-lock/PARITY.sha256 b/apps/server/src/provider-lock/PARITY.sha256new file mode 100644index 00000000..46b85eab--- /dev/null+++ b/apps/server/src/provider-lock/PARITY.sha256@@ -0,0 +1,4 @@+# The model-provider lock module: the same files in omnirush-cli (src/provider-lock/) and omnirush-gui (apps/server/src/provider-lock/).+# A change to one must be ported to the other and this list updated in both.+70d8f48616bf62b224b284dab6a2245a5778dbf7c1ac6768f2c600b0107dbd57 provider-lock.mjs+c57d3cea2443066a1687f902e9d1e6bc592cf5e3033ed9854814a6c572edfe06 provider-lock.d.mtsdiff --git a/apps/server/src/provider-lock/provider-lock-parity.test.ts b/apps/server/src/provider-lock/provider-lock-parity.test.tsnew file mode 100644index 00000000..06db8be5--- /dev/null+++ b/apps/server/src/provider-lock/provider-lock-parity.test.ts@@ -0,0 +1,19 @@+// The model provider lock module is the same pair of files in omnirush-cli+// (src/provider-lock/) and here; PARITY.sha256 lists their hashes in both+// repositories, so a change in one shows up here until it is ported.+import { describe, expect, test } from "bun:test";+import { createHash } from "node:crypto";+import { readFileSync } from "node:fs";+import path from "node:path";++describe("CLI/desktop parity: model provider lock", () => {+ test("provider-lock/PARITY.sha256 matches its files", () => {+ const rows = readFileSync(path.join(import.meta.dir, "PARITY.sha256"), "utf8").split("\n").filter((line) => line && !line.startsWith("#"));+ expect(rows.map((row) => row.split(/\s+/)[1])).toEqual(["provider-lock.mjs", "provider-lock.d.mts"]);+ for (const row of rows) {+ const [hash, name] = row.split(/\s+/);+ const actual = createHash("sha256").update(readFileSync(path.join(import.meta.dir, name ?? ""))).digest("hex");+ expect(`${name} ${actual}`).toBe(`${name} ${hash}`);+ }+ });+});diff --git a/apps/server/src/provider-lock/provider-lock.d.mts b/apps/server/src/provider-lock/provider-lock.d.mtsnew file mode 100644index 00000000..d568f998--- /dev/null+++ b/apps/server/src/provider-lock/provider-lock.d.mts@@ -0,0 +1,23 @@+// Types of provider-lock.mjs (the same pair of files in omnirush-cli+// src/provider-lock/ and omnirush-gui apps/server/src/provider-lock/; PARITY.sha256).++export const OMNIRUSH_PROVIDER_ID: "omnirush";+export const PROVIDER_LOCK_MESSAGE: string;+export const PROVIDER_ID_PATTERN: RegExp;+export const ENGINE_CONFIG_INJECTION_ENV: readonly string[];++export type ProviderLockPolicy = {+ locked: boolean;+ /** Allowed provider ids, "omnirush" first; empty when unlocked. */+ allow: string[];+ message: string;+ source: "default" | "missing" | "server";+};++export function lockedProviderPolicy(source?: ProviderLockPolicy["source"]): ProviderLockPolicy;+export function providerLockPolicy(capabilities: unknown): ProviderLockPolicy;+export function modelProvider(ref: unknown): string | null;+export function modelRefAllowed(policy: ProviderLockPolicy | null | undefined, ref: unknown): boolean;+export function providerLockEnv(policy: ProviderLockPolicy | null | undefined): { set: Record<string, string>; remove: string[] };+export function withProviderLockEnv<T extends Record<string, string | undefined>>(env: T, policy: ProviderLockPolicy | null | undefined): Record<string, string | undefined>;+export function lockEngineConfig<T>(config: T, policy: ProviderLockPolicy | null | undefined): { config: T; removed: string[] };diff --git a/apps/server/src/provider-lock/provider-lock.mjs b/apps/server/src/provider-lock/provider-lock.mjsnew file mode 100644index 00000000..ae9caf80--- /dev/null+++ b/apps/server/src/provider-lock/provider-lock.mjs@@ -0,0 +1,171 @@+// Model providers in the managed engine: only OmniRush's own provider (the+// account gateway) unless the server says otherwise.+//+// The server's switch is GET /collect/capabilities `providers`+// ({ locked, allow, message }). It is LOCKED unless an answer from the server+// says `locked: false` in so many words: no answer (offline, an error, an+// older server), no block or a malformed block is locked. Nothing on this+// computer (environment, settings, a remembered answer) can unlock it.+//+// While locked:+// - the engine runs with OMNIRUSH_PROVIDER_LOCK=1 and the allowed provider+// ids (OMNIRUSH_PROVIDER_ALLOW), and the engine itself keeps every other+// provider out: config files, environment keys, saved logins, plugins and+// the public model list (engine-1.18.32-ux4-pl1 and later);+// - the engine config the app writes lists only the allowed providers and+// names no model of another provider;+// - a model asked for by name (`--model`, an agent's config) must belong to+// an allowed provider, or the app refuses it with `message`.+//+// The same file ships in omnirush-cli (src/provider-lock/) and omnirush-gui+// (apps/server/src/provider-lock/); PARITY.sha256 lists it in both. No imports,+// so the desktop's bundler and the CLI's plain node both load it as is.++export const OMNIRUSH_PROVIDER_ID = "omnirush";+export const PROVIDER_LOCK_MESSAGE = "Only OmniRush models are available.";+export const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;+const MAX_ALLOW = 16;+const MAX_MESSAGE = 300;++/**+ * Engine environment keys that inject configuration from outside the app's+ * own config file. While locked the app removes them from the engine's+ * environment (the engine would drop their provider settings anyway).+ */+export const ENGINE_CONFIG_INJECTION_ENV = Object.freeze([+ "OPENCODE_CONFIG_CONTENT",+ "OPENCODE_CONFIG_DIR",+ "OPENCODE_AUTH_CONTENT",+ "OPENCODE_MODELS_URL",+ "OPENCODE_MODELS_PATH",+]);++function isRecord(value) {+ return typeof value === "object" && value !== null && !Array.isArray(value);+}++function cleanMessage(value) {+ if (typeof value !== "string") return PROVIDER_LOCK_MESSAGE;+ const text = value.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();+ return text ? text.slice(0, MAX_MESSAGE) : PROVIDER_LOCK_MESSAGE;+}++/** The locked policy every missing, failed or malformed answer means. */+export function lockedProviderPolicy(source = "default") {+ return { locked: true, allow: [OMNIRUSH_PROVIDER_ID], message: PROVIDER_LOCK_MESSAGE, source };+}++/**+ * The policy in a /collect/capabilities answer. `capabilities` null/undefined+ * (no answer) or without a well-formed `providers` block is locked.+ * Returns { locked, allow, message, source } with `allow` always naming+ * "omnirush" first.+ */+export function providerLockPolicy(capabilities) {+ const block = isRecord(capabilities) ? capabilities.providers : null;+ if (!isRecord(block)) return lockedProviderPolicy(isRecord(capabilities) ? "missing" : "default");+ const message = cleanMessage(block.message);+ if (block.locked === false) return { locked: false, allow: [], message, source: "server" };+ const allow = [OMNIRUSH_PROVIDER_ID];+ if (Array.isArray(block.allow)) {+ for (const id of block.allow) {+ if (typeof id !== "string" || !PROVIDER_ID_PATTERN.test(id) || allow.includes(id)) continue;+ if (allow.length >= MAX_ALLOW) break;+ allow.push(id);+ }+ }+ return { locked: true, allow, message, source: "server" };+}++/** The provider id of a "provider/model" reference; null for a bare model id or a non-string. */+export function modelProvider(ref) {+ if (typeof ref !== "string") return null;+ const text = ref.trim();+ const slash = text.indexOf("/");+ return slash > 0 ? text.slice(0, slash) : null;+}++/**+ * Whether a model reference may be used under `policy`. A bare id (no+ * provider) is the app's own catalog's to resolve, so it passes here.+ */+export function modelRefAllowed(policy, ref) {+ if (!policy?.locked) return true;+ const provider = modelProvider(ref);+ return provider === null || policy.allow.includes(provider);+}++/**+ * The engine environment changes for `policy`: `set` to add, `remove` to+ * delete from the inherited environment. Unlocked: nothing (the app runs as+ * it did before the lock existed).+ */+export function providerLockEnv(policy) {+ if (!policy?.locked) return { set: {}, remove: [] };+ return {+ set: {+ OMNIRUSH_PROVIDER_LOCK: "1",+ OMNIRUSH_PROVIDER_ALLOW: policy.allow.join(","),+ OMNIRUSH_PROVIDER_LOCK_MESSAGE: policy.message,+ OPENCODE_DISABLE_MODELS_FETCH: "1",+ },+ remove: [...ENGINE_CONFIG_INJECTION_ENV],+ };+}++/** Applies providerLockEnv(policy) to a copy of `env`. */+export function withProviderLockEnv(env, policy) {+ const { set, remove } = providerLockEnv(policy);+ const out = { ...env };+ for (const key of remove) delete out[key];+ return Object.assign(out, set);+}++/**+ * Locks an engine config object the app is about to write: `provider` keeps+ * only allowed ids, `enabled_providers` is exactly the allowed ids,+ * `disabled_providers` is dropped, and `model`, `small_model`, every agent's+ * and command's `model` that names another provider is removed. Returns+ * { config, removed } where `removed` lists what was taken out+ * ("provider:<id>", "model", "agent.<name>.model", ...). Unlocked: the config+ * as it is.+ */+export function lockEngineConfig(config, policy) {+ if (!policy?.locked || !isRecord(config)) return { config, removed: [] };+ const removed = [];+ const out = { ...config };+ if (isRecord(out.provider)) {+ const kept = {};+ for (const [id, value] of Object.entries(out.provider)) {+ if (policy.allow.includes(id)) kept[id] = value;+ else removed.push(`provider:${id}`);+ }+ out.provider = kept;+ }+ out.enabled_providers = [...policy.allow];+ if ("disabled_providers" in out) {+ delete out.disabled_providers;+ removed.push("disabled_providers");+ }+ for (const key of ["model", "small_model"]) {+ if (key in out && !modelRefAllowed(policy, out[key])) {+ delete out[key];+ removed.push(key);+ }+ }+ for (const group of ["agent", "mode", "command"]) {+ if (!isRecord(out[group])) continue;+ const next = {};+ for (const [name, entry] of Object.entries(out[group])) {+ if (isRecord(entry) && "model" in entry && !modelRefAllowed(policy, entry.model)) {+ const { model: _model, ...rest } = entry;+ next[name] = rest;+ removed.push(`${group}.${name}.model`);+ } else {+ next[name] = entry;+ }+ }+ out[group] = next;+ }+ return { config: out, removed };+}diff --git a/apps/server/src/runtime-config-global-providers.test.ts b/apps/server/src/runtime-config-global-providers.test.tsindex 5ba0204e..48f1c798 100644--- a/apps/server/src/runtime-config-global-providers.test.ts+++ b/apps/server/src/runtime-config-global-providers.test.ts@@ -14,6 +14,14 @@ import {import { startServer } from "./server.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+const CLIENT_TOKEN = "owt_global_provider_client";const HOST_TOKEN = "owt_global_provider_host";const roots: string[] = [];@@ -81,6 +89,37 @@ afterEach(async () => {});describe("global runtime providers", () => {+ test("while the server locks model providers, the provider routes refuse other providers and their models", async () => {+ resetProviderLock();+ try {+ const root = await createTempRoot();+ const config = serverConfig(root);+ const server = await startServer(config);+ stops.push(() => server.stop());+ const base = `http://127.0.0.1:${server.port}`;+ const provider = { npm: "@ai-sdk/openai", options: { apiKey: "sk-fake" }, models: { m: {} } };+ const host = await fetch(`${base}/runtime-config/providers`, { method: "PATCH", headers: hostHeaders(), body: JSON.stringify({ provider: { openai: provider } }) });+ expect(host.status).toBe(403);+ expect(await readJsonObject(host)).toMatchObject({ code: "provider_locked", message: "Only OmniRush models are available." });+ const removal = await fetch(`${base}/runtime-config/providers`, { method: "PATCH", headers: hostHeaders(), body: JSON.stringify({ provider: { openai: null } }) });+ expect(removal.status).not.toBe(403);+ const patch = await fetch(`${base}/workspace/ws_1/config`, { method: "PATCH", headers: clientHeaders(), body: JSON.stringify({ opencode: { model: "openai/m" } }) });+ expect(patch.status).toBe(403);+ const file = await fetch(`${base}/workspace/ws_1/opencode-config`, { method: "POST", headers: clientHeaders(), body: JSON.stringify({ scope: "project", content: '{ // fake\n "provider": { "ollama": {} } }' }) });+ expect(file.status).toBe(403);+ const engine = await fetch(`${base}/opencode/auth/openai`, { method: "PUT", headers: clientHeaders(), body: JSON.stringify({ type: "api", key: "sk-fake" }) });+ expect(engine.status).toBe(403);+ const prompt = await fetch(`${base}/workspace/ws_1/opencode/session/ses_x/prompt_async`, { method: "POST", headers: clientHeaders(), body: JSON.stringify({ model: { providerID: "anthropic", modelID: "m" }, parts: [] }) });+ expect(prompt.status).toBe(403);+ expect(await readJsonObject(prompt)).toMatchObject({ code: "provider_locked" });+ const status = await fetch(`${base}/omnirush/provider-lock`, { headers: clientHeaders() });+ expect(await readJsonObject(status)).toMatchObject({ locked: true, allow: ["omnirush"] });+ expect(runtimeProviderMap(await readGlobalRuntimeOpencodeConfig(config))).toEqual({});+ } finally {+ applyProviderLockAnswer({ providers: { locked: false } });+ }+ });+test("round-trips provider upserts and null deletes into the engine-visible file", async () => {const root = await createTempRoot();const config = serverConfig(root);diff --git a/apps/server/src/runtime-config-patch-reload.e2e.test.ts b/apps/server/src/runtime-config-patch-reload.e2e.test.tsindex 564df5bf..d67e4dbd 100644--- a/apps/server/src/runtime-config-patch-reload.e2e.test.ts+++ b/apps/server/src/runtime-config-patch-reload.e2e.test.ts@@ -8,6 +8,14 @@ import { readGlobalRuntimeOpencodeConfig, readRuntimeOpencodeConfig } from "./ruimport { startServer } from "./server.js";import type { ReloadEvent, ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+const stops: Array<() => void | Promise<void>> = [];const roots: string[] = [];diff --git a/apps/server/src/server.ts b/apps/server/src/server.tsindex 7e1404b0..28085d56 100644--- a/apps/server/src/server.ts+++ b/apps/server/src/server.ts@@ -186,6 +186,15 @@ import { rememberServerDefault, watchServerDefault } from "./box/launch.js";import { rememberWebSearchSwitch, watchWebSearchSwitch } from "./web-search.js";import { createChatTracker, rememberComputerUseSwitch } from "./computer-use/desktop.js";import { registerComputerUseRoutes } from "./computer-use/routes.js";+import {+ applyProviderLockAnswer,+ assertConfigWithinProviderLock,+ assertProviderAllowed,+ assertProxiedEngineRequestWithinProviderLock,+ parseJsoncContent,+ providerLockStatus,+ watchProviderLock,+} from "./provider-lock.js";import { normalizeBackend } from "./box/backends/index.js";import { buildOmniRushRuntimeConfigObject, omnirushGatewayConfigured, omnirushRuntimeConfigFilePath, writeOmniRushRuntimeConfigFile } from "./omnirush-runtime-config.js";import { assertMcpAllowed, mcpAllowed, mcpDisabledMessage, mcpPolicyForConfig, refuseAccountLinkedMcp } from "./mcp-policy.js";@@ -1357,6 +1366,7 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {let stopWebSearchWatch: () => void = () => {};let stopMcpPolicyWatch: () => void = () => {};let stopComputerUseWatch: () => void = () => {};+ let stopProviderLockWatch: () => void = () => {};if (gatewayBroker.enabled) {// Read before the first plan and the engine's first config (at most 1.5 s, else the last answer is// used until it comes): a switch flipped or rolled back on the server applies at this start.@@ -1368,9 +1378,20 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {// The model's own web search (web-search.ts), from the same answer. Strict: a failed read keeps// the last answer, while an answer without the block (an older server) turns it off.const readWebSearch = gatewayBroker.sessionUploadCapabilities({ strict: true }).then((capabilities) => rememberWebSearchSwitch(runtimeStorageDir(config), capabilities)).catch(() => false);- const inTime = await Promise.race([Promise.all([read, readWebSearch]).then(() => true), new Promise<false>((resolvePromise) => setTimeout(() => resolvePromise(false), 1_500).unref?.())]);+ // The model provider lock (provider-lock.ts), from the same answer. Strict: a failed read (or no+ // account) keeps it locked; only an answer saying `locked: false` unlocks it, in memory only.+ const readProviderLock = gatewayBroker.sessionUploadCapabilities({ strict: true }).catch(() => null).then((capabilities) => applyProviderLockAnswer(capabilities));+ const inTime = await Promise.race([Promise.all([read, readWebSearch, readProviderLock]).then(() => true), new Promise<false>((resolvePromise) => setTimeout(() => resolvePromise(false), 1_500).unref?.())]);if (!inTime) void read.then((changed) => (changed ? applyServerBoxDefault(config, boxes) : undefined)).catch(() => undefined);if (!inTime) void readWebSearch.then((changed) => (changed ? applyBoxEngineConfig(config, "web_search") : undefined)).catch(() => undefined);+ if (!inTime) void readProviderLock.then((changed) => (changed ? applyBoxEngineConfig(config, "provider_lock", { restart: true }) : undefined)).catch(() => undefined);+ // Read again while the app runs: a switch flipped on the server applies without a restart (the+ // engine config is rewritten and the engine replaced, since its environment carries the lock too).+ stopProviderLockWatch = watchProviderLock({+ read: () => gatewayBroker.sessionUploadCapabilities({ strict: true }),+ apply: () => applyBoxEngineConfig(config, "provider_lock", { restart: true }),+ everyMs: BOX_DEFAULT_REFRESH_MS,+ });stopWebSearchWatch = watchWebSearchSwitch({stateDir: runtimeStorageDir(config),read: () => gatewayBroker.sessionUploadCapabilities({ strict: true }),@@ -1531,6 +1552,7 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {const actor = await requireClient(request, config, tokens);assertOpencodeProxyAllowed(actor, request.method, mount.restPath);await managedDesktopPolicy(config).assertRequest(request, mount.restPath, true);+ await assertProxiedEngineRequestWithinProviderLock(request, mount.restPath);const workspace = await resolveWorkspaceWithoutBootstrap(config, mount.workspaceId);await assertWorkspaceOwnsProxiedSessionRead(config, workspace, request.method, mount.restPath);proxyService = "opencode";@@ -1560,6 +1582,7 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {const actor = await requireClient(request, config, tokens);assertOpencodeProxyAllowed(actor, request.method, mount.restPath);await managedDesktopPolicy(config).assertRequest(request, mount.restPath, true);+ await assertProxiedEngineRequestWithinProviderLock(request, mount.restPath);const workspace = await resolveWorkspaceWithoutBootstrap(config, mount.workspaceId);const connection = engineV2Preview.connection();if (!connection) {@@ -1663,6 +1686,7 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {const actor = await requireClient(request, config, tokens);assertOpencodeProxyAllowed(actor, request.method, url.pathname);await managedDesktopPolicy(config).assertRequest(request, url.pathname, true);+ await assertProxiedEngineRequestWithinProviderLock(request, url.pathname);proxyService = "opencode";const workspace = config.workspaces[0];if (workspace) {@@ -1766,6 +1790,7 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {stopWebSearchWatch();stopMcpPolicyWatch();stopComputerUseWatch();+ stopProviderLockWatch();bestPracticesReloads.stop();// First, and synchronously: archive part uploads in flight are aborted now, not after the other shutdown steps.const captureStopped = capture.stop();@@ -1859,6 +1884,7 @@ export async function startServer(config: ServerConfig): Promise<ServeResult> {stopWebSearchWatch();stopMcpPolicyWatch();stopComputerUseWatch();+ stopProviderLockWatch();const archiveFinals = accountStillStored();if (boxes.hasChats() && await Promise.race([archiveFinals.catch(() => false), new Promise<false>((resolvePromise) => setTimeout(() => resolvePromise(false), 1_000).unref?.())])) {await boxes.finals({ budgetMs: 10_000 }).catch(() => []);@@ -3139,10 +3165,11 @@ async function applyServerBoxDefault(config: ServerConfig, boxes: ReturnType<typ* changed: the engine config file is written again and, when it changed,* the managed engine rolls over to it (as for a best-practices change).*/-async function applyBoxEngineConfig(config: ServerConfig, reason: string): Promise<{ status: "unchanged" | "applied" | "deferred" | "failed" | "unmanaged" }> {+async function applyBoxEngineConfig(config: ServerConfig, reason: string, options: { restart?: boolean } = {}): Promise<{ status: "unchanged" | "applied" | "deferred" | "failed" | "unmanaged" }> {try {const written = await writeOmniRushRuntimeConfigFile(config);- if (!written.changed) return { status: "unchanged" };+ // `restart`: the engine's environment changed too (the provider lock), so a new engine even when the file did not.+ if (!written.changed && !options.restart) return { status: "unchanged" };const pool = enginePoolForConfig(config);const workspaces = config.workspaces.filter((workspace) => resolveWorkspaceOpencodeConnection(config, workspace).baseUrl?.trim());const workspace = findManagedEngineWorkspace(workspaces) ?? workspaces[0];@@ -4397,6 +4424,9 @@ function createRoutes(// The route's pre-2.2.2 path, kept so an engine plugin built before the rename still reports.addRoute(routes, "POST", LEGACY_SESSION_UPLOAD_EVENTS_ROUTE, "policy", sessionUploadEvents);+ // The model provider lock (provider-lock.ts): what the app's model pickers and provider screens show.+ addRoute(routes, "GET", "/omnirush/provider-lock", "client", async () => jsonResponse(providerLockStatus()));+// Sub-agent model and effort (omnirush-subagent-model.ts). The app reads// and writes the setting; the swarm engine plugin resolves every sub-agent// prompt against it with the evaluation token it already holds.@@ -4584,6 +4614,8 @@ function createRoutes(const workspace = resolveEngineRuntimeWorkspace(config);const body = await readJsonBody(ctx.request);const providerPatch = parseRuntimeProviderPatchPayload(body);+ // The model provider lock (provider-lock.ts): only removals, or the allowed providers.+ for (const [providerId, value] of Object.entries(providerPatch)) if (value !== null) assertProviderAllowed(providerId);const result = await writeGlobalRuntimeOpencodeConfig(config, (current) => ({...current,provider: mergeRuntimeProviderUpdate(current.provider, providerPatch),@@ -4698,6 +4730,8 @@ function createRoutes(}const configPath = resolveOpencodeConfigFilePath(scope, workspace.path);+ // The model provider lock (provider-lock.ts): a file that adds another provider or names its model is refused.+ assertConfigWithinProviderLock(parseJsoncContent(content));await requireApproval(ctx, {workspaceId: workspace.id,action: scope === "global" ? "config.global.write" : "config.write",@@ -4782,6 +4816,9 @@ function createRoutes(// rendered from the ENGINE_GLOBAL row only, so a workspace-row write// would never reach the engine.const providerUpdate = isRecord(provider) ? provider : {};+ // The model provider lock (provider-lock.ts): no other provider and no model of one.+ for (const [providerId, value] of Object.entries(providerUpdate)) if (value !== null) assertProviderAllowed(providerId);+ assertConfigWithinProviderLock(topLevelUpdates);if (Object.keys(providerUpdate).length) await managedDesktopPolicy(config).assert("provider");if (Object.keys(providerUpdate).length) {const providerResult = await writeGlobalRuntimeOpencodeConfig(config, (current) => ({diff --git a/apps/server/src/session-uploader.server.e2e.test.ts b/apps/server/src/session-uploader.server.e2e.test.tsindex 443b8eac..56a35ed9 100644--- a/apps/server/src/session-uploader.server.e2e.test.ts+++ b/apps/server/src/session-uploader.server.e2e.test.ts@@ -12,6 +12,14 @@ import { FakeArchiveServer } from "./session-archive/fake-archive-server.js";import { manifestOf, openArchive } from "./session-archive/test-helpers.js";import type { ServerConfig } from "./types.js";+import { afterAll as afterAllUnlocked, beforeAll as beforeAllUnlocked } from "bun:test";+import { applyProviderLockAnswer, resetProviderLock } from "./provider-lock.js";++// These cover the app while the server leaves model providers unlocked+// (providers.locked false); provider-lock.test.ts covers the lock.+beforeAllUnlocked(() => { applyProviderLockAnswer({ providers: { locked: false } }); });+afterAllUnlocked(() => resetProviderLock());+/** Schema 1/2 trace uploads carry their events only in files[0] (__omnirush__/trace.json): read them back as `trace`. */function withTraceEvents<T>(envelope: T): T {const record = envelope as Record<string, unknown>;@@ -835,6 +843,9 @@ describe("session uploader server integration", () => {describe("collection gaps: the v2 mount and local workflow steps", () => {const provider = { provider: "anthropic", model: "claude-sonnet-4-5" };+ // Local workflows use only the providers the server allows (provider-lock.ts): the mock+ // gateway sends no providers block, so the app stays locked to OmniRush's own models.+ const workflowModel = { provider: "omnirush", model: "claude-sonnet-4-5" };test("refuses a v2 prompt dispatch on a local workspace without an account, unless both development flags are set", async () => {const { root, stateDir } = await createWorkspace();@@ -918,9 +929,9 @@ describe("collection gaps: the v2 mount and local workflow steps", () => {test("refuses a local workflow run without an account, unless both development flags are set", async () => {const { root, stateDir } = await createWorkspace();- const engine = startMockEngine(provider);+ const engine = startMockEngine(workflowModel);const omnirush = await startOmniRush(serverConfig({ root, stateDir, engineBaseUrl: engine.baseUrl }));- const workflowId = await createWorkflow(omnirush.base, provider);+ const workflowId = await createWorkflow(omnirush.base, workflowModel);preserveGateEnv();setGateEnv(undefined, undefined);@@ -942,15 +953,15 @@ describe("collection gaps: the v2 mount and local workflow steps", () => {const run = await settledRun(omnirush.base, ((await accepted.json()) as { id: string }).id);expect(run.status).toBe("completed");expect(run.steps.map((step) => [step.status, step.sessionId, step.output])).toEqual([["completed", "ses_workflow", "workflow answer 1"]]);- expect(engine.workflowPrompts).toEqual([{ model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" }, parts: [{ type: "text", text: "Summarise the repository" }] }]);+ expect(engine.workflowPrompts).toEqual([{ model: { providerID: "omnirush", modelID: "claude-sonnet-4-5" }, parts: [{ type: "text", text: "Summarise the repository" }] }]);}, 30_000);test("captures a workflow step exactly like a prompt sent from the app", async () => {const { root, stateDir } = await createWorkspace();- const engine = startMockEngine(provider);+ const engine = startMockEngine(workflowModel);const gateway = startMockGateway();const omnirush = await startOmniRush(serverConfig({ root, stateDir, engineBaseUrl: engine.baseUrl, gatewayUrl: gateway.gatewayUrl }));- const workflowId = await createWorkflow(omnirush.base, provider);+ const workflowId = await createWorkflow(omnirush.base, workflowModel);const accepted = await runWorkflow(omnirush.base, workflowId);expect(accepted.status).toBe(202);const run = await settledRun(omnirush.base, ((await accepted.json()) as { id: string }).id);@@ -970,15 +981,15 @@ describe("collection gaps: the v2 mount and local workflow steps", () => {}expect(events(trace).find((event) => event.type === "engine.request")?.data).toEqual({method: "POST", path: "/session/ses_workflow/message",- body: { model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" }, parts: [{ type: "text", text: "Summarise the repository" }] },+ body: { model: { providerID: "omnirush", modelID: "claude-sonnet-4-5" }, parts: [{ type: "text", text: "Summarise the repository" }] },});expect(events(trace).find((event) => event.type === "engine.response")?.data).toEqual({ method: "POST", path: "/session/ses_workflow/message", status: 200 });expect(events(trace).filter((event) => event.type === "collector.trigger").map((event) => event.data?.trigger)).toEqual(["prompt", "turn_completed"]);expect(events(trace).find((event) => event.type === "session.model")?.data).toEqual({- provider_id: "anthropic", model_id: "claude-sonnet-4-5", variant: "high", agent: "build",+ provider_id: "omnirush", model_id: "claude-sonnet-4-5", variant: "high", agent: "build",});expect((events(trace).find((event) => event.type === "turn.completed")?.data?.messages as unknown[]).length).toBe(2);- expect(gateway.uploads.at(-1)?.envelope.session).toEqual({ provider_id: "anthropic", model_id: "claude-sonnet-4-5", variant: "high", child_session_ids: [] });+ expect(gateway.uploads.at(-1)?.envelope.session).toEqual({ provider_id: "omnirush", model_id: "claude-sonnet-4-5", variant: "high", child_session_ids: [] });}, 60_000);});diff --git a/apps/server/src/session-uploader.ts b/apps/server/src/session-uploader.tsindex 660052b6..cd54e016 100644--- a/apps/server/src/session-uploader.ts+++ b/apps/server/src/session-uploader.ts@@ -881,6 +881,8 @@ export type TraceCapabilities = {computer_use?: Record<string, unknown>;/** The MCP list (mcp-allow/state.ts remembers it): absent is off. */mcp?: Record<string, unknown>;+ /** The model provider lock (provider-lock.ts): the block as the server sent it; absent is locked. */+ providers?: Record<string, unknown>;};