Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🪶 fix: Prevent Soft Default Model Spec from Overriding User Selections (#13642)
Danny Avilada6b74e8ebfe
diff --git a/client/src/hooks/useNewConvo.ts b/client/src/hooks/useNewConvo.tsindex d7c51cfecf..de58d54165 100644--- a/client/src/hooks/useNewConvo.ts+++ b/client/src/hooks/useNewConvo.ts@@ -321,7 +321,7 @@ const useNewConvo = (index = 0) => {};let preset = _preset;- const result = getDefaultModelSpec(startupConfig);+ const result = getDefaultModelSpec(startupConfig, endpointsConfig);const defaultModelSpec = result?.default ?? result?.last ?? result?.softDefault;const shouldApplyModelSpec =result?.softDefault != null@@ -383,6 +383,7 @@ const useNewConvo = (index = 0) => {resetBadges,startupConfig,saveBadgesState,+ endpointsConfig,pauseGlobalAudio,switchToConversation,applyModelSpecEffects,diff --git a/client/src/routes/ChatRoute.tsx b/client/src/routes/ChatRoute.tsxindex eebbc88106..5f55df51dd 100644--- a/client/src/routes/ChatRoute.tsx+++ b/client/src/routes/ChatRoute.tsx@@ -166,7 +166,7 @@ export default function ChatRoute() {}const getNewConvoPreset = () => {- const result = getDefaultModelSpec(startupConfig);+ const result = getDefaultModelSpec(startupConfig, endpointsQuery.data);const spec = result?.default ?? result?.last ?? result?.softDefault;const specPreset = spec ? getModelSpecPreset(spec) : undefined;@@ -212,7 +212,7 @@ export default function ChatRoute() {initialConvoQuery.isError &&isNotFoundError(initialConvoQuery.error)) {- const result = getDefaultModelSpec(startupConfig);+ const result = getDefaultModelSpec(startupConfig, endpointsQuery.data);const spec = result?.default ?? result?.last ?? result?.softDefault;showToast({message: localize('com_ui_conversation_not_found'),diff --git a/client/src/utils/__tests__/getDefaultModelSpec.test.ts b/client/src/utils/__tests__/getDefaultModelSpec.test.tsindex 1127399d2b..e2032e06de 100644--- a/client/src/utils/__tests__/getDefaultModelSpec.test.ts+++ b/client/src/utils/__tests__/getDefaultModelSpec.test.ts@@ -1,5 +1,5 @@import { EModelEndpoint, LocalStorageKeys } from 'librechat-data-provider';-import type { TModelSpec, TStartupConfig } from 'librechat-data-provider';+import type { TModelSpec, TStartupConfig, TEndpointsConfig } from 'librechat-data-provider';import { getDefaultModelSpec } from '../endpoints';const createModelSpec = (name: string, overrides: Partial<TModelSpec> = {}): TModelSpec =>@@ -13,17 +13,80 @@ const createModelSpec = (name: string, overrides: Partial<TModelSpec> = {}): TMo...overrides,}) as TModelSpec;-const createStartupConfig = (list: TModelSpec[]): TStartupConfig =>+const createStartupConfig = (+ list: TModelSpec[],+ {+ prioritize = true,+ modelSelect = true,+ addedEndpoints,+ }: { prioritize?: boolean; modelSelect?: boolean; addedEndpoints?: string[] } = {},+): TStartupConfig =>({interface: {- modelSelect: true,+ modelSelect,},modelSpecs: {- prioritize: true,+ prioritize,list,+ ...(addedEndpoints ? { addedEndpoints } : {}),},}) as TStartupConfig;+const fullEndpointsConfig: TEndpointsConfig = {+ [EModelEndpoint.openAI]: { order: 0 },+ [EModelEndpoint.agents]: { order: 1 },+};++const agentsOnlyEndpointsConfig: TEndpointsConfig = {+ [EModelEndpoint.agents]: { order: 0 },+};++const writeLastModel = (endpoint: string, model: string) => {+ const stored = JSON.parse(localStorage.getItem(LocalStorageKeys.LAST_MODEL) ?? '{}') as Record<+ string,+ string+ >;+ stored[endpoint] = model;+ localStorage.setItem(LocalStorageKeys.LAST_MODEL, JSON.stringify(stored));+};++/** Mirrors what the conversation effect persists after a spec preset is applied */+const persistAppliedSpec = (spec: TModelSpec) => {+ localStorage.setItem(LocalStorageKeys.LAST_SPEC, spec.name);+ writeLastModel(spec.preset.endpoint as string, spec.preset.model as string);+ localStorage.setItem(+ `${LocalStorageKeys.LAST_CONVO_SETUP}_0`,+ JSON.stringify({+ endpoint: spec.preset.endpoint,+ model: spec.preset.model,+ spec: spec.name,+ }),+ );+};++/** Mirrors what the conversation effect persists after the user selects an agent */+const persistAgentSelection = (agentId: string) => {+ localStorage.setItem(`${LocalStorageKeys.AGENT_ID_PREFIX}0`, agentId);+ localStorage.setItem(+ `${LocalStorageKeys.LAST_CONVO_SETUP}_0`,+ JSON.stringify({+ endpoint: EModelEndpoint.agents,+ agent_id: agentId,+ model: null,+ spec: null,+ }),+ );+};++/** Mirrors what the conversation effect persists after an ephemeral endpoint → model pick */+const persistEphemeralSelection = (endpoint: string, model: string) => {+ writeLastModel(endpoint, model);+ localStorage.setItem(+ `${LocalStorageKeys.LAST_CONVO_SETUP}_0`,+ JSON.stringify({ endpoint, model, spec: null }),+ );+};+describe('getDefaultModelSpec', () => {beforeEach(() => {localStorage.clear();@@ -55,7 +118,7 @@ describe('getDefaultModelSpec', () => {JSON.stringify({ [EModelEndpoint.openAI]: 'gpt-4o' }),);- const result = getDefaultModelSpec(createStartupConfig([softSpec]));+ const result = getDefaultModelSpec(createStartupConfig([softSpec]), fullEndpointsConfig);expect(result).toBeUndefined();});@@ -64,7 +127,7 @@ describe('getDefaultModelSpec', () => {const softSpec = createModelSpec('soft-spec', { softDefault: true });localStorage.setItem(`${LocalStorageKeys.AGENT_ID_PREFIX}0`, 'agent_123');- const result = getDefaultModelSpec(createStartupConfig([softSpec]));+ const result = getDefaultModelSpec(createStartupConfig([softSpec]), fullEndpointsConfig);expect(result).toBeUndefined();});@@ -87,4 +150,243 @@ describe('getDefaultModelSpec', () => {expect(result).toEqual({ default: firstSpec });});++ describe('soft default auto-application residue', () => {+ const softSpec = createModelSpec('soft-spec', { softDefault: true });+ const otherSpec = createModelSpec('other-spec');++ it('stays soft after its own application is persisted (prioritized config)', () => {+ persistAppliedSpec(softSpec);++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec]),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });++ it('stays soft after its own application is persisted (modelSelect config)', () => {+ persistAppliedSpec(softSpec);++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });++ it('yields to an agent selected after the soft default was applied', () => {+ persistAppliedSpec(softSpec);+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });++ it('yields to an agent selection even with the prioritized config', () => {+ persistAppliedSpec(softSpec);+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec]),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });++ it('yields to an ephemeral endpoint → model pick after the soft default was applied', () => {+ persistAppliedSpec(softSpec);+ persistEphemeralSelection(EModelEndpoint.openAI, 'gpt-4o');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });++ it('yields to a different spec selected after the soft default was applied', () => {+ persistAppliedSpec(softSpec);+ persistAppliedSpec(otherSpec);++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ last: otherSpec });+ });++ it('yields to a stored agent even when it matches the soft default agent spec', () => {+ const softAgentSpec = createModelSpec('soft-agent-spec', {+ softDefault: true,+ preset: { endpoint: EModelEndpoint.agents, agent_id: 'agent_soft' },+ } as Partial<TModelSpec>);+ localStorage.setItem(`${LocalStorageKeys.AGENT_ID_PREFIX}0`, 'agent_soft');++ const result = getDefaultModelSpec(+ createStartupConfig([softAgentSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });++ it('yields to a stored model selection matching the soft default preset', () => {+ localStorage.setItem(+ LocalStorageKeys.LAST_MODEL,+ JSON.stringify({ [softSpec.preset.endpoint as string]: softSpec.preset.model }),+ );++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });++ it('yields when a different agent is stored than the soft default agent spec', () => {+ const softAgentSpec = createModelSpec('soft-agent-spec', {+ softDefault: true,+ preset: { endpoint: EModelEndpoint.agents, agent_id: 'agent_soft' },+ } as Partial<TModelSpec>);+ localStorage.setItem(`${LocalStorageKeys.AGENT_ID_PREFIX}0`, 'agent_other');++ const result = getDefaultModelSpec(+ createStartupConfig([softAgentSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });+ });++ describe('explicit soft default selection', () => {+ const softSpec = createModelSpec('soft-spec', { softDefault: true });+ const otherSpec = createModelSpec('other-spec');++ it('keeps the soft default selected over older model history (prioritized config)', () => {+ persistEphemeralSelection(EModelEndpoint.openAI, 'gpt-4o');+ persistAppliedSpec(softSpec);++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec]),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });++ it('keeps the soft default selected over older model history (modelSelect config)', () => {+ persistEphemeralSelection(EModelEndpoint.openAI, 'gpt-4o');+ persistAppliedSpec(softSpec);++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });+ });++ describe('no ephemeral endpoint → model options (edge case)', () => {+ const softSpec = createModelSpec('soft-spec', { softDefault: true });+ const otherSpec = createModelSpec('other-spec');++ it('applies the soft default despite a stored agent when modelSelect is disabled', () => {+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { modelSelect: false }),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });++ it('applies the soft default despite a stored agent when addedEndpoints only includes agents', () => {+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], {+ prioritize: false,+ addedEndpoints: [EModelEndpoint.agents],+ }),+ fullEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });++ it('applies the soft default despite a stored agent when agents is the only endpoint', () => {+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ agentsOnlyEndpointsConfig,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });++ it('still defers to the last selected spec', () => {+ persistAppliedSpec(otherSpec);++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ agentsOnlyEndpointsConfig,+ );++ expect(result).toEqual({ last: otherSpec });+ });++ it('keeps the selection gate when addedEndpoints includes ephemeral endpoints', () => {+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], {+ prioritize: false,+ addedEndpoints: [EModelEndpoint.agents, EModelEndpoint.openAI],+ }),+ fullEndpointsConfig,+ );++ expect(result).toBeUndefined();+ });++ it('keeps the selection gate while the endpoints config has not loaded', () => {+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], { prioritize: false }),+ undefined,+ );++ expect(result).toBeUndefined();+ });++ it('detects an agents-only allow-list before the endpoints config loads', () => {+ persistAgentSelection('agent_abc');++ const result = getDefaultModelSpec(+ createStartupConfig([otherSpec, softSpec], {+ prioritize: false,+ addedEndpoints: [EModelEndpoint.agents],+ }),+ undefined,+ );++ expect(result).toEqual({ softDefault: softSpec });+ });+ });});diff --git a/client/src/utils/endpoints.ts b/client/src/utils/endpoints.tsindex 03923c3289..e4cbfc6f46 100644--- a/client/src/utils/endpoints.ts+++ b/client/src/utils/endpoints.ts@@ -203,8 +203,14 @@ export function hasModelSelection(selection?: Partial<StoredModelSelection> | nu);}-function hasStoredModelSelection(): boolean {- if (hasSelectionValue(localStorage.getItem(LocalStorageKeys.LAST_SPEC))) {+/**+ * Whether localStorage holds a model selection the user actually made.+ * Only spec entries naming `softDefaultSpec` are residue of the soft default+ * itself — selections that merely match its preset still count as user choices.+ */+function hasStoredModelSelection(softDefaultSpec?: t.TModelSpec): boolean {+ const lastSpecName = localStorage.getItem(LocalStorageKeys.LAST_SPEC);+ if (hasSelectionValue(lastSpecName) && lastSpecName !== softDefaultSpec?.name) {return true;}@@ -222,10 +228,51 @@ function hasStoredModelSelection(): boolean {const lastConversationSetup = parseStoredModelSelection(localStorage.getItem(LocalStorageKeys.LAST_CONVO_SETUP + '_0'),);+ if (softDefaultSpec && lastConversationSetup?.spec === softDefaultSpec.name) {+ return false;+ }return hasModelSelection(lastConversationSetup);}+/**+ * Whether the selector offers any ephemeral endpoint → model options.+ * False when the endpoints menu is hidden (`modelSelect` disabled) or only+ * agents/assistants picks remain; an empty endpoints config means not loaded.+ */+function hasEphemeralModelOptions({+ endpointsConfig,+ addedEndpoints,+ modelSelect,+}: {+ endpointsConfig?: t.TEndpointsConfig;+ addedEndpoints?: Array<EModelEndpoint | string>;+ modelSelect?: boolean;+}): boolean {+ if (!modelSelect) {+ return false;+ }+ const included = new Set(addedEndpoints ?? []);+ const includesEphemeral =+ included.size === 0 ||+ [...included].some(+ (endpoint) => !isAgentsEndpoint(endpoint) && !isAssistantsEndpoint(endpoint),+ );+ if (!includesEphemeral) {+ return false;+ }+ if (endpointsConfig == null || Object.keys(endpointsConfig).length === 0) {+ return true;+ }+ return Object.entries(endpointsConfig).some(+ ([endpoint, config]) =>+ config != null &&+ !isAgentsEndpoint(endpoint) &&+ !isAssistantsEndpoint(endpoint) &&+ (included.size === 0 || included.has(endpoint)),+ );+}+/** Get the conditional logic for switching conversations */export function getConvoSwitchLogic(params: ConversationInitParams): InitiatedTemplateResult {const { conversation, newEndpoint, endpointsConfig, modularChat = false } = params;@@ -358,10 +405,15 @@ export function applyModelSpecEphemeralAgent({/*** Gets default model spec from config and user preferences.- * Priority: hard admin default → prior user selection → soft first-time default.+ * Priority: hard admin default → prior user selection → soft default.+ * The soft default yields only to selections the user actually made, and acts+ * as the fallback default when no ephemeral endpoint → model options exist.* Legacy first-spec prioritization remains only when no soft default is configured.*/-export function getDefaultModelSpec(startupConfig?: t.TStartupConfig):+export function getDefaultModelSpec(+ startupConfig?: t.TStartupConfig,+ endpointsConfig?: t.TEndpointsConfig,+):| {default?: t.TModelSpec;last?: t.TModelSpec;@@ -369,39 +421,60 @@ export function getDefaultModelSpec(startupConfig?: t.TStartupConfig):}| undefined {const { modelSpecs, interface: interfaceConfig } = startupConfig ?? {};- const { list, prioritize } = modelSpecs ?? {};+ const { list, prioritize, addedEndpoints } = modelSpecs ?? {};if (!list) {return;}const defaultSpec = list?.find((spec) => spec.default);const softDefaultSpec = list?.find((spec) => spec.softDefault);+ const lastConversationSetup = parseStoredModelSelection(+ localStorage.getItem(LocalStorageKeys.LAST_CONVO_SETUP + '_0'),+ );+ const resolveSoftDefault = (): { softDefault: t.TModelSpec } | undefined => {+ if (!softDefaultSpec) {+ return;+ }+ if (lastConversationSetup?.spec === softDefaultSpec.name) {+ return { softDefault: softDefaultSpec };+ }+ const ephemeralOptions = hasEphemeralModelOptions({+ endpointsConfig,+ addedEndpoints,+ modelSelect: interfaceConfig?.modelSelect,+ });+ if (!ephemeralOptions) {+ return { softDefault: softDefaultSpec };+ }+ return hasStoredModelSelection(softDefaultSpec) ? undefined : { softDefault: softDefaultSpec };+ };if (prioritize === true || !interfaceConfig?.modelSelect) {const lastSelectedSpecName = localStorage.getItem(LocalStorageKeys.LAST_SPEC);const lastSelectedSpec = list?.find((spec) => spec.name === lastSelectedSpecName);if (defaultSpec) {return { default: defaultSpec };}+ if (lastSelectedSpec && lastSelectedSpec.name === softDefaultSpec?.name) {+ return resolveSoftDefault();+ }if (lastSelectedSpec) {return { last: lastSelectedSpec };}if (softDefaultSpec) {- return hasStoredModelSelection() ? undefined : { softDefault: softDefaultSpec };+ return resolveSoftDefault();}return { default: list?.[0] };} else if (defaultSpec) {return { default: defaultSpec };}- const lastConversationSetup = parseStoredModelSelection(- localStorage.getItem(LocalStorageKeys.LAST_CONVO_SETUP + '_0'),- );const lastConversationSpecName = lastConversationSetup?.spec;if (!hasSelectionValue(lastConversationSpecName)) {- if (softDefaultSpec && !hasStoredModelSelection()) {- return { softDefault: softDefaultSpec };- }- return;+ return resolveSoftDefault();+ }+ const lastSpec = list?.find((spec) => spec.name === lastConversationSpecName);+ if (lastSpec && lastSpec.name === softDefaultSpec?.name) {+ return resolveSoftDefault();}- return { last: list?.find((spec) => spec.name === lastConversationSpecName) };+ return { last: lastSpec };}export function getModelSpecPreset(modelSpec?: t.TModelSpec) {diff --git a/e2e/config/librechat.e2e.yaml b/e2e/config/librechat.e2e.yamlindex 4ed7224f53..a330ca23d7 100644--- a/e2e/config/librechat.e2e.yaml+++ b/e2e/config/librechat.e2e.yaml@@ -26,9 +26,28 @@ endpoints:titleConvo: falsemodelDisplayLabel: 'Mock Provider B'+ # No model spec mirrors this endpoint's label, so it stays unambiguous in the+ # selector and gives e2e tests a real ephemeral endpoint → model option.+ - name: 'Mock Provider C'+ apiKey: 'e2e-mock-key-c'+ baseURL: 'http://127.0.0.1:8889/v1'+ models:+ default:+ - 'mock-model-c'+ fetch: false+ titleConvo: false+ modelDisplayLabel: 'Mock Provider C'+modelSpecs:prioritize: true- enforce: true+ # Enforcement would reject sends from the non-spec paths addedEndpoints+ # exposes below (buildEndpointOption requires a spec when enforce is true).+ enforce: false+ # Surfaces the endpoints menu (modelSelect defaults on when addedEndpoints is+ # set) limited to entries that don't collide with the spec labels above.+ addedEndpoints:+ - 'Mock Provider C'+ - 'agents'list:- name: 'e2e-mock-provider-a'label: 'Mock Provider A'@@ -58,3 +77,10 @@ modelSpecs:- 'e2e-model-spec-allowed'- 'e2e-model-spec-missing'- 'e2e-model-spec-inaccessible'++ - name: 'e2e-soft-default'+ label: 'E2E Soft Default'+ softDefault: true+ preset:+ endpoint: 'Mock Provider A'+ model: 'mock-model-a'diff --git a/e2e/specs/mock/soft-default.spec.ts b/e2e/specs/mock/soft-default.spec.tsnew file mode 100644index 0000000000..521e8f54fc--- /dev/null+++ b/e2e/specs/mock/soft-default.spec.ts@@ -0,0 +1,106 @@+import { expect, test } from '@playwright/test';+import type { Page } from '@playwright/test';+import { NEW_CHAT_PATH, getAccessToken, requestJson } from './helpers';++/** Label of the `softDefault: true` spec in e2e/config/librechat.e2e.yaml. */+const SOFT_DEFAULT_LABEL = 'E2E Soft Default';++/** Ephemeral endpoint from e2e/config/librechat.e2e.yaml with no mirroring spec. */+const EPHEMERAL_ENDPOINT = { label: 'Mock Provider C', model: 'mock-model-c' };++const uniqueName = (prefix: string) => `${prefix} ${Date.now()}-${Math.floor(Math.random() * 1e4)}`;++const modelTrigger = (page: Page) => page.getByRole('button', { name: 'Select a model' }).first();++/** Reset selection state so the test starts as a fresh instance (auth stays in cookies). */+async function startFresh(page: Page) {+ await page.goto(NEW_CHAT_PATH, { timeout: 10000 });+ await page.evaluate(() => localStorage.clear());+ await page.goto(NEW_CHAT_PATH, { timeout: 10000 });+}++type AgentResponse = {+ id: string;+ name?: string | null;+};++async function createAgent(page: Page, name: string): Promise<AgentResponse> {+ const token = await getAccessToken(page);+ return requestJson<AgentResponse>(page, {+ path: '/api/agents',+ token,+ method: 'POST',+ body: {+ name,+ provider: 'Mock Provider A',+ model: 'mock-model-a',+ model_parameters: {},+ },+ });+}++async function selectAgent(page: Page, agentName: string) {+ await modelTrigger(page).click();+ await page.getByRole('option', { name: 'My Agents' }).click();+ await page.getByRole('option', { name: agentName }).click();+ await expect(modelTrigger(page)).toContainText(agentName);+}++async function selectEphemeralModel(page: Page) {+ await modelTrigger(page).click();+ await page.getByRole('option', { name: EPHEMERAL_ENDPOINT.label }).click();+ await page.getByRole('option', { name: EPHEMERAL_ENDPOINT.model, exact: true }).click();+ await expect(modelTrigger(page)).toContainText(EPHEMERAL_ENDPOINT.model);+}++test.describe('soft default model spec', () => {+ test('applies the soft default on a fresh instance and stays applied across reloads', async ({+ page,+ }) => {+ await startFresh(page);++ await expect(modelTrigger(page)).toContainText(SOFT_DEFAULT_LABEL, { timeout: 15000 });++ // Its own auto-application must not convert it into a sticky "last" selection+ // that would behave differently on the next load.+ await page.reload({ timeout: 10000 });+ await expect(modelTrigger(page)).toContainText(SOFT_DEFAULT_LABEL, { timeout: 15000 });+ });++ test('a previously selected agent outranks the soft default', async ({ page }) => {+ test.setTimeout(120000);+ await startFresh(page);+ await expect(modelTrigger(page)).toContainText(SOFT_DEFAULT_LABEL, { timeout: 15000 });++ const agentName = uniqueName('E2E Soft Agent');+ await createAgent(page, agentName);+ await page.goto(NEW_CHAT_PATH, { timeout: 10000 });++ await selectAgent(page, agentName);++ await page.reload({ timeout: 10000 });+ await expect(modelTrigger(page)).toContainText(agentName, { timeout: 15000 });++ await page.getByTestId('new-chat-button').click();+ await expect(page).toHaveURL(/\/c\/new/, { timeout: 15000 });+ await expect(modelTrigger(page)).toContainText(agentName, { timeout: 15000 });+ });++ test('a previous ephemeral endpoint and model selection outranks the soft default', async ({+ page,+ }) => {+ test.setTimeout(120000);+ await startFresh(page);+ await expect(modelTrigger(page)).toContainText(SOFT_DEFAULT_LABEL, { timeout: 15000 });++ await selectEphemeralModel(page);++ await page.reload({ timeout: 10000 });+ await expect(modelTrigger(page)).toContainText(EPHEMERAL_ENDPOINT.model, { timeout: 15000 });+ await expect(modelTrigger(page)).not.toContainText(SOFT_DEFAULT_LABEL);++ await page.getByTestId('new-chat-button').click();+ await expect(page).toHaveURL(/\/c\/new/, { timeout: 15000 });+ await expect(modelTrigger(page)).toContainText(EPHEMERAL_ENDPOINT.model, { timeout: 15000 });+ });+});