@lobehub/lobehub 2.0.0-next.262 → 2.0.0-next.263

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.263](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.262...v2.0.0-next.263)
+
+<sup>Released on **2026-01-11**</sup>
+
+#### 💄 Styles
+
+- **misc**: ModelParse support to get model settings params & Customize extendParams UI.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: ModelParse support to get model settings params & Customize extendParams UI, closes [#11185](https://github.com/lobehub/lobe-chat/issues/11185) ([94e985a](https://github.com/lobehub/lobe-chat/commit/94e985a))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.262](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.261...v2.0.0-next.262)
 
 <sup>Released on **2026-01-11**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "ModelParse support to get model settings params & Customize extendParams UI."
+      ]
+    },
+    "date": "2026-01-11",
+    "version": "2.0.0-next.263"
+  },
   {
     "children": {
       "improvements": [

package/locales/zh-CN/chat.json

@@ -63,6 +63,7 @@
   "extendParams.reasoningEffort.title": "推理强度",
   "extendParams.textVerbosity.title": "输出详细程度",
   "extendParams.thinking.title": "深度思考开关",
+  "extendParams.thinkingBudget.title": "思考预算",
   "extendParams.thinkingLevel.title": "思考水平",
   "extendParams.title": "模型扩展功能",
   "extendParams.urlContext.desc": "开启后会自动解析网页链接，提取网页内容作为上下文",

package/locales/zh-CN/modelProvider.json

@@ -194,6 +194,26 @@
   "providerModels.item.modelConfig.deployName.title": "模型部署名称",
   "providerModels.item.modelConfig.displayName.placeholder": "请输入模型的展示名称，例如 ChatGPT、GPT-4 等",
   "providerModels.item.modelConfig.displayName.title": "模型展示名称",
+  "providerModels.item.modelConfig.extendParams.extra": "根据模型支持的能力选择扩展参数，将鼠标悬停在选项上可预览配置。错误配置可能导致请求失败。",
+  "providerModels.item.modelConfig.extendParams.options.disableContextCaching.hint": "适用于 Claude 系列，可降低成本并加快响应速度。",
+  "providerModels.item.modelConfig.extendParams.options.enableReasoning.hint": "适用于 Claude、DeepSeek 等推理模型，开启深度推理能力。",
+  "providerModels.item.modelConfig.extendParams.options.gpt5ReasoningEffort.hint": "适用于 GPT-5 系列，控制推理力度。",
+  "providerModels.item.modelConfig.extendParams.options.gpt5_1ReasoningEffort.hint": "适用于 GPT-5.1 系列，控制推理力度。",
+  "providerModels.item.modelConfig.extendParams.options.gpt5_2ProReasoningEffort.hint": "适用于 GPT-5.2 Pro 系列，控制推理力度。",
+  "providerModels.item.modelConfig.extendParams.options.gpt5_2ReasoningEffort.hint": "适用于 GPT-5.2 系列，控制推理力度。",
+  "providerModels.item.modelConfig.extendParams.options.imageAspectRatio.hint": "适用于 Gemini 生图模型，控制生成图像的纵横比。",
+  "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "适用于 Gemini 3 生图模型，控制生成图像的分辨率。",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "适用于 Claude、Qwen3 等模型，控制推理 token 预算。",
+  "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "适用于 OpenAI 等支持推理的模型，控制推理强度。",
+  "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "适用于 GPT-5 系列，控制输出详尽程度。",
+  "providerModels.item.modelConfig.extendParams.options.thinking.hint": "适用于部分豆包系列，允许模型自行决定是否思考。",
+  "providerModels.item.modelConfig.extendParams.options.thinkingBudget.hint": "适用于 Gemini 系列，控制思考预算。",
+  "providerModels.item.modelConfig.extendParams.options.thinkingLevel.hint": "适用于 Gemini 3 Flash Preview 模型，控制思考深度。",
+  "providerModels.item.modelConfig.extendParams.options.thinkingLevel2.hint": "适用于 Gemini 3 Pro Preview 模型，控制思考深度。",
+  "providerModels.item.modelConfig.extendParams.options.urlContext.hint": "适用于 Gemini 系列，支持 URL 上下文输入。",
+  "providerModels.item.modelConfig.extendParams.placeholder": "选择需要启用的扩展参数",
+  "providerModels.item.modelConfig.extendParams.previewFallback": "暂不支持预览",
+  "providerModels.item.modelConfig.extendParams.title": "扩展功能参数",
   "providerModels.item.modelConfig.files.extra": "当前文件上传实现仅为一种 Hack 方案，仅限自行尝试。完整文件上传能力请等待后续实现",
   "providerModels.item.modelConfig.files.title": "支持文件上传",
   "providerModels.item.modelConfig.functionCall.extra": "此配置将仅开启模型使用技能的能力，进而可以为模型添加技能。但是否支持真正使用技能完全取决于模型本身，请自行测试的可用性",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.262",
+  "version": "2.0.0-next.263",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/database/src/models/aiModel.ts

@@ -78,6 +78,7 @@ export class AiModelModel {
         parameters: aiModels.parameters,
         pricing: aiModels.pricing,
         releasedAt: aiModels.releasedAt,
+        settings: aiModels.settings,
         source: aiModels.source,
         type: aiModels.type,
       })
@@ -105,6 +106,7 @@ export class AiModelModel {
         parameters: aiModels.parameters,
         providerId: aiModels.providerId,
         releasedAt: aiModels.releasedAt,
+        settings: aiModels.settings,
         sort: aiModels.sort,
         source: aiModels.source,
         type: aiModels.type,

package/packages/database/src/repositories/aiInfra/index.test.ts

@@ -4,7 +4,7 @@ import type {
   AiProviderRuntimeConfig,
   EnabledProvider,
 } from '@lobechat/types';
-import { AiProviderModelListItem, EnabledAiModel } from 'model-bank';
+import { AiProviderModelListItem, EnabledAiModel, ExtendParamsType } from 'model-bank';
 import { DEFAULT_MODEL_PROVIDER_LIST } from 'model-bank/modelProviders';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -801,6 +801,46 @@ describe('AiInfraRepos', () => {
       expect(merged?.settings).toEqual({ searchImpl: 'tool', searchProvider: 'google' });
     });
 
+    it('should merge builtin settings with user-provided extend params', async () => {
+      const mockProviders = [
+        { enabled: true, id: 'openai', name: 'OpenAI', source: 'builtin' as const },
+      ];
+
+      const userModel: EnabledAiModel = {
+        abilities: {},
+        id: 'gpt-4',
+        providerId: 'openai',
+        enabled: true,
+        type: 'chat',
+        settings: { extendParams: ['reasoningEffort'] as ExtendParamsType[] },
+      };
+
+      const builtinModel = {
+        id: 'gpt-4',
+        enabled: true,
+        type: 'chat' as const,
+        settings: {
+          extendParams: ['thinking'] as ExtendParamsType[],
+          searchImpl: 'params',
+          searchProvider: 'builtin-provider',
+        },
+      };
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue([userModel]);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([builtinModel]);
+
+      const result = await repo.getEnabledModels();
+
+      const merged = result.find((m) => m.id === 'gpt-4');
+      expect(merged).toBeDefined();
+      expect(merged?.settings).toEqual({
+        extendParams: ['reasoningEffort'],
+        searchImpl: 'params',
+        searchProvider: 'builtin-provider',
+      });
+    });
+
     it('should have no settings when both user and builtin have no settings', async () => {
       const mockProviders = [
         { enabled: true, id: 'openai', name: 'OpenAI', source: 'builtin' as const },

package/packages/database/src/repositories/aiInfra/index.ts

@@ -226,7 +226,9 @@ export class AiInfraRepos {
               enabled: typeof user.enabled === 'boolean' ? user.enabled : item.enabled,
               id: item.id,
               providerId: provider.id,
-              settings: user.settings || item.settings,
+              settings: isEmpty(user.settings)
+                ? item.settings
+                : merge(item.settings || {}, user.settings || {}),
               sort: user.sort || undefined,
               type: user.type || item.type,
             };

package/packages/model-runtime/src/providers/openrouter/index.test.ts

@@ -162,14 +162,14 @@ describe('LobeOpenRouterAI - custom features', () => {
       );
     });
 
-    it('should add empty reasoning object when thinking is not enabled', async () => {
+    it('should not add reasoning object when thinking is not enabled', async () => {
       await instance.chat({
         messages: [{ content: 'Hello', role: 'user' }],
         model: 'openai/gpt-4',
       });
 
       expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({ reasoning: {} }),
+        expect.not.objectContaining({ reasoning: expect.anything() }),
         expect.anything(),
       );
     });
@@ -204,22 +204,6 @@ describe('LobeOpenRouterAI - custom features', () => {
       );
     });
 
-    it('should cap reasoning tokens to max_tokens - 1 when budget exceeds max_tokens', async () => {
-      await instance.chat({
-        messages: [{ content: 'Think about this', role: 'user' }],
-        model: 'openai/gpt-4',
-        max_tokens: 1000,
-        thinking: { type: 'enabled', budget_tokens: 2000 },
-      });
-
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reasoning: { max_tokens: 999 }, // min(2000, 1000 - 1) = 999
-        }),
-        expect.anything(),
-      );
-    });
-
     it('should use model maxOutput when no max_tokens provided', async () => {
       // Mock OpenRouterModels to have a specific maxOutput
       const { openrouter } = await import('model-bank');
@@ -241,21 +225,6 @@ describe('LobeOpenRouterAI - custom features', () => {
       }
     });
 
-    it('should use default 32000 when no max_tokens or model maxOutput available', async () => {
-      await instance.chat({
-        messages: [{ content: 'Think about this', role: 'user' }],
-        model: 'unknown/model-without-config',
-        thinking: { type: 'enabled', budget_tokens: 50000 },
-      });
-
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reasoning: { max_tokens: 31999 }, // min(50000, 32000 - 1) = 31999
-        }),
-        expect.anything(),
-      );
-    });
-
     it('should combine enabledSearch and thinking features', async () => {
       await instance.chat({
         messages: [{ content: 'Search and think', role: 'user' }],
@@ -302,12 +271,12 @@ describe('LobeOpenRouterAI - custom features', () => {
       });
 
       expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({ reasoning: {} }),
+        expect.objectContaining({ reasoning: { enabled: false } }),
         expect.anything(),
       );
     });
 
-    it('should handle undefined thinking', async () => {
+    it('should not add reasoning when thinking is undefined', async () => {
       await instance.chat({
         messages: [{ content: 'Hello', role: 'user' }],
         model: 'openai/gpt-4',
@@ -315,23 +284,7 @@ describe('LobeOpenRouterAI - custom features', () => {
       });
 
       expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({ reasoning: {} }),
-        expect.anything(),
-      );
-    });
-
-    it('should cap reasoning tokens to 1 when max_tokens is 2', async () => {
-      await instance.chat({
-        messages: [{ content: 'Think about this', role: 'user' }],
-        model: 'openai/gpt-4',
-        max_tokens: 2,
-        thinking: { type: 'enabled', budget_tokens: 2000 },
-      });
-
-      expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          reasoning: { max_tokens: 1 }, // min(2000, 2 - 1) = 1
-        }),
+        expect.not.objectContaining({ reasoning: expect.anything() }),
         expect.anything(),
       );
     });
@@ -351,7 +304,7 @@ describe('LobeOpenRouterAI - custom features', () => {
       );
     });
 
-    it('should handle 0 budget_tokens (falsy, falls back to 1024)', async () => {
+    it('should handle 0 budget_tokens (passes directly)', async () => {
       await instance.chat({
         messages: [{ content: 'Think about this', role: 'user' }],
         model: 'openai/gpt-4',
@@ -360,7 +313,7 @@ describe('LobeOpenRouterAI - custom features', () => {
 
       expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
         expect.objectContaining({
-          reasoning: { max_tokens: 1024 }, // 0 is falsy, falls back to 1024
+          reasoning: { max_tokens: 0 }, // 0 is passed directly
         }),
         expect.anything(),
       );
@@ -1092,7 +1045,8 @@ describe('LobeOpenRouterAI - custom features', () => {
       const models = await params.models();
 
       const nullMaxOutputModel = models.find((m) => m.id === 'null-maxoutput/model');
-      expect(nullMaxOutputModel?.maxOutput).toBeUndefined();
+      // When top_provider.max_completion_tokens is null, falls back to model.context_length
+      expect(nullMaxOutputModel?.maxOutput).toBe(8192);
     });
 
     it('should format releasedAt from created timestamp', async () => {

package/packages/model-runtime/src/providers/openrouter/index.ts

@@ -1,4 +1,4 @@
-import { ModelProvider, openrouter as OpenRouterModels } from 'model-bank';
+import { ModelProvider } from 'model-bank';
 
 import {
   OpenAICompatibleFactoryOptions,
@@ -16,34 +16,27 @@ export const params = {
   baseURL: 'https://openrouter.ai/api/v1',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { thinking, model, max_tokens } = payload;
-
-      let reasoning: OpenRouterReasoning = {};
-
-      if (thinking?.type === 'enabled') {
-        const modelConfig = OpenRouterModels.find((m) => m.id === model);
-        const defaultMaxOutput = modelConfig?.maxOutput;
-
-        // 配置优先级：用户设置 > 模型配置 > 硬编码默认值
-        const getMaxTokens = () => {
-          if (max_tokens) return max_tokens;
-          if (defaultMaxOutput) return defaultMaxOutput;
-          return undefined;
-        };
-
-        const maxTokens = getMaxTokens() || 32_000; // Claude Opus 4 has minimum maxOutput
-
-        reasoning = {
-          max_tokens: thinking?.budget_tokens
-            ? Math.min(thinking.budget_tokens, maxTokens - 1)
-            : 1024,
-        };
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reasoning_effort, thinking, reasoning: _reasoning, ...rest } = payload;
+
+      let reasoning: OpenRouterReasoning | undefined;
+
+      if (thinking?.type || thinking?.budget_tokens !== undefined || reasoning_effort) {
+        if (thinking?.type === 'disabled') {
+          reasoning = { enabled: false };
+        } else if (thinking?.budget_tokens !== undefined) {
+          reasoning = {
+            max_tokens: thinking?.budget_tokens,
+          };
+        } else if (reasoning_effort) {
+          reasoning = { effort: reasoning_effort };
+        }
       }
 
       return {
-        ...payload,
+        ...rest,
         model: payload.enabledSearch ? `${payload.model}:online` : payload.model,
-        reasoning,
+        ...(reasoning && { reasoning }),
         stream: payload.stream ?? true,
       } as any;
     },
@@ -104,6 +97,8 @@ export const params = {
         displayName += ' (free)';
       }
 
+      const hasReasoning = supported_parameters.includes('reasoning');
+
       return {
         contextWindowTokens: top_provider.context_length || model.context_length,
         description: model.description,
@@ -113,16 +108,41 @@ export const params = {
         maxOutput:
           typeof top_provider.max_completion_tokens === 'number'
             ? top_provider.max_completion_tokens
-            : undefined,
+            : typeof model.context_length === 'number'
+              ? model.context_length
+              : undefined,
         pricing: {
           cachedInput: cachedInputPrice,
           input: inputPrice,
           output: outputPrice,
           writeCacheInput: writeCacheInputPrice,
         },
-        reasoning: supported_parameters.includes('reasoning'),
+        reasoning: hasReasoning,
         releasedAt: new Date(model.created * 1000).toISOString().split('T')[0],
         vision: inputModalities.includes('image'),
+        // Merge all applicable extendParams for settings
+        ...(() => {
+          const extendParams: string[] = [];
+          if (model.description && model.description.includes('`reasoning` `enabled`')) {
+            extendParams.push('enableReasoning');
+          }
+          if (hasReasoning && model.id.includes('gpt-5')) {
+            extendParams.push('gpt5ReasoningEffort');
+          }
+          if (hasReasoning && model.id.includes('openai') && !model.id.includes('gpt-5')) {
+            extendParams.push('reasoningEffort');
+          }
+          if (hasReasoning && model.id.includes('claude')) {
+            extendParams.push('enableReasoning', 'reasoningBudgetToken');
+          }
+          if (model.id.includes('claude') && writeCacheInputPrice && writeCacheInputPrice !== 0) {
+            extendParams.push('disableContextCaching');
+          }
+          if (hasReasoning && model.id.includes('gemini-2.5')) {
+            extendParams.push('reasoningBudgetToken');
+          }
+          return extendParams.length > 0 ? { settings: { extendParams } } : {};
+        })(),
       };
     });
 

package/packages/model-runtime/src/providers/openrouter/type.ts

@@ -3,57 +3,45 @@ interface ModelPricing {
   image?: string;
   input_cache_read?: string;
   input_cache_write?: string;
+  internal_reasoning?: string;
   prompt: string;
   request?: string;
   web_search?: string;
-  internal_reasoning?: string;
 }
 
 interface TopProvider {
   context_length: number;
-  max_completion_tokens: number | null;
   is_moderated: boolean;
+  max_completion_tokens: number | null;
 }
 
 interface Architecture {
-  modality: string;
   input_modalities: string[];
+  instruct_type: string | null;
+  modality: string;
   output_modalities: string[];
   tokenizer: string;
-  instruct_type: string | null;
 }
 
 export interface OpenRouterModelCard {
-  id: string;
+  architecture: Architecture;
   canonical_slug: string;
-  hugging_face_id?: string;
-  name: string;
+  context_length: number;
   created: number;
+  default_parameters?: any | null;
   description?: string;
-  context_length: number;
-  architecture: Architecture;
-  pricing: ModelPricing;
-  top_provider: TopProvider;
+  hugging_face_id?: string;
+  id: string;
+  name: string;
   per_request_limits?: any | null;
+  pricing: ModelPricing;
   supported_parameters: string[];
-  default_parameters?: any | null;
-}
-
-interface OpenRouterOpenAIReasoning {
-  effort: 'high' | 'medium' | 'low';
-  exclude?: boolean;
-}
-
-interface OpenRouterAnthropicReasoning {
-  exclude?: boolean;
-  max_tokens: number;
+  top_provider: TopProvider;
 }
 
-interface OpenRouterCommonReasoning {
+export interface OpenRouterReasoning {
+  effort?: 'high' | 'medium' | 'low' | 'minimal';
+  enabled?: boolean;
   exclude?: boolean;
+  max_tokens?: number;
 }
-
-export type OpenRouterReasoning =
-  | OpenRouterOpenAIReasoning
-  | OpenRouterAnthropicReasoning
-  | OpenRouterCommonReasoning;

package/packages/model-runtime/src/providers/vercelaigateway/index.test.ts

@@ -71,7 +71,7 @@ describe('LobeVercelAIGatewayAI - custom features', () => {
     it('should add reasoning_effort to providerOptions.openai', async () => {
       await instance.chat({
         messages: [{ content: 'Hello', role: 'user' }],
-        model: 'o1-preview',
+        model: 'openai/o1-preview',
         reasoning_effort: 'high',
       });
 
@@ -83,7 +83,7 @@ describe('LobeVercelAIGatewayAI - custom features', () => {
     it('should handle both reasoning_effort and verbosity', async () => {
       await instance.chat({
         messages: [{ content: 'Hello', role: 'user' }],
-        model: 'o1-preview',
+        model: 'openai/o1-preview',
         reasoning_effort: 'medium',
         verbosity: 'low',
       });
@@ -96,7 +96,7 @@ describe('LobeVercelAIGatewayAI - custom features', () => {
     it('should handle verbosity without reasoning_effort', async () => {
       await instance.chat({
         messages: [{ content: 'Hello', role: 'user' }],
-        model: 'gpt-4o',
+        model: 'openai/gpt-4o',
         verbosity: 'high',
       });
 
@@ -119,13 +119,13 @@ describe('LobeVercelAIGatewayAI - custom features', () => {
       await instance.chat({
         max_tokens: 1000,
         messages: [{ content: 'Hello', role: 'user' }],
-        model: 'o1-preview',
+        model: 'openai/o1-preview',
         reasoning_effort: 'high',
         temperature: 0.7,
       });
 
       const calledPayload = (instance['client'].chat.completions.create as any).mock.calls[0][0];
-      expect(calledPayload.model).toBe('o1-preview');
+      expect(calledPayload.model).toBe('openai/o1-preview');
       expect(calledPayload.temperature).toBe(0.7);
       expect(calledPayload.max_tokens).toBe(1000);
       expect(calledPayload.reasoning_effort).toBeUndefined();
@@ -138,7 +138,7 @@ describe('LobeVercelAIGatewayAI - custom features', () => {
         vi.clearAllMocks();
         await instance.chat({
           messages: [{ content: 'Hello', role: 'user' }],
-          model: 'o1-preview',
+          model: 'openai/o1-preview',
           reasoning_effort: effort,
         } as any);
 

package/packages/model-runtime/src/providers/vercelaigateway/index.ts

@@ -23,6 +23,11 @@ export interface VercelAIGatewayModelCard {
   type?: string;
 }
 
+export interface VercelAIGatewayReasoning {
+  enabled?: boolean;
+  max_tokens?: number;
+}
+
 export const formatPrice = (price?: string | number) => {
   if (price === undefined || price === null) return undefined;
   const n = typeof price === 'number' ? price : Number(price);
@@ -35,23 +40,41 @@ export const params = {
   baseURL: 'https://ai-gateway.vercel.sh/v1',
   chatCompletion: {
     handlePayload: (payload) => {
-      const { model, reasoning_effort, verbosity, ...rest } = payload;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { reasoning_effort, thinking, reasoning: _reasoning, verbosity, ...rest } = payload;
 
-      const providerOptions: any = {};
-      if (reasoning_effort || verbosity) {
-        providerOptions.openai = {};
-        if (reasoning_effort) {
-          providerOptions.openai.reasoningEffort = reasoning_effort;
-          providerOptions.openai.reasoningSummary = 'auto';
-        }
-        if (verbosity) {
-          providerOptions.openai.textVerbosity = verbosity;
+      let reasoning: VercelAIGatewayReasoning | undefined;
+
+      if (thinking?.type || thinking?.budget_tokens !== undefined || reasoning_effort) {
+        if (thinking?.type === 'disabled') {
+          reasoning = { enabled: false };
+        } else if (thinking?.budget_tokens !== undefined) {
+          reasoning = {
+            enabled: true,
+            max_tokens: thinking?.budget_tokens,
+          };
+        } else if (reasoning_effort) {
+          reasoning = { enabled: true };
         }
       }
 
+      const providerOptions: any = {};
+      if ((verbosity || reasoning) && payload.model.includes('openai')) {
+        providerOptions.openai = {
+          ...(reasoning_effort && {
+            reasoningEffort: reasoning_effort,
+            reasoningSummary: 'auto',
+          }),
+          ...(verbosity && {
+            textVerbosity: verbosity,
+          }),
+        };
+      }
+
       return {
         ...rest,
-        model,
+        model: payload.model,
+        ...(reasoning && { reasoning }),
         providerOptions,
       } as any;
     },
@@ -99,6 +122,26 @@ export const params = {
         reasoning: tags.includes('reasoning') || false,
         type: m.type === 'embedding' ? 'embedding' : 'chat',
         vision: tags.includes('vision') || false,
+        // Merge all applicable extendParams for settings
+        ...(() => {
+          const extendParams: string[] = [];
+          if (tags.includes('reasoning') && m.id.includes('gpt-5')) {
+            extendParams.push('gpt5ReasoningEffort', 'textVerbosity');
+          }
+          if (tags.includes('reasoning') && m.id.includes('openai') && !m.id.includes('gpt-5')) {
+            extendParams.push('reasoningEffort', 'textVerbosity');
+          }
+          if (tags.includes('reasoning') && m.id.includes('claude')) {
+            extendParams.push('enableReasoning', 'reasoningBudgetToken');
+          }
+          if (m.id.includes('claude') && writeCacheInputPrice && writeCacheInputPrice !== 0) {
+            extendParams.push('disableContextCaching');
+          }
+          if (tags.includes('reasoning') && m.id.includes('gemini-2.5')) {
+            extendParams.push('reasoningBudgetToken');
+          }
+          return extendParams.length > 0 ? { settings: { extendParams } } : {};
+        })(),
       } as any;
     });