Skip to content

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.ts
index 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.ts
index 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 | n
export 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?: s
requestJson<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.ts
index 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.ts
new file mode 100644
index 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.tsx
index 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() ? (
<RetryActionButton
label="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.tsx
index 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.locked
const hasOrganizationPrompts = organizationPrompts !== undefined
return (
diff --git a/apps/app/src/components/model-select.tsx b/apps/app/src/components/model-select.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.tsx
index 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 : <button
type="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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.tsx
index 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.ts
index 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 } fro
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());
+
/**
* 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.ts
index 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.ts
index 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), so
diff --git a/apps/server/src/embedded-lifecycle.test.ts b/apps/server/src/embedded-lifecycle.test.ts
index 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.ts
index 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.ProcessEnv
const 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.ts
index 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.ts
index 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), never
diff --git a/apps/server/src/local-workflows.ts b/apps/server/src/local-workflows.ts
index 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.ts
index 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.ts
index 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.ts
index 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 "./manage
import { 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.ts
index 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): Pr
const 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.sha256
new file mode 100644
index 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.mts
diff --git a/apps/server/src/provider-lock/provider-lock-parity.test.ts b/apps/server/src/provider-lock/provider-lock-parity.test.ts
new file mode 100644
index 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.mts
new file mode 100644
index 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.mjs
new file mode 100644
index 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.ts
index 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.ts
index 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 "./ru
import { 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.ts
index 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.ts
index 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.ts
index 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>;
};