Skip to content

A desktop coding agent with free access to frontier models.

TypeScript

fix: a new chat in another project starts on that project's model or the default

ogsamrat01d1b41e0750
diff --git a/apps/app/src/react-app/shell/project-model-prefs.ts b/apps/app/src/react-app/shell/project-model-prefs.ts
new file mode 100644
index 00000000..96fb395b
--- /dev/null
+++ b/apps/app/src/react-app/shell/project-model-prefs.ts
@@ -0,0 +1,66 @@
+// A model picked in a project stays that project's: a new chat in another
+// project starts on that project's own pick, else on the app default
+// (Settings), never on the pick last made elsewhere.
+import { useCallback, useMemo } from "react";
+
+import type { LocalPreferences, useLocal } from "@/react-app/kernel/local-provider";
+import { useSessionModelStore, type SessionModelSelection } from "@/react-app/domains/session/surface/session-model-store";
+
+type LocalValue = ReturnType<typeof useLocal>;
+
+/** The project's pick lives in the per-chat model memory under this stand-in id. */
+export function projectModelKey(workspaceId: string): string {
+ return `project:${workspaceId}`;
+}
+
+/** Remember `selection` as the project's own pick. */
+export function rememberProjectModel(workspaceId: string, selection: SessionModelSelection): void {
+ const store = useSessionModelStore.getState();
+ store.setModel(projectModelKey(workspaceId), selection.model, selection.variant);
+ store.setVariant(projectModelKey(workspaceId), selection.variant);
+}
+
+/** The app preferences as a project sees them: its own pick over the app default. */
+type ModelPrefs = Pick<LocalPreferences, "defaultModel" | "modelVariant">;
+
+export function projectModelPrefs<P extends ModelPrefs>(prefs: P, own: SessionModelSelection | null): P {
+ return own ? { ...prefs, defaultModel: own.model, modelVariant: own.variant } : prefs;
+}
+
+/** A route update split in two: a model or effort change is the project's own pick, everything else the app's. */
+export function splitProjectModelUpdate<P extends ModelPrefs>(
+ seen: P,
+ next: P,
+ app: P,
+): { app: P; own: SessionModelSelection | null } {
+ const sameModel = next.defaultModel?.providerID === seen.defaultModel?.providerID
+ && next.defaultModel?.modelID === seen.defaultModel?.modelID;
+ const changed = !sameModel || (next.modelVariant ?? null) !== (seen.modelVariant ?? null);
+ return {
+ app: { ...next, defaultModel: app.defaultModel, modelVariant: app.modelVariant },
+ own: changed && next.defaultModel ? { model: next.defaultModel, variant: next.modelVariant ?? null } : null,
+ };
+}
+
+/** `useLocal()` for the session route, scoped to the open project's model pick. */
+export function useProjectModelLocal(app: LocalValue, workspaceId: string): LocalValue {
+ const key = workspaceId ? projectModelKey(workspaceId) : "";
+ const own = useSessionModelStore((state) => (key ? state.bySessionId[key] ?? null : null));
+ const prefs = useMemo(() => projectModelPrefs(app.prefs, own), [app.prefs, own]);
+ const setAppPrefs = app.setPrefs;
+ const setPrefs = useCallback((updater: (previous: LocalPreferences) => LocalPreferences) => {
+ if (!key) {
+ setAppPrefs(updater);
+ return;
+ }
+ setAppPrefs((previous) => {
+ const seen = projectModelPrefs(previous, useSessionModelStore.getState().bySessionId[key] ?? null);
+ const split = splitProjectModelUpdate(seen, updater(seen), previous);
+ // Not inside React's state update: the model store is another store.
+ const own = split.own;
+ if (own) queueMicrotask(() => rememberProjectModel(workspaceId, own));
+ return split.app;
+ });
+ }, [key, setAppPrefs, workspaceId]);
+ return useMemo(() => ({ ...app, prefs, setPrefs }), [app, prefs, setPrefs]);
+}
diff --git a/apps/app/src/react-app/shell/session-route.tsx b/apps/app/src/react-app/shell/session-route.tsx
index 436e6f9a..0a8f1b5c 100644
--- a/apps/app/src/react-app/shell/session-route.tsx
+++ b/apps/app/src/react-app/shell/session-route.tsx
@@ -106,6 +106,7 @@ import {
} from "@/react-app/shell/route-workspaces";
import { reloadEngineWithDesktopFallback } from "@/react-app/shell/engine-reload-escalation";
import { useLocal } from "@/react-app/kernel/local-provider";
+import { projectModelKey, rememberProjectModel, useProjectModelLocal } from "./project-model-prefs";
import { usePlatform } from "@/react-app/kernel/platform";
import {
SessionPage,
@@ -406,7 +407,7 @@ export function SessionRoute() {
const toggleSidebar = useUiStateStore((state) => state.toggleSidebar);
const denAuth = useDenAuth();
const { config: shellConfig } = useShellConfig();
- const local = useLocal();
+ const appLocal = useLocal();
const automationDeploymentEnabled = useAutomationDeploymentEnabled();
// Desktop and Web share one Automations surface; the runtime only decides
// the placement of what each creates. Den's deployment flag stays the gate.
@@ -535,6 +536,8 @@ export function SessionRoute() {
onServerSettingsChanged: () => setOmniRushServerSettingsVersion((value) => value + 1),
onHostInfo: setOmniRushServerHostInfoState,
});
+ // Model picks here are the open project's own (project-model-prefs.ts); Settings keeps the app default.
+ const local = useProjectModelLocal(appLocal, selectedWorkspaceId);
// "Send feedback" from a menu that does not know the open session (Help menu, sidebar).
useEffect(() => {
setFeedbackCurrentSession(selectedSessionId ?? null);
@@ -2041,6 +2044,7 @@ export function SessionRoute() {
selectedWorkspaceEndpoint?.opencodeBaseUrl ?? null,
selectedWorkspaceId || null,
]),
+ draftScope: sessionDraftScope,
selectedModel: local.prefs.defaultModel ?? { providerID: "", modelID: "" },
modelOptions: organizationAssignedModelOptions,
modelUnavailable: selectedModelUnavailable,
@@ -2274,23 +2278,16 @@ export function SessionRoute() {
);
- const applyLastUsedModelToSession = useCallback((sessionId: string) => {
- const previous = selectedSessionId ? getSessionModelSelection(selectedSessionId) : null;
- const model = previous?.model ?? local.prefs.defaultModel;
+ const applyLastUsedModelToSession = useCallback((sessionId: string, workspaceId: string) => {
+ // The open chat's model carries over only inside its own project; another project starts on its own pick or the app default.
+ const previous = selectedSessionId && workspaceId === selectedWorkspaceId ? getSessionModelSelection(selectedSessionId) : null;
+ const own = previous ?? getSessionModelSelection(projectModelKey(workspaceId));
+ const model = own?.model ?? appLocal.prefs.defaultModel;
if (!model?.providerID || !model.modelID) return;
- const variant = previous ? previous.variant : (local.prefs.modelVariant ?? null);
+ const variant = own ? own.variant : (appLocal.prefs.modelVariant ?? null);
useSessionModelStore.getState().setModel(sessionId, model, variant);
- local.setPrefs((current) => {
- if (
- current.defaultModel?.providerID === model.providerID
- && current.defaultModel.modelID === model.modelID
- && (current.modelVariant ?? null) === variant
- ) {
- return current;
- }
- return { ...current, defaultModel: model, modelVariant: variant };
- });
- }, [local, selectedSessionId]);
+ if (previous) rememberProjectModel(workspaceId, previous);
+ }, [appLocal.prefs.defaultModel, appLocal.prefs.modelVariant, selectedSessionId, selectedWorkspaceId]);
const handleCreateTaskInWorkspaceWithOpenMode = useCallback(async (
workspaceId: string,
@@ -2347,7 +2344,7 @@ export function SessionRoute() {
}
useComposerStateStore.setState({ pendingFocusSessionId: session.id });
rememberPendingCreatedSession(workspaceId, session.id);
- applyLastUsedModelToSession(session.id);
+ applyLastUsedModelToSession(session.id, workspaceId);
setSessionsByWorkspaceId((current) => {
const next = {
...current,
@@ -3401,6 +3398,10 @@ export function SessionRoute() {
).session.create({ directory: workspacePath || undefined })
.then((result) => unwrap(result))
: null;
+ // A supplied prompt never just disappears: without its chat it goes back to the composer with this error.
+ if (!session && (firstTaskPrompt || firstTaskAttachments.length > 0)) {
+ throw new Error("The project was added but its chat could not be started yet. Send the message again.");
+ }
setLegacySelectedWorkspaceId(targetWorkspaceId);
writeActiveWorkspaceId(targetWorkspaceId);
if (projectLabel) {
@@ -3953,7 +3954,7 @@ export function SessionRoute() {
}
}
rememberPendingCreatedSession(workspaceId, session.id);
- applyLastUsedModelToSession(session.id);
+ applyLastUsedModelToSession(session.id, workspaceId);
setSessionsByWorkspaceId((current) => ({
...current,
[workspaceId]: mergeWorkspaceRouteSession(current[workspaceId] ?? [], session),
diff --git a/apps/app/tests/composer-model-controls.test.ts b/apps/app/tests/composer-model-controls.test.ts
index 0b47162b..d9a57132 100644
--- a/apps/app/tests/composer-model-controls.test.ts
+++ b/apps/app/tests/composer-model-controls.test.ts
@@ -66,7 +66,7 @@ describe("composer model controls", () => {
const sessionProviderAuthSource = readFileSync(sessionProviderAuthPath, "utf8");
expect(sessionRouteSource).toContain('await refreshCloudProviderSync("manual");');
- expect(sessionRouteSource).toContain("applyLastUsedModelToSession(session.id)");
+ expect(sessionRouteSource).toContain("applyLastUsedModelToSession(session.id, workspaceId)");
expect(sessionProviderAuthSource).toContain(
"setCompletedCloudProviderSync({ context: cloudProviderSyncContext, providerList });",
);
diff --git a/apps/app/tests/project-model-prefs.test.ts b/apps/app/tests/project-model-prefs.test.ts
new file mode 100644
index 00000000..7e3115d4
--- /dev/null
+++ b/apps/app/tests/project-model-prefs.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ModelRef } from "../src/app/types";
+import { projectModelPrefs, splitProjectModelUpdate } from "../src/react-app/shell/project-model-prefs";
+
+const appDefault = { providerID: "omnirush", modelID: "gpt-6-astra" };
+const pickInA = { providerID: "omnirush", modelID: "gpt-6.1-sol" };
+const ownOfB = { providerID: "omnirush", modelID: "kimi-k3.1-pro" };
+
+function prefs(): { showThinking: boolean; modelVariant: string | null; defaultModel: ModelRef | null } {
+ return { showThinking: false, modelVariant: null, defaultModel: appDefault };
+}
+
+describe("project model picks", () => {
+ test("a pick in project A stays A's: a new chat in project B gets the app default, or B's own pick", () => {
+ const app = prefs();
+ // Picking in A, as the route's model handlers do through setPrefs.
+ const seenInA = projectModelPrefs(app, null);
+ const split = splitProjectModelUpdate(seenInA, { ...seenInA, defaultModel: pickInA, modelVariant: "high" }, app);
+ expect(split.own).toEqual({ model: pickInA, variant: "high" });
+ expect(split.app.defaultModel).toEqual(appDefault);
+ expect(split.app.modelVariant).toBeNull();
+
+ expect(projectModelPrefs(split.app, split.own).defaultModel).toEqual(pickInA);
+ expect(projectModelPrefs(split.app, null).defaultModel).toEqual(appDefault);
+ expect(projectModelPrefs(split.app, { model: ownOfB, variant: null }).defaultModel).toEqual(ownOfB);
+ });
+
+ test("other preference changes pass through and leave the project's pick alone", () => {
+ const app = prefs();
+ const seen = projectModelPrefs(app, { model: ownOfB, variant: "low" });
+ const split = splitProjectModelUpdate(seen, { ...seen, showThinking: true }, app);
+ expect(split.own).toBeNull();
+ expect(split.app.showThinking).toBe(true);
+ expect(split.app.defaultModel).toEqual(appDefault);
+ });
+});