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: Render Google Settings From the Shared Schema and Bound Them Per Model (#14989)
Marco Beretta227a99ede850
diff --git a/client/src/components/Endpoints/Settings/Google.tsx b/client/src/components/Endpoints/Settings/Google.tsxindex d01ba06598..cc6b7ddb70 100644--- a/client/src/components/Endpoints/Settings/Google.tsx+++ b/client/src/components/Endpoints/Settings/Google.tsx@@ -1,314 +1,127 @@-import TextareaAutosize from 'react-textarea-autosize';-import { EModelEndpoint, endpointSettings } from 'librechat-data-provider';+import { useEffect, useMemo, useRef } from 'react';import {- Input,- Label,- Slider,- HoverCard,- InputNumber,- SelectDropDown,- HoverCardTrigger,-} from '@librechat/client';-import type { TModelSelectProps, OnInputNumberChange } from '~/common';-import { cn, defaultTextProps, optionText, removeFocusOutlines, removeFocusRings } from '~/utils';-import OptionHoverAlt from '~/components/SidePanel/Parameters/OptionHover';-import { useLocalize, useDebouncedInput } from '~/hooks';-import OptionHover from './OptionHover';-import { ESide } from '~/common';+ getEndpointField,+ getSettingsKeys,+ presetSettings,+ applyModelAwareDefaults,+ clampSettingRange,+} from 'librechat-data-provider';+import type { SettingsConfiguration, SettingDefinition } from 'librechat-data-provider';+import type { TModelSelectProps } from '~/common';+import { componentMapping } from '~/components/SidePanel/Parameters/components';+import { useGetEndpointsQuery } from '~/data-provider';-export default function Settings({ conversation, setOption, models, readonly }: TModelSelectProps) {- const localize = useLocalize();- const google = endpointSettings[EModelEndpoint.google];- const {- model,- modelLabel,- promptPrefix,- temperature,- topP,- topK,- maxContextTokens,- maxOutputTokens,- } = conversation ?? {};+export default function GoogleSettings({+ conversation,+ setOption,+ models,+ readonly,+}: TModelSelectProps) {+ const { data: endpointsConfig } = useGetEndpointsQuery();- const [setMaxContextTokens, maxContextTokensValue] = useDebouncedInput<number | null | undefined>(- {- setOption,- optionKey: 'maxContextTokens',- initialValue: maxContextTokens,- },- );+ const parameters = useMemo(() => {+ /** A preset for a Google-compatible endpoint need not carry `endpointType`,+ * so the configured type is resolved the same way EndpointSettings resolves+ * it to pick this component. Falling back to the endpoint's custom name+ * would miss `presetSettings` entirely and blank the panel. */+ const endpointType =+ getEndpointField(endpointsConfig, conversation?.endpoint, 'type') ??+ conversation?.endpointType;+ const model = conversation?.model ?? '';+ const [combinedKey, endpointKey] = getSettingsKeys(+ endpointType ?? conversation?.endpoint ?? '',+ model,+ );+ const columns = presetSettings[combinedKey] ?? presetSettings[endpointKey];+ if (!columns) {+ return undefined;+ }++ /** Google's max output token ceiling moved with Gemini 2.5/3, so the raw+ * definition's default is stale for current models. */+ const withModelDefaults = (settings: SettingsConfiguration) =>+ applyModelAwareDefaults(settings, endpointKey, model);++ const col1 = withModelDefaults(columns.col1);+ const col2 = withModelDefaults(columns.col2);- if (!conversation) {+ return { col1, col2 };+ }, [conversation?.endpoint, conversation?.endpointType, conversation?.model, endpointsConfig]);++ /** Only the rendered definition follows the model; the value already stored+ * in the preset does not. Switching a 2.5 Pro preset to Flash would leave a+ * 32,768 thinking budget in place, past the new ceiling, and Save would+ * persist it without the untouched field ever being focused. */+ const appliedModelRef = useRef<string | undefined>(conversation?.model ?? undefined);+ const model = conversation?.model ?? undefined;+ useEffect(() => {+ if (appliedModelRef.current === model) {+ return;+ }+ appliedModelRef.current = model;+ if (!parameters || !setOption) {+ return;+ }+ for (const setting of [...parameters.col1, ...parameters.col2]) {+ if (setting == null || setting.type !== 'number' || setting.range == null) {+ continue;+ }+ /** Same marker the field-level clamp uses: a model that does not narrow+ * this parameter leaves the shared fallback range in place. */+ if (setting.range.modelSpecific !== true) {+ continue;+ }+ const stored = conversation?.[setting.key];+ if (typeof stored !== 'number') {+ continue;+ }+ const clamped = clampSettingRange(stored, setting.range);+ if (clamped !== stored) {+ setOption(setting.key)(clamped);+ }+ }+ }, [model, parameters, conversation, setOption]);++ if (!parameters) {return null;}- const setModel = setOption('model');- const setModelLabel = setOption('modelLabel');- const setPromptPrefix = setOption('promptPrefix');- const setTemperature = setOption('temperature');- const setTopP = setOption('topP');- const setTopK = setOption('topK');- const setMaxOutputTokens = setOption('maxOutputTokens');- const maxOutputTokensDefault = google.maxOutputTokens.reset(model ?? '');+ const renderComponent = (setting: SettingDefinition | undefined) => {+ if (!setting) {+ return null;+ }+ const Component = componentMapping[setting.component];+ if (!Component) {+ return null;+ }+ const { key, default: defaultValue, ...rest } = setting;++ const props = {+ key,+ settingKey: key,+ defaultValue,+ ...rest,+ readonly,+ setOption,+ conversation,+ };++ if (key === 'model') {+ return <Component {...props} options={models} />;+ }++ return <Component {...props} />;+ };return (- <div className="grid grid-cols-5 gap-6">- <div className="col-span-5 flex flex-col items-center justify-start gap-6 sm:col-span-3">- <div className="grid w-full items-center gap-2">- <SelectDropDown- title={localize('com_ui_model')}- value={model ?? ''}- setValue={setModel}- availableValues={models}- disabled={readonly}- className={cn(defaultTextProps, 'flex w-full resize-none', removeFocusRings)}- containerClassName="flex w-full resize-none"- />+ <div className="h-auto max-w-full overflow-x-hidden p-3">+ <div className="grid grid-cols-1 gap-6 md:grid-cols-5">+ <div className="flex flex-col gap-6 md:col-span-3">+ {parameters.col1.map(renderComponent)}</div>- <div className="grid w-full items-center gap-2">- <Label htmlFor="modelLabel" className="text-left text-sm font-medium">- {localize('com_endpoint_custom_name')}{' '}- <small className="opacity-40">({localize('com_endpoint_default_blank')})</small>- </Label>- <Input- id="modelLabel"- disabled={readonly}- value={modelLabel || ''}- onChange={(e) => setModelLabel(e.target.value ?? null)}- placeholder={localize('com_endpoint_google_custom_name_placeholder')}- className={cn(- defaultTextProps,- 'flex h-10 max-h-10 w-full resize-none px-3 py-2',- removeFocusOutlines,- )}- />+ <div className="flex flex-col gap-6 md:col-span-2">+ {parameters.col2.map(renderComponent)}</div>- <div className="grid w-full items-center gap-2">- <Label htmlFor="promptPrefix" className="text-left text-sm font-medium">- {localize('com_endpoint_prompt_prefix')}{' '}- <small className="opacity-40">({localize('com_endpoint_default_blank')})</small>- </Label>- <TextareaAutosize- id="promptPrefix"- disabled={readonly}- value={promptPrefix || ''}- onChange={(e) => setPromptPrefix(e.target.value ?? null)}- placeholder={localize('com_endpoint_prompt_prefix_placeholder')}- className={cn(- defaultTextProps,- 'flex max-h-[138px] min-h-[100px] w-full resize-none px-3 py-2',- )}- />- </div>- </div>- <div className="col-span-5 flex flex-col items-center justify-start gap-6 px-3 sm:col-span-2">- <HoverCard openDelay={300}>- <HoverCardTrigger className="grid w-full items-center gap-2">- <div className="mt-1 flex w-full justify-between">- <Label htmlFor="max-context-tokens" className="text-left text-sm font-medium">- {localize('com_endpoint_context_tokens')}{' '}- </Label>- <InputNumber- id="max-context-tokens"- stringMode={false}- disabled={readonly}- value={maxContextTokensValue as number}- onChange={setMaxContextTokens as OnInputNumberChange}- placeholder={localize('com_nav_theme_system')}- min={10}- max={2000000}- step={1000}- controls={false}- className={cn(- defaultTextProps,- cn(- optionText,- 'reset-rc-number-input reset-rc-number-input-text-right h-auto w-12 border-0 group-hover/temp:border-border-light',- 'w-1/3',- ),- )}- />- </div>- </HoverCardTrigger>- <OptionHoverAlt- description="com_endpoint_context_info"- langCode={true}- side={ESide.Left}- />- </HoverCard>- <HoverCard openDelay={300}>- <HoverCardTrigger className="grid w-full items-center gap-2">- <div className="flex justify-between">- <Label htmlFor="temp-int" className="text-left text-sm font-medium">- {localize('com_endpoint_temperature')}{' '}- <small className="opacity-40">- ({localize('com_endpoint_default')}: {google.temperature.default})- </small>- </Label>- <InputNumber- id="temp-int"- disabled={readonly}- value={temperature}- onChange={(value) => setTemperature(value ?? google.temperature.default)}- max={google.temperature.max}- min={google.temperature.min}- step={google.temperature.step}- controls={false}- className={cn(- defaultTextProps,- cn(- optionText,- 'reset-rc-number-input reset-rc-number-input-text-right h-auto w-12 border-0 group-hover/temp:border-border-light',- ),- )}- />- </div>- <Slider- disabled={readonly}- value={[temperature ?? google.temperature.default]}- onValueChange={(value) => setTemperature(value[0])}- onDoubleClick={() => setTemperature(google.temperature.default)}- max={google.temperature.max}- min={google.temperature.min}- step={google.temperature.step}- className="flex h-4 w-full"- aria-labelledby="temp-int"- />- </HoverCardTrigger>- <OptionHover endpoint={conversation.endpoint ?? ''} type="temp" side={ESide.Left} />- </HoverCard>- <HoverCard openDelay={300}>- <HoverCardTrigger className="grid w-full items-center gap-2">- <div className="flex justify-between">- <Label htmlFor="top-p-int" className="text-left text-sm font-medium">- {localize('com_endpoint_top_p')}{' '}- <small className="opacity-40">- ({localize('com_endpoint_default_with_num', { 0: google.topP.default + '' })})- </small>- </Label>- <InputNumber- id="top-p-int"- disabled={readonly}- value={topP}- onChange={(value) => setTopP(value ?? google.topP.default)}- max={google.topP.max}- min={google.topP.min}- step={google.topP.step}- controls={false}- className={cn(- defaultTextProps,- cn(- optionText,- 'reset-rc-number-input reset-rc-number-input-text-right h-auto w-12 border-0 group-hover/temp:border-border-light',- ),- )}- />- </div>- <Slider- disabled={readonly}- value={[topP ?? google.topP.default]}- onValueChange={(value) => setTopP(value[0])}- onDoubleClick={() => setTopP(google.topP.default)}- max={google.topP.max}- min={google.topP.min}- step={google.topP.step}- className="flex h-4 w-full"- aria-labelledby="top-p-int"- />- </HoverCardTrigger>- <OptionHover endpoint={conversation.endpoint ?? ''} type="topp" side={ESide.Left} />- </HoverCard>-- <HoverCard openDelay={300}>- <HoverCardTrigger className="grid w-full items-center gap-2">- <div className="flex justify-between">- <Label htmlFor="top-k-int" className="text-left text-sm font-medium">- {localize('com_endpoint_top_k')}{' '}- <small className="opacity-40">- ({localize('com_endpoint_default_with_num', { 0: google.topK.default + '' })})- </small>- </Label>- <InputNumber- id="top-k-int"- disabled={readonly}- value={topK}- onChange={(value) => setTopK(value ?? google.topK.default)}- max={google.topK.max}- min={google.topK.min}- step={google.topK.step}- controls={false}- className={cn(- defaultTextProps,- cn(- optionText,- 'reset-rc-number-input reset-rc-number-input-text-right h-auto w-12 border-0 group-hover/temp:border-border-light',- ),- )}- />- </div>- <Slider- disabled={readonly}- value={[topK ?? google.topK.default]}- onValueChange={(value) => setTopK(value[0])}- onDoubleClick={() => setTopK(google.topK.default)}- max={google.topK.max}- min={google.topK.min}- step={google.topK.step}- className="flex h-4 w-full"- aria-labelledby="top-k-int"- />- </HoverCardTrigger>- <OptionHover endpoint={conversation.endpoint ?? ''} type="topk" side={ESide.Left} />- </HoverCard>- <HoverCard openDelay={300}>- <HoverCardTrigger className="grid w-full items-center gap-2">- <div className="flex justify-between">- <Label htmlFor="max-tokens-int" className="text-left text-sm font-medium">- {localize('com_endpoint_max_output_tokens')}{' '}- <small className="opacity-40">- (- {localize('com_endpoint_default_with_num', {- 0: maxOutputTokensDefault + '',- })}- )- </small>- </Label>- <InputNumber- id="max-tokens-int"- disabled={readonly}- value={maxOutputTokens}- onChange={(value) => setMaxOutputTokens(Number(value))}- max={google.maxOutputTokens.max}- min={google.maxOutputTokens.min}- step={google.maxOutputTokens.step}- controls={false}- className={cn(- defaultTextProps,- cn(- optionText,- 'reset-rc-number-input reset-rc-number-input-text-right h-auto w-12 border-0 group-hover/temp:border-border-light',- ),- )}- />- </div>- <Slider- disabled={readonly}- value={[maxOutputTokens ?? maxOutputTokensDefault]}- onValueChange={(value) => setMaxOutputTokens(value[0])}- onDoubleClick={() => setMaxOutputTokens(maxOutputTokensDefault)}- max={google.maxOutputTokens.max}- min={google.maxOutputTokens.min}- step={google.maxOutputTokens.step}- className="flex h-4 w-full"- aria-labelledby="max-tokens-int"- />- </HoverCardTrigger>- <OptionHover- endpoint={conversation.endpoint ?? ''}- type="maxoutputtokens"- side={ESide.Left}- />- </HoverCard></div></div>);diff --git a/client/src/components/SidePanel/Parameters/DynamicInput.tsx b/client/src/components/SidePanel/Parameters/DynamicInput.tsxindex 19d43cfaf3..4bdf7c29b4 100644--- a/client/src/components/SidePanel/Parameters/DynamicInput.tsx+++ b/client/src/components/SidePanel/Parameters/DynamicInput.tsx@@ -1,5 +1,6 @@-import { OptionTypes, SettingTypes } from 'librechat-data-provider';+import { useEffect, useRef } from 'react';import { Label, Input, HoverCard, HoverCardTrigger } from '@librechat/client';+import { OptionTypes, SettingTypes, clampSettingRange } from 'librechat-data-provider';import type { DynamicSettingProps } from 'librechat-data-provider';import { useLocalize, useDebouncedInput, useParameterEffects, TranslationKeys } from '~/hooks';import { cn, sanitizeIntegerInput } from '~/utils';@@ -28,7 +29,9 @@ function DynamicInput({const localize = useLocalize();const { preset } = useChatContext();- const [setInputValue, inputValue, setLocalValue] = useDebouncedInput<string | number>({+ const [setInputValue, inputValue, setLocalValue, flushInputValue] = useDebouncedInput<+ string | number+ >({optionKey: settingKey,initialValue: optionType !== OptionTypes.Custom ? conversation?.[settingKey] : defaultValue,setter: () => ({}),@@ -61,6 +64,101 @@ function DynamicInput({setInputValue(e, type === SettingTypes.String ? false : !isNaN(Number(e.target.value)));};+ /** The schema declares a range for number fields, but nothing enforced it, so+ * a value past the endpoint's ceiling (a Google output limit above 65535,+ * say) was persisted and only rejected later by the provider. Clamping on+ * blur rather than on change leaves partially typed numbers alone. */+ const handleInputBlur = () => {+ /** Clicking Save blurs the field first, so committing the pending edit here+ * is what stops submitPreset reading the value from before it. */+ flushInputValue();+ if (type !== SettingTypes.Number || range == null) {+ return;+ }+ if (inputValue === '' || inputValue == null || inputValue === '-') {+ return;+ }+ const numeric = Number(inputValue);+ if (Number.isNaN(numeric)) {+ return;+ }+ const clamped = clampSettingRange(numeric, range);+ if (clamped === numeric) {+ return;+ }+ /** Two writes, because one alone is not enough. Going through the debounced+ * setter supersedes the out-of-range value typing already queued (lodash+ * debounce keeps only the latest args) but would not land for another+ * delay, so a Save clicked inside that window would still read the bad+ * value. Calling setOption directly closes that window; the later trailing+ * invocation then rewrites the same clamped value. */+ setInputValue(clamped, true);+ setOption?.(settingKey)(clamped);+ };++ /** A model switch can change this field's bounds while a write typed just+ * before it is still queued. Clamping only what is already committed would+ * let that queued value land afterwards, past the new ceiling. Re-clamping+ * through the same debouncer replaces its arguments, so the queued write+ * becomes the corrected one. */+ const rangeKey = range != null ? `${range.min}:${range.max}:${range.positiveMin ?? ''}` : '';+ /** The panel stays mounted while navigating, so the stored value can be+ * replaced under an unchanged range. */+ const identityKey = preset?.presetId ?? conversation?.conversationId ?? '';+ /** Null rather than the first pair, so a stored value that the shared range+ * allowed but the selected model does not is normalized on mount too, not+ * only once the user switches models or blurs the field. */+ const normalizedRef = useRef<{+ identity: string;+ range: string;+ stored: unknown;+ } | null>(null);+ const storedValue = conversation?.[settingKey];+ useEffect(() => {+ const normalized = normalizedRef.current;+ const identityChanged = normalized == null || normalized.identity !== identityKey;+ const rangeChanged = normalized == null || normalized.range !== rangeKey;+ /** Applying a preset over the open conversation replaces the stored value+ * without touching either key, and useParameterEffects then pushes it into+ * this field. The user's own edits reach the conversation through this+ * same field, so by the time they land the two agree and the value stays+ * on the blur-clamped path rather than being corrected mid-edit. */+ const replacedExternally =+ normalized != null && normalized.stored !== storedValue && storedValue !== inputValue;+ normalizedRef.current = { identity: identityKey, range: rangeKey, stored: storedValue };+ if (!identityChanged && !rangeChanged && !replacedExternally) {+ return;+ }+ if (type !== SettingTypes.Number || range == null) {+ return;+ }+ /** Only a range the model actually narrowed should rewrite a stored value.+ * A model that ignores this parameter leaves the shared fallback in place,+ * and clamping to that would discard a value set for another model. */+ if (range.modelSpecific !== true) {+ return;+ }+ /** A range change is the one trigger where the local value is what matters:+ * a write typed just before the model switch is still queued in it. The+ * others are a value arriving from outside this field, which the local one+ * has not caught up to yet. */+ const candidate = identityChanged || replacedExternally ? storedValue : inputValue;+ if (candidate === '' || candidate == null || candidate === '-') {+ return;+ }+ const numeric = Number(candidate);+ if (Number.isNaN(numeric)) {+ return;+ }+ const clamped = clampSettingRange(numeric, range);+ if (clamped === numeric) {+ return;+ }+ setInputValue(clamped, true);+ setOption?.(settingKey)(clamped);+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, [identityKey, rangeKey, storedValue]);+const placeholderText = placeholderCode? localize(placeholder as TranslationKeys) || placeholder: placeholder;@@ -96,6 +194,7 @@ function DynamicInput({inputMode={type === 'number' ? 'numeric' : undefined}value={inputValue ?? defaultValue ?? ''}onChange={handleInputChange}+ onBlur={handleInputBlur}placeholder={placeholderText}className={cn('flex h-9 max-h-9 w-full resize-none rounded-lg border border-border-light bg-surface-secondary px-3 py-2',diff --git a/client/src/components/SidePanel/Parameters/DynamicSlider.tsx b/client/src/components/SidePanel/Parameters/DynamicSlider.tsxindex 91841c3c22..76adba8c3f 100644--- a/client/src/components/SidePanel/Parameters/DynamicSlider.tsx+++ b/client/src/components/SidePanel/Parameters/DynamicSlider.tsx@@ -1,5 +1,5 @@import { useMemo, useCallback } from 'react';-import { OptionTypes } from 'librechat-data-provider';+import { OptionTypes, clampSettingRange } from 'librechat-data-provider';import { Label, Slider, HoverCard, Input, InputNumber, HoverCardTrigger } from '@librechat/client';import type { DynamicSettingProps } from 'librechat-data-provider';import { useLocalize, useDebouncedInput, useParameterEffects, TranslationKeys } from '~/hooks';@@ -33,7 +33,9 @@ function DynamicSlider({[options, range],);- const [setInputValue, inputValue, setLocalValue] = useDebouncedInput<string | number>({+ const [setInputValue, inputValue, setLocalValue, flushInputValue] = useDebouncedInput<+ string | number+ >({optionKey: settingKey,initialValue: optionType !== OptionTypes.Custom ? conversation?.[settingKey] : defaultValue,setter: () => ({}),@@ -123,6 +125,19 @@ function DynamicSlider({return String(defaultValue ?? '');}, [defaultValue, enumMappings, localize]);+ /** A typed value can land in the gap between a sentinel minimum and its+ * positive floor, which the generated schema rejects. Corrected on blur+ * rather than while the number is still being typed. */+ const handleNumberBlur = useCallback(() => {+ if (range != null && inputValue != null && inputValue !== '') {+ const numeric = Number(inputValue);+ if (Number.isFinite(numeric)) {+ setInputValue(clampSettingRange(numeric, range));+ }+ }+ flushInputValue();+ }, [range, inputValue, setInputValue, flushInputValue]);+const handleValueChange = useCallback((value: number) => {if (isEnum) {@@ -175,6 +190,9 @@ function DynamicSlider({disabled={readonly}value={inputValue ?? defaultValue}onChange={(value) => setInputValue(Number(value))}+ /** Clicking Save blurs this first, so the pending edit is+ * committed before submitPreset reads the preset. */+ onBlur={handleNumberBlur}max={range ? range.max : (options?.length ?? 0) - 1}min={range ? range.min : 0}step={range ? (range.step ?? 1) : 1}@@ -214,7 +232,28 @@ function DynamicSlider({: ((inputValue as number) ?? (defaultValue as number)),]}onValueChange={(value) => handleValueChange(value[0])}- onDoubleClick={() => setInputValue(defaultValue as string | number)}+ /** Fires once the drag or keypress settles, which is the point the+ * chosen value should be in the preset rather than pending. It is+ * set again here before flushing because the keyboard path commits+ * before it reports the change, leaving the debouncer empty for a+ * flush that only follows the drag path. The track also steps+ * straight through the gap between a sentinel minimum and its+ * positive floor, which the generated schema rejects, so the+ * released value has to land outside it. */+ onValueCommit={(value) => {+ if (!isEnum && range != null) {+ setInputValue(clampSettingRange(value[0], range));+ }+ flushInputValue();+ }}+ /** The browser dispatches this after the second release, so the+ * commit above has already fired and the reset would otherwise sit+ * in the debouncer while an action clicked next reads the old+ * value. */+ onDoubleClick={() => {+ setInputValue(defaultValue as string | number);+ flushInputValue();+ }}max={max}aria-label={localize(label as TranslationKeys)}min={range ? range.min : 0}diff --git a/client/src/components/SidePanel/Parameters/DynamicTextarea.tsx b/client/src/components/SidePanel/Parameters/DynamicTextarea.tsxindex df4b342ae0..a6092555e8 100644--- a/client/src/components/SidePanel/Parameters/DynamicTextarea.tsx+++ b/client/src/components/SidePanel/Parameters/DynamicTextarea.tsx@@ -26,7 +26,9 @@ function DynamicTextarea({const localize = useLocalize();const { preset } = useChatContext();- const [setInputValue, inputValue, setLocalValue] = useDebouncedInput<string | null>({+ const [setInputValue, inputValue, setLocalValue, flushInputValue] = useDebouncedInput<+ string | null+ >({optionKey: settingKey,initialValue:optionType !== OptionTypes.Custom@@ -75,6 +77,9 @@ function DynamicTextarea({disabled={readonly}value={inputValue ?? ''}onChange={setInputValue}+ /** Clicking Save blurs this first, so the pending edit is committed+ * before submitPreset reads the preset. */+ onBlur={flushInputValue}aria-label={localize(label as TranslationKeys)}placeholder={placeholderCodediff --git a/client/src/components/SidePanel/Parameters/__tests__/DynamicInput.spec.tsx b/client/src/components/SidePanel/Parameters/__tests__/DynamicInput.spec.tsxindex 5cd348ab90..f898689b09 100644--- a/client/src/components/SidePanel/Parameters/__tests__/DynamicInput.spec.tsx+++ b/client/src/components/SidePanel/Parameters/__tests__/DynamicInput.spec.tsx@@ -13,10 +13,12 @@ function setup({type,range,settingKey,+ conversation = {},}: {type: 'number' | 'string';range?: SettingRange;settingKey: string;+ conversation?: Record<string, unknown>;}) {const commit = jest.fn();const setOption = jest.fn(() => commit) as unknown as TSetOption;@@ -27,13 +29,35 @@ function setup({type={type}range={range}setOption={setOption}- conversation={{}}+ conversation={conversation}/></ChatContext.Provider>,);return { input: screen.getByRole('textbox'), commit };}+function setupNavigable(range: SettingRange, conversation: Record<string, unknown>) {+ const commit = jest.fn();+ const setOption = jest.fn(() => commit) as unknown as TSetOption;+ const tree = (next: Record<string, unknown>) => (+ <ChatContext.Provider value={chatContextValue}>+ <DynamicInput+ settingKey="thinkingBudget"+ type="number"+ range={range}+ setOption={setOption}+ conversation={next}+ />+ </ChatContext.Provider>+ );+ const { rerender } = render(tree(conversation));+ return {+ commit,+ input: () => screen.getByRole('textbox'),+ navigate: (next: Record<string, unknown>) => rerender(tree(next)),+ };+}+describe('DynamicInput', () => {beforeEach(() => {jest.useFakeTimers();@@ -110,6 +134,173 @@ describe('DynamicInput', () => {expect(commit).toHaveBeenLastCalledWith(-1);});+ it('keeps thinkingBudget -1 on blur when a model-specific positive floor is set', () => {+ const { input, commit } = setup({+ type: 'number',+ range: { min: -1, max: 32768, step: 1, positiveMin: 128 },+ settingKey: 'thinkingBudget',+ });++ fireEvent.change(input, { target: { value: '-1' } });+ fireEvent.blur(input);++ expect(input).toHaveValue('-1');+ act(() => {+ jest.advanceTimersByTime(500);+ });+ expect(commit).toHaveBeenLastCalledWith(-1);+ });++ /**+ * A preset saved while the shared range was in force can hold a budget the+ * selected model rejects. Waiting for a model switch or a blur would leave it+ * displayed, savable and sendable.+ */+ it('normalizes a stored value the selected model no longer allows on mount', () => {+ const { input, commit } = setup({+ type: 'number',+ range: { min: -1, max: 24576, step: 1, positiveMin: 0, modelSpecific: true },+ settingKey: 'thinkingBudget',+ conversation: { thinkingBudget: 32000 },+ });++ expect(input).toHaveValue('24576');+ expect(commit).toHaveBeenLastCalledWith(24576);+ });++ it('leaves a stored value inside the model range untouched on mount', () => {+ const { input, commit } = setup({+ type: 'number',+ range: { min: -1, max: 24576, step: 1, positiveMin: 0, modelSpecific: true },+ settingKey: 'thinkingBudget',+ conversation: { thinkingBudget: 2048 },+ });++ expect(input).toHaveValue('2048');+ expect(commit).not.toHaveBeenCalled();+ });++ /** The shared fallback stays in place for models that ignore the parameter,+ * so clamping to it would discard a value set for another model. */+ it('does not normalize on mount against a range the model did not narrow', () => {+ const { input, commit } = setup({+ type: 'number',+ range: { min: -1, max: 24576, step: 1 },+ settingKey: 'thinkingBudget',+ conversation: { thinkingBudget: 32000 },+ });++ expect(input).toHaveValue('32000');+ expect(commit).not.toHaveBeenCalled();+ });++ /**+ * The panel stays mounted across conversations, so a legacy value can arrive+ * under a range that never changed. Keying only on the range left it above+ * the model ceiling, savable and sendable.+ */+ it('normalizes when a navigation brings in a value the same range rejects', () => {+ const range: SettingRange = {+ min: -1,+ max: 24576,+ step: 1,+ positiveMin: 0,+ modelSpecific: true,+ };+ const { navigate, input, commit } = setupNavigable(range, {+ conversationId: 'convo-a',+ thinkingBudget: 2048,+ });+ expect(commit).not.toHaveBeenCalled();++ navigate({ conversationId: 'convo-b', thinkingBudget: 32000 });++ expect(input()).toHaveValue('24576');+ expect(commit).toHaveBeenLastCalledWith(24576);+ });++ it('leaves a navigation alone when the incoming value fits the range', () => {+ const range: SettingRange = {+ min: -1,+ max: 24576,+ step: 1,+ positiveMin: 0,+ modelSpecific: true,+ };+ const { navigate, commit } = setupNavigable(range, {+ conversationId: 'convo-a',+ thinkingBudget: 2048,+ });++ navigate({ conversationId: 'convo-b', thinkingBudget: 4096 });++ expect(commit).not.toHaveBeenCalled();+ });++ /**+ * Applying a preset over the open conversation keeps the conversation id and+ * the model, so neither key moves; the value simply arrives.+ */+ it('normalizes a stored value replaced under an unchanged conversation', () => {+ const range: SettingRange = {+ min: -1,+ max: 24576,+ step: 1,+ positiveMin: 0,+ modelSpecific: true,+ };+ const { navigate, input, commit } = setupNavigable(range, {+ conversationId: 'convo-a',+ thinkingBudget: 2048,+ });++ navigate({ conversationId: 'convo-a', thinkingBudget: 32000 });++ expect(input()).toHaveValue('24576');+ expect(commit).toHaveBeenLastCalledWith(24576);+ });++ /**+ * A typed value reaches the conversation through this same field, so the two+ * agree by the time it lands. Correcting it there would fight the user+ * mid-edit, which is why clamping belongs on blur.+ */+ it('leaves the value the user typed to the blur clamp when it lands', () => {+ const range: SettingRange = {+ min: -1,+ max: 32768,+ step: 1,+ positiveMin: 128,+ modelSpecific: true,+ };+ const { navigate, input, commit } = setupNavigable(range, {+ conversationId: 'convo-a',+ thinkingBudget: 2048,+ });++ fireEvent.change(input(), { target: { value: '50' } });+ /** The debounced write reaching the conversation, which is what the+ * normalization would otherwise read as an external replacement. */+ navigate({ conversationId: 'convo-a', thinkingBudget: 50 });++ expect(input()).toHaveValue('50');+ expect(commit).not.toHaveBeenCalledWith(128);+ });++ it('clamps a positive thinkingBudget below the model floor on blur', () => {+ const { input, commit } = setup({+ type: 'number',+ range: { min: -1, max: 32768, step: 1, positiveMin: 128 },+ settingKey: 'thinkingBudget',+ });++ fireEvent.change(input, { target: { value: '50' } });+ fireEvent.blur(input);++ expect(input).toHaveValue('128');+ expect(commit).toHaveBeenLastCalledWith(128);+ });+it('drops the minus sign when the range does not permit negatives', async () => {const user = userEvent.setup({ advanceTimers: jest.advanceTimersByTime });const { input, commit } = setup({ type: 'number', settingKey: 'max_tokens' });diff --git a/client/src/components/SidePanel/Parameters/__tests__/DynamicSlider.spec.tsx b/client/src/components/SidePanel/Parameters/__tests__/DynamicSlider.spec.tsxnew file mode 100644index 0000000000..936e3e4e92--- /dev/null+++ b/client/src/components/SidePanel/Parameters/__tests__/DynamicSlider.spec.tsx@@ -0,0 +1,128 @@+import React from 'react';+import { render, screen, act, fireEvent } from '@testing-library/react';+import type { TSetOption, SettingRange } from 'librechat-data-provider';+import DynamicSlider from '../DynamicSlider';+import { ChatContext } from '~/Providers';++type ChatContextValue = React.ContextType<typeof ChatContext>;++const chatContextValue = { preset: null } as unknown as ChatContextValue;++const range: SettingRange = { min: 0, max: 2, step: 0.01 };++function setup(conversationValue: number) {+ const commit = jest.fn();+ const setOption = jest.fn(() => commit) as unknown as TSetOption;+ render(+ <ChatContext.Provider value={chatContextValue}>+ <DynamicSlider+ settingKey="temperature"+ label="Temperature"+ type="number"+ range={range}+ defaultValue={1}+ setOption={setOption}+ conversation={{ temperature: conversationValue }}+ />+ </ChatContext.Provider>,+ );+ return { slider: screen.getByRole('slider'), commit };+}++const sentinelRange: SettingRange = { min: -1, max: 32768, step: 1, positiveMin: 128 };++function setupSentinel(conversationValue: number) {+ const commit = jest.fn();+ const setOption = jest.fn(() => commit) as unknown as TSetOption;+ render(+ <ChatContext.Provider value={chatContextValue}>+ <DynamicSlider+ settingKey="thinkingBudget"+ label="Thinking budget"+ type="number"+ range={sentinelRange}+ defaultValue={-1}+ setOption={setOption}+ conversation={{ thinkingBudget: conversationValue }}+ />+ </ChatContext.Provider>,+ );+ return { slider: screen.getByRole('slider'), commit };+}++describe('DynamicSlider', () => {+ beforeEach(() => {+ jest.useFakeTimers();+ });++ afterEach(() => {+ jest.useRealTimers();+ });++ /**+ * The browser dispatches `dblclick` after the second pointer release, so the+ * commit has already flushed by the time the reset is queued. An action+ * clicked in the debounce window would otherwise read the pre-reset value.+ */+ it('commits a double-click reset without waiting for the debounce', () => {+ const { slider, commit } = setup(0.2);++ fireEvent.doubleClick(slider);++ expect(commit).toHaveBeenCalledWith(1);+ });++ it('still lands the reset exactly once after the debounce elapses', () => {+ const { slider, commit } = setup(0.2);++ fireEvent.doubleClick(slider);+ act(() => {+ jest.advanceTimersByTime(1000);+ });++ expect(commit).toHaveBeenCalledTimes(1);+ expect(commit).toHaveBeenLastCalledWith(1);+ });++ /**+ * A configured sentinel range leaves a gap the track steps straight through,+ * and `generateDynamicSchema` rejects exactly those values, so the UI must not+ * be able to persist one.+ */+ it('lifts a committed value out of the sentinel gap', () => {+ const { slider, commit } = setupSentinel(-1);++ fireEvent.keyDown(slider, { key: 'ArrowRight' });++ expect(commit).toHaveBeenLastCalledWith(128);+ });++ it('leaves a committed value outside the gap alone', () => {+ const { slider, commit } = setupSentinel(2048);++ fireEvent.keyDown(slider, { key: 'ArrowRight' });++ expect(commit).toHaveBeenLastCalledWith(2049);+ });++ /** The adjacent number input reaches the same gap the track does. */+ it('lifts a typed value out of the sentinel gap on blur', () => {+ const { commit } = setupSentinel(-1);+ const input = screen.getByRole('spinbutton');++ fireEvent.change(input, { target: { value: '50' } });+ fireEvent.blur(input);++ expect(commit).toHaveBeenLastCalledWith(128);+ });++ it('leaves a typed value outside the gap alone on blur', () => {+ const { commit } = setupSentinel(-1);+ const input = screen.getByRole('spinbutton');++ fireEvent.change(input, { target: { value: '2048' } });+ fireEvent.blur(input);++ expect(commit).toHaveBeenLastCalledWith(2048);+ });+});diff --git a/client/src/hooks/Conversations/__tests__/useDebouncedInput.spec.tsx b/client/src/hooks/Conversations/__tests__/useDebouncedInput.spec.tsxnew file mode 100644index 0000000000..45eb196a8a--- /dev/null+++ b/client/src/hooks/Conversations/__tests__/useDebouncedInput.spec.tsx@@ -0,0 +1,65 @@+import { renderHook, act } from '@testing-library/react';+import useDebouncedInput from '../useDebouncedInput';++describe('useDebouncedInput', () => {+ beforeEach(() => jest.useFakeTimers());+ afterEach(() => jest.useRealTimers());++ /** Callers do not memoize either callback: setOption is a plain arrow in+ * useSetIndexOptions and the dynamic settings pass `setter` inline. If the+ * debouncer depended on them it would be rebuilt every render, so the flush+ * would reach an instance holding nothing while the previous instance's+ * timer still fired the superseded value. */+ it('flushes the pending edit even though the callbacks change identity', () => {+ const committed: unknown[] = [];+ const render = () =>+ renderHook(+ ({ tick }: { tick: number }) =>+ useDebouncedInput<string>({+ optionKey: 'promptPrefix',+ initialValue: '',+ /** A new function every render, as the real call sites pass. */+ setOption: () => (value: unknown) => committed.push([tick, value]),+ setter: () => ({}) as never,+ }),+ { initialProps: { tick: 0 } },+ );++ const { result, rerender } = render();++ act(() => {+ result.current[0]('edited', false);+ });+ rerender({ tick: 1 });+ expect(committed).toHaveLength(0);++ act(() => {+ result.current[3]();+ });++ expect(committed).toHaveLength(1);+ expect((committed[0] as unknown[])[1]).toBe('edited');+ });++ it('does not commit before the delay elapses', () => {+ const committed: unknown[] = [];+ const { result } = renderHook(() =>+ useDebouncedInput<string>({+ optionKey: 'promptPrefix',+ initialValue: '',+ setOption: () => (value: unknown) => committed.push(value),+ setter: () => ({}) as never,+ }),+ );++ act(() => {+ result.current[0]('typed', false);+ });+ expect(committed).toHaveLength(0);++ act(() => {+ jest.advanceTimersByTime(1000);+ });+ expect(committed).toEqual(['typed']);+ });+});diff --git a/client/src/hooks/Conversations/useDebouncedInput.ts b/client/src/hooks/Conversations/useDebouncedInput.tsindex 73fbb66723..8fbe0b1294 100644--- a/client/src/hooks/Conversations/useDebouncedInput.ts+++ b/client/src/hooks/Conversations/useDebouncedInput.ts@@ -1,5 +1,5 @@+import React, { useState, useCallback, useMemo, useRef } from 'react';import debounce from 'lodash/debounce';-import React, { useState, useCallback, useMemo } from 'react';import type { SetterOrUpdater } from 'recoil';import type { TSetOption } from '~/common';import { defaultDebouncedDelay } from '~/common';@@ -23,16 +23,38 @@ function useDebouncedInput<T = unknown>({(e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement> | T, numeric?: boolean) => void,T,SetterOrUpdater<T>,- // (newValue: string) => void,+ () => void,] {const [value, setValue] = useState<T>(initialValue);- /** A debounced function to call the passed setOption with the optionKey and new value.- *- Note: We use useMemo to ensure our debounced function is stable across renders and properly typed. */+ /** The callbacks are read through refs so the debounced function itself stays+ * stable. Neither is memoized by its caller: `setOption` is a plain arrow in+ * useSetIndexOptions and the dynamic settings pass `setter: () => ({})`+ * inline, so depending on them rebuilt the debouncer on every render. Each+ * render then produced a fresh instance while the previous one kept its+ * timer, which left `flush()` pointing at an instance with nothing pending+ * and let a superseded value land after a correction. */+ const setOptionRef = useRef(setOption);+ const setterRef = useRef(setter);+ setOptionRef.current = setOption;+ setterRef.current = setter;++ /** A debounced function to call the passed setOption with the optionKey and new value. */const setDebouncedOption = useMemo(- () => debounce(setOption && optionKey ? setOption(optionKey) : setter || (() => {}), delay),- [setOption, optionKey, setter, delay],+ () =>+ debounce((newValue: T) => {+ const currentSetOption = setOptionRef.current;+ if (currentSetOption && optionKey != null) {+ /** T is the caller's field type; TSetOption is typed against the whole+ * conversation union, which does not narrow per key. The previous+ * form passed the setter to debounce directly and inherited the same+ * looseness. */+ (currentSetOption(optionKey) as (value: T) => void)(newValue);+ return;+ }+ setterRef.current?.(newValue);+ }, delay),+ [optionKey, delay],);/** An onChange handler that updates the local state and the debounced option */@@ -52,7 +74,13 @@ function useDebouncedInput<T = unknown>({},[setDebouncedOption],);- return [onChange, value, setValue];+ /** Lets a caller commit a pending edit immediately, e.g. on blur, so a Save+ * clicked in the same gesture does not read the pre-edit value. */+ const flush = useCallback(() => {+ setDebouncedOption.flush();+ }, [setDebouncedOption]);++ return [onChange, value, setValue, flush];}export default useDebouncedInput;diff --git a/client/src/hooks/Conversations/useParameterEffects.ts b/client/src/hooks/Conversations/useParameterEffects.tsindex a39113342e..f61a908354 100644--- a/client/src/hooks/Conversations/useParameterEffects.ts+++ b/client/src/hooks/Conversations/useParameterEffects.ts@@ -47,8 +47,12 @@ function useParameterEffects<T = unknown>({}idRef.current = conversationId;- setInputValue(defaultValue as T);- }, [setInputValue, conversation?.conversationId, defaultValue]);+ /** Seed from what the conversation already holds, falling back to the+ * definition default. Resetting to the default unconditionally made saved+ * values read as defaults until the delayed sync below corrected them, and+ * editing inside that window wrote the default back. */+ setInputValue((conversation?.[settingKey] ?? defaultValue) as T);+ }, [setInputValue, conversation, conversation?.conversationId, settingKey, defaultValue]);/** Resets the local state if presetId changed */useEffect(() => {@@ -62,8 +66,8 @@ function useParameterEffects<T = unknown>({}presetIdRef.current = presetId;- setInputValue(defaultValue as T);- }, [setInputValue, preset?.presetId, defaultValue]);+ setInputValue((preset?.[settingKey] ?? conversation?.[settingKey] ?? defaultValue) as T);+ }, [setInputValue, preset, preset?.presetId, conversation, settingKey, defaultValue]);}export default useParameterEffects;diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex d905e52f27..208bd2a1ee 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -286,7 +286,6 @@"com_endpoint_export": "Export","com_endpoint_export_share": "Export/Share","com_endpoint_frequency_penalty": "Frequency Penalty",- "com_endpoint_google_custom_name_placeholder": "Set a custom name for Google","com_endpoint_google_maxoutputtokens": "Maximum number of tokens that can be generated in the response. Specify a lower value for shorter responses and a higher value for longer responses. Note: models may stop before reaching this maximum.","com_endpoint_google_temp": "Higher values = more random, while lower values = more focused and deterministic. We recommend altering this or Top P but not both.","com_endpoint_google_thinking": "Enables or disables reasoning. Supported by Gemini 2.5 and 3 series. Note: Gemini 3 Pro cannot fully disable thinking.",@@ -352,7 +351,6 @@"com_endpoint_prompt_prefix": "Custom Instructions","com_endpoint_prompt_prefix_assistants": "Additional Instructions","com_endpoint_prompt_prefix_assistants_placeholder": "Set additional instructions or context on top of the Assistant's main instructions. Ignored if empty.",- "com_endpoint_prompt_prefix_placeholder": "Set custom instructions or context. Ignored if empty.","com_endpoint_reasoning_context": "Reasoning Context","com_endpoint_reasoning_effort": "Reasoning Effort","com_endpoint_reasoning_mode": "Reasoning Mode",diff --git a/packages/data-provider/specs/config-schemas.spec.ts b/packages/data-provider/specs/config-schemas.spec.tsindex d3ab111480..2ce5724f19 100644--- a/packages/data-provider/specs/config-schemas.spec.ts+++ b/packages/data-provider/specs/config-schemas.spec.ts@@ -47,6 +47,40 @@ describe('paramDefinitionSchema', () => {expect(result.success).toBe(true);});+ /**+ * The shared `SettingRange` exposes it, so a configured sentinel range would+ * otherwise reach the UI with its positive floor silently dropped.+ */+ it('preserves a configured positiveMin on the range', () => {+ const result = paramDefinitionSchema.safeParse({+ key: 'thinkingBudget',+ type: 'number',+ component: 'slider',+ range: { min: -1, max: 32768, step: 1, positiveMin: 128 },+ });++ expect(result.success).toBe(true);+ expect(result.success && result.data.range).toEqual({+ min: -1,+ max: 32768,+ step: 1,+ positiveMin: 128,+ });+ });++ /** The floor would admit nothing but the sentinel while the clamp maps every+ * non-negative input onto a maximum the generated schema then rejects. */+ it('rejects a positiveMin above the range maximum', () => {+ const result = paramDefinitionSchema.safeParse({+ key: 'thinkingBudget',+ type: 'number',+ component: 'slider',+ range: { min: -1, max: 100, positiveMin: 200 },+ });++ expect(result.success).toBe(false);+ });+it('rejects columns > 4', () => {const result = paramDefinitionSchema.safeParse({key: 'test',diff --git a/packages/data-provider/specs/generate.spec.ts b/packages/data-provider/specs/generate.spec.tsindex 2c3cda0f17..4b79d76c5f 100644--- a/packages/data-provider/specs/generate.spec.ts+++ b/packages/data-provider/specs/generate.spec.ts@@ -1,5 +1,10 @@import { ZodError, z } from 'zod';-import { generateDynamicSchema, validateSettingDefinitions, OptionTypes } from '../src/generate';+import {+ generateDynamicSchema,+ validateSettingDefinitions,+ OptionTypes,+ clampSettingRange,+} from '../src/generate';import type { SettingsConfiguration } from '../src/generate';describe('generateDynamicSchema', () => {@@ -194,6 +199,171 @@ describe('generateDynamicSchema', () => {});});+describe('generateDynamicSchema with positiveMin', () => {+ const settings = [+ {+ key: 'thinkingBudget',+ type: 'number',+ component: 'input',+ range: { min: -1, max: 32768, positiveMin: 128 },+ },+ ] as SettingsConfiguration;++ it('accepts the sentinel and values at or above the floor', () => {+ const schema = generateDynamicSchema(settings);+ expect(schema.safeParse({ thinkingBudget: -1 }).success).toBe(true);+ expect(schema.safeParse({ thinkingBudget: 128 }).success).toBe(true);+ expect(schema.safeParse({ thinkingBudget: 32768 }).success).toBe(true);+ });++ it('rejects non-negative values below the floor', () => {+ const schema = generateDynamicSchema(settings);+ expect(schema.safeParse({ thinkingBudget: 0 }).success).toBe(false);+ expect(schema.safeParse({ thinkingBudget: 127 }).success).toBe(false);+ });+});++describe('positiveMin default validation', () => {+ const definition = (defaultValue: number): SettingsConfiguration => [+ {+ key: 'thinkingBudget',+ type: 'number',+ component: 'slider',+ optionType: 'custom',+ default: defaultValue,+ range: { min: -1, max: 32768, step: 1, positiveMin: 128 },+ },+ ];++ it('rejects a default between the sentinel and the positive floor', () => {+ for (const invalid of [0, 127]) {+ expect(() => validateSettingDefinitions(definition(invalid))).toThrow(+ /Must be -1 or at least 128/,+ );+ }+ });++ it('accepts the sentinel itself and any value at or above the floor', () => {+ expect(() => validateSettingDefinitions(definition(-1))).not.toThrow();+ expect(() => validateSettingDefinitions(definition(128))).not.toThrow();+ });+});++describe('positiveMin range validation', () => {+ /**+ * `default` is optional and this validator populates it, so a midpoint taken+ * across the sentinel gap would make an otherwise coherent definition fail+ * the validation in the same pass.+ */+ it('synthesizes a slider default inside the admissible interval', () => {+ const settings: SettingsConfiguration = [+ {+ key: 'budget',+ type: 'number',+ component: 'slider',+ optionType: 'custom',+ range: { min: -1, max: 100, step: 1, positiveMin: 80 },+ },+ ];++ expect(() => validateSettingDefinitions(settings)).not.toThrow();+ expect(settings[0].default).toBe(90);+ });++ it('rejects a positive floor above the maximum', () => {+ const settings: SettingsConfiguration = [+ {+ key: 'thinkingBudget',+ type: 'number',+ component: 'slider',+ optionType: 'custom',+ range: { min: -1, max: 100, step: 1, positiveMin: 200 },+ },+ ];++ expect(() => validateSettingDefinitions(settings)).toThrow(/cannot exceed max/);+ });+});++describe('clampSettingRange', () => {+ const proThinkingBudget = { min: -1, max: 32768, step: 1, positiveMin: 128 };++ it('preserves the negative sentinel', () => {+ expect(clampSettingRange(-1, proThinkingBudget)).toBe(-1);+ });++ it('clamps positive values below the model floor up to that floor', () => {+ expect(clampSettingRange(0, proThinkingBudget)).toBe(128);+ expect(clampSettingRange(127, proThinkingBudget)).toBe(128);+ });++ it('leaves values inside the supported positive range alone', () => {+ expect(clampSettingRange(128, proThinkingBudget)).toBe(128);+ expect(clampSettingRange(2000, proThinkingBudget)).toBe(2000);+ });++ it('still enforces the ceiling', () => {+ expect(clampSettingRange(40000, proThinkingBudget)).toBe(32768);+ });++ it('clamps values below the sentinel up to the sentinel', () => {+ expect(clampSettingRange(-2, proThinkingBudget)).toBe(-1);+ });++ /** The minimum is the sentinel whatever its sign, and the generated schema+ * admits it outright, so the clamp must not lift it to the floor. */+ it('preserves a non-negative sentinel minimum', () => {+ const range = { min: 0, max: 100, step: 1, positiveMin: 10 };+ const settings: SettingsConfiguration = [+ {+ key: 'budget',+ type: 'number',+ component: 'slider',+ optionType: 'custom',+ range,+ },+ ];+ const schema = generateDynamicSchema(settings);++ expect(clampSettingRange(0, range)).toBe(0);+ expect(schema.safeParse({ budget: 0 }).success).toBe(true);+ /** Still inside the gap, so it lifts to the floor. */+ expect(clampSettingRange(5, range)).toBe(10);+ expect(clampSettingRange(-3, range)).toBe(0);+ });++ it('treats a zero positiveMin as a valid floor rather than a missing one', () => {+ const flash = { min: -1, max: 24576, step: 1, positiveMin: 0 };+ expect(clampSettingRange(0, flash)).toBe(0);+ expect(clampSettingRange(-1, flash)).toBe(-1);+ });++ /**+ * The generated schema admits the sentinel or the positive floor and nothing+ * between them, so a stored fraction has to resolve to one of those rather+ * than survive a normalization the schema then rejects.+ */+ it('resolves a value between the sentinel and the floor to the sentinel', () => {+ const settings: SettingsConfiguration = [+ {+ key: 'thinkingBudget',+ type: 'number',+ component: 'slider',+ optionType: 'model',+ range: proThinkingBudget,+ },+ ];+ const schema = generateDynamicSchema(settings);++ for (const stored of [-0.5, -0.001]) {+ const clamped = clampSettingRange(stored, proThinkingBudget);+ expect(clamped).toBe(-1);+ expect(schema.safeParse({ thinkingBudget: stored }).success).toBe(false);+ expect(schema.safeParse({ thinkingBudget: clamped }).success).toBe(true);+ }+ });+});+describe('validateSettingDefinitions', () => {test('should throw error for Conversation optionType', () => {const validSettings: SettingsConfiguration = [diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 007db9d438..9822ffbc68 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -1089,6 +1089,14 @@ export const paramDefinitionSchema = z.object({min: z.number(),max: z.number(),step: z.number().optional(),+ positiveMin: z.number().optional(),+ })+ /** A floor above the ceiling admits nothing but the sentinel, while the+ * clamp maps every non-negative input onto a maximum the generated schema+ * then rejects. */+ .refine((value) => value.positiveMin == null || value.positiveMin <= value.max, {+ message: 'range.positiveMin cannot exceed range.max',+ path: ['positiveMin'],}).optional(),enumMappings: z.record(z.union([z.number(), z.boolean(), z.string()])).optional(),diff --git a/packages/data-provider/src/generate.ts b/packages/data-provider/src/generate.tsindex c184983505..e12934ee4e 100644--- a/packages/data-provider/src/generate.ts+++ b/packages/data-provider/src/generate.ts@@ -1,7 +1,7 @@import { z, ZodArray, ZodError, ZodIssueCode } from 'zod';-import { tConversationSchema, googleSettings as google, openAISettings as openAI } from './schemas';import type { ZodIssue } from 'zod';import type { TConversation, TSetOption, TPreset } from './schemas';+import { tConversationSchema, googleSettings as google, openAISettings as openAI } from './schemas';export type GoogleSettings = Partial<typeof google>;export type OpenAISettings = Partial<typeof google>;@@ -97,6 +97,38 @@ export interface SettingRange {min: number;max: number;step?: number;+ /**+ * Inclusive floor for non-negative values. Use when `min` is a sentinel+ * (Google thinkingBudget `-1` for auto) and positive values have a higher+ * documented minimum.+ */+ positiveMin?: number;+ /**+ * Set when this range came from the selected model rather than the shared+ * fallback. Only then is it safe to normalize a stored value against it: a+ * model that does not use the parameter leaves the generic range in place,+ * and clamping to that would discard a value set for another model.+ */+ modelSpecific?: boolean;+}++export function clampSettingRange(value: number, range: SettingRange): number {+ if (range.positiveMin != null) {+ /** The minimum carries its own meaning here (Google's -1 for automatic),+ * and the schema admits it outright, so it survives rather than being+ * lifted to the floor. It need not be negative to be the sentinel. */+ if (value === range.min) {+ return range.min;+ }+ /** Below the sentinel there is nothing admissible to lift to, so the value+ * resolves to it. Between the sentinel and the floor, the floor is the+ * nearest value the generated schema accepts. */+ if (value < Math.max(range.min, 0)) {+ return range.min;+ }+ return Math.min(Math.max(value, range.positiveMin), range.max);+ }+ return Math.min(Math.max(value, range.min), range.max);}export type SettingsConfiguration = SettingDefinition[];@@ -118,10 +150,23 @@ export function generateDynamicSchema(settings: SettingsConfiguration) {} = setting;if (type === SettingTypes.Number) {- let schema = z.number();+ let numberSchema = z.number();if (range) {- schema = schema.min(range.min);- schema = schema.max(range.max);+ numberSchema = numberSchema.min(range.min);+ numberSchema = numberSchema.max(range.max);+ }+ /** Widened deliberately: refine returns ZodEffects, not ZodNumber, and+ * the number-specific chaining is already done above. */+ let schema: z.ZodTypeAny = numberSchema;+ if (range?.positiveMin != null) {+ /** Mirrors clampSettingRange so the generated schema and the clamp+ * agree: `min` only admits the sentinel, and any non-negative value+ * must clear the documented floor. */+ const { positiveMin, min } = range;+ schema = numberSchema.refine(+ (value) => value === min || value >= positiveMin,+ `Expected ${min} or a value of at least ${positiveMin}`,+ );}if (typeof defaultValue === 'number') {schemaFields[key] = schema.default(defaultValue);@@ -363,8 +408,12 @@ export function validateSettingDefinitions(settings: SettingsConfiguration): voiif (setting.component === ComponentTypes.Slider && setting.type === SettingTypes.Number) {if (setting.default === undefined && setting.range) {- // Set default to the middle of the range if unspecified- setting.default = Math.round((setting.range.min + setting.range.max) / 2);+ /** The midpoint of the admissible interval, which a positive floor+ * narrows: the span between the sentinel and that floor holds no value+ * the generated schema accepts, so a midpoint taken across it would+ * fail the validation below. */+ const floor = Math.max(setting.range.min, setting.range.positiveMin ?? setting.range.min);+ setting.default = Math.round((floor + setting.range.max) / 2);}}@@ -530,6 +579,32 @@ export function validateSettingDefinitions(settings: SettingsConfiguration): voi});}+ if (+ setting.type === SettingTypes.Number &&+ setting.range?.positiveMin != null &&+ setting.range.positiveMin > setting.range.max+ ) {+ errors.push({+ code: ZodIssueCode.custom,+ message: `Invalid range for setting ${setting.key}. positiveMin (${setting.range.positiveMin}) cannot exceed max (${setting.range.max}).`,+ path: ['range'],+ });+ }++ if (+ setting.type === SettingTypes.Number &&+ setting.range?.positiveMin != null &&+ typeof setting.default === 'number' &&+ setting.default !== setting.range.min &&+ setting.default < setting.range.positiveMin+ ) {+ errors.push({+ code: ZodIssueCode.custom,+ message: `Invalid default value for setting ${setting.key}. Must be ${setting.range.min} or at least ${setting.range.positiveMin}.`,+ path: ['default'],+ });+ }+// Validate enumMappingsif (setting.enumMappings && setting.type === SettingTypes.Enum && setting.options) {for (const option of setting.options) {diff --git a/packages/data-provider/src/parameterSettings.spec.ts b/packages/data-provider/src/parameterSettings.spec.tsindex a072459bc1..f38e838084 100644--- a/packages/data-provider/src/parameterSettings.spec.ts+++ b/packages/data-provider/src/parameterSettings.spec.ts@@ -5,6 +5,10 @@ import { EModelEndpoint } from './types';const googleParams = paramSettings[EModelEndpoint.google] as SettingDefinition[];const anthropicParams = paramSettings[EModelEndpoint.anthropic] as SettingDefinition[];const maxOut = (params: SettingDefinition[]) => params.find((p) => p.key === 'maxOutputTokens');+const maxContext = (params: SettingDefinition[]) =>+ params.find((p) => p.key === 'maxContextTokens');+const thinkingBudget = (params: SettingDefinition[]) =>+ params.find((p) => p.key === 'thinkingBudget');const hasSetting = (params: SettingDefinition[], key: string) =>params.some((param) => param.key === key);@@ -76,4 +80,54 @@ describe('applyModelAwareDefaults', () => {const final = modelAware.map((p) => (p.key === 'maxOutputTokens' ? override : p));expect(maxOut(final)?.default).toBe(2048);});++ it('keeps thinkingBudget -1 as the range minimum and applies the Pro floor separately', () => {+ const result = applyModelAwareDefaults(googleParams, EModelEndpoint.google, 'gemini-2.5-pro');+ expect(thinkingBudget(result)?.range).toMatchObject({+ min: -1,+ max: 32768,+ positiveMin: 128,+ });+ });++ it('applies the Flash Lite thinking-budget floor without raising the sentinel minimum', () => {+ const result = applyModelAwareDefaults(+ googleParams,+ EModelEndpoint.google,+ 'gemini-2.5-flash-lite',+ );+ expect(thinkingBudget(result)?.range).toMatchObject({+ min: -1,+ max: 24576,+ positiveMin: 512,+ });+ });++ it('applies the Flash thinking-budget ceiling and a zero positive floor', () => {+ const result = applyModelAwareDefaults(googleParams, EModelEndpoint.google, 'gemini-2.5-flash');+ expect(thinkingBudget(result)?.range).toMatchObject({+ min: -1,+ max: 24576,+ positiveMin: 0,+ });+ });+});++/**+ * The field is rendered by every endpoint, so bounds written for Gemini would+ * silently clamp a context window another provider accepts.+ */+describe('maxContextTokens bounds', () => {+ it('bounds the Google field to the documented context window', () => {+ expect(maxContext(googleParams)?.range).toEqual({ min: 10, max: 2000000, step: 1000 });+ });++ it('leaves every other endpoint unbounded', () => {+ const bounded = Object.entries(paramSettings)+ .filter(([endpoint]) => endpoint !== EModelEndpoint.google)+ .filter(([, params]) => maxContext(params as SettingDefinition[])?.range != null)+ .map(([endpoint]) => endpoint);++ expect(bounded).toEqual([]);+ });});diff --git a/packages/data-provider/src/parameterSettings.ts b/packages/data-provider/src/parameterSettings.tsindex af2b779119..1a6a2cad66 100644--- a/packages/data-provider/src/parameterSettings.ts+++ b/packages/data-provider/src/parameterSettings.ts@@ -6,6 +6,7 @@ import {EModelEndpoint,openAISettings,googleSettings,+ getGoogleThinkingBudgetBounds,Providers,ReasoningEffort,AnthropicEffort,@@ -690,6 +691,16 @@ const meta: Record<string, SettingDefinition> = {};const google: Record<string, SettingDefinition> = {+ /** Bounds the hand-rolled editor enforced through InputNumber, and they stay+ * scoped to this endpoint: the shared definition is rendered by every other+ * endpoint, whose own context windows may fall outside them. */+ maxContextTokens: createDefinition(librechat.maxContextTokens, {+ range: {+ min: googleSettings.maxContextTokens.min,+ max: googleSettings.maxContextTokens.max,+ step: googleSettings.maxContextTokens.step,+ },+ }),temperature: createDefinition(baseDefinitions.temperature, {default: googleSettings.temperature.default,range: {@@ -830,7 +841,7 @@ const google: Record<string, SettingDefinition> = {const googleConfig: SettingsConfiguration = [librechat.modelLabel,librechat.promptPrefix,- librechat.maxContextTokens,+ google.maxContextTokens,google.maxOutputTokens,google.temperature,google.topP,@@ -851,7 +862,7 @@ const googleCol1: SettingsConfiguration = [];const googleCol2: SettingsConfiguration = [- librechat.maxContextTokens,+ google.maxContextTokens,google.maxOutputTokens,google.temperature,google.topP,@@ -1264,14 +1275,32 @@ export function applyModelAwareDefaults(if (!model) {return settings;}-const modelAwareSettings =endpoint === EModelEndpoint.google- ? settings.map((setting) =>- setting.key === 'maxOutputTokens'- ? { ...setting, default: googleSettings.maxOutputTokens.reset(model) }- : setting,- )+ ? settings.map((setting) => {+ if (setting.key === 'maxOutputTokens') {+ return { ...setting, default: googleSettings.maxOutputTokens.reset(model) };+ }+ /** The shared thinking budget range is model-agnostic, so it caps Pro below+ * its real ceiling and accepts Flash values the provider rejects. The+ * maximum and the positive floor move together. `range.min` stays -1 so+ * the "decide automatically" sentinel remains typeable. */+ if (setting.key === 'thinkingBudget' && setting.range != null) {+ const bounds = getGoogleThinkingBudgetBounds(model);+ if (bounds != null) {+ return {+ ...setting,+ range: {+ ...setting.range,+ max: bounds.max,+ positiveMin: bounds.min,+ modelSpecific: true,+ },+ };+ }+ }+ return setting;+ }): settings;if (endpoint !== EModelEndpoint.anthropic || supportsPromptCache(model)) {diff --git a/packages/data-provider/src/schemas.spec.ts b/packages/data-provider/src/schemas.spec.tsindex 2439a232df..fca60a549c 100644--- a/packages/data-provider/src/schemas.spec.ts+++ b/packages/data-provider/src/schemas.spec.ts@@ -12,6 +12,7 @@ import {eReasoningModeSchema,eReasoningContextSchema,subagentThreadLineageSchema,+ getGoogleThinkingBudgetBounds,} from './schemas';describe('anthropicSettings', () => {@@ -519,6 +520,37 @@ describe('googleSettings', () => {});});+ describe('getGoogleThinkingBudgetBounds()', () => {+ it('returns the documented Pro floor and ceiling', () => {+ expect(getGoogleThinkingBudgetBounds('gemini-2.5-pro')).toEqual({ min: 128, max: 32768 });+ expect(getGoogleThinkingBudgetBounds('gemini-2.5-pro-preview-05-06')).toEqual({+ min: 128,+ max: 32768,+ });+ });++ it('returns the documented Flash floor and ceiling', () => {+ expect(getGoogleThinkingBudgetBounds('gemini-2.5-flash')).toEqual({ min: 0, max: 24576 });+ });++ it('returns the documented Flash Lite floor and ceiling', () => {+ expect(getGoogleThinkingBudgetBounds('gemini-2.5-flash-lite')).toEqual({+ min: 512,+ max: 24576,+ });+ expect(getGoogleThinkingBudgetBounds('gemini-2.5-flash-lite-preview-09-2025')).toEqual({+ min: 512,+ max: 24576,+ });+ });++ it('does not apply 2.5 bounds to other Gemini families', () => {+ expect(getGoogleThinkingBudgetBounds('gemini-2.0-flash')).toBeUndefined();+ expect(getGoogleThinkingBudgetBounds('gemini-3-pro')).toBeUndefined();+ expect(getGoogleThinkingBudgetBounds('gemini-1.5-pro')).toBeUndefined();+ });+ });+describe('compactGoogleSchema (model-aware maxOutputTokens)', () => {it('strips the model default for current Gemini models', () => {const result = compactGoogleSchema.parse({diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.tsindex 39d62751b4..f86fb37f65 100644--- a/packages/data-provider/src/schemas.ts+++ b/packages/data-provider/src/schemas.ts@@ -461,10 +461,55 @@ const getGoogleMaxOutputTokens = (modelName: string): number => {return GOOGLE_LEGACY_MAX_OUTPUT;};+/**+ * Per-model thinking budget bounds, documented in+ * `com_endpoint_google_thinking_budget`: Gemini 2.5 Pro accepts 128-32,768,+ * Flash accepts 0-24,576, and Flash Lite accepts 512-24,576. The generic+ * 32,000 in the shared definition both under-limits Pro and lets invalid+ * Flash values through.+ *+ * `-1` remains the "decide automatically" sentinel and is not part of these+ * floors. Callers must keep `range.min` at -1 and apply `min` only to+ * non-negative values.+ */+const GOOGLE_THINKING_BUDGET_PRO_MAX = 32768 as const;+const GOOGLE_THINKING_BUDGET_FLASH_MAX = 24576 as const;+const GOOGLE_THINKING_BUDGET_PRO_MIN = 128 as const;+const GOOGLE_THINKING_BUDGET_FLASH_MIN = 0 as const;+const GOOGLE_THINKING_BUDGET_FLASH_LITE_MIN = 512 as const;++export type GoogleThinkingBudgetBounds = { min: number; max: number };++export const getGoogleThinkingBudgetBounds = (+ modelName: string,+): GoogleThinkingBudgetBounds | undefined => {+ if (!/gemini-2\.5/i.test(modelName)) {+ return undefined;+ }+ if (/flash[-_.]?lite/i.test(modelName)) {+ return { min: GOOGLE_THINKING_BUDGET_FLASH_LITE_MIN, max: GOOGLE_THINKING_BUDGET_FLASH_MAX };+ }+ if (/flash/i.test(modelName)) {+ return { min: GOOGLE_THINKING_BUDGET_FLASH_MIN, max: GOOGLE_THINKING_BUDGET_FLASH_MAX };+ }+ if (/pro/i.test(modelName)) {+ return { min: GOOGLE_THINKING_BUDGET_PRO_MIN, max: GOOGLE_THINKING_BUDGET_PRO_MAX };+ }+ return undefined;+};++export const getGoogleThinkingBudgetMax = (modelName: string): number | undefined =>+ getGoogleThinkingBudgetBounds(modelName)?.max;+export const googleSettings = {model: {default: 'gemini-1.5-flash-latest' as const,},+ maxContextTokens: {+ min: 10 as const,+ max: 2000000 as const,+ step: 1000 as const,+ },maxOutputTokens: {min: 1 as const,max: GOOGLE_MAX_OUTPUT,@@ -1308,6 +1353,7 @@ export const googleBaseSchema = tConversationSchema.pick({examples: true,temperature: true,maxOutputTokens: true,+ resendFiles: true,artifacts: true,topP: true,topK: true,