import type { ResponsesApiRouting, TModelReasoning, TReasoningCapabilityMap } from './types'; import type { SettingDefinition, SettingsConfiguration } from './generate'; import type { TReasoningOverride } from './schemas'; import { Verbosity, ImageDetail, ThinkingLevel, ThinkingDisplay, EModelEndpoint, openAISettings, googleSettings, getGoogleThinkingBudgetBounds, Providers, ReasoningEffort, AnthropicEffort, ReasoningSummary, ReasoningMode, ReasoningContext, BedrockProviders, anthropicSettings, } from './types'; import { hasAlwaysOnThinking, hasAdaptiveHaikuThinking, hasBetweenToolsThinkingFloor, supportsPromptCache, supportsAdaptiveThinking, } from './bedrock'; import { getModelKey, getSettingsKeys, reasoningOverrideSchema, ReasoningParameterFormat, } from './schemas'; import { resolveEffectiveUseResponsesApi } from './file-config'; import { clampSettingRange } from './generate'; import { gpt6Tier } from './families'; // Base definitions const baseDefinitions: Record = { model: { key: 'model', label: 'com_ui_model', labelCode: true, type: 'string', component: 'dropdown', optionType: 'model', selectPlaceholder: 'com_ui_select_model', searchPlaceholder: 'com_ui_select_search_model', searchPlaceholderCode: true, selectPlaceholderCode: true, columnSpan: 4, }, temperature: { key: 'temperature', label: 'com_endpoint_temperature', labelCode: true, description: 'com_endpoint_openai_temp', descriptionCode: true, type: 'number', component: 'slider', optionType: 'model', columnSpan: 4, }, topP: { key: 'topP', label: 'com_endpoint_top_p', labelCode: true, description: 'com_endpoint_anthropic_topp', descriptionCode: true, type: 'number', component: 'slider', optionType: 'model', columnSpan: 4, }, stop: { key: 'stop', label: 'com_endpoint_stop', labelCode: true, description: 'com_endpoint_openai_stop', descriptionCode: true, placeholder: 'com_endpoint_stop_placeholder', placeholderCode: true, type: 'array', default: [], component: 'tags', optionType: 'conversation', minTags: 0, maxTags: 4, }, }; const createDefinition = ( base: Partial, overrides: Partial, ): SettingDefinition => { return { ...base, ...overrides } as SettingDefinition; }; export const librechat = { modelLabel: { key: 'modelLabel', label: 'com_endpoint_custom_name', labelCode: true, type: 'string', default: '', component: 'input', placeholder: 'com_endpoint_openai_custom_name_placeholder', placeholderCode: true, optionType: 'conversation', } as const, maxContextTokens: { key: 'maxContextTokens', label: 'com_endpoint_context_tokens', labelCode: true, type: 'number', component: 'input', placeholder: 'com_endpoint_default', placeholderCode: true, description: 'com_endpoint_context_info', descriptionCode: true, optionType: 'model', columnSpan: 2, } as const, resendFiles: { key: 'resendFiles', label: 'com_endpoint_plug_resend_files', labelCode: true, description: 'com_endpoint_openai_resend_files', descriptionCode: true, type: 'boolean', default: true, component: 'switch', optionType: 'conversation', showDefault: false, columnSpan: 2, } as const, promptPrefix: { key: 'promptPrefix', label: 'com_endpoint_prompt_prefix', labelCode: true, type: 'string', default: '', component: 'textarea', placeholder: 'com_endpoint_openai_prompt_prefix_placeholder', placeholderCode: true, optionType: 'model', } as const, /** Controls how LibreChat encodes image content blocks, not a provider request * parameter — so it belongs to this group and is stripped from model options. */ imageDetail: { key: 'imageDetail', label: 'com_endpoint_plug_image_detail', labelCode: true, description: 'com_endpoint_openai_detail', descriptionCode: true, type: 'enum', default: ImageDetail.auto, component: 'slider', options: [ImageDetail.low, ImageDetail.auto, ImageDetail.high], enumMappings: { [ImageDetail.low]: 'com_ui_low', [ImageDetail.auto]: 'com_ui_auto', [ImageDetail.high]: 'com_ui_high', }, optionType: 'conversation', columnSpan: 2, } as SettingDefinition, fileTokenLimit: { key: 'fileTokenLimit', label: 'com_ui_file_token_limit', labelCode: true, description: 'com_ui_file_token_limit_desc', descriptionCode: true, placeholder: 'com_endpoint_default', placeholderCode: true, type: 'number', component: 'input', columnSpan: 2, } as const, }; const openAIParams: Record = { chatGptLabel: { ...librechat.modelLabel, key: 'chatGptLabel', }, promptPrefix: librechat.promptPrefix, temperature: createDefinition(baseDefinitions.temperature, { default: openAISettings.temperature.default, range: { min: openAISettings.temperature.min, max: openAISettings.temperature.max, step: openAISettings.temperature.step, }, }), top_p: createDefinition(baseDefinitions.topP, { key: 'top_p', default: openAISettings.top_p.default, range: { min: openAISettings.top_p.min, max: openAISettings.top_p.max, step: openAISettings.top_p.step, }, }), frequency_penalty: { key: 'frequency_penalty', label: 'com_endpoint_frequency_penalty', labelCode: true, description: 'com_endpoint_openai_freq', descriptionCode: true, type: 'number', default: openAISettings.frequency_penalty.default, range: { min: openAISettings.frequency_penalty.min, max: openAISettings.frequency_penalty.max, step: openAISettings.frequency_penalty.step, }, component: 'slider', optionType: 'model', columnSpan: 4, }, presence_penalty: { key: 'presence_penalty', label: 'com_endpoint_presence_penalty', labelCode: true, description: 'com_endpoint_openai_pres', descriptionCode: true, type: 'number', default: openAISettings.presence_penalty.default, range: { min: openAISettings.presence_penalty.min, max: openAISettings.presence_penalty.max, step: openAISettings.presence_penalty.step, }, component: 'slider', optionType: 'model', columnSpan: 4, }, max_tokens: { key: 'max_tokens', label: 'com_endpoint_max_output_tokens', labelCode: true, type: 'number', component: 'input', description: 'com_endpoint_openai_max_tokens', descriptionCode: true, placeholder: 'com_endpoint_default', placeholderCode: true, optionType: 'model', columnSpan: 2, }, reasoning_effort: { key: 'reasoning_effort', label: 'com_endpoint_reasoning_effort', labelCode: true, description: 'com_endpoint_openai_reasoning_effort', descriptionCode: true, type: 'enum', default: ReasoningEffort.unset, component: 'slider', options: [ ReasoningEffort.unset, ReasoningEffort.none, ReasoningEffort.minimal, ReasoningEffort.low, ReasoningEffort.medium, ReasoningEffort.high, ReasoningEffort.xhigh, ReasoningEffort.max, ], enumMappings: { [ReasoningEffort.unset]: 'com_ui_auto', [ReasoningEffort.none]: 'com_ui_none', [ReasoningEffort.minimal]: 'com_ui_minimal', [ReasoningEffort.low]: 'com_ui_low', [ReasoningEffort.medium]: 'com_ui_medium', [ReasoningEffort.high]: 'com_ui_high', [ReasoningEffort.xhigh]: 'com_ui_xhigh', [ReasoningEffort.max]: 'com_ui_max', }, optionType: 'model', columnSpan: 4, }, useResponsesApi: { key: 'useResponsesApi', label: 'com_endpoint_use_responses_api', labelCode: true, description: 'com_endpoint_openai_use_responses_api', descriptionCode: true, type: 'boolean', default: false, component: 'switch', optionType: 'model', showDefault: false, columnSpan: 2, }, web_search: { key: 'web_search', label: 'com_ui_web_search', labelCode: true, description: 'com_endpoint_openai_use_web_search', descriptionCode: true, type: 'boolean', default: false, component: 'switch', optionType: 'model', showDefault: false, columnSpan: 2, }, reasoning_summary: { key: 'reasoning_summary', label: 'com_endpoint_reasoning_summary', labelCode: true, description: 'com_endpoint_openai_reasoning_summary', descriptionCode: true, type: 'enum', default: ReasoningSummary.none, component: 'slider', options: [ ReasoningSummary.none, ReasoningSummary.auto, ReasoningSummary.concise, ReasoningSummary.detailed, ], enumMappings: { [ReasoningSummary.none]: 'com_ui_unset', [ReasoningSummary.auto]: 'com_ui_auto', [ReasoningSummary.concise]: 'com_ui_concise', [ReasoningSummary.detailed]: 'com_ui_detailed', }, optionType: 'model', columnSpan: 4, }, reasoning_mode: { key: 'reasoning_mode', label: 'com_endpoint_reasoning_mode', labelCode: true, description: 'com_endpoint_openai_reasoning_mode', descriptionCode: true, type: 'enum', default: ReasoningMode.unset, component: 'slider', options: [ReasoningMode.unset, ReasoningMode.standard, ReasoningMode.pro], enumMappings: { [ReasoningMode.unset]: 'com_ui_unset', [ReasoningMode.standard]: 'com_ui_standard', [ReasoningMode.pro]: 'com_ui_pro', }, optionType: 'model', columnSpan: 4, }, reasoning_context: { key: 'reasoning_context', label: 'com_endpoint_reasoning_context', labelCode: true, description: 'com_endpoint_openai_reasoning_context', descriptionCode: true, type: 'enum', default: ReasoningContext.unset, component: 'slider', options: [ ReasoningContext.unset, ReasoningContext.auto, ReasoningContext.current_turn, ReasoningContext.all_turns, ], enumMappings: { [ReasoningContext.unset]: 'com_ui_unset', [ReasoningContext.auto]: 'com_ui_auto', [ReasoningContext.current_turn]: 'com_ui_current_turn', [ReasoningContext.all_turns]: 'com_ui_all_turns', }, optionType: 'model', columnSpan: 4, }, verbosity: { key: 'verbosity', label: 'com_endpoint_verbosity', labelCode: true, description: 'com_endpoint_openai_verbosity', descriptionCode: true, type: 'enum', default: Verbosity.none, component: 'slider', options: [Verbosity.none, Verbosity.low, Verbosity.medium, Verbosity.high], enumMappings: { [Verbosity.none]: 'com_ui_none', [Verbosity.low]: 'com_ui_low', [Verbosity.medium]: 'com_ui_medium', [Verbosity.high]: 'com_ui_high', }, optionType: 'model', columnSpan: 4, }, disableStreaming: { key: 'disableStreaming', label: 'com_endpoint_disable_streaming_label', labelCode: true, description: 'com_endpoint_disable_streaming', descriptionCode: true, type: 'boolean', default: false, component: 'switch', optionType: 'model', showDefault: false, columnSpan: 2, } as const, }; const anthropic: Record = { maxOutputTokens: { key: 'maxOutputTokens', label: 'com_endpoint_max_output_tokens', labelCode: true, type: 'number', component: 'input', description: 'com_endpoint_anthropic_maxoutputtokens', descriptionCode: true, placeholder: 'com_endpoint_default', placeholderCode: true, range: { min: anthropicSettings.maxOutputTokens.min, max: anthropicSettings.maxOutputTokens.max, step: anthropicSettings.maxOutputTokens.step, }, optionType: 'model', columnSpan: 2, }, temperature: createDefinition(baseDefinitions.temperature, { default: anthropicSettings.temperature.default, range: { min: anthropicSettings.temperature.min, max: anthropicSettings.temperature.max, step: anthropicSettings.temperature.step, }, }), topP: createDefinition(baseDefinitions.topP, { default: anthropicSettings.topP.default, range: { min: anthropicSettings.topP.min, max: anthropicSettings.topP.max, step: anthropicSettings.topP.step, }, }), topK: { key: 'topK', label: 'com_endpoint_top_k', labelCode: true, description: 'com_endpoint_anthropic_topk', descriptionCode: true, type: 'number', default: anthropicSettings.topK.default, range: { min: anthropicSettings.topK.min, max: anthropicSettings.topK.max, step: anthropicSettings.topK.step, }, component: 'slider', optionType: 'model', columnSpan: 4, }, promptCache: { key: 'promptCache', label: 'com_endpoint_prompt_cache', labelCode: true, description: 'com_endpoint_anthropic_prompt_cache', descriptionCode: true, type: 'boolean', default: anthropicSettings.promptCache.default, component: 'switch', optionType: 'conversation', showDefault: false, columnSpan: 2, }, promptCacheTtl: { key: 'promptCacheTtl', label: 'com_endpoint_prompt_cache_ttl', labelCode: true, description: 'com_endpoint_anthropic_prompt_cache_ttl', descriptionCode: true, type: 'enum', default: anthropicSettings.promptCacheTtl.default, options: ['5m', '1h'], component: 'combobox', optionType: 'conversation', showDefault: false, selectPlaceholder: 'com_endpoint_prompt_cache_ttl_default', selectPlaceholderCode: true, columnSpan: 2, }, thinking: { key: 'thinking', label: 'com_endpoint_thinking', labelCode: true, description: 'com_endpoint_anthropic_thinking', descriptionCode: true, type: 'boolean', default: anthropicSettings.thinking.default, component: 'switch', optionType: 'conversation', showDefault: false, columnSpan: 2, }, thinkingBudget: { key: 'thinkingBudget', label: 'com_endpoint_thinking_budget', labelCode: true, description: 'com_endpoint_anthropic_thinking_budget', descriptionCode: true, type: 'number', component: 'input', default: anthropicSettings.thinkingBudget.default, range: { min: anthropicSettings.thinkingBudget.min, max: anthropicSettings.thinkingBudget.max, step: anthropicSettings.thinkingBudget.step, }, optionType: 'conversation', columnSpan: 2, }, web_search: { key: 'web_search', label: 'com_ui_web_search', labelCode: true, description: 'com_endpoint_anthropic_use_web_search', descriptionCode: true, type: 'boolean', default: anthropicSettings.web_search.default, component: 'switch', optionType: 'conversation', showDefault: false, columnSpan: 2, }, effort: { key: 'effort', label: 'com_endpoint_effort', labelCode: true, description: 'com_endpoint_anthropic_effort', descriptionCode: true, type: 'enum', default: anthropicSettings.effort.default, component: 'slider', options: anthropicSettings.effort.options, enumMappings: { [AnthropicEffort.unset]: 'com_ui_auto', [AnthropicEffort.low]: 'com_ui_low', [AnthropicEffort.medium]: 'com_ui_medium', [AnthropicEffort.high]: 'com_ui_high', [AnthropicEffort.xhigh]: 'com_ui_xhigh', [AnthropicEffort.max]: 'com_ui_max', }, optionType: 'model', columnSpan: 4, }, thinkingDisplay: { key: 'thinkingDisplay', label: 'com_endpoint_anthropic_thinking_display', labelCode: true, description: 'com_endpoint_anthropic_thinking_display_desc', descriptionCode: true, type: 'enum', default: anthropicSettings.thinkingDisplay.default, component: 'slider', options: anthropicSettings.thinkingDisplay.options, enumMappings: { [ThinkingDisplay.auto]: 'com_ui_auto', [ThinkingDisplay.summarized]: 'com_ui_summarized', [ThinkingDisplay.omitted]: 'com_ui_omitted', [ThinkingDisplay.updates]: 'com_ui_updates', }, optionType: 'model', columnSpan: 4, }, }; const bedrock: Record = { system: { key: 'system', label: 'com_endpoint_prompt_prefix', labelCode: true, type: 'string', default: '', component: 'textarea', placeholder: 'com_endpoint_openai_prompt_prefix_placeholder', placeholderCode: true, optionType: 'model', }, region: { key: 'region', type: 'string', label: 'com_ui_region', labelCode: true, component: 'combobox', optionType: 'conversation', selectPlaceholder: 'com_ui_select_region', searchPlaceholder: 'com_ui_select_search_region', searchPlaceholderCode: true, selectPlaceholderCode: true, columnSpan: 2, }, maxTokens: { key: 'maxTokens', label: 'com_endpoint_max_output_tokens', labelCode: true, type: 'number', component: 'input', description: 'com_endpoint_anthropic_maxoutputtokens', descriptionCode: true, placeholder: 'com_endpoint_default', placeholderCode: true, optionType: 'model', columnSpan: 2, }, temperature: createDefinition(baseDefinitions.temperature, { default: 1, range: { min: 0, max: 1, step: 0.01 }, }), topK: createDefinition(anthropic.topK, { range: { min: 0, max: 500, step: 1 }, }), topP: createDefinition(baseDefinitions.topP, { default: 0.999, range: { min: 0, max: 1, step: 0.01 }, }), promptCache: { key: 'promptCache', label: 'com_endpoint_prompt_cache', labelCode: true, type: 'boolean', description: 'com_endpoint_anthropic_prompt_cache', descriptionCode: true, default: true, component: 'switch', optionType: 'conversation', showDefault: false, columnSpan: 2, }, promptCacheTtl: { key: 'promptCacheTtl', label: 'com_endpoint_prompt_cache_ttl', labelCode: true, description: 'com_endpoint_anthropic_prompt_cache_ttl', descriptionCode: true, type: 'enum', default: undefined, options: ['5m', '1h'], component: 'combobox', optionType: 'conversation', showDefault: false, selectPlaceholder: 'com_endpoint_prompt_cache_ttl_default', selectPlaceholderCode: true, columnSpan: 2, }, reasoning_effort: { key: 'reasoning_effort', label: 'com_endpoint_reasoning_effort', labelCode: true, description: 'com_endpoint_bedrock_reasoning_effort', descriptionCode: true, type: 'enum', default: ReasoningEffort.unset, component: 'slider', options: [ ReasoningEffort.unset, ReasoningEffort.low, ReasoningEffort.medium, ReasoningEffort.high, ], enumMappings: { [ReasoningEffort.unset]: 'com_ui_off', [ReasoningEffort.low]: 'com_ui_low', [ReasoningEffort.medium]: 'com_ui_medium', [ReasoningEffort.high]: 'com_ui_high', }, optionType: 'model', columnSpan: 4, }, }; const mistral: Record = { temperature: createDefinition(baseDefinitions.temperature, { default: 0.7, range: { min: 0, max: 1, step: 0.01 }, }), topP: createDefinition(baseDefinitions.topP, { range: { min: 0, max: 1, step: 0.01 }, }), }; const cohere: Record = { temperature: createDefinition(baseDefinitions.temperature, { default: 0.3, range: { min: 0, max: 1, step: 0.01 }, }), topP: createDefinition(baseDefinitions.topP, { default: 0.75, range: { min: 0.01, max: 0.99, step: 0.01 }, }), }; const meta: Record = { temperature: createDefinition(baseDefinitions.temperature, { default: 0.5, range: { min: 0, max: 1, step: 0.01 }, }), topP: createDefinition(baseDefinitions.topP, { default: 0.9, range: { min: 0, max: 1, step: 0.01 }, }), }; const google: Record = { /** 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: { min: googleSettings.temperature.min, max: googleSettings.temperature.max, step: googleSettings.temperature.step, }, }), topP: createDefinition(baseDefinitions.topP, { default: googleSettings.topP.default, range: { min: googleSettings.topP.min, max: googleSettings.topP.max, step: googleSettings.topP.step, }, }), topK: { key: 'topK', label: 'com_endpoint_top_k', labelCode: true, description: 'com_endpoint_google_topk', descriptionCode: true, type: 'number', default: googleSettings.topK.default, range: { min: googleSettings.topK.min, max: googleSettings.topK.max, step: googleSettings.topK.step, }, component: 'slider', optionType: 'model', columnSpan: 4, }, maxOutputTokens: { key: 'maxOutputTokens', label: 'com_endpoint_max_output_tokens', labelCode: true, type: 'number', component: 'input', description: 'com_endpoint_google_maxoutputtokens', descriptionCode: true, placeholder: 'com_endpoint_default', placeholderCode: true, default: googleSettings.maxOutputTokens.default, range: { min: googleSettings.maxOutputTokens.min, max: googleSettings.maxOutputTokens.max, step: googleSettings.maxOutputTokens.step, }, optionType: 'model', columnSpan: 2, }, thinking: { key: 'thinking', label: 'com_endpoint_thinking', labelCode: true, description: 'com_endpoint_google_thinking', descriptionCode: true, type: 'boolean', default: googleSettings.thinking.default, component: 'switch', optionType: 'conversation', showDefault: false, columnSpan: 2, }, thinkingBudget: { key: 'thinkingBudget', label: 'com_endpoint_thinking_budget', labelCode: true, description: 'com_endpoint_google_thinking_budget', descriptionCode: true, placeholder: 'com_ui_auto', placeholderCode: true, type: 'number', component: 'input', range: { min: googleSettings.thinkingBudget.min, max: googleSettings.thinkingBudget.max, step: googleSettings.thinkingBudget.step, }, optionType: 'conversation', columnSpan: 2, }, thinkingLevel: { key: 'thinkingLevel', label: 'com_endpoint_thinking_level', labelCode: true, description: 'com_endpoint_google_thinking_level', descriptionCode: true, type: 'enum', default: ThinkingLevel.unset, component: 'slider', options: [ ThinkingLevel.unset, ThinkingLevel.minimal, ThinkingLevel.low, ThinkingLevel.medium, ThinkingLevel.high, ], enumMappings: { [ThinkingLevel.unset]: 'com_ui_auto', [ThinkingLevel.minimal]: 'com_ui_minimal', [ThinkingLevel.low]: 'com_ui_low', [ThinkingLevel.medium]: 'com_ui_medium', [ThinkingLevel.high]: 'com_ui_high', }, optionType: 'conversation', columnSpan: 4, }, web_search: { key: 'web_search', label: 'com_endpoint_use_search_grounding', labelCode: true, description: 'com_endpoint_google_use_search_grounding', descriptionCode: true, type: 'boolean', default: false, component: 'switch', optionType: 'model', showDefault: false, columnSpan: 2, }, url_context: { key: 'url_context', label: 'com_endpoint_use_url_context', labelCode: true, description: 'com_endpoint_google_use_url_context', descriptionCode: true, type: 'boolean', default: false, component: 'switch', optionType: 'model', showDefault: false, columnSpan: 2, }, }; const googleConfig: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, google.maxContextTokens, google.maxOutputTokens, google.temperature, google.topP, google.topK, librechat.resendFiles, google.thinking, google.thinkingBudget, google.thinkingLevel, google.web_search, google.url_context, librechat.fileTokenLimit, ]; const googleCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const googleCol2: SettingsConfiguration = [ google.maxContextTokens, google.maxOutputTokens, google.temperature, google.topP, google.topK, librechat.resendFiles, google.thinking, google.thinkingBudget, google.thinkingLevel, google.web_search, google.url_context, librechat.fileTokenLimit, ]; const openAI: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, librechat.maxContextTokens, openAIParams.max_tokens, openAIParams.temperature, openAIParams.top_p, openAIParams.frequency_penalty, openAIParams.presence_penalty, baseDefinitions.stop, librechat.resendFiles, librechat.imageDetail, openAIParams.web_search, openAIParams.reasoning_effort, openAIParams.useResponsesApi, openAIParams.reasoning_summary, openAIParams.reasoning_mode, openAIParams.reasoning_context, openAIParams.verbosity, openAIParams.disableStreaming, librechat.fileTokenLimit, ]; const openRouter: SettingsConfiguration = [ ...openAI, anthropic.promptCache, anthropic.promptCacheTtl, ]; const openAICol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const openAICol2: SettingsConfiguration = [ librechat.maxContextTokens, openAIParams.max_tokens, openAIParams.temperature, openAIParams.top_p, openAIParams.frequency_penalty, openAIParams.presence_penalty, baseDefinitions.stop, librechat.resendFiles, librechat.imageDetail, openAIParams.reasoning_effort, openAIParams.reasoning_summary, openAIParams.reasoning_mode, openAIParams.reasoning_context, openAIParams.verbosity, openAIParams.useResponsesApi, openAIParams.web_search, openAIParams.disableStreaming, librechat.fileTokenLimit, ]; const anthropicConfig: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, librechat.maxContextTokens, anthropic.maxOutputTokens, anthropic.temperature, anthropic.topP, anthropic.topK, librechat.resendFiles, anthropic.promptCache, anthropic.promptCacheTtl, anthropic.thinking, anthropic.thinkingBudget, anthropic.effort, anthropic.thinkingDisplay, anthropic.web_search, librechat.fileTokenLimit, ]; const anthropicCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const anthropicCol2: SettingsConfiguration = [ librechat.maxContextTokens, anthropic.maxOutputTokens, anthropic.temperature, anthropic.topP, anthropic.topK, librechat.resendFiles, anthropic.promptCache, anthropic.promptCacheTtl, anthropic.thinking, anthropic.thinkingBudget, anthropic.effort, anthropic.thinkingDisplay, anthropic.web_search, librechat.fileTokenLimit, ]; const bedrockAnthropic: SettingsConfiguration = [ librechat.modelLabel, bedrock.system, librechat.maxContextTokens, bedrock.maxTokens, bedrock.temperature, bedrock.topP, bedrock.topK, baseDefinitions.stop, librechat.resendFiles, bedrock.region, bedrock.promptCache, bedrock.promptCacheTtl, anthropic.thinking, anthropic.thinkingBudget, anthropic.effort, anthropic.thinkingDisplay, librechat.fileTokenLimit, ]; const bedrockMistral: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, librechat.maxContextTokens, bedrock.maxTokens, mistral.temperature, mistral.topP, librechat.resendFiles, bedrock.region, librechat.fileTokenLimit, ]; const bedrockCohere: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, librechat.maxContextTokens, bedrock.maxTokens, cohere.temperature, cohere.topP, librechat.resendFiles, bedrock.region, librechat.fileTokenLimit, ]; const bedrockGeneral: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, librechat.maxContextTokens, meta.temperature, meta.topP, librechat.resendFiles, bedrock.region, bedrock.promptCache, bedrock.promptCacheTtl, librechat.fileTokenLimit, ]; const bedrockAnthropicCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, bedrock.system, baseDefinitions.stop, ]; const bedrockAnthropicCol2: SettingsConfiguration = [ librechat.maxContextTokens, bedrock.maxTokens, bedrock.temperature, bedrock.topP, bedrock.topK, librechat.resendFiles, bedrock.region, bedrock.promptCache, bedrock.promptCacheTtl, anthropic.thinking, anthropic.thinkingBudget, anthropic.effort, anthropic.thinkingDisplay, librechat.fileTokenLimit, ]; const bedrockMistralCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const bedrockMistralCol2: SettingsConfiguration = [ librechat.maxContextTokens, bedrock.maxTokens, mistral.temperature, mistral.topP, librechat.resendFiles, bedrock.region, librechat.fileTokenLimit, ]; const bedrockCohereCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const bedrockCohereCol2: SettingsConfiguration = [ librechat.maxContextTokens, bedrock.maxTokens, cohere.temperature, cohere.topP, librechat.resendFiles, bedrock.region, librechat.fileTokenLimit, ]; const bedrockGeneralCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const bedrockGeneralCol2: SettingsConfiguration = [ librechat.maxContextTokens, meta.temperature, meta.topP, librechat.resendFiles, bedrock.region, bedrock.promptCache, bedrock.promptCacheTtl, librechat.fileTokenLimit, ]; const bedrockZAI: SettingsConfiguration = [ librechat.modelLabel, librechat.promptPrefix, librechat.maxContextTokens, meta.temperature, meta.topP, librechat.resendFiles, bedrock.region, bedrock.reasoning_effort, librechat.fileTokenLimit, ]; const bedrockZAICol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, librechat.promptPrefix, ]; const bedrockZAICol2: SettingsConfiguration = [ librechat.maxContextTokens, meta.temperature, meta.topP, librechat.resendFiles, bedrock.region, bedrock.reasoning_effort, librechat.fileTokenLimit, ]; const bedrockMoonshot: SettingsConfiguration = [ librechat.modelLabel, bedrock.system, librechat.maxContextTokens, createDefinition(bedrock.maxTokens, { default: 16384, }), bedrock.temperature, bedrock.topP, baseDefinitions.stop, librechat.resendFiles, bedrock.region, bedrock.reasoning_effort, librechat.fileTokenLimit, ]; const bedrockMoonshotCol1: SettingsConfiguration = [ baseDefinitions.model as SettingDefinition, librechat.modelLabel, bedrock.system, baseDefinitions.stop, ]; const bedrockMoonshotCol2: SettingsConfiguration = [ librechat.maxContextTokens, createDefinition(bedrock.maxTokens, { default: 16384, }), bedrock.temperature, bedrock.topP, librechat.resendFiles, bedrock.region, bedrock.reasoning_effort, librechat.fileTokenLimit, ]; export const paramSettings: Record = { [EModelEndpoint.openAI]: openAI, [EModelEndpoint.azureOpenAI]: openAI, [EModelEndpoint.custom]: openAI, [Providers.OPENROUTER]: openRouter, [EModelEndpoint.anthropic]: anthropicConfig, [`${EModelEndpoint.bedrock}-${BedrockProviders.Anthropic}`]: bedrockAnthropic, [`${EModelEndpoint.bedrock}-${BedrockProviders.MistralAI}`]: bedrockMistral, [`${EModelEndpoint.bedrock}-${BedrockProviders.Cohere}`]: bedrockCohere, [`${EModelEndpoint.bedrock}-${BedrockProviders.Meta}`]: bedrockGeneral, [`${EModelEndpoint.bedrock}-${BedrockProviders.AI21}`]: bedrockGeneral, [`${EModelEndpoint.bedrock}-${BedrockProviders.Amazon}`]: bedrockGeneral, [`${EModelEndpoint.bedrock}-${BedrockProviders.DeepSeek}`]: bedrockGeneral, [`${EModelEndpoint.bedrock}-${BedrockProviders.Moonshot}`]: bedrockMoonshot, [`${EModelEndpoint.bedrock}-${BedrockProviders.MoonshotAI}`]: bedrockMoonshot, [`${EModelEndpoint.bedrock}-${BedrockProviders.OpenAI}`]: bedrockGeneral, [`${EModelEndpoint.bedrock}-${BedrockProviders.ZAI}`]: bedrockZAI, [EModelEndpoint.google]: googleConfig, }; /** * Maps effective backend param names for OpenAI-compatible/Azure endpoints (as deleted from * `llmConfig` via `dropParams`, e.g. `maxTokens`) to their corresponding UI/conversation keys * (e.g. `max_tokens`). Native providers (anthropic, google, bedrock, ...) already render these * same camelCase names as their UI key (e.g. `topP`), so this alias must only be applied to * OpenAI-compatible parameter sets — see `resolveDropParamsUIKeys`. */ const dropParamsBackendToUIKey: Record = { maxTokens: 'max_tokens', topP: 'top_p', frequencyPenalty: 'frequency_penalty', presencePenalty: 'presence_penalty', }; /** Endpoint keys whose parameter settings render the OpenAI-compatible (snake_case) UI keys. */ const openAILikeParamEndpointKeys: Set = new Set([ EModelEndpoint.openAI, EModelEndpoint.azureOpenAI, EModelEndpoint.custom, Providers.OPENROUTER, ]); /** * Normalizes an admin-configured `dropParams` list into the UI/conversation keys used to hide * the matching controls in the settings panels. `endpointKey` should be the same key used to * resolve the panel's parameter settings (e.g. `overriddenEndpointKey`); the backend-name alias * is only applied for OpenAI-compatible endpoints, since native providers (anthropic, google, * bedrock, ...) already use these backend names as their UI key. */ export function resolveDropParamsUIKeys( dropParams: string[] | undefined, endpointKey: string, ): Set { if (!dropParams || dropParams.length === 0) { return new Set(); } if (!openAILikeParamEndpointKeys.has(endpointKey)) { return new Set(dropParams); } return new Set(dropParams.map((param) => dropParamsBackendToUIKey[param] ?? param)); } const openAIColumns = { col1: openAICol1, col2: openAICol2, }; const bedrockGeneralColumns = { col1: bedrockGeneralCol1, col2: bedrockGeneralCol2, }; export const presetSettings: Record< string, | { col1: SettingsConfiguration; col2: SettingsConfiguration; } | undefined > = { [EModelEndpoint.openAI]: openAIColumns, [EModelEndpoint.azureOpenAI]: openAIColumns, [EModelEndpoint.custom]: openAIColumns, [Providers.OPENROUTER]: { col1: openAICol1, col2: [...openAICol2, anthropic.promptCache, anthropic.promptCacheTtl], }, [EModelEndpoint.anthropic]: { col1: anthropicCol1, col2: anthropicCol2, }, [`${EModelEndpoint.bedrock}-${BedrockProviders.Anthropic}`]: { col1: bedrockAnthropicCol1, col2: bedrockAnthropicCol2, }, [`${EModelEndpoint.bedrock}-${BedrockProviders.MistralAI}`]: { col1: bedrockMistralCol1, col2: bedrockMistralCol2, }, [`${EModelEndpoint.bedrock}-${BedrockProviders.Cohere}`]: { col1: bedrockCohereCol1, col2: bedrockCohereCol2, }, [`${EModelEndpoint.bedrock}-${BedrockProviders.Meta}`]: bedrockGeneralColumns, [`${EModelEndpoint.bedrock}-${BedrockProviders.AI21}`]: bedrockGeneralColumns, [`${EModelEndpoint.bedrock}-${BedrockProviders.Amazon}`]: bedrockGeneralColumns, [`${EModelEndpoint.bedrock}-${BedrockProviders.DeepSeek}`]: bedrockGeneralColumns, [`${EModelEndpoint.bedrock}-${BedrockProviders.Moonshot}`]: { col1: bedrockMoonshotCol1, col2: bedrockMoonshotCol2, }, [`${EModelEndpoint.bedrock}-${BedrockProviders.MoonshotAI}`]: { col1: bedrockMoonshotCol1, col2: bedrockMoonshotCol2, }, [`${EModelEndpoint.bedrock}-${BedrockProviders.OpenAI}`]: bedrockGeneralColumns, [`${EModelEndpoint.bedrock}-${BedrockProviders.ZAI}`]: { col1: bedrockZAICol1, col2: bedrockZAICol2, }, [EModelEndpoint.google]: { col1: googleCol1, col2: googleCol2, }, }; export const agentParamSettings: Record = Object.entries( presetSettings, ).reduce>((acc, [key, value]) => { if (value) { acc[key] = value.col2; } return acc; }, {}); export const reasoningSettingKeys = [ 'reasoning_effort', 'effort', 'thinkingLevel', 'thinkingBudget', ] as const; export type ReasoningSettingKey = (typeof reasoningSettingKeys)[number]; const findReasoningSetting = ( settings: SettingsConfiguration, key: ReasoningSettingKey, ): SettingDefinition | undefined => settings.find((setting) => setting.key === key); const knownReasoningProviderEndpoints: Record = { [EModelEndpoint.openAI]: true, [EModelEndpoint.azureOpenAI]: true, [EModelEndpoint.anthropic]: true, [EModelEndpoint.bedrock]: true, [`${EModelEndpoint.bedrock}-${BedrockProviders.Anthropic}`]: true, [`${EModelEndpoint.bedrock}-${BedrockProviders.Moonshot}`]: true, [`${EModelEndpoint.bedrock}-${BedrockProviders.MoonshotAI}`]: true, [`${EModelEndpoint.bedrock}-${BedrockProviders.ZAI}`]: true, }; const isKnownReasoningProvider = (endpoint?: string | null): boolean => endpoint != null && knownReasoningProviderEndpoints[endpoint] === true; const isKnownOpenAIReasoningModel = (model: string): boolean => /(?:^|[/._-])(?:o[134](?:[-.]|$)|gpt[-.]?(?:[5-9]|\d{2,})(?:[-.]|$)|gpt[-.]?oss(?:[-.]|$))/i.test( model, ); const isManualClaudeThinkingModel = (model: string): boolean => /claude-3[-.]7|claude-(?:sonnet|opus|haiku)-[4-9]|claude-[4-9](?:[-.][0-9]+)?-(?:sonnet|opus|haiku)/i.test( model, ); /** * Selects the request-scoped reasoning control supported by the active model. * Custom and OpenRouter endpoints remain definition-driven because their model * catalogs are deployment-owned and cannot be inferred safely from a name. */ export function resolveReasoningSetting({ endpoint, model, settings, }: { endpoint: string; model?: string | null; settings: SettingsConfiguration; }): SettingDefinition | undefined { if (!model) { return undefined; } if (endpoint === EModelEndpoint.google) { if (getGoogleThinkingBudgetBounds(model) != null) { return findReasoningSetting(settings, 'thinkingBudget'); } if (/gemini-(?:[3-9]|\d{2,})|gemma-(?:[4-9]|\d{2,})/i.test(model)) { return findReasoningSetting(settings, 'thinkingLevel'); } return undefined; } const isAnthropicEndpoint = endpoint === EModelEndpoint.anthropic || endpoint === `${EModelEndpoint.bedrock}-${BedrockProviders.Anthropic}` || (endpoint === EModelEndpoint.bedrock && getModelKey(endpoint, model) === BedrockProviders.Anthropic); if (isAnthropicEndpoint) { if (supportsAdaptiveThinking(model)) { return findReasoningSetting(settings, 'effort'); } if (isManualClaudeThinkingModel(model)) { return findReasoningSetting(settings, 'thinkingBudget'); } return undefined; } if (endpoint === EModelEndpoint.azureOpenAI) { /* Azure deployment names are administrator-defined and often contain no * model-family signal. An explicit resolved parameter definition is the * capability evidence available to this layer. */ return findReasoningSetting(settings, 'reasoning_effort'); } if (endpoint === EModelEndpoint.openAI) { return isKnownOpenAIReasoningModel(model) ? findReasoningSetting(settings, 'reasoning_effort') : undefined; } return reasoningSettingKeys.reduce( (resolved, key) => resolved ?? findReasoningSetting(settings, key), undefined, ); } /** Narrows an enum reasoning setting to the options a request-scoped override * can carry. A deployment may declare provider values the override schema does * not accept; offering them rendered a choice that could never be submitted. */ const toSubmittableReasoningSetting = ( setting: SettingDefinition | undefined, ): SettingDefinition | undefined => { if (setting?.options == null) { return setting; } const options = setting.options.filter( (option) => reasoningOverrideSchema.safeParse({ key: setting.key, value: option }).success, ); if (options.length === setting.options.length) { return setting; } return options.length === 0 ? undefined : { ...setting, options }; }; /** * The definitions `resolveReasoningSettingForTarget` should see for one model: the endpoint's own, * plus the efforts the model's Azure deployment declares. `model` comes from the request, so the * lookup only trusts an array, never a property inherited by a model named `constructor`. */ export function getReasoningParamDefinitions( endpointConfig: | { customParams?: { paramDefinitions?: Partial[] | null } | null; modelReasoningEfforts?: Record; } | null | undefined | false, model?: string | null, ): Partial[] | null | undefined { if (!endpointConfig) { return undefined; } const paramDefinitions = endpointConfig.customParams?.paramDefinitions; const efforts = model == null ? undefined : endpointConfig.modelReasoningEfforts?.[model]; if (!Array.isArray(efforts)) { return paramDefinitions; } const options = [ ReasoningEffort.unset, ...efforts.filter((effort) => effort !== ReasoningEffort.unset), ]; return [...(paramDefinitions ?? []), { key: 'reasoning_effort', options }]; } /** Builds the effective reasoning definition shared by the composer and the server. * A model-spec lock is part of capability resolution, not a caller-only UI check: * both surfaces must see the same unavailable result before an override is staged. */ export function resolveReasoningSettingForTarget({ endpoint, model, isAgent = false, defaultParamsEndpoint, reasoningFormat, paramDefinitions, blockedReasoningKeys, modelReasoning, }: { endpoint: string; model?: string | null; isAgent?: boolean; defaultParamsEndpoint?: string | null; reasoningFormat?: ReasoningParameterFormat | null; paramDefinitions?: Partial[] | null; blockedReasoningKeys?: ReadonlySet; /** Provider-reported efforts for `model`; see {@link applyModelAwareDefaults}. */ modelReasoning?: TModelReasoning | null; }): SettingDefinition | undefined { if (!model || reasoningFormat === ReasoningParameterFormat.disabled) { return undefined; } const [combinedSettingsKey, endpointSettingsKey] = getSettingsKeys(endpoint, model); const effectiveDefaultParamsEndpoint = defaultParamsEndpoint ?? endpointSettingsKey; const hasExplicitCapability = (paramDefinitions?.some((setting) => reasoningSettingKeys.includes(setting.key as ReasoningSettingKey), ) ?? false) || reasoningFormat != null || isKnownReasoningProvider(effectiveDefaultParamsEndpoint); const usesGenericSettings = endpoint === EModelEndpoint.custom || endpoint === Providers.OPENROUTER || paramSettings[endpoint] == null; if (usesGenericSettings && !hasExplicitCapability) { return undefined; } const baseSettings = isAgent ? (agentParamSettings[combinedSettingsKey] ?? agentParamSettings[effectiveDefaultParamsEndpoint] ?? agentParamSettings[endpointSettingsKey] ?? paramSettings[combinedSettingsKey] ?? paramSettings[effectiveDefaultParamsEndpoint] ?? paramSettings[endpointSettingsKey] ?? []) : (paramSettings[combinedSettingsKey] ?? paramSettings[effectiveDefaultParamsEndpoint] ?? paramSettings[endpointSettingsKey] ?? []); const customSettingsByKey = new Map( (paramDefinitions ?? []).flatMap((setting) => setting.key == null ? [] : ([[setting.key, setting]] as const), ), ); const settings = applyModelAwareDefaults( baseSettings, effectiveDefaultParamsEndpoint, model, undefined, effectiveModelReasoning(modelReasoning, paramDefinitions), ).map((setting) => { const override = customSettingsByKey.get(setting.key); return override == null ? setting : { ...setting, ...override }; }); const declaredReasoningSettings = (paramDefinitions ?? []) .filter((setting) => reasoningSettingKeys.includes(setting.key as ReasoningSettingKey)) .filter((setting) => !settings.some((baseSetting) => baseSetting.key === setting.key)) .map((setting) => setting as SettingDefinition); const effectiveSettings = [...settings, ...declaredReasoningSettings]; const explicitReasoningKey = paramDefinitions?.find((setting) => reasoningSettingKeys.includes(setting.key as ReasoningSettingKey), )?.key as ReasoningSettingKey | undefined; if (explicitReasoningKey != null) { const explicitSetting = findReasoningSetting(effectiveSettings, explicitReasoningKey); return explicitSetting != null && blockedReasoningKeys?.has(explicitSetting.key) ? undefined : toSubmittableReasoningSetting(explicitSetting); } const resolutionEndpoint = isKnownReasoningProvider(effectiveDefaultParamsEndpoint) ? effectiveDefaultParamsEndpoint : endpoint; if ( resolutionEndpoint === EModelEndpoint.azureOpenAI && !paramDefinitions?.some((setting) => reasoningSettingKeys.includes(setting.key as ReasoningSettingKey), ) ) { return undefined; } const resolvedSetting = resolveReasoningSetting({ endpoint: resolutionEndpoint, model, settings: effectiveSettings, }); return resolvedSetting != null && blockedReasoningKeys?.has(resolvedSetting.key) ? undefined : toSubmittableReasoningSetting(resolvedSetting); } /** Confirms that a stored one-shot override still belongs to the selected * model and remains inside its advertised enum or numeric range. */ export function isReasoningOverrideSupported( reasoningOverride: TReasoningOverride, setting: SettingDefinition | undefined, ): boolean { if (setting?.key !== reasoningOverride.key) { return false; } if (typeof reasoningOverride.value === 'number') { return ( setting.range == null || clampSettingRange(reasoningOverride.value, setting.range) === reasoningOverride.value ); } return setting.options == null || setting.options.includes(reasoningOverride.value); } const knownReasoningEfforts: ReadonlySet = new Set(Object.values(ReasoningEffort)); /** * Whether a stored or submitted effort is acceptable for a model, by the same * rules {@link narrowOpenRouterEfforts} uses to build the control: anything is * accepted while the capabilities are unknown, Auto always is (it sends no * effort), and otherwise the effort must be one the provider reports, with * `none` refused for a model whose reasoning is mandatory. */ export function isOpenRouterEffortSupported( effort: string, modelReasoning: TModelReasoning | null | undefined, ): boolean { if (modelReasoning === undefined || effort === ReasoningEffort.unset) { return true; } if (modelReasoning === null) { return false; } if (modelReasoning.mandatory === true && effort === ReasoningEffort.none) { return false; } return modelReasoning.efforts.includes(effort); } /** Whether an administrator defined `reasoning_effort` for the endpoint. */ export function hasExplicitReasoningEffort( paramDefinitions?: Partial[] | null, ): boolean { return paramDefinitions?.some((setting) => setting.key === 'reasoning_effort') === true; } /** * An administrator-defined `reasoning_effort` is authoritative for its endpoint, * so the provider's per-model efforts must not narrow or remove it. */ export function effectiveModelReasoning( modelReasoning: TModelReasoning | null | undefined, paramDefinitions?: Partial[] | null, ): TModelReasoning | null | undefined { return hasExplicitReasoningEffort(paramDefinitions) ? undefined : modelReasoning; } /** * The efforts to offer for one OpenRouter model. Without the endpoint's capabilities, because * the request is still loading or failed, nothing is offered (`null`): a choice made from the * generic list could be refused by the server. Once they are known the model's own efforts * apply, and a model the provider does not list keeps the generic list (`undefined`). An * administrator-defined `reasoning_effort` is never narrowed or hidden. */ export function resolveModelReasoning({ capabilities, endpoint, model, paramDefinitions, }: { capabilities: TReasoningCapabilityMap | undefined; endpoint: string; model: string; paramDefinitions?: Partial[] | null; }): TModelReasoning | null | undefined { const reported = capabilities == null ? null : getModelReasoning(capabilities, endpoint, model); return effectiveModelReasoning(reported, paramDefinitions); } /** * Looks one model up in an endpoint's provider-reported reasoning efforts, for * {@link applyModelAwareDefaults}. `undefined` means unknown: the endpoint was not resolved, * or the provider does not list the model (an alias such as `~openai/gpt-latest`, or a model * released since the catalog was read), so the generic efforts stay. `null` means the provider * lists the model and exposes no effort selection for it. A routing variant (`model:nitro`) is * matched to its base model. */ export function getModelReasoning( capabilities: TReasoningCapabilityMap | undefined, endpoint: string, model: string, ): TModelReasoning | undefined | null { /** Model ids and endpoint names are unrestricted strings, so only own properties count: an id * such as `constructor` must not resolve to a member of `Object.prototype`. */ const own = (record: Record | undefined, key: string): T | undefined => record != null && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined; const models = own(capabilities, endpoint); const listed = own(models, model) ?? own(models, model.split(':')[0]); if (listed == null) { return undefined; } return listed.efforts.length === 0 ? null : listed; } /** * Narrows the effort setting to what one OpenRouter model accepts. A model with * no reasoning metadata, or none this client knows, has no effort control: the * provider says to omit effort selection then, and sending one is rejected. * `none` is dropped when the model's reasoning is mandatory. Auto stays because * it sends no effort at all. */ function narrowOpenRouterEfforts( settings: SettingsConfiguration, modelReasoning: TModelReasoning | null, ): SettingsConfiguration { const supported = (modelReasoning?.efforts ?? []).filter( (effort) => knownReasoningEfforts.has(effort) && !(modelReasoning?.mandatory === true && effort === ReasoningEffort.none), ); return settings.flatMap((setting) => { if (setting.key !== 'reasoning_effort') { return [setting]; } if (supported.length === 0) { return []; } const options = setting.options?.filter( (option) => option === ReasoningEffort.unset || supported.includes(String(option)), ); return [{ ...setting, options }]; }); } /** * Resolves model-aware defaults for a settings configuration before rendering. * Google's `maxOutputTokens` default depends on the selected Gemini model so that * current models (2.5 and 3+) surface their 64K output limit instead of the legacy 8K value. * Anthropic prompt-cache controls are only surfaced for models that support them. * * `modelReasoning` is the provider-reported effort set for the model on an OpenRouter * endpoint: `undefined` while it is unknown (the generic list is kept), `null` when the * provider reports no reasoning for the model, otherwise the efforts to offer. */ export function applyModelAwareDefaults( settings: SettingsConfiguration, endpoint: string, model?: string, responsesApiRouting?: ResponsesApiRouting, modelReasoning?: TModelReasoning | null, ): SettingsConfiguration { const resolved = applyModelFamilyDefaults(settings, endpoint, model, responsesApiRouting); return model && endpoint === Providers.OPENROUTER && modelReasoning !== undefined ? narrowOpenRouterEfforts(resolved, modelReasoning) : resolved; } function applyModelFamilyDefaults( settings: SettingsConfiguration, endpoint: string, model?: string, responsesApiRouting?: ResponsesApiRouting, ): SettingsConfiguration { if (!model) { return settings; } if (/^grok-4[.-]7(?:$|[-:])/.test(model.split('/').pop() ?? '')) { return settings.map((setting) => setting.key === 'reasoning_effort' ? { ...setting, options: [ ReasoningEffort.unset, ReasoningEffort.low, ReasoningEffort.medium, ReasoningEffort.high, ReasoningEffort.xhigh, ], } : setting, ); } const tier = gpt6Tier(model); if (tier === 'sol' || tier === 'luna') { return settings.map((setting) => { if (setting.key === 'reasoning_effort') { return { ...setting, options: setting.options?.filter((effort) => effort !== ReasoningEffort.minimal), }; } /** Match the native backend's unset default without writing into stored * settings. Explicit false still overrides this rendered default. */ if (setting.key === 'useResponsesApi') { const route = (value?: boolean) => resolveEffectiveUseResponsesApi({ endpoint, model, routing: responsesApiRouting, value }); return { ...setting, default: route() ?? false, enumMappings: { true: route(true) ?? true, false: route(false) ?? false }, }; } return setting; }); } if (hasAlwaysOnThinking(model)) { return settings.filter( (setting) => !['thinking', 'thinkingBudget', 'temperature', 'topP', 'topK'].includes(setting.key), ); } /** Sonnet 5.5+ keeps the toggle: "off" maps to its `between_tools` floor. */ if (hasBetweenToolsThinkingFloor(model)) { return settings .map((setting) => setting.key === 'thinking' ? { ...setting, description: 'com_endpoint_anthropic_thinking_between_tools' } : setting, ) .filter( (setting) => !['thinkingBudget', 'temperature', 'topP', 'topK'].includes(setting.key), ); } /** Haiku 5.5+ keeps the toggle ("off" sends `disabled`) but rejects budgets and sampling. */ if (hasAdaptiveHaikuThinking(model)) { return settings.filter( (setting) => !['thinkingBudget', 'temperature', 'topP', 'topK'].includes(setting.key), ); } const modelAwareSettings = endpoint === EModelEndpoint.google ? 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)) { return modelAwareSettings; } return modelAwareSettings.filter( (setting) => setting.key !== 'promptCache' && setting.key !== 'promptCacheTtl', ); }