A desktop coding agent with free access to frontier models.
TypeScript
fix: switch only for a blocked provider after the lock answer or a retired model
ogsamratc791be3afd1a
diff --git a/apps/app/src/app/lib/provider-lock.ts b/apps/app/src/app/lib/provider-lock.tsindex 977617cb..fb98af76 100644--- a/apps/app/src/app/lib/provider-lock.ts+++ b/apps/app/src/app/lib/provider-lock.ts@@ -47,11 +47,31 @@ export function providerLockState(): ProviderLockState {return state;}+/** Whether the app's server has answered at least once (until then the start state, locked, is assumed). */+let answered = false;++export function providerLockAnswered(): boolean {+ return answered;+}+/** 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;+ const nowAnswered = answered || isRecord(value);+ if (+ nowAnswered === answered+ && next.locked === state.locked && next.message === state.message && next.allow.join(",") === state.allow.join(",")+ ) return;+ answered = nowAnswered;+ // A new object, so subscribers re-render when only `answered` changed.+ state = { ...next };+ for (const listener of listeners) listener();+}++/** Back to the start state: locked, not answered (tests). */+export function resetProviderLockState(): void {+ answered = false;+ state = LOCKED;for (const listener of listeners) listener();}diff --git a/apps/app/src/react-app/domains/session/surface/model-availability.ts b/apps/app/src/react-app/domains/session/surface/model-availability.tsindex 51f9cc8d..28e6c799 100644--- a/apps/app/src/react-app/domains/session/surface/model-availability.ts+++ b/apps/app/src/react-app/domains/session/surface/model-availability.ts@@ -108,20 +108,29 @@ export function computeModelAvailability(/*** The model an existing conversation switches to when the model it remembers- * can no longer be used (its provider is locked or blocked, it is not- * connected, or the model left the catalog): the global default, once that is- * confirmed available and differs from it. Null keeps the remembered model- * (still pending, fine, or no usable default to switch to).+ * can no longer be used: the global default, once that is confirmed available+ * and differs from it. Only for two definite cases:+ * - its provider is blocked (the server's provider lock, or desktop policy),+ * once the server has answered the lock (`lockAnswered`; until then the+ * app assumes locked, which must not rewrite a chat on an unlocked server);+ * - an OmniRush model that left the catalog.+ * Anything else (an organization's provider not connected, another provider's+ * model missing) keeps the remembered model and the picker. Null: no switch.*/export function sessionModelFallback(input: {sessionModel: ModelRef | null | undefined;sessionAvailability: ModelAvailability;defaultModel: ModelRef | null | undefined;defaultAvailability: ModelAvailability;+ lockAnswered: boolean;}): ModelRef | null {- const { sessionModel, defaultModel } = input;+ const { sessionModel, defaultModel, sessionAvailability } = input;if (!sessionModel || !defaultModel) return null;- if (input.sessionAvailability.status !== "unavailable") return null;+ if (sessionAvailability.status !== "unavailable") return null;+ const definite = sessionAvailability.reason === "provider_blocked"+ ? input.lockAnswered+ : sessionAvailability.reason === "model_missing" && sessionModel.providerID.trim().toLowerCase() === "omnirush";+ if (!definite) return null;if (input.defaultAvailability.status !== "available") return null;if (sessionModel.providerID === defaultModel.providerID && sessionModel.modelID === defaultModel.modelID) return null;return { providerID: defaultModel.providerID, modelID: defaultModel.modelID };diff --git a/apps/app/src/react-app/shell/session-route.tsx b/apps/app/src/react-app/shell/session-route.tsxindex 2281bb34..27d32243 100644--- a/apps/app/src/react-app/shell/session-route.tsx+++ b/apps/app/src/react-app/shell/session-route.tsx@@ -1,5 +1,5 @@/** @jsxImportSource react */-import { isProviderLocked, providerLockMessage } from "@/app/lib/provider-lock";+import { isProviderLocked, providerLockAnswered, providerLockMessage, useProviderLock } from "@/app/lib/provider-lock";import { useEditorStore } from "../domains/session/editor/editor-store";import { isElectronRuntime } from "../../app/utils";import {@@ -1109,12 +1109,15 @@ export function SessionRoute() {// locked or blocked, or the model left the catalog: e.g. a chat from before an// update) moves to the working default with a notice, instead of a disabled// composer and a picker to sort out.+ // Re-renders when the server's lock answer arrives (providerLockAnswered below).+ useProviderLock();const sessionFallbackModel = activeComposerTargetsSession? sessionModelFallback({sessionModel: selectedSessionModelSelection?.model,sessionAvailability: activeComposerAvailability,defaultModel: local.prefs.defaultModel,defaultAvailability: resolveModelAvailability(local.prefs.defaultModel ?? null),+ lockAnswered: providerLockAnswered(),}): null;const sessionFallbackKey = sessionFallbackModel && selectedSessionId && selectedSessionModelSelection@@ -1157,8 +1160,10 @@ export function SessionRoute() {signedIn: denAuth.isSignedIn,cloudProviderSyncReady,// Silent default repair only applies when the broken selection IS the- // default; a conversation's own unavailable model must surface the- // picker for that conversation instead.+ // default. A conversation's own unavailable model moves to the default+ // with a notice when that is definite (sessionModelFallback: a blocked+ // provider, a retired OmniRush model); otherwise the picker surfaces+ // for that conversation.entitledOrgDefaultModel: activeComposerTargetsSession ? false : Boolean(entitledOrgDefaultModel),organizationModelsEmpty,autoOpenedUnavailableModelKey: autoOpenedUnavailableModelRef.current,diff --git a/apps/app/tests/session-model-fallback.test.ts b/apps/app/tests/session-model-fallback.test.tsindex ce649115..03165354 100644--- a/apps/app/tests/session-model-fallback.test.ts+++ b/apps/app/tests/session-model-fallback.test.ts@@ -46,12 +46,18 @@ function context(overrides: Partial<ModelAvailabilityContext> = {}): ModelAvailaconst omnirushDefault = { providerID: "omnirush", modelID: "gpt-6-astra" };-function fallbackFor(sessionModel: { providerID: string; modelID: string }, ctx = context(), defaultModel = omnirushDefault) {+function fallbackFor(+ sessionModel: { providerID: string; modelID: string },+ ctx = context(),+ defaultModel = omnirushDefault,+ lockAnswered = true,+) {return sessionModelFallback({sessionModel,sessionAvailability: computeModelAvailability(sessionModel, ctx),defaultModel,defaultAvailability: computeModelAvailability(defaultModel, ctx),+ lockAnswered,});}@@ -89,9 +95,45 @@ describe("a conversation's remembered model that can no longer be used", () => {sessionAvailability: { status: "unavailable", reason: "provider_blocked" },defaultModel: null,defaultAvailability: { status: "pending" },+ lockAnswered: true,})).toBeNull();});+ test("a blocked provider does not move the chat before the server answered the lock", () => {+ // The app starts locked until its server answers; an unlocked server must not see chats rewritten.+ expect(fallbackFor({ providerID: "mockai", modelID: "mock-1" }, context(), omnirushDefault, false)).toBeNull();+ // A retired OmniRush model does not depend on the lock.+ expect(fallbackFor({ providerID: "omnirush", modelID: "gpt-5.6-sol" }, context(), omnirushDefault, false)).toEqual(omnirushDefault);+ });++ test("an organization's provider that is not connected, or another provider's missing model, keeps the picker", () => {+ const base = { defaultModel: omnirushDefault, defaultAvailability: { status: "available" } as const, lockAnswered: true };+ expect(sessionModelFallback({+ ...base,+ sessionModel: { providerID: "lpr_acme", modelID: "acme-large" },+ sessionAvailability: { status: "unavailable", reason: "provider_not_connected" },+ })).toBeNull();+ expect(sessionModelFallback({+ ...base,+ sessionModel: { providerID: "lpr_acme", modelID: "acme-old" },+ sessionAvailability: { status: "unavailable", reason: "model_missing" },+ })).toBeNull();+ });++ test("the lock state records the server's first answer", async () => {+ const lock = await import("../src/app/lib/provider-lock");+ lock.resetProviderLockState();+ expect(lock.providerLockAnswered()).toBe(false);+ lock.setProviderLockState(null);+ expect(lock.providerLockAnswered()).toBe(false);+ const before = lock.providerLockState();+ lock.setProviderLockState({ locked: true, message: "Only OmniRush models are available." });+ expect(lock.providerLockAnswered()).toBe(true);+ // Same lock, new object: subscribers re-render for the answer.+ expect(lock.providerLockState()).not.toBe(before);+ expect(lock.providerLockState().locked).toBe(true);+ });+test("the session route switches with a notice instead of opening the picker", () => {const source = readFileSync(join(import.meta.dir, "../src/react-app/shell/session-route.tsx"), "utf8");expect(source).toContain("sessionModelFallback({");