Skip to content

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.ts
index 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.ts
index 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.tsx
index 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.ts
index 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> = {}): ModelAvaila
const 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({");