Test/ai-core (#11307)

* test: 1

* test: 2

* test: 3

* format

* chore: move provider from config to utils

* fix: 4

* test: 5

* chore: redundant logic

* test: add reasoning model tests and improve provider options typings

* chore: format

* test 6

* chore: format

* test: 7

* test: 8

* fix: test

* fix: format and typecheck

* fix error

* test: isClaude4SeriesModel

* fix: test

* fix: test

---------

Co-authored-by: defi-failure <159208748+defi-failure@users.noreply.github.com>

biome.jsonc

@@ -14,7 +14,7 @@
       }
     },
     "enabled": true,
-    "includes": ["**/*.json", "!*.json", "!**/package.json"]
+    "includes": ["**/*.json", "!*.json", "!**/package.json", "!coverage/**"]
   },
   "css": {
     "formatter": {
@@ -23,7 +23,7 @@
   },
   "files": {
     "ignoreUnknown": false,
-    "includes": ["**", "!**/.claude/**"],
+    "includes": ["**", "!**/.claude/**", "!**/.vscode/**"],
     "maxSize": 2097152
   },
   "formatter": {

package.json

@@ -119,6 +119,7 @@
     "@ai-sdk/mistral": "^2.0.23",
     "@ai-sdk/openai": "patch:@ai-sdk/openai@npm%3A2.0.64#~/.yarn/patches/@ai-sdk-openai-npm-2.0.64-48f99f5bf3.patch",
     "@ai-sdk/perplexity": "^2.0.17",
+    "@ai-sdk/test-server": "^0.0.1",
     "@ant-design/v5-patch-for-react-19": "^1.0.3",
     "@anthropic-ai/sdk": "^0.41.0",
     "@anthropic-ai/vertex-sdk": "patch:@anthropic-ai/vertex-sdk@npm%3A0.11.4#~/.yarn/patches/@anthropic-ai-vertex-sdk-npm-0.11.4-c19cb41edb.patch",

packages/aiCore/src/__tests__/fixtures/mock-providers.ts

@@ -0,0 +1,180 @@
+/**
+ * Mock Provider Instances
+ * Provides mock implementations for all supported AI providers
+ */
+
+import type { ImageModelV2, LanguageModelV2 } from '@ai-sdk/provider'
+import { vi } from 'vitest'
+
+/**
+ * Creates a mock language model with customizable behavior
+ */
+export function createMockLanguageModel(overrides?: Partial<LanguageModelV2>): LanguageModelV2 {
+  return {
+    specificationVersion: 'v1',
+    provider: 'mock-provider',
+    modelId: 'mock-model',
+    defaultObjectGenerationMode: 'tool',
+
+    doGenerate: vi.fn().mockResolvedValue({
+      text: 'Mock response text',
+      finishReason: 'stop',
+      usage: {
+        promptTokens: 10,
+        completionTokens: 20,
+        totalTokens: 30
+      },
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      rawResponse: { headers: {} },
+      warnings: []
+    }),
+
+    doStream: vi.fn().mockReturnValue({
+      stream: (async function* () {
+        yield {
+          type: 'text-delta',
+          textDelta: 'Mock '
+        }
+        yield {
+          type: 'text-delta',
+          textDelta: 'streaming '
+        }
+        yield {
+          type: 'text-delta',
+          textDelta: 'response'
+        }
+        yield {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: {
+            promptTokens: 10,
+            completionTokens: 15,
+            totalTokens: 25
+          }
+        }
+      })(),
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      rawResponse: { headers: {} },
+      warnings: []
+    }),
+
+    ...overrides
+  } as LanguageModelV2
+}
+
+/**
+ * Creates a mock image model with customizable behavior
+ */
+export function createMockImageModel(overrides?: Partial<ImageModelV2>): ImageModelV2 {
+  return {
+    specificationVersion: 'v2',
+    provider: 'mock-provider',
+    modelId: 'mock-image-model',
+
+    doGenerate: vi.fn().mockResolvedValue({
+      images: [
+        {
+          base64: 'mock-base64-image-data',
+          uint8Array: new Uint8Array([1, 2, 3, 4, 5]),
+          mimeType: 'image/png'
+        }
+      ],
+      warnings: []
+    }),
+
+    ...overrides
+  } as ImageModelV2
+}
+
+/**
+ * Mock provider configurations for testing
+ */
+export const mockProviderConfigs = {
+  openai: {
+    apiKey: 'sk-test-openai-key-123456789',
+    baseURL: 'https://api.openai.com/v1',
+    organization: 'test-org'
+  },
+
+  anthropic: {
+    apiKey: 'sk-ant-test-key-123456789',
+    baseURL: 'https://api.anthropic.com'
+  },
+
+  google: {
+    apiKey: 'test-google-api-key-123456789',
+    baseURL: 'https://generativelanguage.googleapis.com/v1'
+  },
+
+  xai: {
+    apiKey: 'xai-test-key-123456789',
+    baseURL: 'https://api.x.ai/v1'
+  },
+
+  azure: {
+    apiKey: 'test-azure-key-123456789',
+    resourceName: 'test-resource',
+    deployment: 'test-deployment'
+  },
+
+  deepseek: {
+    apiKey: 'sk-test-deepseek-key-123456789',
+    baseURL: 'https://api.deepseek.com/v1'
+  },
+
+  openrouter: {
+    apiKey: 'sk-or-test-key-123456789',
+    baseURL: 'https://openrouter.ai/api/v1'
+  },
+
+  huggingface: {
+    apiKey: 'hf_test_key_123456789',
+    baseURL: 'https://api-inference.huggingface.co'
+  },
+
+  'openai-compatible': {
+    apiKey: 'test-compatible-key-123456789',
+    baseURL: 'https://api.example.com/v1',
+    name: 'test-provider'
+  },
+
+  'openai-chat': {
+    apiKey: 'sk-test-chat-key-123456789',
+    baseURL: 'https://api.openai.com/v1'
+  }
+} as const
+
+/**
+ * Mock provider instances for testing
+ */
+export const mockProviderInstances = {
+  openai: {
+    name: 'openai-mock',
+    languageModel: createMockLanguageModel({ provider: 'openai', modelId: 'gpt-4' }),
+    imageModel: createMockImageModel({ provider: 'openai', modelId: 'dall-e-3' })
+  },
+
+  anthropic: {
+    name: 'anthropic-mock',
+    languageModel: createMockLanguageModel({ provider: 'anthropic', modelId: 'claude-3-5-sonnet-20241022' })
+  },
+
+  google: {
+    name: 'google-mock',
+    languageModel: createMockLanguageModel({ provider: 'google', modelId: 'gemini-2.0-flash-exp' }),
+    imageModel: createMockImageModel({ provider: 'google', modelId: 'imagen-3.0-generate-001' })
+  },
+
+  xai: {
+    name: 'xai-mock',
+    languageModel: createMockLanguageModel({ provider: 'xai', modelId: 'grok-2-latest' }),
+    imageModel: createMockImageModel({ provider: 'xai', modelId: 'grok-2-image-latest' })
+  },
+
+  deepseek: {
+    name: 'deepseek-mock',
+    languageModel: createMockLanguageModel({ provider: 'deepseek', modelId: 'deepseek-chat' })
+  }
+}
+
+export type ProviderId = keyof typeof mockProviderConfigs

packages/aiCore/src/__tests__/fixtures/mock-responses.ts

@@ -0,0 +1,331 @@
+/**
+ * Mock Responses
+ * Provides realistic mock responses for all provider types
+ */
+
+import { jsonSchema, type ModelMessage, type Tool } from 'ai'
+
+/**
+ * Standard test messages for all scenarios
+ */
+export const testMessages = {
+  simple: [{ role: 'user' as const, content: 'Hello, how are you?' }],
+
+  conversation: [
+    { role: 'user' as const, content: 'What is the capital of France?' },
+    { role: 'assistant' as const, content: 'The capital of France is Paris.' },
+    { role: 'user' as const, content: 'What is its population?' }
+  ],
+
+  withSystem: [
+    { role: 'system' as const, content: 'You are a helpful assistant that provides concise answers.' },
+    { role: 'user' as const, content: 'Explain quantum computing in one sentence.' }
+  ],
+
+  withImages: [
+    {
+      role: 'user' as const,
+      content: [
+        { type: 'text' as const, text: 'What is in this image?' },
+        {
+          type: 'image' as const,
+          image:
+            'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=='
+        }
+      ]
+    }
+  ],
+
+  toolUse: [{ role: 'user' as const, content: 'What is the weather in San Francisco?' }],
+
+  multiTurn: [
+    { role: 'user' as const, content: 'Can you help me with a math problem?' },
+    { role: 'assistant' as const, content: 'Of course! What math problem would you like help with?' },
+    { role: 'user' as const, content: 'What is 15 * 23?' },
+    { role: 'assistant' as const, content: '15 * 23 = 345' },
+    { role: 'user' as const, content: 'Now divide that by 5' }
+  ]
+} satisfies Record<string, ModelMessage[]>
+
+/**
+ * Standard test tools for tool calling scenarios
+ */
+export const testTools: Record<string, Tool> = {
+  getWeather: {
+    description: 'Get the current weather in a given location',
+    inputSchema: jsonSchema({
+      type: 'object',
+      properties: {
+        location: {
+          type: 'string',
+          description: 'The city and state, e.g. San Francisco, CA'
+        },
+        unit: {
+          type: 'string',
+          enum: ['celsius', 'fahrenheit'],
+          description: 'The temperature unit to use'
+        }
+      },
+      required: ['location']
+    }),
+    execute: async ({ location, unit = 'fahrenheit' }) => {
+      return {
+        location,
+        temperature: unit === 'celsius' ? 22 : 72,
+        unit,
+        condition: 'sunny'
+      }
+    }
+  },
+
+  calculate: {
+    description: 'Perform a mathematical calculation',
+    inputSchema: jsonSchema({
+      type: 'object',
+      properties: {
+        operation: {
+          type: 'string',
+          enum: ['add', 'subtract', 'multiply', 'divide'],
+          description: 'The operation to perform'
+        },
+        a: {
+          type: 'number',
+          description: 'The first number'
+        },
+        b: {
+          type: 'number',
+          description: 'The second number'
+        }
+      },
+      required: ['operation', 'a', 'b']
+    }),
+    execute: async ({ operation, a, b }) => {
+      const operations = {
+        add: (x: number, y: number) => x + y,
+        subtract: (x: number, y: number) => x - y,
+        multiply: (x: number, y: number) => x * y,
+        divide: (x: number, y: number) => x / y
+      }
+      return { result: operations[operation as keyof typeof operations](a, b) }
+    }
+  },
+
+  searchDatabase: {
+    description: 'Search for information in a database',
+    inputSchema: jsonSchema({
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'The search query'
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of results to return',
+          default: 10
+        }
+      },
+      required: ['query']
+    }),
+    execute: async ({ query, limit = 10 }) => {
+      return {
+        results: [
+          { id: 1, title: `Result 1 for ${query}`, relevance: 0.95 },
+          { id: 2, title: `Result 2 for ${query}`, relevance: 0.87 }
+        ].slice(0, limit)
+      }
+    }
+  }
+}
+
+/**
+ * Mock streaming chunks for different providers
+ */
+export const mockStreamingChunks = {
+  text: [
+    { type: 'text-delta' as const, textDelta: 'Hello' },
+    { type: 'text-delta' as const, textDelta: ', ' },
+    { type: 'text-delta' as const, textDelta: 'this ' },
+    { type: 'text-delta' as const, textDelta: 'is ' },
+    { type: 'text-delta' as const, textDelta: 'a ' },
+    { type: 'text-delta' as const, textDelta: 'test.' }
+  ],
+
+  withToolCall: [
+    { type: 'text-delta' as const, textDelta: 'Let me check the weather for you.' },
+    {
+      type: 'tool-call-delta' as const,
+      toolCallType: 'function' as const,
+      toolCallId: 'call_123',
+      toolName: 'getWeather',
+      argsTextDelta: '{"location":'
+    },
+    {
+      type: 'tool-call-delta' as const,
+      toolCallType: 'function' as const,
+      toolCallId: 'call_123',
+      toolName: 'getWeather',
+      argsTextDelta: ' "San Francisco, CA"}'
+    },
+    {
+      type: 'tool-call' as const,
+      toolCallType: 'function' as const,
+      toolCallId: 'call_123',
+      toolName: 'getWeather',
+      args: { location: 'San Francisco, CA' }
+    }
+  ],
+
+  withFinish: [
+    { type: 'text-delta' as const, textDelta: 'Complete response.' },
+    {
+      type: 'finish' as const,
+      finishReason: 'stop' as const,
+      usage: {
+        promptTokens: 10,
+        completionTokens: 5,
+        totalTokens: 15
+      }
+    }
+  ]
+}
+
+/**
+ * Mock complete responses for non-streaming scenarios
+ */
+export const mockCompleteResponses = {
+  simple: {
+    text: 'This is a simple response.',
+    finishReason: 'stop' as const,
+    usage: {
+      promptTokens: 15,
+      completionTokens: 8,
+      totalTokens: 23
+    }
+  },
+
+  withToolCalls: {
+    text: 'I will check the weather for you.',
+    toolCalls: [
+      {
+        toolCallId: 'call_456',
+        toolName: 'getWeather',
+        args: { location: 'New York, NY', unit: 'celsius' }
+      }
+    ],
+    finishReason: 'tool-calls' as const,
+    usage: {
+      promptTokens: 25,
+      completionTokens: 12,
+      totalTokens: 37
+    }
+  },
+
+  withWarnings: {
+    text: 'Response with warnings.',
+    finishReason: 'stop' as const,
+    usage: {
+      promptTokens: 10,
+      completionTokens: 5,
+      totalTokens: 15
+    },
+    warnings: [
+      {
+        type: 'unsupported-setting' as const,
+        message: 'Temperature parameter not supported for this model'
+      }
+    ]
+  }
+}
+
+/**
+ * Mock image generation responses
+ */
+export const mockImageResponses = {
+  single: {
+    image: {
+      base64: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      uint8Array: new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82]),
+      mimeType: 'image/png' as const
+    },
+    warnings: []
+  },
+
+  multiple: {
+    images: [
+      {
+        base64: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+        uint8Array: new Uint8Array([137, 80, 78, 71]),
+        mimeType: 'image/png' as const
+      },
+      {
+        base64: 'iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAYAAABytg0kAAAAEklEQVR42mNk+M9QzwAEjDAGACCKAgdZ9zImAAAAAElFTkSuQmCC',
+        uint8Array: new Uint8Array([137, 80, 78, 71]),
+        mimeType: 'image/png' as const
+      }
+    ],
+    warnings: []
+  },
+
+  withProviderMetadata: {
+    image: {
+      base64: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      uint8Array: new Uint8Array([137, 80, 78, 71]),
+      mimeType: 'image/png' as const
+    },
+    providerMetadata: {
+      openai: {
+        images: [
+          {
+            revisedPrompt: 'A detailed and enhanced version of the original prompt'
+          }
+        ]
+      }
+    },
+    warnings: []
+  }
+}
+
+/**
+ * Mock error responses
+ */
+export const mockErrors = {
+  invalidApiKey: {
+    name: 'APIError',
+    message: 'Invalid API key provided',
+    statusCode: 401
+  },
+
+  rateLimitExceeded: {
+    name: 'RateLimitError',
+    message: 'Rate limit exceeded. Please try again later.',
+    statusCode: 429,
+    headers: {
+      'retry-after': '60'
+    }
+  },
+
+  modelNotFound: {
+    name: 'ModelNotFoundError',
+    message: 'The requested model was not found',
+    statusCode: 404
+  },
+
+  contextLengthExceeded: {
+    name: 'ContextLengthError',
+    message: "This model's maximum context length is 4096 tokens",
+    statusCode: 400
+  },
+
+  timeout: {
+    name: 'TimeoutError',
+    message: 'Request timed out after 30000ms',
+    code: 'ETIMEDOUT'
+  },
+
+  networkError: {
+    name: 'NetworkError',
+    message: 'Network connection failed',
+    code: 'ECONNREFUSED'
+  }
+}

packages/aiCore/src/__tests__/helpers/provider-test-utils.ts

@@ -0,0 +1,329 @@
+/**
+ * Provider-Specific Test Utilities
+ * Helper functions for testing individual providers with all their parameters
+ */
+
+import type { Tool } from 'ai'
+import { expect } from 'vitest'
+
+/**
+ * Provider parameter configurations for comprehensive testing
+ */
+export const providerParameterMatrix = {
+  openai: {
+    models: ['gpt-4', 'gpt-4-turbo', 'gpt-3.5-turbo', 'gpt-4o'],
+    parameters: {
+      temperature: [0, 0.5, 0.7, 1.0, 1.5, 2.0],
+      maxTokens: [100, 500, 1000, 2000, 4000],
+      topP: [0.1, 0.5, 0.9, 1.0],
+      frequencyPenalty: [-2.0, -1.0, 0, 1.0, 2.0],
+      presencePenalty: [-2.0, -1.0, 0, 1.0, 2.0],
+      stop: [undefined, ['stop'], ['STOP', 'END']],
+      seed: [undefined, 12345, 67890],
+      responseFormat: [undefined, { type: 'json_object' as const }],
+      user: [undefined, 'test-user-123']
+    },
+    toolChoice: ['auto', 'required', 'none', { type: 'function' as const, name: 'getWeather' }],
+    parallelToolCalls: [true, false]
+  },
+
+  anthropic: {
+    models: ['claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
+    parameters: {
+      temperature: [0, 0.5, 1.0],
+      maxTokens: [100, 1000, 4000, 8000],
+      topP: [0.1, 0.5, 0.9, 1.0],
+      topK: [undefined, 1, 5, 10, 40],
+      stop: [undefined, ['Human:', 'Assistant:']],
+      metadata: [undefined, { userId: 'test-123' }]
+    },
+    toolChoice: ['auto', 'any', { type: 'tool' as const, name: 'getWeather' }]
+  },
+
+  google: {
+    models: ['gemini-2.0-flash-exp', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+    parameters: {
+      temperature: [0, 0.5, 0.9, 1.0],
+      maxTokens: [100, 1000, 2000, 8000],
+      topP: [0.1, 0.5, 0.95, 1.0],
+      topK: [undefined, 1, 16, 40],
+      stopSequences: [undefined, ['END'], ['STOP', 'TERMINATE']]
+    },
+    safetySettings: [
+      undefined,
+      [
+        { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_MEDIUM_AND_ABOVE' },
+        { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH' }
+      ]
+    ]
+  },
+
+  xai: {
+    models: ['grok-2-latest', 'grok-2-1212'],
+    parameters: {
+      temperature: [0, 0.5, 1.0, 1.5],
+      maxTokens: [100, 500, 2000, 4000],
+      topP: [0.1, 0.5, 0.9, 1.0],
+      stop: [undefined, ['STOP'], ['END', 'TERMINATE']],
+      seed: [undefined, 12345]
+    }
+  },
+
+  deepseek: {
+    models: ['deepseek-chat', 'deepseek-coder'],
+    parameters: {
+      temperature: [0, 0.5, 1.0],
+      maxTokens: [100, 1000, 4000],
+      topP: [0.1, 0.5, 0.95],
+      frequencyPenalty: [0, 0.5, 1.0],
+      presencePenalty: [0, 0.5, 1.0],
+      stop: [undefined, ['```'], ['END']]
+    }
+  },
+
+  azure: {
+    deployments: ['gpt-4-deployment', 'gpt-35-turbo-deployment'],
+    parameters: {
+      temperature: [0, 0.7, 1.0],
+      maxTokens: [100, 1000, 2000],
+      topP: [0.1, 0.5, 0.95],
+      frequencyPenalty: [0, 1.0],
+      presencePenalty: [0, 1.0],
+      stop: [undefined, ['STOP']]
+    }
+  }
+} as const
+
+/**
+ * Creates test cases for all parameter combinations
+ */
+export function generateParameterTestCases<T extends Record<string, any[]>>(
+  params: T,
+  maxCombinations = 50
+): Array<Partial<{ [K in keyof T]: T[K][number] }>> {
+  const keys = Object.keys(params) as Array<keyof T>
+  const testCases: Array<Partial<{ [K in keyof T]: T[K][number] }>> = []
+
+  // Generate combinations using sampling strategy for large parameter spaces
+  const totalCombinations = keys.reduce((acc, key) => acc * params[key].length, 1)
+
+  if (totalCombinations <= maxCombinations) {
+    // Generate all combinations if total is small
+    generateAllCombinations(params, keys, 0, {}, testCases)
+  } else {
+    // Sample diverse combinations if total is large
+    generateSampledCombinations(params, keys, maxCombinations, testCases)
+  }
+
+  return testCases
+}
+
+function generateAllCombinations<T extends Record<string, any[]>>(
+  params: T,
+  keys: Array<keyof T>,
+  index: number,
+  current: Partial<{ [K in keyof T]: T[K][number] }>,
+  results: Array<Partial<{ [K in keyof T]: T[K][number] }>>
+) {
+  if (index === keys.length) {
+    results.push({ ...current })
+    return
+  }
+
+  const key = keys[index]
+  for (const value of params[key]) {
+    generateAllCombinations(params, keys, index + 1, { ...current, [key]: value }, results)
+  }
+}
+
+function generateSampledCombinations<T extends Record<string, any[]>>(
+  params: T,
+  keys: Array<keyof T>,
+  count: number,
+  results: Array<Partial<{ [K in keyof T]: T[K][number] }>>
+) {
+  // Generate edge cases first (min/max values)
+  const edgeCase1: any = {}
+  const edgeCase2: any = {}
+
+  for (const key of keys) {
+    edgeCase1[key] = params[key][0]
+    edgeCase2[key] = params[key][params[key].length - 1]
+  }
+
+  results.push(edgeCase1, edgeCase2)
+
+  // Generate random combinations for the rest
+  for (let i = results.length; i < count; i++) {
+    const combination: any = {}
+    for (const key of keys) {
+      const values = params[key]
+      combination[key] = values[Math.floor(Math.random() * values.length)]
+    }
+    results.push(combination)
+  }
+}
+
+/**
+ * Validates that all provider-specific parameters are correctly passed through
+ */
+export function validateProviderParams(providerId: string, actualParams: any, expectedParams: any): void {
+  const requiredFields: Record<string, string[]> = {
+    openai: ['model', 'messages'],
+    anthropic: ['model', 'messages'],
+    google: ['model', 'contents'],
+    xai: ['model', 'messages'],
+    deepseek: ['model', 'messages'],
+    azure: ['messages']
+  }
+
+  const fields = requiredFields[providerId] || ['model', 'messages']
+
+  for (const field of fields) {
+    expect(actualParams).toHaveProperty(field)
+  }
+
+  // Validate optional parameters if they were provided
+  const optionalParams = ['temperature', 'max_tokens', 'top_p', 'stop', 'tools']
+
+  for (const param of optionalParams) {
+    if (expectedParams[param] !== undefined) {
+      expect(actualParams[param]).toEqual(expectedParams[param])
+    }
+  }
+}
+
+/**
+ * Creates a comprehensive test suite for a provider
+ */
+// oxlint-disable-next-line no-unused-vars
+export function createProviderTestSuite(_providerId: string) {
+  return {
+    testBasicCompletion: async (executor: any, model: string) => {
+      const result = await executor.generateText({
+        model,
+        messages: [{ role: 'user' as const, content: 'Hello' }]
+      })
+
+      expect(result).toBeDefined()
+      expect(result.text).toBeDefined()
+      expect(typeof result.text).toBe('string')
+    },
+
+    testStreaming: async (executor: any, model: string) => {
+      const chunks: any[] = []
+      const result = await executor.streamText({
+        model,
+        messages: [{ role: 'user' as const, content: 'Hello' }]
+      })
+
+      for await (const chunk of result.textStream) {
+        chunks.push(chunk)
+      }
+
+      expect(chunks.length).toBeGreaterThan(0)
+    },
+
+    testTemperature: async (executor: any, model: string, temperatures: number[]) => {
+      for (const temperature of temperatures) {
+        const result = await executor.generateText({
+          model,
+          messages: [{ role: 'user' as const, content: 'Hello' }],
+          temperature
+        })
+
+        expect(result).toBeDefined()
+      }
+    },
+
+    testMaxTokens: async (executor: any, model: string, maxTokensValues: number[]) => {
+      for (const maxTokens of maxTokensValues) {
+        const result = await executor.generateText({
+          model,
+          messages: [{ role: 'user' as const, content: 'Hello' }],
+          maxTokens
+        })
+
+        expect(result).toBeDefined()
+        if (result.usage?.completionTokens) {
+          expect(result.usage.completionTokens).toBeLessThanOrEqual(maxTokens)
+        }
+      }
+    },
+
+    testToolCalling: async (executor: any, model: string, tools: Record<string, Tool>) => {
+      const result = await executor.generateText({
+        model,
+        messages: [{ role: 'user' as const, content: 'What is the weather in SF?' }],
+        tools
+      })
+
+      expect(result).toBeDefined()
+    },
+
+    testStopSequences: async (executor: any, model: string, stopSequences: string[][]) => {
+      for (const stop of stopSequences) {
+        const result = await executor.generateText({
+          model,
+          messages: [{ role: 'user' as const, content: 'Count to 10' }],
+          stop
+        })
+
+        expect(result).toBeDefined()
+      }
+    }
+  }
+}
+
+/**
+ * Generates test data for vision/multimodal testing
+ */
+export function createVisionTestData() {
+  return {
+    imageUrl: 'https://example.com/test-image.jpg',
+    base64Image:
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+    messages: [
+      {
+        role: 'user' as const,
+        content: [
+          { type: 'text' as const, text: 'What is in this image?' },
+          {
+            type: 'image' as const,
+            image:
+              'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=='
+          }
+        ]
+      }
+    ]
+  }
+}
+
+/**
+ * Creates mock responses for different finish reasons
+ */
+export function createFinishReasonMocks() {
+  return {
+    stop: {
+      text: 'Complete response.',
+      finishReason: 'stop' as const,
+      usage: { promptTokens: 10, completionTokens: 5, totalTokens: 15 }
+    },
+    length: {
+      text: 'Incomplete response due to',
+      finishReason: 'length' as const,
+      usage: { promptTokens: 10, completionTokens: 100, totalTokens: 110 }
+    },
+    'tool-calls': {
+      text: 'Calling tools',
+      finishReason: 'tool-calls' as const,
+      toolCalls: [{ toolCallId: 'call_1', toolName: 'getWeather', args: { location: 'SF' } }],
+      usage: { promptTokens: 10, completionTokens: 8, totalTokens: 18 }
+    },
+    'content-filter': {
+      text: '',
+      finishReason: 'content-filter' as const,
+      usage: { promptTokens: 10, completionTokens: 0, totalTokens: 10 }
+    }
+  }
+}

packages/aiCore/src/__tests__/helpers/test-utils.ts

@@ -0,0 +1,291 @@
+/**
+ * Test Utilities
+ * Helper functions for testing AI Core functionality
+ */
+
+import { expect, vi } from 'vitest'
+
+import type { ProviderId } from '../fixtures/mock-providers'
+import { createMockImageModel, createMockLanguageModel, mockProviderConfigs } from '../fixtures/mock-providers'
+
+/**
+ * Creates a test provider with streaming support
+ */
+export function createTestStreamingProvider(chunks: any[]) {
+  return createMockLanguageModel({
+    doStream: vi.fn().mockReturnValue({
+      stream: (async function* () {
+        for (const chunk of chunks) {
+          yield chunk
+        }
+      })(),
+      rawCall: { rawPrompt: null, rawSettings: {} },
+      rawResponse: { headers: {} },
+      warnings: []
+    })
+  })
+}
+
+/**
+ * Creates a test provider that throws errors
+ */
+export function createErrorProvider(error: Error) {
+  return createMockLanguageModel({
+    doGenerate: vi.fn().mockRejectedValue(error),
+    doStream: vi.fn().mockImplementation(() => {
+      throw error
+    })
+  })
+}
+
+/**
+ * Collects all chunks from a stream
+ */
+export async function collectStreamChunks<T>(stream: AsyncIterable<T>): Promise<T[]> {
+  const chunks: T[] = []
+  for await (const chunk of stream) {
+    chunks.push(chunk)
+  }
+  return chunks
+}
+
+/**
+ * Waits for a specific number of milliseconds
+ */
+export function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Creates a mock abort controller that aborts after a delay
+ */
+export function createDelayedAbortController(delayMs: number): AbortController {
+  const controller = new AbortController()
+  setTimeout(() => controller.abort(), delayMs)
+  return controller
+}
+
+/**
+ * Asserts that a function throws an error with a specific message
+ */
+export async function expectError(fn: () => Promise<any>, expectedMessage?: string | RegExp): Promise<Error> {
+  try {
+    await fn()
+    throw new Error('Expected function to throw an error, but it did not')
+  } catch (error) {
+    if (expectedMessage) {
+      const message = (error as Error).message
+      if (typeof expectedMessage === 'string') {
+        if (!message.includes(expectedMessage)) {
+          throw new Error(`Expected error message to include "${expectedMessage}", but got "${message}"`)
+        }
+      } else {
+        if (!expectedMessage.test(message)) {
+          throw new Error(`Expected error message to match ${expectedMessage}, but got "${message}"`)
+        }
+      }
+    }
+    return error as Error
+  }
+}
+
+/**
+ * Creates a spy function that tracks calls and arguments
+ */
+export function createSpy<T extends (...args: any[]) => any>() {
+  const calls: Array<{ args: Parameters<T>; result?: ReturnType<T>; error?: Error }> = []
+
+  const spy = vi.fn((...args: Parameters<T>) => {
+    try {
+      const result = undefined as ReturnType<T>
+      calls.push({ args, result })
+      return result
+    } catch (error) {
+      calls.push({ args, error: error as Error })
+      throw error
+    }
+  })
+
+  return {
+    fn: spy,
+    calls,
+    getCalls: () => calls,
+    getCallCount: () => calls.length,
+    getLastCall: () => calls[calls.length - 1],
+    reset: () => {
+      calls.length = 0
+      spy.mockClear()
+    }
+  }
+}
+
+/**
+ * Validates provider configuration
+ */
+export function validateProviderConfig(providerId: ProviderId) {
+  const config = mockProviderConfigs[providerId]
+  if (!config) {
+    throw new Error(`No mock configuration found for provider: ${providerId}`)
+  }
+
+  if (!config.apiKey) {
+    throw new Error(`Provider ${providerId} is missing apiKey in mock config`)
+  }
+
+  return config
+}
+
+/**
+ * Creates a test context with common setup
+ */
+export function createTestContext() {
+  const mocks = {
+    languageModel: createMockLanguageModel(),
+    imageModel: createMockImageModel(),
+    providers: new Map<string, any>()
+  }
+
+  const cleanup = () => {
+    mocks.providers.clear()
+    vi.clearAllMocks()
+  }
+
+  return {
+    mocks,
+    cleanup
+  }
+}
+
+/**
+ * Measures execution time of an async function
+ */
+export async function measureTime<T>(fn: () => Promise<T>): Promise<{ result: T; duration: number }> {
+  const start = Date.now()
+  const result = await fn()
+  const duration = Date.now() - start
+  return { result, duration }
+}
+
+/**
+ * Retries a function until it succeeds or max attempts reached
+ */
+export async function retryUntilSuccess<T>(fn: () => Promise<T>, maxAttempts = 3, delayMs = 100): Promise<T> {
+  let lastError: Error | undefined
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn()
+    } catch (error) {
+      lastError = error as Error
+      if (attempt < maxAttempts) {
+        await wait(delayMs)
+      }
+    }
+  }
+
+  throw lastError || new Error('All retry attempts failed')
+}
+
+/**
+ * Creates a mock streaming response that emits chunks at intervals
+ */
+export function createTimedStream<T>(chunks: T[], intervalMs = 10) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (const chunk of chunks) {
+        await wait(intervalMs)
+        yield chunk
+      }
+    }
+  }
+}
+
+/**
+ * Asserts that two objects are deeply equal, ignoring specified keys
+ */
+export function assertDeepEqualIgnoring<T extends Record<string, any>>(
+  actual: T,
+  expected: T,
+  ignoreKeys: string[] = []
+): void {
+  const filterKeys = (obj: T): Partial<T> => {
+    const filtered = { ...obj }
+    for (const key of ignoreKeys) {
+      delete filtered[key]
+    }
+    return filtered
+  }
+
+  const filteredActual = filterKeys(actual)
+  const filteredExpected = filterKeys(expected)
+
+  expect(filteredActual).toEqual(filteredExpected)
+}
+
+/**
+ * Creates a provider mock that simulates rate limiting
+ */
+export function createRateLimitedProvider(limitPerSecond: number) {
+  const calls: number[] = []
+
+  return createMockLanguageModel({
+    doGenerate: vi.fn().mockImplementation(async () => {
+      const now = Date.now()
+      calls.push(now)
+
+      // Remove calls older than 1 second
+      const recentCalls = calls.filter((time) => now - time < 1000)
+
+      if (recentCalls.length > limitPerSecond) {
+        throw new Error('Rate limit exceeded')
+      }
+
+      return {
+        text: 'Rate limited response',
+        finishReason: 'stop' as const,
+        usage: { promptTokens: 10, completionTokens: 5, totalTokens: 15 },
+        rawCall: { rawPrompt: null, rawSettings: {} },
+        rawResponse: { headers: {} },
+        warnings: []
+      }
+    })
+  })
+}
+
+/**
+ * Validates streaming response structure
+ */
+export function validateStreamChunk(chunk: any): void {
+  expect(chunk).toBeDefined()
+  expect(chunk).toHaveProperty('type')
+
+  if (chunk.type === 'text-delta') {
+    expect(chunk).toHaveProperty('textDelta')
+    expect(typeof chunk.textDelta).toBe('string')
+  } else if (chunk.type === 'finish') {
+    expect(chunk).toHaveProperty('finishReason')
+    expect(chunk).toHaveProperty('usage')
+  } else if (chunk.type === 'tool-call') {
+    expect(chunk).toHaveProperty('toolCallId')
+    expect(chunk).toHaveProperty('toolName')
+    expect(chunk).toHaveProperty('args')
+  }
+}
+
+/**
+ * Creates a test logger that captures log messages
+ */
+export function createTestLogger() {
+  const logs: Array<{ level: string; message: string; meta?: any }> = []
+
+  return {
+    info: (message: string, meta?: any) => logs.push({ level: 'info', message, meta }),
+    warn: (message: string, meta?: any) => logs.push({ level: 'warn', message, meta }),
+    error: (message: string, meta?: any) => logs.push({ level: 'error', message, meta }),
+    debug: (message: string, meta?: any) => logs.push({ level: 'debug', message, meta }),
+    getLogs: () => logs,
+    clear: () => {
+      logs.length = 0
+    }
+  }
+}

packages/aiCore/src/__tests__/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Test Infrastructure Exports
+ * Central export point for all test utilities, fixtures, and helpers
+ */
+
+// Fixtures
+export * from './fixtures/mock-providers'
+export * from './fixtures/mock-responses'
+
+// Helpers
+export * from './helpers/provider-test-utils'
+export * from './helpers/test-utils'

packages/aiCore/src/core/runtime/__tests__/generateText.test.ts

@@ -0,0 +1,499 @@
+/**
+ * RuntimeExecutor.generateText Comprehensive Tests
+ * Tests non-streaming text generation across all providers with various parameters
+ */
+
+import { generateText } from 'ai'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  createMockLanguageModel,
+  mockCompleteResponses,
+  mockProviderConfigs,
+  testMessages,
+  testTools
+} from '../../../__tests__'
+import type { AiPlugin } from '../../plugins'
+import { globalRegistryManagement } from '../../providers/RegistryManagement'
+import { RuntimeExecutor } from '../executor'
+
+// Mock AI SDK
+vi.mock('ai', () => ({
+  generateText: vi.fn()
+}))
+
+vi.mock('../../providers/RegistryManagement', () => ({
+  globalRegistryManagement: {
+    languageModel: vi.fn()
+  },
+  DEFAULT_SEPARATOR: '|'
+}))
+
+describe('RuntimeExecutor.generateText', () => {
+  let executor: RuntimeExecutor<'openai'>
+  let mockLanguageModel: any
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    executor = RuntimeExecutor.create('openai', mockProviderConfigs.openai)
+
+    mockLanguageModel = createMockLanguageModel({
+      provider: 'openai',
+      modelId: 'gpt-4'
+    })
+
+    vi.mocked(globalRegistryManagement.languageModel).mockReturnValue(mockLanguageModel)
+    vi.mocked(generateText).mockResolvedValue(mockCompleteResponses.simple as any)
+  })
+
+  describe('Basic Functionality', () => {
+    it('should generate text with minimal parameters', async () => {
+      const result = await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      expect(generateText).toHaveBeenCalledWith({
+        model: mockLanguageModel,
+        messages: testMessages.simple
+      })
+
+      expect(result.text).toBe('This is a simple response.')
+      expect(result.finishReason).toBe('stop')
+      expect(result.usage).toBeDefined()
+    })
+
+    it('should generate with system messages', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.withSystem
+      })
+
+      expect(generateText).toHaveBeenCalledWith({
+        model: mockLanguageModel,
+        messages: testMessages.withSystem
+      })
+    })
+
+    it('should generate with conversation history', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.conversation
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: testMessages.conversation
+        })
+      )
+    })
+  })
+
+  describe('All Parameter Combinations', () => {
+    it('should support all parameters together', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        temperature: 0.7,
+        maxOutputTokens: 500,
+        topP: 0.9,
+        frequencyPenalty: 0.5,
+        presencePenalty: 0.3,
+        stopSequences: ['STOP'],
+        seed: 12345
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          temperature: 0.7,
+          maxOutputTokens: 500,
+          topP: 0.9,
+          frequencyPenalty: 0.5,
+          presencePenalty: 0.3,
+          stopSequences: ['STOP'],
+          seed: 12345
+        })
+      )
+    })
+
+    it('should support partial parameters', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        temperature: 0.5,
+        maxOutputTokens: 100
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          temperature: 0.5,
+          maxOutputTokens: 100
+        })
+      )
+    })
+  })
+
+  describe('Tool Calling', () => {
+    beforeEach(() => {
+      vi.mocked(generateText).mockResolvedValue(mockCompleteResponses.withToolCalls as any)
+    })
+
+    it('should support tool calling', async () => {
+      const result = await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.toolUse,
+        tools: testTools
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tools: testTools
+        })
+      )
+
+      expect(result.toolCalls).toBeDefined()
+      expect(result.toolCalls).toHaveLength(1)
+    })
+
+    it('should support toolChoice auto', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.toolUse,
+        tools: testTools,
+        toolChoice: 'auto'
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolChoice: 'auto'
+        })
+      )
+    })
+
+    it('should support toolChoice required', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.toolUse,
+        tools: testTools,
+        toolChoice: 'required'
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolChoice: 'required'
+        })
+      )
+    })
+
+    it('should support toolChoice none', async () => {
+      vi.mocked(generateText).mockResolvedValue(mockCompleteResponses.simple as any)
+
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        tools: testTools,
+        toolChoice: 'none'
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolChoice: 'none'
+        })
+      )
+    })
+
+    it('should support specific tool selection', async () => {
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.toolUse,
+        tools: testTools,
+        toolChoice: {
+          type: 'tool',
+          toolName: 'getWeather'
+        }
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          toolChoice: {
+            type: 'tool',
+            toolName: 'getWeather'
+          }
+        })
+      )
+    })
+  })
+
+  describe('Multiple Providers', () => {
+    it('should work with Anthropic provider', async () => {
+      const anthropicExecutor = RuntimeExecutor.create('anthropic', mockProviderConfigs.anthropic)
+
+      const anthropicModel = createMockLanguageModel({
+        provider: 'anthropic',
+        modelId: 'claude-3-5-sonnet-20241022'
+      })
+
+      vi.mocked(globalRegistryManagement.languageModel).mockReturnValue(anthropicModel)
+
+      await anthropicExecutor.generateText({
+        model: 'claude-3-5-sonnet-20241022',
+        messages: testMessages.simple
+      })
+
+      expect(globalRegistryManagement.languageModel).toHaveBeenCalledWith('anthropic|claude-3-5-sonnet-20241022')
+    })
+
+    it('should work with Google provider', async () => {
+      const googleExecutor = RuntimeExecutor.create('google', mockProviderConfigs.google)
+
+      const googleModel = createMockLanguageModel({
+        provider: 'google',
+        modelId: 'gemini-2.0-flash-exp'
+      })
+
+      vi.mocked(globalRegistryManagement.languageModel).mockReturnValue(googleModel)
+
+      await googleExecutor.generateText({
+        model: 'gemini-2.0-flash-exp',
+        messages: testMessages.simple
+      })
+
+      expect(globalRegistryManagement.languageModel).toHaveBeenCalledWith('google|gemini-2.0-flash-exp')
+    })
+
+    it('should work with xAI provider', async () => {
+      const xaiExecutor = RuntimeExecutor.create('xai', mockProviderConfigs.xai)
+
+      const xaiModel = createMockLanguageModel({
+        provider: 'xai',
+        modelId: 'grok-2-latest'
+      })
+
+      vi.mocked(globalRegistryManagement.languageModel).mockReturnValue(xaiModel)
+
+      await xaiExecutor.generateText({
+        model: 'grok-2-latest',
+        messages: testMessages.simple
+      })
+
+      expect(globalRegistryManagement.languageModel).toHaveBeenCalledWith('xai|grok-2-latest')
+    })
+
+    it('should work with DeepSeek provider', async () => {
+      const deepseekExecutor = RuntimeExecutor.create('deepseek', mockProviderConfigs.deepseek)
+
+      const deepseekModel = createMockLanguageModel({
+        provider: 'deepseek',
+        modelId: 'deepseek-chat'
+      })
+
+      vi.mocked(globalRegistryManagement.languageModel).mockReturnValue(deepseekModel)
+
+      await deepseekExecutor.generateText({
+        model: 'deepseek-chat',
+        messages: testMessages.simple
+      })
+
+      expect(globalRegistryManagement.languageModel).toHaveBeenCalledWith('deepseek|deepseek-chat')
+    })
+  })
+
+  describe('Plugin Integration', () => {
+    it('should execute all plugin hooks', async () => {
+      const pluginCalls: string[] = []
+
+      const testPlugin: AiPlugin = {
+        name: 'test-plugin',
+        onRequestStart: vi.fn(async () => {
+          pluginCalls.push('onRequestStart')
+        }),
+        transformParams: vi.fn(async (params) => {
+          pluginCalls.push('transformParams')
+          return { ...params, temperature: 0.8 }
+        }),
+        transformResult: vi.fn(async (result) => {
+          pluginCalls.push('transformResult')
+          return { ...result, text: result.text + ' [modified]' }
+        }),
+        onRequestEnd: vi.fn(async () => {
+          pluginCalls.push('onRequestEnd')
+        })
+      }
+
+      const executorWithPlugin = RuntimeExecutor.create('openai', mockProviderConfigs.openai, [testPlugin])
+
+      const result = await executorWithPlugin.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      expect(pluginCalls).toEqual(['onRequestStart', 'transformParams', 'transformResult', 'onRequestEnd'])
+
+      // Verify transformed parameters
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          temperature: 0.8
+        })
+      )
+
+      // Verify transformed result
+      expect(result.text).toContain('[modified]')
+    })
+
+    it('should handle multiple plugins in order', async () => {
+      const pluginOrder: string[] = []
+
+      const plugin1: AiPlugin = {
+        name: 'plugin-1',
+        transformParams: vi.fn(async (params) => {
+          pluginOrder.push('plugin-1')
+          return { ...params, temperature: 0.5 }
+        })
+      }
+
+      const plugin2: AiPlugin = {
+        name: 'plugin-2',
+        transformParams: vi.fn(async (params) => {
+          pluginOrder.push('plugin-2')
+          return { ...params, maxTokens: 200 }
+        })
+      }
+
+      const executorWithPlugins = RuntimeExecutor.create('openai', mockProviderConfigs.openai, [plugin1, plugin2])
+
+      await executorWithPlugins.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      expect(pluginOrder).toEqual(['plugin-1', 'plugin-2'])
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          temperature: 0.5,
+          maxTokens: 200
+        })
+      )
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle API errors', async () => {
+      const error = new Error('API request failed')
+      vi.mocked(generateText).mockRejectedValue(error)
+
+      await expect(
+        executor.generateText({
+          model: 'gpt-4',
+          messages: testMessages.simple
+        })
+      ).rejects.toThrow('API request failed')
+    })
+
+    it('should execute onError plugin hook', async () => {
+      const error = new Error('Generation failed')
+      vi.mocked(generateText).mockRejectedValue(error)
+
+      const errorPlugin: AiPlugin = {
+        name: 'error-handler',
+        onError: vi.fn()
+      }
+
+      const executorWithPlugin = RuntimeExecutor.create('openai', mockProviderConfigs.openai, [errorPlugin])
+
+      await expect(
+        executorWithPlugin.generateText({
+          model: 'gpt-4',
+          messages: testMessages.simple
+        })
+      ).rejects.toThrow('Generation failed')
+
+      expect(errorPlugin.onError).toHaveBeenCalledWith(
+        error,
+        expect.objectContaining({
+          providerId: 'openai',
+          modelId: 'gpt-4'
+        })
+      )
+    })
+
+    it('should handle model not found error', async () => {
+      const error = new Error('Model not found: invalid-model')
+      vi.mocked(globalRegistryManagement.languageModel).mockImplementation(() => {
+        throw error
+      })
+
+      await expect(
+        executor.generateText({
+          model: 'invalid-model',
+          messages: testMessages.simple
+        })
+      ).rejects.toThrow('Model not found')
+    })
+  })
+
+  describe('Usage and Metadata', () => {
+    it('should return usage information', async () => {
+      const result = await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      expect(result.usage).toBeDefined()
+      expect(result.usage.inputTokens).toBe(15)
+      expect(result.usage.outputTokens).toBe(8)
+      expect(result.usage.totalTokens).toBe(23)
+    })
+
+    it('should handle warnings', async () => {
+      vi.mocked(generateText).mockResolvedValue(mockCompleteResponses.withWarnings as any)
+
+      const result = await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        temperature: 2.5 // Unsupported value
+      })
+
+      expect(result.warnings).toBeDefined()
+      expect(result.warnings).toHaveLength(1)
+      expect(result.warnings![0].type).toBe('unsupported-setting')
+    })
+  })
+
+  describe('Abort Signal', () => {
+    it('should support abort signal', async () => {
+      const abortController = new AbortController()
+
+      await executor.generateText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        abortSignal: abortController.signal
+      })
+
+      expect(generateText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          abortSignal: abortController.signal
+        })
+      )
+    })
+
+    it('should handle aborted request', async () => {
+      const abortError = new Error('Request aborted')
+      abortError.name = 'AbortError'
+
+      vi.mocked(generateText).mockRejectedValue(abortError)
+
+      const abortController = new AbortController()
+      abortController.abort()
+
+      await expect(
+        executor.generateText({
+          model: 'gpt-4',
+          messages: testMessages.simple,
+          abortSignal: abortController.signal
+        })
+      ).rejects.toThrow('Request aborted')
+    })
+  })
+})

packages/aiCore/src/core/runtime/__tests__/streamText.test.ts

@@ -0,0 +1,525 @@
+/**
+ * RuntimeExecutor.streamText Comprehensive Tests
+ * Tests streaming text generation across all providers with various parameters
+ */
+
+import { streamText } from 'ai'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { collectStreamChunks, createMockLanguageModel, mockProviderConfigs, testMessages } from '../../../__tests__'
+import type { AiPlugin } from '../../plugins'
+import { globalRegistryManagement } from '../../providers/RegistryManagement'
+import { RuntimeExecutor } from '../executor'
+
+// Mock AI SDK
+vi.mock('ai', () => ({
+  streamText: vi.fn()
+}))
+
+vi.mock('../../providers/RegistryManagement', () => ({
+  globalRegistryManagement: {
+    languageModel: vi.fn()
+  },
+  DEFAULT_SEPARATOR: '|'
+}))
+
+describe('RuntimeExecutor.streamText', () => {
+  let executor: RuntimeExecutor<'openai'>
+  let mockLanguageModel: any
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    executor = RuntimeExecutor.create('openai', mockProviderConfigs.openai)
+
+    mockLanguageModel = createMockLanguageModel({
+      provider: 'openai',
+      modelId: 'gpt-4'
+    })
+
+    vi.mocked(globalRegistryManagement.languageModel).mockReturnValue(mockLanguageModel)
+  })
+
+  describe('Basic Functionality', () => {
+    it('should stream text with minimal parameters', async () => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Hello'
+          yield ' '
+          yield 'World'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Hello' }
+          yield { type: 'text-delta', textDelta: ' ' }
+          yield { type: 'text-delta', textDelta: 'World' }
+        })(),
+        usage: Promise.resolve({ promptTokens: 5, completionTokens: 3, totalTokens: 8 })
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      const result = await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      expect(streamText).toHaveBeenCalledWith({
+        model: mockLanguageModel,
+        messages: testMessages.simple
+      })
+
+      const chunks = await collectStreamChunks(result.textStream)
+      expect(chunks).toEqual(['Hello', ' ', 'World'])
+    })
+
+    it('should stream with system messages', async () => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.withSystem
+      })
+
+      expect(streamText).toHaveBeenCalledWith({
+        model: mockLanguageModel,
+        messages: testMessages.withSystem
+      })
+    })
+
+    it('should stream multi-turn conversations', async () => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Multi-turn response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Multi-turn response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.multiTurn
+      })
+
+      expect(streamText).toHaveBeenCalled()
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: testMessages.multiTurn
+        })
+      )
+    })
+  })
+
+  describe('Temperature Parameter', () => {
+    const temperatures = [0, 0.3, 0.5, 0.7, 0.9, 1.0, 1.5, 2.0]
+
+    it.each(temperatures)('should support temperature=%s', async (temperature) => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        temperature
+      })
+
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          temperature
+        })
+      )
+    })
+  })
+
+  describe('Max Tokens Parameter', () => {
+    const maxTokensValues = [10, 50, 100, 500, 1000, 2000, 4000]
+
+    it.each(maxTokensValues)('should support maxTokens=%s', async (maxTokens) => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        maxOutputTokens: maxTokens
+      })
+
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          maxTokens
+        })
+      )
+    })
+  })
+
+  describe('Top P Parameter', () => {
+    const topPValues = [0.1, 0.3, 0.5, 0.7, 0.9, 0.95, 1.0]
+
+    it.each(topPValues)('should support topP=%s', async (topP) => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        topP
+      })
+
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          topP
+        })
+      )
+    })
+  })
+
+  describe('Frequency and Presence Penalty', () => {
+    it('should support frequency penalty', async () => {
+      const penalties = [-2.0, -1.0, 0, 0.5, 1.0, 1.5, 2.0]
+
+      for (const frequencyPenalty of penalties) {
+        vi.clearAllMocks()
+
+        const mockStream = {
+          textStream: (async function* () {
+            yield 'Response'
+          })(),
+          fullStream: (async function* () {
+            yield { type: 'text-delta', textDelta: 'Response' }
+          })()
+        }
+
+        vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+        await executor.streamText({
+          model: 'gpt-4',
+          messages: testMessages.simple,
+          frequencyPenalty
+        })
+
+        expect(streamText).toHaveBeenCalledWith(
+          expect.objectContaining({
+            frequencyPenalty
+          })
+        )
+      }
+    })
+
+    it('should support presence penalty', async () => {
+      const penalties = [-2.0, -1.0, 0, 0.5, 1.0, 1.5, 2.0]
+
+      for (const presencePenalty of penalties) {
+        vi.clearAllMocks()
+
+        const mockStream = {
+          textStream: (async function* () {
+            yield 'Response'
+          })(),
+          fullStream: (async function* () {
+            yield { type: 'text-delta', textDelta: 'Response' }
+          })()
+        }
+
+        vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+        await executor.streamText({
+          model: 'gpt-4',
+          messages: testMessages.simple,
+          presencePenalty
+        })
+
+        expect(streamText).toHaveBeenCalledWith(
+          expect.objectContaining({
+            presencePenalty
+          })
+        )
+      }
+    })
+
+    it('should support both penalties together', async () => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        frequencyPenalty: 0.5,
+        presencePenalty: 0.5
+      })
+
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          frequencyPenalty: 0.5,
+          presencePenalty: 0.5
+        })
+      )
+    })
+  })
+
+  describe('Seed Parameter', () => {
+    it('should support seed for deterministic output', async () => {
+      const seeds = [0, 12345, 67890, 999999]
+
+      for (const seed of seeds) {
+        vi.clearAllMocks()
+
+        const mockStream = {
+          textStream: (async function* () {
+            yield 'Response'
+          })(),
+          fullStream: (async function* () {
+            yield { type: 'text-delta', textDelta: 'Response' }
+          })()
+        }
+
+        vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+        await executor.streamText({
+          model: 'gpt-4',
+          messages: testMessages.simple,
+          seed
+        })
+
+        expect(streamText).toHaveBeenCalledWith(
+          expect.objectContaining({
+            seed
+          })
+        )
+      }
+    })
+  })
+
+  describe('Abort Signal', () => {
+    it('should support abort signal', async () => {
+      const abortController = new AbortController()
+
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        abortSignal: abortController.signal
+      })
+
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          abortSignal: abortController.signal
+        })
+      )
+    })
+
+    it('should handle abort during streaming', async () => {
+      const abortController = new AbortController()
+
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Start'
+          // Simulate abort
+          abortController.abort()
+          throw new Error('Aborted')
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Start' }
+          throw new Error('Aborted')
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      const result = await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple,
+        abortSignal: abortController.signal
+      })
+
+      await expect(async () => {
+        // oxlint-disable-next-line no-unused-vars
+        for await (const _chunk of result.textStream) {
+          // Stream should be interrupted
+        }
+      }).rejects.toThrow('Aborted')
+    })
+  })
+
+  describe('Plugin Integration', () => {
+    it('should execute plugins during streaming', async () => {
+      const pluginCalls: string[] = []
+
+      const testPlugin: AiPlugin = {
+        name: 'test-plugin',
+        onRequestStart: vi.fn(async () => {
+          pluginCalls.push('onRequestStart')
+        }),
+        transformParams: vi.fn(async (params) => {
+          pluginCalls.push('transformParams')
+          return { ...params, temperature: 0.5 }
+        }),
+        onRequestEnd: vi.fn(async () => {
+          pluginCalls.push('onRequestEnd')
+        })
+      }
+
+      const executorWithPlugin = RuntimeExecutor.create('openai', mockProviderConfigs.openai, [testPlugin])
+
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      const result = await executorWithPlugin.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      // Consume stream
+      // oxlint-disable-next-line no-unused-vars
+      for await (const _chunk of result.textStream) {
+        // Stream chunks
+      }
+
+      expect(pluginCalls).toContain('onRequestStart')
+      expect(pluginCalls).toContain('transformParams')
+
+      // Verify transformed parameters were used
+      expect(streamText).toHaveBeenCalledWith(
+        expect.objectContaining({
+          temperature: 0.5
+        })
+      )
+    })
+  })
+
+  describe('Full Stream with Finish Reason', () => {
+    it('should provide finish reason in full stream', async () => {
+      const mockStream = {
+        textStream: (async function* () {
+          yield 'Response'
+        })(),
+        fullStream: (async function* () {
+          yield { type: 'text-delta', textDelta: 'Response' }
+          yield {
+            type: 'finish',
+            finishReason: 'stop',
+            usage: { promptTokens: 5, completionTokens: 3, totalTokens: 8 }
+          }
+        })()
+      }
+
+      vi.mocked(streamText).mockResolvedValue(mockStream as any)
+
+      const result = await executor.streamText({
+        model: 'gpt-4',
+        messages: testMessages.simple
+      })
+
+      const fullChunks = await collectStreamChunks(result.fullStream)
+
+      expect(fullChunks).toHaveLength(2)
+      expect(fullChunks[0]).toEqual({ type: 'text-delta', textDelta: 'Response' })
+      expect(fullChunks[1]).toEqual({
+        type: 'finish',
+        finishReason: 'stop',
+        usage: { promptTokens: 5, completionTokens: 3, totalTokens: 8 }
+      })
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle streaming errors', async () => {
+      const error = new Error('Streaming failed')
+      vi.mocked(streamText).mockRejectedValue(error)
+
+      await expect(
+        executor.streamText({
+          model: 'gpt-4',
+          messages: testMessages.simple
+        })
+      ).rejects.toThrow('Streaming failed')
+    })
+
+    it('should execute onError plugin hook on failure', async () => {
+      const error = new Error('Stream error')
+      vi.mocked(streamText).mockRejectedValue(error)
+
+      const errorPlugin: AiPlugin = {
+        name: 'error-handler',
+        onError: vi.fn()
+      }
+
+      const executorWithPlugin = RuntimeExecutor.create('openai', mockProviderConfigs.openai, [errorPlugin])
+
+      await expect(
+        executorWithPlugin.streamText({
+          model: 'gpt-4',
+          messages: testMessages.simple
+        })
+      ).rejects.toThrow('Stream error')
+
+      expect(errorPlugin.onError).toHaveBeenCalledWith(
+        error,
+        expect.objectContaining({
+          providerId: 'openai',
+          modelId: 'gpt-4'
+        })
+      )
+    })
+  })
+})

src/renderer/src/aiCore/legacy/clients/ApiClientFactory.ts

@@ -1,6 +1,6 @@
 import { loggerService } from '@logger'
-import { isNewApiProvider } from '@renderer/config/providers'
 import type { Provider } from '@renderer/types'
+import { isNewApiProvider } from '@renderer/utils/provider'
 
 import { AihubmixAPIClient } from './aihubmix/AihubmixAPIClient'
 import { AnthropicAPIClient } from './anthropic/AnthropicAPIClient'

src/renderer/src/aiCore/legacy/clients/BaseApiClient.ts

@@ -7,7 +7,6 @@ import {
   isSupportFlexServiceTierModel
 } from '@renderer/config/models'
 import { REFERENCE_PROMPT } from '@renderer/config/prompts'
-import { isSupportServiceTierProvider } from '@renderer/config/providers'
 import { getLMStudioKeepAliveTime } from '@renderer/hooks/useLMStudio'
 import { getAssistantSettings } from '@renderer/services/AssistantService'
 import type {
@@ -48,6 +47,7 @@ import type {
 import { isJSON, parseJSON } from '@renderer/utils'
 import { addAbortController, removeAbortController } from '@renderer/utils/abortController'
 import { findFileBlocks, getMainTextContent } from '@renderer/utils/messageUtils/find'
+import { isSupportServiceTierProvider } from '@renderer/utils/provider'
 import { defaultTimeout } from '@shared/config/constant'
 import { defaultAppHeaders } from '@shared/utils'
 import { isEmpty } from 'lodash'

src/renderer/src/aiCore/legacy/clients/__tests__/ApiClientFactory.test.ts

@@ -58,10 +58,27 @@ vi.mock('../aws/AwsBedrockAPIClient', () => ({
   AwsBedrockAPIClient: vi.fn().mockImplementation(() => ({}))
 }))
 
+vi.mock('@renderer/services/AssistantService.ts', () => ({
+  getDefaultAssistant: () => {
+    return {
+      id: 'default',
+      name: 'default',
+      emoji: '😀',
+      prompt: '',
+      topics: [],
+      messages: [],
+      type: 'assistant',
+      regularPhrases: [],
+      settings: {}
+    }
+  }
+}))
+
 // Mock the models config to prevent circular dependency issues
 vi.mock('@renderer/config/models', () => ({
   findTokenLimit: vi.fn(),
   isReasoningModel: vi.fn(),
+  isOpenAILLMModel: vi.fn(),
   SYSTEM_MODELS: {
     silicon: [],
     defaultModel: []

src/renderer/src/aiCore/legacy/clients/gemini/VertexAPIClient.ts

@@ -1,7 +1,8 @@
 import { GoogleGenAI } from '@google/genai'
 import { loggerService } from '@logger'
-import { createVertexProvider, isVertexAIConfigured, isVertexProvider } from '@renderer/hooks/useVertexAI'
+import { createVertexProvider, isVertexAIConfigured } from '@renderer/hooks/useVertexAI'
 import type { Model, Provider, VertexProvider } from '@renderer/types'
+import { isVertexProvider } from '@renderer/utils/provider'
 import { isEmpty } from 'lodash'
 
 import { AnthropicVertexClient } from '../anthropic/AnthropicVertexClient'

src/renderer/src/aiCore/legacy/clients/openai/OpenAIApiClient.ts

@@ -10,7 +10,6 @@ import { DEFAULT_MAX_TOKENS } from '@renderer/config/constant'
 import {
   findTokenLimit,
   GEMINI_FLASH_MODEL_REGEX,
-  getOpenAIWebSearchParams,
   getThinkModelType,
   isClaudeReasoningModel,
   isDeepSeekHybridInferenceModel,
@@ -40,12 +39,6 @@ import {
   MODEL_SUPPORTED_REASONING_EFFORT,
   ZHIPU_RESULT_TOKENS
 } from '@renderer/config/models'
-import {
-  isSupportArrayContentProvider,
-  isSupportDeveloperRoleProvider,
-  isSupportEnableThinkingProvider,
-  isSupportStreamOptionsProvider
-} from '@renderer/config/providers'
 import { mapLanguageToQwenMTModel } from '@renderer/config/translate'
 import { processPostsuffixQwen3Model, processReqMessages } from '@renderer/services/ModelMessageService'
 import { estimateTextTokens } from '@renderer/services/TokenService'
@@ -89,6 +82,12 @@ import {
   openAIToolsToMcpTool
 } from '@renderer/utils/mcp-tools'
 import { findFileBlocks, findImageBlocks } from '@renderer/utils/messageUtils/find'
+import {
+  isSupportArrayContentProvider,
+  isSupportDeveloperRoleProvider,
+  isSupportEnableThinkingProvider,
+  isSupportStreamOptionsProvider
+} from '@renderer/utils/provider'
 import { t } from 'i18next'
 
 import type { GenericChunk } from '../../middleware/schemas'
@@ -743,7 +742,7 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
             : {}),
           ...this.getProviderSpecificParameters(assistant, model),
           ...reasoningEffort,
-          ...getOpenAIWebSearchParams(model, enableWebSearch),
+          // ...getOpenAIWebSearchParams(model, enableWebSearch),
           // OpenRouter usage tracking
           ...(this.provider.id === 'openrouter' ? { usage: { include: true } } : {}),
           ...extra_body,

src/renderer/src/aiCore/legacy/clients/openai/OpenAIResponseAPIClient.ts

@@ -12,7 +12,6 @@ import {
   isSupportVerbosityModel,
   isVisionModel
 } from '@renderer/config/models'
-import { isSupportDeveloperRoleProvider } from '@renderer/config/providers'
 import { estimateTextTokens } from '@renderer/services/TokenService'
 import type {
   FileMetadata,
@@ -43,6 +42,7 @@ import {
   openAIToolsToMcpTool
 } from '@renderer/utils/mcp-tools'
 import { findFileBlocks, findImageBlocks } from '@renderer/utils/messageUtils/find'
+import { isSupportDeveloperRoleProvider } from '@renderer/utils/provider'
 import { MB } from '@shared/config/constant'
 import { t } from 'i18next'
 import { isEmpty } from 'lodash'

src/renderer/src/aiCore/legacy/middleware/common/ErrorHandlerMiddleware.ts

@@ -1,6 +1,7 @@
 import { loggerService } from '@logger'
 import { isZhipuModel } from '@renderer/config/models'
 import { getStoreProviders } from '@renderer/hooks/useStore'
+import { getDefaultModel } from '@renderer/services/AssistantService'
 import type { Chunk } from '@renderer/types/chunk'
 
 import type { CompletionsParams, CompletionsResult } from '../schemas'
@@ -66,7 +67,7 @@ export const ErrorHandlerMiddleware =
   }
 
 function handleError(error: any, params: CompletionsParams): any {
-  if (isZhipuModel(params.assistant.model) && error.status && !params.enableGenerateImage) {
+  if (isZhipuModel(params.assistant.model || getDefaultModel()) && error.status && !params.enableGenerateImage) {
     return handleZhipuError(error)
   }
 

src/renderer/src/aiCore/middleware/AiSdkMiddlewareBuilder.ts

@@ -1,10 +1,10 @@
 import type { WebSearchPluginConfig } from '@cherrystudio/ai-core/built-in/plugins'
 import { loggerService } from '@logger'
 import { isSupportedThinkingTokenQwenModel } from '@renderer/config/models'
-import { isSupportEnableThinkingProvider } from '@renderer/config/providers'
 import type { MCPTool } from '@renderer/types'
 import { type Assistant, type Message, type Model, type Provider } from '@renderer/types'
 import type { Chunk } from '@renderer/types/chunk'
+import { isSupportEnableThinkingProvider } from '@renderer/utils/provider'
 import type { LanguageModelMiddleware } from 'ai'
 import { extractReasoningMiddleware, simulateStreamingMiddleware } from 'ai'
 import { isEmpty } from 'lodash'

src/renderer/src/aiCore/prepareParams/__tests__/message-converter.test.ts

@@ -0,0 +1,234 @@
+import type { Message, Model } from '@renderer/types'
+import type { FileMetadata } from '@renderer/types/file'
+import { FileTypes } from '@renderer/types/file'
+import {
+  AssistantMessageStatus,
+  type FileMessageBlock,
+  type ImageMessageBlock,
+  MessageBlockStatus,
+  MessageBlockType,
+  type ThinkingMessageBlock,
+  UserMessageStatus
+} from '@renderer/types/newMessage'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { convertFileBlockToFilePartMock, convertFileBlockToTextPartMock } = vi.hoisted(() => ({
+  convertFileBlockToFilePartMock: vi.fn(),
+  convertFileBlockToTextPartMock: vi.fn()
+}))
+
+vi.mock('../fileProcessor', () => ({
+  convertFileBlockToFilePart: convertFileBlockToFilePartMock,
+  convertFileBlockToTextPart: convertFileBlockToTextPartMock
+}))
+
+const visionModelIds = new Set(['gpt-4o-mini', 'qwen-image-edit'])
+const imageEnhancementModelIds = new Set(['qwen-image-edit'])
+
+vi.mock('@renderer/config/models', () => ({
+  isVisionModel: (model: Model) => visionModelIds.has(model.id),
+  isImageEnhancementModel: (model: Model) => imageEnhancementModelIds.has(model.id)
+}))
+
+type MockableMessage = Message & {
+  __mockContent?: string
+  __mockFileBlocks?: FileMessageBlock[]
+  __mockImageBlocks?: ImageMessageBlock[]
+  __mockThinkingBlocks?: ThinkingMessageBlock[]
+}
+
+vi.mock('@renderer/utils/messageUtils/find', () => ({
+  getMainTextContent: (message: Message) => (message as MockableMessage).__mockContent ?? '',
+  findFileBlocks: (message: Message) => (message as MockableMessage).__mockFileBlocks ?? [],
+  findImageBlocks: (message: Message) => (message as MockableMessage).__mockImageBlocks ?? [],
+  findThinkingBlocks: (message: Message) => (message as MockableMessage).__mockThinkingBlocks ?? []
+}))
+
+import { convertMessagesToSdkMessages, convertMessageToSdkParam } from '../messageConverter'
+
+let messageCounter = 0
+let blockCounter = 0
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'gpt-4o-mini',
+  name: 'GPT-4o mini',
+  provider: 'openai',
+  group: 'openai',
+  ...overrides
+})
+
+const createMessage = (role: Message['role']): MockableMessage =>
+  ({
+    id: `message-${++messageCounter}`,
+    role,
+    assistantId: 'assistant-1',
+    topicId: 'topic-1',
+    createdAt: new Date(2024, 0, 1, 0, 0, messageCounter).toISOString(),
+    status: role === 'assistant' ? AssistantMessageStatus.SUCCESS : UserMessageStatus.SUCCESS,
+    blocks: []
+  }) as MockableMessage
+
+const createFileBlock = (
+  messageId: string,
+  overrides: Partial<Omit<FileMessageBlock, 'file' | 'messageId' | 'type'>> & { file?: Partial<FileMetadata> } = {}
+): FileMessageBlock => {
+  const { file, ...blockOverrides } = overrides
+  const timestamp = new Date(2024, 0, 1, 0, 0, ++blockCounter).toISOString()
+  return {
+    id: blockOverrides.id ?? `file-block-${blockCounter}`,
+    messageId,
+    type: MessageBlockType.FILE,
+    createdAt: blockOverrides.createdAt ?? timestamp,
+    status: blockOverrides.status ?? MessageBlockStatus.SUCCESS,
+    file: {
+      id: file?.id ?? `file-${blockCounter}`,
+      name: file?.name ?? 'document.txt',
+      origin_name: file?.origin_name ?? 'document.txt',
+      path: file?.path ?? '/tmp/document.txt',
+      size: file?.size ?? 1024,
+      ext: file?.ext ?? '.txt',
+      type: file?.type ?? FileTypes.TEXT,
+      created_at: file?.created_at ?? timestamp,
+      count: file?.count ?? 1,
+      ...file
+    },
+    ...blockOverrides
+  }
+}
+
+const createImageBlock = (
+  messageId: string,
+  overrides: Partial<Omit<ImageMessageBlock, 'type' | 'messageId'>> = {}
+): ImageMessageBlock => ({
+  id: overrides.id ?? `image-block-${++blockCounter}`,
+  messageId,
+  type: MessageBlockType.IMAGE,
+  createdAt: overrides.createdAt ?? new Date(2024, 0, 1, 0, 0, blockCounter).toISOString(),
+  status: overrides.status ?? MessageBlockStatus.SUCCESS,
+  url: overrides.url ?? 'https://example.com/image.png',
+  ...overrides
+})
+
+describe('messageConverter', () => {
+  beforeEach(() => {
+    convertFileBlockToFilePartMock.mockReset()
+    convertFileBlockToTextPartMock.mockReset()
+    convertFileBlockToFilePartMock.mockResolvedValue(null)
+    convertFileBlockToTextPartMock.mockResolvedValue(null)
+    messageCounter = 0
+    blockCounter = 0
+  })
+
+  describe('convertMessageToSdkParam', () => {
+    it('includes text and image parts for user messages on vision models', async () => {
+      const model = createModel()
+      const message = createMessage('user')
+      message.__mockContent = 'Describe this picture'
+      message.__mockImageBlocks = [createImageBlock(message.id, { url: 'https://example.com/cat.png' })]
+
+      const result = await convertMessageToSdkParam(message, true, model)
+
+      expect(result).toEqual({
+        role: 'user',
+        content: [
+          { type: 'text', text: 'Describe this picture' },
+          { type: 'image', image: 'https://example.com/cat.png' }
+        ]
+      })
+    })
+
+    it('returns file instructions as a system message when native uploads succeed', async () => {
+      const model = createModel()
+      const message = createMessage('user')
+      message.__mockContent = 'Summarize the PDF'
+      message.__mockFileBlocks = [createFileBlock(message.id)]
+      convertFileBlockToFilePartMock.mockResolvedValueOnce({
+        type: 'file',
+        filename: 'document.pdf',
+        mediaType: 'application/pdf',
+        data: 'fileid://remote-file'
+      })
+
+      const result = await convertMessageToSdkParam(message, false, model)
+
+      expect(result).toEqual([
+        {
+          role: 'system',
+          content: 'fileid://remote-file'
+        },
+        {
+          role: 'user',
+          content: [{ type: 'text', text: 'Summarize the PDF' }]
+        }
+      ])
+    })
+  })
+
+  describe('convertMessagesToSdkMessages', () => {
+    it('appends assistant images to the final user message for image enhancement models', async () => {
+      const model = createModel({ id: 'qwen-image-edit', name: 'Qwen Image Edit', provider: 'qwen', group: 'qwen' })
+      const initialUser = createMessage('user')
+      initialUser.__mockContent = 'Start editing'
+
+      const assistant = createMessage('assistant')
+      assistant.__mockContent = 'Here is the current preview'
+      assistant.__mockImageBlocks = [createImageBlock(assistant.id, { url: 'https://example.com/preview.png' })]
+
+      const finalUser = createMessage('user')
+      finalUser.__mockContent = 'Increase the brightness'
+
+      const result = await convertMessagesToSdkMessages([initialUser, assistant, finalUser], model)
+
+      expect(result).toEqual([
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Here is the current preview' }]
+        },
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'Increase the brightness' },
+            { type: 'image', image: 'https://example.com/preview.png' }
+          ]
+        }
+      ])
+    })
+
+    it('preserves preceding system instructions when building enhancement payloads', async () => {
+      const model = createModel({ id: 'qwen-image-edit', name: 'Qwen Image Edit', provider: 'qwen', group: 'qwen' })
+      const fileUser = createMessage('user')
+      fileUser.__mockContent = 'Use this document as inspiration'
+      fileUser.__mockFileBlocks = [createFileBlock(fileUser.id, { file: { ext: '.pdf', type: FileTypes.DOCUMENT } })]
+      convertFileBlockToFilePartMock.mockResolvedValueOnce({
+        type: 'file',
+        filename: 'reference.pdf',
+        mediaType: 'application/pdf',
+        data: 'fileid://reference'
+      })
+
+      const assistant = createMessage('assistant')
+      assistant.__mockContent = 'Generated previews ready'
+      assistant.__mockImageBlocks = [createImageBlock(assistant.id, { url: 'https://example.com/reference.png' })]
+
+      const finalUser = createMessage('user')
+      finalUser.__mockContent = 'Apply the edits'
+
+      const result = await convertMessagesToSdkMessages([fileUser, assistant, finalUser], model)
+
+      expect(result).toEqual([
+        { role: 'system', content: 'fileid://reference' },
+        {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'Generated previews ready' }]
+        },
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'Apply the edits' },
+            { type: 'image', image: 'https://example.com/reference.png' }
+          ]
+        }
+      ])
+    })
+  })
+})

src/renderer/src/aiCore/prepareParams/__tests__/model-parameters.test.ts

@@ -0,0 +1,218 @@
+import type { Assistant, AssistantSettings, Model, Topic } from '@renderer/types'
+import { TopicType } from '@renderer/types'
+import { defaultTimeout } from '@shared/config/constant'
+import { describe, expect, it, vi } from 'vitest'
+
+import { getTemperature, getTimeout, getTopP } from '../modelParameters'
+
+vi.mock('@renderer/services/AssistantService', () => ({
+  getAssistantSettings: (assistant: Assistant): AssistantSettings => ({
+    contextCount: assistant.settings?.contextCount ?? 4096,
+    temperature: assistant.settings?.temperature ?? 0.7,
+    enableTemperature: assistant.settings?.enableTemperature ?? true,
+    topP: assistant.settings?.topP ?? 1,
+    enableTopP: assistant.settings?.enableTopP ?? false,
+    enableMaxTokens: assistant.settings?.enableMaxTokens ?? false,
+    maxTokens: assistant.settings?.maxTokens,
+    streamOutput: assistant.settings?.streamOutput ?? true,
+    toolUseMode: assistant.settings?.toolUseMode ?? 'prompt',
+    defaultModel: assistant.defaultModel,
+    customParameters: assistant.settings?.customParameters ?? [],
+    reasoning_effort: assistant.settings?.reasoning_effort,
+    reasoning_effort_cache: assistant.settings?.reasoning_effort_cache,
+    qwenThinkMode: assistant.settings?.qwenThinkMode
+  })
+}))
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  getStoreSetting: vi.fn(),
+  useSettings: vi.fn(() => ({})),
+  useNavbarPosition: vi.fn(() => ({ navbarPosition: 'left', isLeftNavbar: true, isTopNavbar: false }))
+}))
+
+vi.mock('@renderer/hooks/useStore', () => ({
+  getStoreProviders: vi.fn(() => [])
+}))
+
+vi.mock('@renderer/store/settings', () => ({
+  default: (state = { settings: {} }) => state
+}))
+
+vi.mock('@renderer/store/assistants', () => ({
+  default: (state = { assistants: [] }) => state
+}))
+
+const createTopic = (assistantId: string): Topic => ({
+  id: `topic-${assistantId}`,
+  assistantId,
+  name: 'topic',
+  createdAt: new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+  messages: [],
+  type: TopicType.Chat
+})
+
+const createAssistant = (settings: Assistant['settings'] = {}): Assistant => {
+  const assistantId = 'assistant-1'
+  return {
+    id: assistantId,
+    name: 'Test Assistant',
+    prompt: 'prompt',
+    topics: [createTopic(assistantId)],
+    type: 'assistant',
+    settings
+  }
+}
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'gpt-4o',
+  provider: 'openai',
+  name: 'GPT-4o',
+  group: 'openai',
+  ...overrides
+})
+
+describe('modelParameters', () => {
+  describe('getTemperature', () => {
+    it('returns undefined when reasoning effort is enabled for Claude models', () => {
+      const assistant = createAssistant({ reasoning_effort: 'medium' })
+      const model = createModel({ id: 'claude-opus-4', name: 'Claude Opus 4', provider: 'anthropic', group: 'claude' })
+
+      expect(getTemperature(assistant, model)).toBeUndefined()
+    })
+
+    it('returns undefined for models without temperature/topP support', () => {
+      const assistant = createAssistant({ enableTemperature: true })
+      const model = createModel({ id: 'qwen-mt-large', name: 'Qwen MT', provider: 'qwen', group: 'qwen' })
+
+      expect(getTemperature(assistant, model)).toBeUndefined()
+    })
+
+    it('returns undefined for Claude 4.5 reasoning models when only TopP is enabled', () => {
+      const assistant = createAssistant({ enableTopP: true, enableTemperature: false })
+      const model = createModel({
+        id: 'claude-sonnet-4.5',
+        name: 'Claude Sonnet 4.5',
+        provider: 'anthropic',
+        group: 'claude'
+      })
+
+      expect(getTemperature(assistant, model)).toBeUndefined()
+    })
+
+    it('returns configured temperature when enabled', () => {
+      const assistant = createAssistant({ enableTemperature: true, temperature: 0.42 })
+      const model = createModel({ id: 'gpt-4o', provider: 'openai', group: 'openai' })
+
+      expect(getTemperature(assistant, model)).toBe(0.42)
+    })
+
+    it('returns undefined when temperature is disabled', () => {
+      const assistant = createAssistant({ enableTemperature: false, temperature: 0.9 })
+      const model = createModel({ id: 'gpt-4o', provider: 'openai', group: 'openai' })
+
+      expect(getTemperature(assistant, model)).toBeUndefined()
+    })
+
+    it('clamps temperature to max 1.0 for Zhipu models', () => {
+      const assistant = createAssistant({ enableTemperature: true, temperature: 2.0 })
+      const model = createModel({ id: 'glm-4-plus', name: 'GLM-4 Plus', provider: 'zhipu', group: 'zhipu' })
+
+      expect(getTemperature(assistant, model)).toBe(1.0)
+    })
+
+    it('clamps temperature to max 1.0 for Anthropic models', () => {
+      const assistant = createAssistant({ enableTemperature: true, temperature: 1.5 })
+      const model = createModel({
+        id: 'claude-sonnet-3.5',
+        name: 'Claude 3.5 Sonnet',
+        provider: 'anthropic',
+        group: 'claude'
+      })
+
+      expect(getTemperature(assistant, model)).toBe(1.0)
+    })
+
+    it('clamps temperature to max 1.0 for Moonshot models', () => {
+      const assistant = createAssistant({ enableTemperature: true, temperature: 2.0 })
+      const model = createModel({
+        id: 'moonshot-v1-8k',
+        name: 'Moonshot v1 8k',
+        provider: 'moonshot',
+        group: 'moonshot'
+      })
+
+      expect(getTemperature(assistant, model)).toBe(1.0)
+    })
+
+    it('does not clamp temperature for OpenAI models', () => {
+      const assistant = createAssistant({ enableTemperature: true, temperature: 2.0 })
+      const model = createModel({ id: 'gpt-4o', provider: 'openai', group: 'openai' })
+
+      expect(getTemperature(assistant, model)).toBe(2.0)
+    })
+
+    it('does not clamp temperature when it is already within limits', () => {
+      const assistant = createAssistant({ enableTemperature: true, temperature: 0.8 })
+      const model = createModel({ id: 'glm-4-plus', name: 'GLM-4 Plus', provider: 'zhipu', group: 'zhipu' })
+
+      expect(getTemperature(assistant, model)).toBe(0.8)
+    })
+  })
+
+  describe('getTopP', () => {
+    it('returns undefined when reasoning effort is enabled for Claude models', () => {
+      const assistant = createAssistant({ reasoning_effort: 'high' })
+      const model = createModel({ id: 'claude-opus-4', provider: 'anthropic', group: 'claude' })
+
+      expect(getTopP(assistant, model)).toBeUndefined()
+    })
+
+    it('returns undefined for models without TopP support', () => {
+      const assistant = createAssistant({ enableTopP: true })
+      const model = createModel({ id: 'qwen-mt-small', name: 'Qwen MT', provider: 'qwen', group: 'qwen' })
+
+      expect(getTopP(assistant, model)).toBeUndefined()
+    })
+
+    it('returns undefined for Claude 4.5 reasoning models when temperature is enabled', () => {
+      const assistant = createAssistant({ enableTemperature: true })
+      const model = createModel({
+        id: 'claude-opus-4.5',
+        name: 'Claude Opus 4.5',
+        provider: 'anthropic',
+        group: 'claude'
+      })
+
+      expect(getTopP(assistant, model)).toBeUndefined()
+    })
+
+    it('returns configured TopP when enabled', () => {
+      const assistant = createAssistant({ enableTopP: true, topP: 0.73 })
+      const model = createModel({ id: 'gpt-4o', provider: 'openai', group: 'openai' })
+
+      expect(getTopP(assistant, model)).toBe(0.73)
+    })
+
+    it('returns undefined when TopP is disabled', () => {
+      const assistant = createAssistant({ enableTopP: false, topP: 0.5 })
+      const model = createModel({ id: 'gpt-4o', provider: 'openai', group: 'openai' })
+
+      expect(getTopP(assistant, model)).toBeUndefined()
+    })
+  })
+
+  describe('getTimeout', () => {
+    it('uses an extended timeout for flex service tier models', () => {
+      const model = createModel({ id: 'o3-pro', provider: 'openai', group: 'openai' })
+
+      expect(getTimeout(model)).toBe(15 * 1000 * 60)
+    })
+
+    it('falls back to the default timeout otherwise', () => {
+      const model = createModel({ id: 'gpt-4o', provider: 'openai', group: 'openai' })
+
+      expect(getTimeout(model)).toBe(defaultTimeout)
+    })
+  })
+})

src/renderer/src/aiCore/prepareParams/header.ts

@@ -1,9 +1,8 @@
 import { isClaude4SeriesModel, isClaude45ReasoningModel } from '@renderer/config/models'
-import { isAwsBedrockProvider } from '@renderer/config/providers'
-import { isVertexProvider } from '@renderer/hooks/useVertexAI'
 import { getProviderByModel } from '@renderer/services/AssistantService'
 import type { Assistant, Model } from '@renderer/types'
 import { isToolUseModeFunction } from '@renderer/utils/assistant'
+import { isAwsBedrockProvider, isVertexProvider } from '@renderer/utils/provider'
 
 // https://docs.claude.com/en/docs/build-with-claude/extended-thinking#interleaved-thinking
 const INTERLEAVED_THINKING_HEADER = 'interleaved-thinking-2025-05-14'

src/renderer/src/aiCore/prepareParams/modelCapabilities.ts

@@ -85,19 +85,6 @@ export function supportsLargeFileUpload(model: Model): boolean {
   })
 }
 
-/**
- * 检查模型是否支持TopP
- */
-export function supportsTopP(model: Model): boolean {
-  const provider = getProviderByModel(model)
-
-  if (provider?.type === 'anthropic' || model?.endpoint_type === 'anthropic') {
-    return false
-  }
-
-  return true
-}
-
 /**
  * 获取提供商特定的文件大小限制
  */

src/renderer/src/aiCore/prepareParams/modelParameters.ts

@@ -3,17 +3,27 @@
  * 处理温度、TopP、超时等基础参数的获取逻辑
  */
 
+import { DEFAULT_MAX_TOKENS } from '@renderer/config/constant'
 import {
   isClaude45ReasoningModel,
   isClaudeReasoningModel,
+  isMaxTemperatureOneModel,
   isNotSupportTemperatureAndTopP,
-  isSupportedFlexServiceTier
+  isSupportedFlexServiceTier,
+  isSupportedThinkingTokenClaudeModel
 } from '@renderer/config/models'
-import { getAssistantSettings } from '@renderer/services/AssistantService'
+import { getAssistantSettings, getProviderByModel } from '@renderer/services/AssistantService'
 import type { Assistant, Model } from '@renderer/types'
 import { defaultTimeout } from '@shared/config/constant'
 
+import { getAnthropicThinkingBudget } from '../utils/reasoning'
+
 /**
+ * Claude 4.5 推理模型:
+ * - 只启用 temperature → 使用 temperature
+ * - 只启用 top_p → 使用 top_p
+ * - 同时启用 → temperature 生效,top_p 被忽略
+ * - 都不启用 → 都不使用
  * 获取温度参数
  */
 export function getTemperature(assistant: Assistant, model: Model): number | undefined {
@@ -27,7 +37,11 @@ export function getTemperature(assistant: Assistant, model: Model): number | und
     return undefined
   }
   const assistantSettings = getAssistantSettings(assistant)
-  return assistantSettings?.enableTemperature ? assistantSettings?.temperature : undefined
+  let temperature = assistantSettings?.temperature
+  if (temperature && isMaxTemperatureOneModel(model)) {
+    temperature = Math.min(1, temperature)
+  }
+  return assistantSettings?.enableTemperature ? temperature : undefined
 }
 
 /**
@@ -56,3 +70,18 @@ export function getTimeout(model: Model): number {
   }
   return defaultTimeout
 }
+
+export function getMaxTokens(assistant: Assistant, model: Model): number | undefined {
+  // NOTE: ai-sdk会把maxToken和budgetToken加起来
+  let { maxTokens = DEFAULT_MAX_TOKENS } = getAssistantSettings(assistant)
+
+  const provider = getProviderByModel(model)
+  if (isSupportedThinkingTokenClaudeModel(model) && ['anthropic', 'aws-bedrock'].includes(provider.type)) {
+    const { reasoning_effort: reasoningEffort } = getAssistantSettings(assistant)
+    const budget = getAnthropicThinkingBudget(maxTokens, reasoningEffort, model.id)
+    if (budget) {
+      maxTokens -= budget
+    }
+  }
+  return maxTokens
+}

src/renderer/src/aiCore/prepareParams/parameterBuilder.ts

@@ -17,11 +17,10 @@ import {
   isOpenRouterBuiltInWebSearchModel,
   isReasoningModel,
   isSupportedReasoningEffortModel,
-  isSupportedThinkingTokenClaudeModel,
   isSupportedThinkingTokenModel,
   isWebSearchModel
 } from '@renderer/config/models'
-import { getAssistantSettings, getDefaultModel } from '@renderer/services/AssistantService'
+import { getDefaultModel } from '@renderer/services/AssistantService'
 import store from '@renderer/store'
 import type { CherryWebSearchConfig } from '@renderer/store/websearch'
 import { type Assistant, type MCPTool, type Provider } from '@renderer/types'
@@ -34,11 +33,9 @@ import { stepCountIs } from 'ai'
 import { getAiSdkProviderId } from '../provider/factory'
 import { setupToolsConfig } from '../utils/mcp'
 import { buildProviderOptions } from '../utils/options'
-import { getAnthropicThinkingBudget } from '../utils/reasoning'
 import { buildProviderBuiltinWebSearchConfig } from '../utils/websearch'
 import { addAnthropicHeaders } from './header'
-import { supportsTopP } from './modelCapabilities'
+import { getMaxTokens, getTemperature, getTopP } from './modelParameters'
-import { getTemperature, getTopP } from './modelParameters'
 
 const logger = loggerService.withContext('parameterBuilder')
 
@@ -78,8 +75,6 @@ export async function buildStreamTextParams(
   const model = assistant.model || getDefaultModel()
   const aiSdkProviderId = getAiSdkProviderId(provider)
 
-  let { maxTokens } = getAssistantSettings(assistant)
-
   // 这三个变量透传出来，交给下面启用插件/中间件
   // 也可以在外部构建好再传入buildStreamTextParams
   // FIXME: qwen3即使关闭思考仍然会导致enableReasoning的结果为true
@@ -116,20 +111,6 @@ export async function buildStreamTextParams(
     enableGenerateImage
   })
 
-  // NOTE: ai-sdk会把maxToken和budgetToken加起来
-  if (
-    enableReasoning &&
-    maxTokens !== undefined &&
-    isSupportedThinkingTokenClaudeModel(model) &&
-    (provider.type === 'anthropic' || provider.type === 'aws-bedrock')
-  ) {
-    const { reasoning_effort: reasoningEffort } = getAssistantSettings(assistant)
-    const budget = getAnthropicThinkingBudget(maxTokens, reasoningEffort, model.id)
-    if (budget) {
-      maxTokens -= budget
-    }
-  }
-
   let webSearchPluginConfig: WebSearchPluginConfig | undefined = undefined
   if (enableWebSearch) {
     if (isBaseProvider(aiSdkProviderId)) {
@@ -189,8 +170,9 @@ export async function buildStreamTextParams(
   // 构建基础参数
   const params: StreamTextParams = {
     messages: sdkMessages,
-    maxOutputTokens: maxTokens,
+    maxOutputTokens: getMaxTokens(assistant, model),
     temperature: getTemperature(assistant, model),
+    topP: getTopP(assistant, model),
     abortSignal: options.requestOptions?.signal,
     headers,
     providerOptions,
@@ -198,10 +180,6 @@ export async function buildStreamTextParams(
     maxRetries: 0
   }
 
-  if (supportsTopP(model)) {
-    params.topP = getTopP(assistant, model)
-  }
-
   if (tools) {
     params.tools = tools
   }

src/renderer/src/aiCore/provider/__tests__/providerConfig.test.ts

@@ -34,7 +34,7 @@ vi.mock('@renderer/utils/api', () => ({
   }))
 }))
 
-vi.mock('@renderer/config/providers', async (importOriginal) => {
+vi.mock('@renderer/utils/provider', async (importOriginal) => {
   const actual = (await importOriginal()) as any
   return {
     ...actual,
@@ -53,10 +53,21 @@ vi.mock('@renderer/hooks/useVertexAI', () => ({
   createVertexProvider: vi.fn()
 }))
 
-import { isCherryAIProvider, isPerplexityProvider } from '@renderer/config/providers'
+vi.mock('@renderer/services/AssistantService', () => ({
+  getProviderByModel: vi.fn(),
+  getAssistantSettings: vi.fn(),
+  getDefaultAssistant: vi.fn().mockReturnValue({
+    id: 'default',
+    name: 'Default Assistant',
+    prompt: '',
+    settings: {}
+  })
+}))
+
 import { getProviderByModel } from '@renderer/services/AssistantService'
 import type { Model, Provider } from '@renderer/types'
 import { formatApiHost } from '@renderer/utils/api'
+import { isCherryAIProvider, isPerplexityProvider } from '@renderer/utils/provider'
 
 import { COPILOT_DEFAULT_HEADERS, COPILOT_EDITOR_VERSION, isCopilotResponsesModel } from '../constants'
 import { getActualProvider, providerToAiSdkConfig } from '../providerConfig'

src/renderer/src/aiCore/provider/providerConfig.ts

@@ -6,14 +6,6 @@ import {
   type ProviderSettingsMap
 } from '@cherrystudio/ai-core/provider'
 import { isOpenAIChatCompletionOnlyModel } from '@renderer/config/models'
-import {
-  isAnthropicProvider,
-  isAzureOpenAIProvider,
-  isCherryAIProvider,
-  isGeminiProvider,
-  isNewApiProvider,
-  isPerplexityProvider
-} from '@renderer/config/providers'
 import {
   getAwsBedrockAccessKeyId,
   getAwsBedrockApiKey,
@@ -21,11 +13,20 @@ import {
   getAwsBedrockRegion,
   getAwsBedrockSecretAccessKey
 } from '@renderer/hooks/useAwsBedrock'
-import { createVertexProvider, isVertexAIConfigured, isVertexProvider } from '@renderer/hooks/useVertexAI'
+import { createVertexProvider, isVertexAIConfigured } from '@renderer/hooks/useVertexAI'
 import { getProviderByModel } from '@renderer/services/AssistantService'
 import store from '@renderer/store'
 import { isSystemProvider, type Model, type Provider, SystemProviderIds } from '@renderer/types'
 import { formatApiHost, formatAzureOpenAIApiHost, formatVertexApiHost, routeToEndpoint } from '@renderer/utils/api'
+import {
+  isAnthropicProvider,
+  isAzureOpenAIProvider,
+  isCherryAIProvider,
+  isGeminiProvider,
+  isNewApiProvider,
+  isPerplexityProvider,
+  isVertexProvider
+} from '@renderer/utils/provider'
 import { cloneDeep } from 'lodash'
 
 import { aihubmixProviderCreator, newApiResolverCreator, vertexAnthropicProviderCreator } from './config'

src/renderer/src/aiCore/utils/__tests__/image.test.ts

@@ -0,0 +1,121 @@
+/**
+ * image.ts Unit Tests
+ * Tests for Gemini image generation utilities
+ */
+
+import type { Model, Provider } from '@renderer/types'
+import { SystemProviderIds } from '@renderer/types'
+import { describe, expect, it } from 'vitest'
+
+import { buildGeminiGenerateImageParams, isOpenRouterGeminiGenerateImageModel } from '../image'
+
+describe('image utils', () => {
+  describe('buildGeminiGenerateImageParams', () => {
+    it('should return correct response modalities', () => {
+      const result = buildGeminiGenerateImageParams()
+
+      expect(result).toEqual({
+        responseModalities: ['TEXT', 'IMAGE']
+      })
+    })
+
+    it('should return an object with responseModalities property', () => {
+      const result = buildGeminiGenerateImageParams()
+
+      expect(result).toHaveProperty('responseModalities')
+      expect(Array.isArray(result.responseModalities)).toBe(true)
+      expect(result.responseModalities).toHaveLength(2)
+    })
+  })
+
+  describe('isOpenRouterGeminiGenerateImageModel', () => {
+    const mockOpenRouterProvider: Provider = {
+      id: SystemProviderIds.openrouter,
+      name: 'OpenRouter',
+      apiKey: 'test-key',
+      apiHost: 'https://openrouter.ai/api/v1',
+      isSystem: true
+    } as Provider
+
+    const mockOtherProvider: Provider = {
+      id: SystemProviderIds.openai,
+      name: 'OpenAI',
+      apiKey: 'test-key',
+      apiHost: 'https://api.openai.com/v1',
+      isSystem: true
+    } as Provider
+
+    it('should return true for OpenRouter Gemini 2.5 Flash Image model', () => {
+      const model: Model = {
+        id: 'google/gemini-2.5-flash-image-preview',
+        name: 'Gemini 2.5 Flash Image',
+        provider: SystemProviderIds.openrouter
+      } as Model
+
+      const result = isOpenRouterGeminiGenerateImageModel(model, mockOpenRouterProvider)
+      expect(result).toBe(true)
+    })
+
+    it('should return false for non-Gemini model on OpenRouter', () => {
+      const model: Model = {
+        id: 'openai/gpt-4',
+        name: 'GPT-4',
+        provider: SystemProviderIds.openrouter
+      } as Model
+
+      const result = isOpenRouterGeminiGenerateImageModel(model, mockOpenRouterProvider)
+      expect(result).toBe(false)
+    })
+
+    it('should return false for Gemini model on non-OpenRouter provider', () => {
+      const model: Model = {
+        id: 'gemini-2.5-flash-image-preview',
+        name: 'Gemini 2.5 Flash Image',
+        provider: SystemProviderIds.gemini
+      } as Model
+
+      const result = isOpenRouterGeminiGenerateImageModel(model, mockOtherProvider)
+      expect(result).toBe(false)
+    })
+
+    it('should return false for Gemini model without image suffix', () => {
+      const model: Model = {
+        id: 'google/gemini-2.5-flash',
+        name: 'Gemini 2.5 Flash',
+        provider: SystemProviderIds.openrouter
+      } as Model
+
+      const result = isOpenRouterGeminiGenerateImageModel(model, mockOpenRouterProvider)
+      expect(result).toBe(false)
+    })
+
+    it('should handle model ID with partial match', () => {
+      const model: Model = {
+        id: 'google/gemini-2.5-flash-image-generation',
+        name: 'Gemini Image Gen',
+        provider: SystemProviderIds.openrouter
+      } as Model
+
+      const result = isOpenRouterGeminiGenerateImageModel(model, mockOpenRouterProvider)
+      expect(result).toBe(true)
+    })
+
+    it('should return false for custom provider', () => {
+      const customProvider: Provider = {
+        id: 'custom-provider-123',
+        name: 'Custom Provider',
+        apiKey: 'test-key',
+        apiHost: 'https://custom.com'
+      } as Provider
+
+      const model: Model = {
+        id: 'gemini-2.5-flash-image-preview',
+        name: 'Gemini 2.5 Flash Image',
+        provider: 'custom-provider-123'
+      } as Model
+
+      const result = isOpenRouterGeminiGenerateImageModel(model, customProvider)
+      expect(result).toBe(false)
+    })
+  })
+})

src/renderer/src/aiCore/utils/__tests__/mcp.test.ts

@@ -0,0 +1,435 @@
+/**
+ * mcp.ts Unit Tests
+ * Tests for MCP tools configuration and conversion utilities
+ */
+
+import type { MCPTool } from '@renderer/types'
+import type { Tool } from 'ai'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { convertMcpToolsToAiSdkTools, setupToolsConfig } from '../mcp'
+
+// Mock dependencies
+vi.mock('@logger', () => ({
+  loggerService: {
+    withContext: () => ({
+      debug: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      info: vi.fn()
+    })
+  }
+}))
+
+vi.mock('@renderer/utils/mcp-tools', () => ({
+  getMcpServerByTool: vi.fn(() => ({ id: 'test-server', autoApprove: false })),
+  isToolAutoApproved: vi.fn(() => false),
+  callMCPTool: vi.fn(async () => ({
+    content: [{ type: 'text', text: 'Tool executed successfully' }],
+    isError: false
+  }))
+}))
+
+vi.mock('@renderer/utils/userConfirmation', () => ({
+  requestToolConfirmation: vi.fn(async () => true)
+}))
+
+describe('mcp utils', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('setupToolsConfig', () => {
+    it('should return undefined when no MCP tools provided', () => {
+      const result = setupToolsConfig()
+      expect(result).toBeUndefined()
+    })
+
+    it('should return undefined when empty MCP tools array provided', () => {
+      const result = setupToolsConfig([])
+      expect(result).toBeUndefined()
+    })
+
+    it('should convert MCP tools to AI SDK tools format', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'test-tool-1',
+          serverId: 'test-server',
+          serverName: 'test-server',
+          name: 'test-tool',
+          description: 'A test tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              query: { type: 'string' }
+            }
+          }
+        }
+      ]
+
+      const result = setupToolsConfig(mcpTools)
+
+      expect(result).not.toBeUndefined()
+      expect(Object.keys(result!)).toEqual(['test-tool'])
+      expect(result!['test-tool']).toHaveProperty('description')
+      expect(result!['test-tool']).toHaveProperty('inputSchema')
+      expect(result!['test-tool']).toHaveProperty('execute')
+    })
+
+    it('should handle multiple MCP tools', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'tool1-id',
+          serverId: 'server1',
+          serverName: 'server1',
+          name: 'tool1',
+          description: 'First tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        },
+        {
+          id: 'tool2-id',
+          serverId: 'server2',
+          serverName: 'server2',
+          name: 'tool2',
+          description: 'Second tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const result = setupToolsConfig(mcpTools)
+
+      expect(result).not.toBeUndefined()
+      expect(Object.keys(result!)).toHaveLength(2)
+      expect(Object.keys(result!)).toEqual(['tool1', 'tool2'])
+    })
+  })
+
+  describe('convertMcpToolsToAiSdkTools', () => {
+    it('should convert single MCP tool to AI SDK tool', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'get-weather-id',
+          serverId: 'weather-server',
+          serverName: 'weather-server',
+          name: 'get-weather',
+          description: 'Get weather information',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              location: { type: 'string' }
+            },
+            required: ['location']
+          }
+        }
+      ]
+
+      const result = convertMcpToolsToAiSdkTools(mcpTools)
+
+      expect(Object.keys(result)).toEqual(['get-weather'])
+
+      const tool = result['get-weather'] as Tool
+      expect(tool.description).toBe('Get weather information')
+      expect(tool.inputSchema).toBeDefined()
+      expect(typeof tool.execute).toBe('function')
+    })
+
+    it('should handle tool without description', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'no-desc-tool-id',
+          serverId: 'test-server',
+          serverName: 'test-server',
+          name: 'no-desc-tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const result = convertMcpToolsToAiSdkTools(mcpTools)
+
+      expect(Object.keys(result)).toEqual(['no-desc-tool'])
+      const tool = result['no-desc-tool'] as Tool
+      expect(tool.description).toBe('Tool from test-server')
+    })
+
+    it('should convert empty tools array', () => {
+      const result = convertMcpToolsToAiSdkTools([])
+      expect(result).toEqual({})
+    })
+
+    it('should handle complex input schemas', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'complex-tool-id',
+          serverId: 'server',
+          serverName: 'server',
+          name: 'complex-tool',
+          description: 'Tool with complex schema',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              age: { type: 'number' },
+              tags: {
+                type: 'array',
+                items: { type: 'string' }
+              },
+              metadata: {
+                type: 'object',
+                properties: {
+                  key: { type: 'string' }
+                }
+              }
+            },
+            required: ['name']
+          }
+        }
+      ]
+
+      const result = convertMcpToolsToAiSdkTools(mcpTools)
+
+      expect(Object.keys(result)).toEqual(['complex-tool'])
+      const tool = result['complex-tool'] as Tool
+      expect(tool.inputSchema).toBeDefined()
+      expect(typeof tool.execute).toBe('function')
+    })
+
+    it('should preserve tool names with special characters', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'special-tool-id',
+          serverId: 'server',
+          serverName: 'server',
+          name: 'tool_with-special.chars',
+          description: 'Special chars tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const result = convertMcpToolsToAiSdkTools(mcpTools)
+      expect(Object.keys(result)).toEqual(['tool_with-special.chars'])
+    })
+
+    it('should handle multiple tools with different schemas', () => {
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'string-tool-id',
+          serverId: 'server1',
+          serverName: 'server1',
+          name: 'string-tool',
+          description: 'String tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              input: { type: 'string' }
+            }
+          }
+        },
+        {
+          id: 'number-tool-id',
+          serverId: 'server2',
+          serverName: 'server2',
+          name: 'number-tool',
+          description: 'Number tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              count: { type: 'number' }
+            }
+          }
+        },
+        {
+          id: 'boolean-tool-id',
+          serverId: 'server3',
+          serverName: 'server3',
+          name: 'boolean-tool',
+          description: 'Boolean tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              enabled: { type: 'boolean' }
+            }
+          }
+        }
+      ]
+
+      const result = convertMcpToolsToAiSdkTools(mcpTools)
+
+      expect(Object.keys(result).sort()).toEqual(['boolean-tool', 'number-tool', 'string-tool'])
+      expect(result['string-tool']).toBeDefined()
+      expect(result['number-tool']).toBeDefined()
+      expect(result['boolean-tool']).toBeDefined()
+    })
+  })
+
+  describe('tool execution', () => {
+    it('should execute tool with user confirmation', async () => {
+      const { callMCPTool } = await import('@renderer/utils/mcp-tools')
+      const { requestToolConfirmation } = await import('@renderer/utils/userConfirmation')
+
+      vi.mocked(requestToolConfirmation).mockResolvedValue(true)
+      vi.mocked(callMCPTool).mockResolvedValue({
+        content: [{ type: 'text', text: 'Success' }],
+        isError: false
+      })
+
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'test-exec-tool-id',
+          serverId: 'test-server',
+          serverName: 'test-server',
+          name: 'test-exec-tool',
+          description: 'Test execution tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const tools = convertMcpToolsToAiSdkTools(mcpTools)
+      const tool = tools['test-exec-tool'] as Tool
+      const result = await tool.execute!({}, { messages: [], abortSignal: undefined, toolCallId: 'test-call-123' })
+
+      expect(requestToolConfirmation).toHaveBeenCalled()
+      expect(callMCPTool).toHaveBeenCalled()
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'Success' }],
+        isError: false
+      })
+    })
+
+    it('should handle user cancellation', async () => {
+      const { requestToolConfirmation } = await import('@renderer/utils/userConfirmation')
+      const { callMCPTool } = await import('@renderer/utils/mcp-tools')
+
+      vi.mocked(requestToolConfirmation).mockResolvedValue(false)
+
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'cancelled-tool-id',
+          serverId: 'test-server',
+          serverName: 'test-server',
+          name: 'cancelled-tool',
+          description: 'Tool to cancel',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const tools = convertMcpToolsToAiSdkTools(mcpTools)
+      const tool = tools['cancelled-tool'] as Tool
+      const result = await tool.execute!({}, { messages: [], abortSignal: undefined, toolCallId: 'cancel-call-123' })
+
+      expect(requestToolConfirmation).toHaveBeenCalled()
+      expect(callMCPTool).not.toHaveBeenCalled()
+      expect(result).toEqual({
+        content: [
+          {
+            type: 'text',
+            text: 'User declined to execute tool "cancelled-tool".'
+          }
+        ],
+        isError: false
+      })
+    })
+
+    it('should handle tool execution error', async () => {
+      const { callMCPTool } = await import('@renderer/utils/mcp-tools')
+      const { requestToolConfirmation } = await import('@renderer/utils/userConfirmation')
+
+      vi.mocked(requestToolConfirmation).mockResolvedValue(true)
+      vi.mocked(callMCPTool).mockResolvedValue({
+        content: [{ type: 'text', text: 'Error occurred' }],
+        isError: true
+      })
+
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'error-tool-id',
+          serverId: 'test-server',
+          serverName: 'test-server',
+          name: 'error-tool',
+          description: 'Tool that errors',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const tools = convertMcpToolsToAiSdkTools(mcpTools)
+      const tool = tools['error-tool'] as Tool
+
+      await expect(
+        tool.execute!({}, { messages: [], abortSignal: undefined, toolCallId: 'error-call-123' })
+      ).rejects.toEqual({
+        content: [{ type: 'text', text: 'Error occurred' }],
+        isError: true
+      })
+    })
+
+    it('should auto-approve when enabled', async () => {
+      const { callMCPTool, isToolAutoApproved } = await import('@renderer/utils/mcp-tools')
+      const { requestToolConfirmation } = await import('@renderer/utils/userConfirmation')
+
+      vi.mocked(isToolAutoApproved).mockReturnValue(true)
+      vi.mocked(callMCPTool).mockResolvedValue({
+        content: [{ type: 'text', text: 'Auto-approved success' }],
+        isError: false
+      })
+
+      const mcpTools: MCPTool[] = [
+        {
+          id: 'auto-approve-tool-id',
+          serverId: 'test-server',
+          serverName: 'test-server',
+          name: 'auto-approve-tool',
+          description: 'Auto-approved tool',
+          type: 'mcp',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+
+      const tools = convertMcpToolsToAiSdkTools(mcpTools)
+      const tool = tools['auto-approve-tool'] as Tool
+      const result = await tool.execute!({}, { messages: [], abortSignal: undefined, toolCallId: 'auto-call-123' })
+
+      expect(requestToolConfirmation).not.toHaveBeenCalled()
+      expect(callMCPTool).toHaveBeenCalled()
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'Auto-approved success' }],
+        isError: false
+      })
+    })
+  })
+})

src/renderer/src/aiCore/utils/__tests__/options.test.ts

@@ -0,0 +1,542 @@
+/**
+ * options.ts Unit Tests
+ * Tests for building provider-specific options
+ */
+
+import type { Assistant, Model, Provider } from '@renderer/types'
+import { OpenAIServiceTiers, SystemProviderIds } from '@renderer/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { buildProviderOptions } from '../options'
+
+// Mock dependencies
+vi.mock('@cherrystudio/ai-core/provider', async (importOriginal) => {
+  const actual = (await importOriginal()) as object
+  return {
+    ...actual,
+    baseProviderIdSchema: {
+      safeParse: vi.fn((id) => {
+        const baseProviders = [
+          'openai',
+          'openai-chat',
+          'azure',
+          'azure-responses',
+          'huggingface',
+          'anthropic',
+          'google',
+          'xai',
+          'deepseek',
+          'openrouter',
+          'openai-compatible'
+        ]
+        if (baseProviders.includes(id)) {
+          return { success: true, data: id }
+        }
+        return { success: false }
+      })
+    },
+    customProviderIdSchema: {
+      safeParse: vi.fn((id) => {
+        const customProviders = ['google-vertex', 'google-vertex-anthropic', 'bedrock']
+        if (customProviders.includes(id)) {
+          return { success: true, data: id }
+        }
+        return { success: false, error: new Error('Invalid provider') }
+      })
+    }
+  }
+})
+
+vi.mock('../provider/factory', () => ({
+  getAiSdkProviderId: vi.fn((provider) => {
+    // Simulate the provider ID mapping
+    const mapping: Record<string, string> = {
+      [SystemProviderIds.gemini]: 'google',
+      [SystemProviderIds.openai]: 'openai',
+      [SystemProviderIds.anthropic]: 'anthropic',
+      [SystemProviderIds.grok]: 'xai',
+      [SystemProviderIds.deepseek]: 'deepseek',
+      [SystemProviderIds.openrouter]: 'openrouter'
+    }
+    return mapping[provider.id] || provider.id
+  })
+}))
+
+vi.mock('@renderer/config/models', async (importOriginal) => ({
+  ...(await importOriginal()),
+  isOpenAIModel: vi.fn((model) => model.id.includes('gpt') || model.id.includes('o1')),
+  isQwenMTModel: vi.fn(() => false),
+  isSupportFlexServiceTierModel: vi.fn(() => true),
+  isOpenAILLMModel: vi.fn(() => true),
+  SYSTEM_MODELS: {
+    defaultModel: [
+      { id: 'default-1', name: 'Default 1' },
+      { id: 'default-2', name: 'Default 2' },
+      { id: 'default-3', name: 'Default 3' }
+    ]
+  }
+}))
+
+vi.mock('@renderer/utils/provider', () => ({
+  isSupportServiceTierProvider: vi.fn((provider) => {
+    return [SystemProviderIds.openai, SystemProviderIds.groq].includes(provider.id)
+  })
+}))
+
+vi.mock('@renderer/store/settings', () => ({
+  default: (state = { settings: {} }) => state
+}))
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  getStoreSetting: vi.fn((key) => {
+    if (key === 'openAI') {
+      return { summaryText: 'off', verbosity: 'medium' } as any
+    }
+    return {}
+  })
+}))
+
+vi.mock('@renderer/services/AssistantService', () => ({
+  getDefaultAssistant: vi.fn(() => ({
+    id: 'default',
+    name: 'Default Assistant',
+    settings: {}
+  })),
+  getAssistantSettings: vi.fn(() => ({
+    reasoning_effort: 'medium',
+    maxTokens: 4096
+  })),
+  getProviderByModel: vi.fn((model: Model) => ({
+    id: model.provider,
+    name: 'Mock Provider'
+  }))
+}))
+
+vi.mock('../reasoning', () => ({
+  getOpenAIReasoningParams: vi.fn(() => ({ reasoningEffort: 'medium' })),
+  getAnthropicReasoningParams: vi.fn(() => ({
+    thinking: { type: 'enabled', budgetTokens: 5000 }
+  })),
+  getGeminiReasoningParams: vi.fn(() => ({
+    thinkingConfig: { include_thoughts: true }
+  })),
+  getXAIReasoningParams: vi.fn(() => ({ reasoningEffort: 'high' })),
+  getBedrockReasoningParams: vi.fn(() => ({
+    reasoningConfig: { type: 'enabled', budgetTokens: 5000 }
+  })),
+  getReasoningEffort: vi.fn(() => ({ reasoningEffort: 'medium' })),
+  getCustomParameters: vi.fn(() => ({}))
+}))
+
+vi.mock('../image', () => ({
+  buildGeminiGenerateImageParams: vi.fn(() => ({
+    responseModalities: ['TEXT', 'IMAGE']
+  }))
+}))
+
+vi.mock('../websearch', () => ({
+  getWebSearchParams: vi.fn(() => ({ enable_search: true }))
+}))
+
+const ensureWindowApi = () => {
+  const globalWindow = window as any
+  globalWindow.api = globalWindow.api || {}
+  globalWindow.api.getAppInfo = globalWindow.api.getAppInfo || vi.fn(async () => ({ notesPath: '' }))
+}
+
+ensureWindowApi()
+
+describe('options utils', () => {
+  const mockAssistant: Assistant = {
+    id: 'test-assistant',
+    name: 'Test Assistant',
+    settings: {}
+  } as Assistant
+
+  const mockModel: Model = {
+    id: 'gpt-4',
+    name: 'GPT-4',
+    provider: SystemProviderIds.openai
+  } as Model
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('buildProviderOptions', () => {
+    describe('OpenAI provider', () => {
+      const openaiProvider: Provider = {
+        id: SystemProviderIds.openai,
+        name: 'OpenAI',
+        type: 'openai-response',
+        apiKey: 'test-key',
+        apiHost: 'https://api.openai.com/v1',
+        isSystem: true
+      } as Provider
+
+      it('should build basic OpenAI options', () => {
+        const result = buildProviderOptions(mockAssistant, mockModel, openaiProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('openai')
+        expect(result.openai).toBeDefined()
+      })
+
+      it('should include reasoning parameters when enabled', () => {
+        const result = buildProviderOptions(mockAssistant, mockModel, openaiProvider, {
+          enableReasoning: true,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result.openai).toHaveProperty('reasoningEffort')
+        expect(result.openai.reasoningEffort).toBe('medium')
+      })
+
+      it('should include service tier when supported', () => {
+        const providerWithServiceTier: Provider = {
+          ...openaiProvider,
+          serviceTier: OpenAIServiceTiers.auto
+        }
+
+        const result = buildProviderOptions(mockAssistant, mockModel, providerWithServiceTier, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result.openai).toHaveProperty('serviceTier')
+        expect(result.openai.serviceTier).toBe(OpenAIServiceTiers.auto)
+      })
+    })
+
+    describe('Anthropic provider', () => {
+      const anthropicProvider: Provider = {
+        id: SystemProviderIds.anthropic,
+        name: 'Anthropic',
+        type: 'anthropic',
+        apiKey: 'test-key',
+        apiHost: 'https://api.anthropic.com',
+        isSystem: true
+      } as Provider
+
+      const anthropicModel: Model = {
+        id: 'claude-3-5-sonnet-20241022',
+        name: 'Claude 3.5 Sonnet',
+        provider: SystemProviderIds.anthropic
+      } as Model
+
+      it('should build basic Anthropic options', () => {
+        const result = buildProviderOptions(mockAssistant, anthropicModel, anthropicProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('anthropic')
+        expect(result.anthropic).toBeDefined()
+      })
+
+      it('should include reasoning parameters when enabled', () => {
+        const result = buildProviderOptions(mockAssistant, anthropicModel, anthropicProvider, {
+          enableReasoning: true,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result.anthropic).toHaveProperty('thinking')
+        expect(result.anthropic.thinking).toEqual({
+          type: 'enabled',
+          budgetTokens: 5000
+        })
+      })
+    })
+
+    describe('Google provider', () => {
+      const googleProvider: Provider = {
+        id: SystemProviderIds.gemini,
+        name: 'Google',
+        type: 'gemini',
+        apiKey: 'test-key',
+        apiHost: 'https://generativelanguage.googleapis.com',
+        isSystem: true,
+        models: [{ id: 'gemini-2.0-flash-exp' }] as Model[]
+      } as Provider
+
+      const googleModel: Model = {
+        id: 'gemini-2.0-flash-exp',
+        name: 'Gemini 2.0 Flash',
+        provider: SystemProviderIds.gemini
+      } as Model
+
+      it('should build basic Google options', () => {
+        const result = buildProviderOptions(mockAssistant, googleModel, googleProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('google')
+        expect(result.google).toBeDefined()
+      })
+
+      it('should include reasoning parameters when enabled', () => {
+        const result = buildProviderOptions(mockAssistant, googleModel, googleProvider, {
+          enableReasoning: true,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result.google).toHaveProperty('thinkingConfig')
+        expect(result.google.thinkingConfig).toEqual({
+          include_thoughts: true
+        })
+      })
+
+      it('should include image generation parameters when enabled', () => {
+        const result = buildProviderOptions(mockAssistant, googleModel, googleProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: true
+        })
+
+        expect(result.google).toHaveProperty('responseModalities')
+        expect(result.google.responseModalities).toEqual(['TEXT', 'IMAGE'])
+      })
+    })
+
+    describe('xAI provider', () => {
+      const xaiProvider = {
+        id: SystemProviderIds.grok,
+        name: 'xAI',
+        type: 'new-api',
+        apiKey: 'test-key',
+        apiHost: 'https://api.x.ai/v1',
+        isSystem: true,
+        models: [] as Model[]
+      } as Provider
+
+      const xaiModel: Model = {
+        id: 'grok-2-latest',
+        name: 'Grok 2',
+        provider: SystemProviderIds.grok
+      } as Model
+
+      it('should build basic xAI options', () => {
+        const result = buildProviderOptions(mockAssistant, xaiModel, xaiProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('xai')
+        expect(result.xai).toBeDefined()
+      })
+
+      it('should include reasoning parameters when enabled', () => {
+        const result = buildProviderOptions(mockAssistant, xaiModel, xaiProvider, {
+          enableReasoning: true,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result.xai).toHaveProperty('reasoningEffort')
+        expect(result.xai.reasoningEffort).toBe('high')
+      })
+    })
+
+    describe('DeepSeek provider', () => {
+      const deepseekProvider: Provider = {
+        id: SystemProviderIds.deepseek,
+        name: 'DeepSeek',
+        type: 'openai',
+        apiKey: 'test-key',
+        apiHost: 'https://api.deepseek.com',
+        isSystem: true
+      } as Provider
+
+      const deepseekModel: Model = {
+        id: 'deepseek-chat',
+        name: 'DeepSeek Chat',
+        provider: SystemProviderIds.deepseek
+      } as Model
+
+      it('should build basic DeepSeek options', () => {
+        const result = buildProviderOptions(mockAssistant, deepseekModel, deepseekProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('deepseek')
+        expect(result.deepseek).toBeDefined()
+      })
+    })
+
+    describe('OpenRouter provider', () => {
+      const openrouterProvider: Provider = {
+        id: SystemProviderIds.openrouter,
+        name: 'OpenRouter',
+        type: 'openai',
+        apiKey: 'test-key',
+        apiHost: 'https://openrouter.ai/api/v1',
+        isSystem: true
+      } as Provider
+
+      const openrouterModel: Model = {
+        id: 'openai/gpt-4',
+        name: 'GPT-4',
+        provider: SystemProviderIds.openrouter
+      } as Model
+
+      it('should build basic OpenRouter options', () => {
+        const result = buildProviderOptions(mockAssistant, openrouterModel, openrouterProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('openrouter')
+        expect(result.openrouter).toBeDefined()
+      })
+
+      it('should include web search parameters when enabled', () => {
+        const result = buildProviderOptions(mockAssistant, openrouterModel, openrouterProvider, {
+          enableReasoning: false,
+          enableWebSearch: true,
+          enableGenerateImage: false
+        })
+
+        expect(result.openrouter).toHaveProperty('enable_search')
+      })
+    })
+
+    describe('Custom parameters', () => {
+      it('should merge custom parameters', async () => {
+        const { getCustomParameters } = await import('../reasoning')
+
+        vi.mocked(getCustomParameters).mockReturnValue({
+          custom_param: 'custom_value',
+          another_param: 123
+        })
+
+        const result = buildProviderOptions(
+          mockAssistant,
+          mockModel,
+          {
+            id: SystemProviderIds.openai,
+            name: 'OpenAI',
+            type: 'openai',
+            apiKey: 'test-key',
+            apiHost: 'https://api.openai.com/v1'
+          } as Provider,
+          {
+            enableReasoning: false,
+            enableWebSearch: false,
+            enableGenerateImage: false
+          }
+        )
+
+        expect(result.openai).toHaveProperty('custom_param')
+        expect(result.openai.custom_param).toBe('custom_value')
+        expect(result.openai).toHaveProperty('another_param')
+        expect(result.openai.another_param).toBe(123)
+      })
+    })
+
+    describe('Multiple capabilities', () => {
+      const googleProvider = {
+        id: SystemProviderIds.gemini,
+        name: 'Google',
+        type: 'gemini',
+        apiKey: 'test-key',
+        apiHost: 'https://generativelanguage.googleapis.com',
+        isSystem: true,
+        models: [] as Model[]
+      } as Provider
+
+      const googleModel: Model = {
+        id: 'gemini-2.0-flash-exp',
+        name: 'Gemini 2.0 Flash',
+        provider: SystemProviderIds.gemini
+      } as Model
+
+      it('should combine reasoning and image generation', () => {
+        const result = buildProviderOptions(mockAssistant, googleModel, googleProvider, {
+          enableReasoning: true,
+          enableWebSearch: false,
+          enableGenerateImage: true
+        })
+
+        expect(result.google).toHaveProperty('thinkingConfig')
+        expect(result.google).toHaveProperty('responseModalities')
+      })
+
+      it('should handle all capabilities enabled', () => {
+        const result = buildProviderOptions(mockAssistant, googleModel, googleProvider, {
+          enableReasoning: true,
+          enableWebSearch: true,
+          enableGenerateImage: true
+        })
+
+        expect(result.google).toBeDefined()
+        expect(Object.keys(result.google).length).toBeGreaterThan(0)
+      })
+    })
+
+    describe('Vertex AI providers', () => {
+      it('should map google-vertex to google', () => {
+        const vertexProvider = {
+          id: 'google-vertex',
+          name: 'Vertex AI',
+          type: 'vertexai',
+          apiKey: 'test-key',
+          apiHost: 'https://vertex-ai.googleapis.com',
+          models: [] as Model[]
+        } as Provider
+
+        const vertexModel: Model = {
+          id: 'gemini-2.0-flash-exp',
+          name: 'Gemini 2.0 Flash',
+          provider: 'google-vertex'
+        } as Model
+
+        const result = buildProviderOptions(mockAssistant, vertexModel, vertexProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('google')
+      })
+
+      it('should map google-vertex-anthropic to anthropic', () => {
+        const vertexAnthropicProvider = {
+          id: 'google-vertex-anthropic',
+          name: 'Vertex AI Anthropic',
+          type: 'vertex-anthropic',
+          apiKey: 'test-key',
+          apiHost: 'https://vertex-ai.googleapis.com',
+          models: [] as Model[]
+        } as Provider
+
+        const vertexModel: Model = {
+          id: 'claude-3-5-sonnet-20241022',
+          name: 'Claude 3.5 Sonnet',
+          provider: 'google-vertex-anthropic'
+        } as Model
+
+        const result = buildProviderOptions(mockAssistant, vertexModel, vertexAnthropicProvider, {
+          enableReasoning: false,
+          enableWebSearch: false,
+          enableGenerateImage: false
+        })
+
+        expect(result).toHaveProperty('anthropic')
+      })
+    })
+  })
+})

src/renderer/src/aiCore/utils/__tests__/websearch.test.ts

@@ -0,0 +1,384 @@
+/**
+ * websearch.ts Unit Tests
+ * Tests for web search parameters generation utilities
+ */
+
+import type { CherryWebSearchConfig } from '@renderer/store/websearch'
+import type { Model } from '@renderer/types'
+import { describe, expect, it, vi } from 'vitest'
+
+import { buildProviderBuiltinWebSearchConfig, getWebSearchParams } from '../websearch'
+
+// Mock dependencies
+vi.mock('@renderer/config/models', () => ({
+  isOpenAIWebSearchChatCompletionOnlyModel: vi.fn((model) => model?.id?.includes('o1-pro') ?? false),
+  isOpenAIDeepResearchModel: vi.fn((model) => model?.id?.includes('o3-mini') ?? false)
+}))
+
+vi.mock('@renderer/utils/blacklistMatchPattern', () => ({
+  mapRegexToPatterns: vi.fn((patterns) => patterns || [])
+}))
+
+describe('websearch utils', () => {
+  describe('getWebSearchParams', () => {
+    it('should return enhancement params for hunyuan provider', () => {
+      const model: Model = {
+        id: 'hunyuan-model',
+        name: 'Hunyuan Model',
+        provider: 'hunyuan'
+      } as Model
+
+      const result = getWebSearchParams(model)
+
+      expect(result).toEqual({
+        enable_enhancement: true,
+        citation: true,
+        search_info: true
+      })
+    })
+
+    it('should return search params for dashscope provider', () => {
+      const model: Model = {
+        id: 'qwen-model',
+        name: 'Qwen Model',
+        provider: 'dashscope'
+      } as Model
+
+      const result = getWebSearchParams(model)
+
+      expect(result).toEqual({
+        enable_search: true,
+        search_options: {
+          forced_search: true
+        }
+      })
+    })
+
+    it('should return web_search_options for OpenAI web search models', () => {
+      const model: Model = {
+        id: 'o1-pro',
+        name: 'O1 Pro',
+        provider: 'openai'
+      } as Model
+
+      const result = getWebSearchParams(model)
+
+      expect(result).toEqual({
+        web_search_options: {}
+      })
+    })
+
+    it('should return empty object for other providers', () => {
+      const model: Model = {
+        id: 'gpt-4',
+        name: 'GPT-4',
+        provider: 'openai'
+      } as Model
+
+      const result = getWebSearchParams(model)
+
+      expect(result).toEqual({})
+    })
+
+    it('should return empty object for custom provider', () => {
+      const model: Model = {
+        id: 'custom-model',
+        name: 'Custom Model',
+        provider: 'custom-provider'
+      } as Model
+
+      const result = getWebSearchParams(model)
+
+      expect(result).toEqual({})
+    })
+  })
+
+  describe('buildProviderBuiltinWebSearchConfig', () => {
+    const defaultWebSearchConfig: CherryWebSearchConfig = {
+      searchWithTime: true,
+      maxResults: 50,
+      excludeDomains: []
+    }
+
+    describe('openai provider', () => {
+      it('should return low search context size for low maxResults', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 20,
+          excludeDomains: []
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('openai', config)
+
+        expect(result).toEqual({
+          openai: {
+            searchContextSize: 'low'
+          }
+        })
+      })
+
+      it('should return medium search context size for medium maxResults', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 50,
+          excludeDomains: []
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('openai', config)
+
+        expect(result).toEqual({
+          openai: {
+            searchContextSize: 'medium'
+          }
+        })
+      })
+
+      it('should return high search context size for high maxResults', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 80,
+          excludeDomains: []
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('openai', config)
+
+        expect(result).toEqual({
+          openai: {
+            searchContextSize: 'high'
+          }
+        })
+      })
+
+      it('should use medium for deep research models regardless of maxResults', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 100,
+          excludeDomains: []
+        }
+
+        const model: Model = {
+          id: 'o3-mini',
+          name: 'O3 Mini',
+          provider: 'openai'
+        } as Model
+
+        const result = buildProviderBuiltinWebSearchConfig('openai', config, model)
+
+        expect(result).toEqual({
+          openai: {
+            searchContextSize: 'medium'
+          }
+        })
+      })
+    })
+
+    describe('openai-chat provider', () => {
+      it('should return correct search context size', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 50,
+          excludeDomains: []
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('openai-chat', config)
+
+        expect(result).toEqual({
+          'openai-chat': {
+            searchContextSize: 'medium'
+          }
+        })
+      })
+
+      it('should handle deep research models', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 100,
+          excludeDomains: []
+        }
+
+        const model: Model = {
+          id: 'o3-mini',
+          name: 'O3 Mini',
+          provider: 'openai'
+        } as Model
+
+        const result = buildProviderBuiltinWebSearchConfig('openai-chat', config, model)
+
+        expect(result).toEqual({
+          'openai-chat': {
+            searchContextSize: 'medium'
+          }
+        })
+      })
+    })
+
+    describe('anthropic provider', () => {
+      it('should return anthropic search options with maxUses', () => {
+        const result = buildProviderBuiltinWebSearchConfig('anthropic', defaultWebSearchConfig)
+
+        expect(result).toEqual({
+          anthropic: {
+            maxUses: 50,
+            blockedDomains: undefined
+          }
+        })
+      })
+
+      it('should include blockedDomains when excludeDomains provided', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 30,
+          excludeDomains: ['example.com', 'test.com']
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('anthropic', config)
+
+        expect(result).toEqual({
+          anthropic: {
+            maxUses: 30,
+            blockedDomains: ['example.com', 'test.com']
+          }
+        })
+      })
+
+      it('should not include blockedDomains when empty', () => {
+        const result = buildProviderBuiltinWebSearchConfig('anthropic', defaultWebSearchConfig)
+
+        expect(result).toEqual({
+          anthropic: {
+            maxUses: 50,
+            blockedDomains: undefined
+          }
+        })
+      })
+    })
+
+    describe('xai provider', () => {
+      it('should return xai search options', () => {
+        const result = buildProviderBuiltinWebSearchConfig('xai', defaultWebSearchConfig)
+
+        expect(result).toEqual({
+          xai: {
+            maxSearchResults: 50,
+            returnCitations: true,
+            sources: [{ type: 'web', excludedWebsites: [] }, { type: 'news' }, { type: 'x' }],
+            mode: 'on'
+          }
+        })
+      })
+
+      it('should limit excluded websites to 5', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 40,
+          excludeDomains: ['site1.com', 'site2.com', 'site3.com', 'site4.com', 'site5.com', 'site6.com', 'site7.com']
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('xai', config)
+
+        expect(result?.xai?.sources).toBeDefined()
+        const webSource = result?.xai?.sources?.[0]
+        if (webSource && webSource.type === 'web') {
+          expect(webSource.excludedWebsites).toHaveLength(5)
+        }
+      })
+
+      it('should include all sources types', () => {
+        const result = buildProviderBuiltinWebSearchConfig('xai', defaultWebSearchConfig)
+
+        expect(result?.xai?.sources).toHaveLength(3)
+        expect(result?.xai?.sources?.[0].type).toBe('web')
+        expect(result?.xai?.sources?.[1].type).toBe('news')
+        expect(result?.xai?.sources?.[2].type).toBe('x')
+      })
+    })
+
+    describe('openrouter provider', () => {
+      it('should return openrouter plugins config', () => {
+        const result = buildProviderBuiltinWebSearchConfig('openrouter', defaultWebSearchConfig)
+
+        expect(result).toEqual({
+          openrouter: {
+            plugins: [
+              {
+                id: 'web',
+                max_results: 50
+              }
+            ]
+          }
+        })
+      })
+
+      it('should respect custom maxResults', () => {
+        const config: CherryWebSearchConfig = {
+          searchWithTime: true,
+          maxResults: 75,
+          excludeDomains: []
+        }
+
+        const result = buildProviderBuiltinWebSearchConfig('openrouter', config)
+
+        expect(result).toEqual({
+          openrouter: {
+            plugins: [
+              {
+                id: 'web',
+                max_results: 75
+              }
+            ]
+          }
+        })
+      })
+    })
+
+    describe('unsupported provider', () => {
+      it('should return empty object for unsupported provider', () => {
+        const result = buildProviderBuiltinWebSearchConfig('unsupported' as any, defaultWebSearchConfig)
+
+        expect(result).toEqual({})
+      })
+
+      it('should return empty object for google provider', () => {
+        const result = buildProviderBuiltinWebSearchConfig('google', defaultWebSearchConfig)
+
+        expect(result).toEqual({})
+      })
+    })
+
+    describe('edge cases', () => {
+      it('should handle maxResults at boundary values', () => {
+        // Test boundary at 33 (low/medium)
+        const config33: CherryWebSearchConfig = { searchWithTime: true, maxResults: 33, excludeDomains: [] }
+        const result33 = buildProviderBuiltinWebSearchConfig('openai', config33)
+        expect(result33?.openai?.searchContextSize).toBe('low')
+
+        // Test boundary at 34 (medium)
+        const config34: CherryWebSearchConfig = { searchWithTime: true, maxResults: 34, excludeDomains: [] }
+        const result34 = buildProviderBuiltinWebSearchConfig('openai', config34)
+        expect(result34?.openai?.searchContextSize).toBe('medium')
+
+        // Test boundary at 66 (medium)
+        const config66: CherryWebSearchConfig = { searchWithTime: true, maxResults: 66, excludeDomains: [] }
+        const result66 = buildProviderBuiltinWebSearchConfig('openai', config66)
+        expect(result66?.openai?.searchContextSize).toBe('medium')
+
+        // Test boundary at 67 (high)
+        const config67: CherryWebSearchConfig = { searchWithTime: true, maxResults: 67, excludeDomains: [] }
+        const result67 = buildProviderBuiltinWebSearchConfig('openai', config67)
+        expect(result67?.openai?.searchContextSize).toBe('high')
+      })
+
+      it('should handle zero maxResults', () => {
+        const config: CherryWebSearchConfig = { searchWithTime: true, maxResults: 0, excludeDomains: [] }
+        const result = buildProviderBuiltinWebSearchConfig('openai', config)
+        expect(result?.openai?.searchContextSize).toBe('low')
+      })
+
+      it('should handle very large maxResults', () => {
+        const config: CherryWebSearchConfig = { searchWithTime: true, maxResults: 1000, excludeDomains: [] }
+        const result = buildProviderBuiltinWebSearchConfig('openai', config)
+        expect(result?.openai?.searchContextSize).toBe('high')
+      })
+    })
+  })
+})

src/renderer/src/aiCore/utils/options.ts

@@ -1,3 +1,4 @@
+import type { BedrockProviderOptions } from '@ai-sdk/amazon-bedrock'
 import type { AnthropicProviderOptions } from '@ai-sdk/anthropic'
 import type { GoogleGenerativeAIProviderOptions } from '@ai-sdk/google'
 import type { OpenAIResponsesProviderOptions } from '@ai-sdk/openai'
@@ -11,29 +12,26 @@ import {
   isSupportFlexServiceTierModel,
   isSupportVerbosityModel
 } from '@renderer/config/models'
-import { isSupportServiceTierProvider } from '@renderer/config/providers'
 import { mapLanguageToQwenMTModel } from '@renderer/config/translate'
 import { getStoreSetting } from '@renderer/hooks/useSettings'
-import type { RootState } from '@renderer/store'
-import type {
-  Assistant,
-  GroqServiceTier,
-  GroqSystemProvider,
-  Model,
-  NotGroqProvider,
-  OpenAIServiceTier,
-  Provider,
-  ServiceTier
-} from '@renderer/types'
 import {
+  type Assistant,
+  type GroqServiceTier,
   GroqServiceTiers,
+  type GroqSystemProvider,
   isGroqServiceTier,
   isGroqSystemProvider,
   isOpenAIServiceTier,
   isTranslateAssistant,
-  OpenAIServiceTiers
+  type Model,
+  type NotGroqProvider,
+  type OpenAIServiceTier,
+  OpenAIServiceTiers,
+  type Provider,
+  type ServiceTier
 } from '@renderer/types'
 import type { OpenAIVerbosity } from '@renderer/types/aiCoreTypes'
+import { isSupportServiceTierProvider } from '@renderer/utils/provider'
 import type { JSONValue } from 'ai'
 import { t } from 'i18next'
 
@@ -239,8 +237,7 @@ function buildOpenAIProviderOptions(
   serviceTier: OpenAIServiceTier
 ): OpenAIResponsesProviderOptions {
   const { enableReasoning } = capabilities
-  let providerOptions: Record<string, any> = {}
+  let providerOptions: OpenAIResponsesProviderOptions = {}
-
   // OpenAI 推理参数
   if (enableReasoning) {
     const reasoningParams = getOpenAIReasoningParams(assistant, model)
@@ -251,8 +248,8 @@ function buildOpenAIProviderOptions(
   }
 
   if (isSupportVerbosityModel(model)) {
-    const state: RootState = window.store?.getState()
+    const openAI = getStoreSetting<'openAI'>('openAI')
-    const userVerbosity = state?.settings?.openAI?.verbosity
+    const userVerbosity = openAI?.verbosity
 
     if (userVerbosity && ['low', 'medium', 'high'].includes(userVerbosity)) {
       const supportedVerbosity = getModelSupportedVerbosity(model)
@@ -287,7 +284,7 @@ function buildAnthropicProviderOptions(
   }
 ): AnthropicProviderOptions {
   const { enableReasoning } = capabilities
-  let providerOptions: Record<string, any> = {}
+  let providerOptions: AnthropicProviderOptions = {}
 
   // Anthropic 推理参数
   if (enableReasoning) {
@@ -314,7 +311,7 @@ function buildGeminiProviderOptions(
   }
 ): GoogleGenerativeAIProviderOptions {
   const { enableReasoning, enableGenerateImage } = capabilities
-  let providerOptions: Record<string, any> = {}
+  let providerOptions: GoogleGenerativeAIProviderOptions = {}
 
   // Gemini 推理参数
   if (enableReasoning) {
@@ -393,9 +390,9 @@ function buildBedrockProviderOptions(
     enableWebSearch: boolean
     enableGenerateImage: boolean
   }
-): Record<string, any> {
+): BedrockProviderOptions {
   const { enableReasoning } = capabilities
-  let providerOptions: Record<string, any> = {}
+  let providerOptions: BedrockProviderOptions = {}
 
   if (enableReasoning) {
     const reasoningParams = getBedrockReasoningParams(assistant, model)

src/renderer/src/aiCore/utils/reasoning.ts

@@ -33,13 +33,13 @@ import {
   isSupportedThinkingTokenZhipuModel,
   MODEL_SUPPORTED_REASONING_EFFORT
 } from '@renderer/config/models'
-import { isSupportEnableThinkingProvider } from '@renderer/config/providers'
 import { getStoreSetting } from '@renderer/hooks/useSettings'
 import { getAssistantSettings, getProviderByModel } from '@renderer/services/AssistantService'
 import type { Assistant, Model } from '@renderer/types'
 import { EFFORT_RATIO, isSystemProvider, SystemProviderIds } from '@renderer/types'
 import type { OpenAISummaryText } from '@renderer/types/aiCoreTypes'
 import type { ReasoningEffortOptionalParams } from '@renderer/types/sdk'
+import { isSupportEnableThinkingProvider } from '@renderer/utils/provider'
 import { toInteger } from 'lodash'
 
 const logger = loggerService.withContext('reasoning')
@@ -131,7 +131,7 @@ export function getReasoningEffort(assistant: Assistant, model: Model): Reasonin
     }
 
     // Specially for GPT-5.1. Suppose this is a OpenAI Compatible provider
-    if (isGPT51SeriesModel(model) && reasoningEffort === 'none') {
+    if (isGPT51SeriesModel(model)) {
       return {
         reasoningEffort: 'none'
       }

src/renderer/src/config/__test__/reasoning.test.ts

@@ -1,553 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import {
-  findTokenLimit,
-  isDoubaoSeedAfter251015,
-  isDoubaoThinkingAutoModel,
-  isGeminiReasoningModel,
-  isLingReasoningModel,
-  isSupportedThinkingTokenGeminiModel
-} from '../models/reasoning'
-
-vi.mock('@renderer/store', () => ({
-  default: {
-    getState: () => ({
-      llm: {
-        settings: {}
-      }
-    })
-  }
-}))
-
-// FIXME: Idk why it's imported. Maybe circular dependency somewhere
-vi.mock('@renderer/services/AssistantService.ts', () => ({
-  getDefaultAssistant: () => {
-    return {
-      id: 'default',
-      name: 'default',
-      emoji: '😀',
-      prompt: '',
-      topics: [],
-      messages: [],
-      type: 'assistant',
-      regularPhrases: [],
-      settings: {}
-    }
-  }
-}))
-
-describe('Doubao Models', () => {
-  describe('isDoubaoThinkingAutoModel', () => {
-    it('should return false for invalid models', () => {
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1-6-251015',
-          name: 'doubao-seed-1-6-251015',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1-6-lite-251015',
-          name: 'doubao-seed-1-6-lite-251015',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1-6-thinking-250715',
-          name: 'doubao-seed-1-6-thinking-250715',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1-6-flash',
-          name: 'doubao-seed-1-6-flash',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1-6-thinking',
-          name: 'doubao-seed-1-6-thinking',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-
-    it('should return true for valid models', () => {
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1-6-250615',
-          name: 'doubao-seed-1-6-250615',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'Doubao-Seed-1.6',
-          name: 'Doubao-Seed-1.6',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-1-5-thinking-pro-m',
-          name: 'doubao-1-5-thinking-pro-m',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-seed-1.6-lite',
-          name: 'doubao-seed-1.6-lite',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isDoubaoThinkingAutoModel({
-          id: 'doubao-1-5-thinking-pro-m-12345',
-          name: 'doubao-1-5-thinking-pro-m-12345',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-  })
-
-  describe('isDoubaoSeedAfter251015', () => {
-    it('should return true for models matching the pattern', () => {
-      expect(
-        isDoubaoSeedAfter251015({
-          id: 'doubao-seed-1-6-251015',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isDoubaoSeedAfter251015({
-          id: 'doubao-seed-1-6-lite-251015',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return false for models not matching the pattern', () => {
-      expect(
-        isDoubaoSeedAfter251015({
-          id: 'doubao-seed-1-6-250615',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoSeedAfter251015({
-          id: 'Doubao-Seed-1.6',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoSeedAfter251015({
-          id: 'doubao-1-5-thinking-pro-m',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isDoubaoSeedAfter251015({
-          id: 'doubao-seed-1-6-lite-251016',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-  })
-})
-describe('Ling Models', () => {
-  describe('isLingReasoningModel', () => {
-    it('should return false for ling variants', () => {
-      expect(
-        isLingReasoningModel({
-          id: 'ling-1t',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isLingReasoningModel({
-          id: 'ling-flash-2.0',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isLingReasoningModel({
-          id: 'ling-mini-2.0',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-
-    it('should return true for ring variants', () => {
-      expect(
-        isLingReasoningModel({
-          id: 'ring-1t',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isLingReasoningModel({
-          id: 'ring-flash-2.0',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isLingReasoningModel({
-          id: 'ring-mini-2.0',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-  })
-})
-
-describe('Gemini Models', () => {
-  describe('isSupportedThinkingTokenGeminiModel', () => {
-    it('should return true for gemini 2.5 models', () => {
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-2.5-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-2.5-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-2.5-flash-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-2.5-pro-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini latest models', () => {
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-flash-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-pro-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-flash-lite-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini 3 models', () => {
-      // Preview versions
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-3-pro-preview',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'google/gemini-3-pro-preview',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      // Future stable versions
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-3-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-3-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'google/gemini-3-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'google/gemini-3-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return false for image and tts models', () => {
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-2.5-flash-image',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-2.5-flash-preview-tts',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-
-    it('should return false for older gemini models', () => {
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-1.5-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-1.5-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isSupportedThinkingTokenGeminiModel({
-          id: 'gemini-1.0-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-  })
-
-  describe('isGeminiReasoningModel', () => {
-    it('should return true for gemini thinking models', () => {
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-2.0-flash-thinking',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-thinking-exp',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for supported thinking token gemini models', () => {
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-2.5-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-2.5-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini-3 models', () => {
-      // Preview versions
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-3-pro-preview',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isGeminiReasoningModel({
-          id: 'google/gemini-3-pro-preview',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      // Future stable versions
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-3-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-3-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isGeminiReasoningModel({
-          id: 'google/gemini-3-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isGeminiReasoningModel({
-          id: 'google/gemini-3-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return false for older gemini models without thinking', () => {
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-1.5-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-      expect(
-        isGeminiReasoningModel({
-          id: 'gemini-1.5-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-
-    it('should return false for undefined model', () => {
-      expect(isGeminiReasoningModel(undefined)).toBe(false)
-    })
-  })
-})
-
-describe('findTokenLimit', () => {
-  const cases: Array<{ modelId: string; expected: { min: number; max: number } }> = [
-    { modelId: 'gemini-2.5-flash-lite-exp', expected: { min: 512, max: 24_576 } },
-    { modelId: 'gemini-1.5-flash', expected: { min: 0, max: 24_576 } },
-    { modelId: 'gemini-1.5-pro-001', expected: { min: 128, max: 32_768 } },
-    { modelId: 'qwen3-235b-a22b-thinking-2507', expected: { min: 0, max: 81_920 } },
-    { modelId: 'qwen3-30b-a3b-thinking-2507', expected: { min: 0, max: 81_920 } },
-    { modelId: 'qwen3-vl-235b-a22b-thinking', expected: { min: 0, max: 81_920 } },
-    { modelId: 'qwen3-vl-30b-a3b-thinking', expected: { min: 0, max: 81_920 } },
-    { modelId: 'qwen-plus-2025-07-14', expected: { min: 0, max: 38_912 } },
-    { modelId: 'qwen-plus-2025-04-28', expected: { min: 0, max: 38_912 } },
-    { modelId: 'qwen3-1.7b', expected: { min: 0, max: 30_720 } },
-    { modelId: 'qwen3-0.6b', expected: { min: 0, max: 30_720 } },
-    { modelId: 'qwen-plus-ultra', expected: { min: 0, max: 81_920 } },
-    { modelId: 'qwen-turbo-pro', expected: { min: 0, max: 38_912 } },
-    { modelId: 'qwen-flash-lite', expected: { min: 0, max: 81_920 } },
-    { modelId: 'qwen3-7b', expected: { min: 1_024, max: 38_912 } },
-    { modelId: 'claude-3.7-sonnet-extended', expected: { min: 1_024, max: 64_000 } },
-    { modelId: 'claude-sonnet-4.1', expected: { min: 1_024, max: 64_000 } },
-    { modelId: 'claude-sonnet-4-5-20250929', expected: { min: 1_024, max: 64_000 } },
-    { modelId: 'claude-opus-4-1-extended', expected: { min: 1_024, max: 32_000 } }
-  ]
-
-  it.each(cases)('returns correct limits for $modelId', ({ modelId, expected }) => {
-    expect(findTokenLimit(modelId)).toEqual(expected)
-  })
-
-  it('returns undefined for unknown models', () => {
-    expect(findTokenLimit('unknown-model')).toBeUndefined()
-  })
-})

src/renderer/src/config/__test__/vision.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { isVisionModel } from '../models/vision'
-
-vi.mock('@renderer/store', () => ({
-  default: {
-    getState: () => ({
-      llm: {
-        settings: {}
-      }
-    })
-  }
-}))
-
-// FIXME: Idk why it's imported. Maybe circular dependency somewhere
-vi.mock('@renderer/services/AssistantService.ts', () => ({
-  getDefaultAssistant: () => {
-    return {
-      id: 'default',
-      name: 'default',
-      emoji: '😀',
-      prompt: '',
-      topics: [],
-      messages: [],
-      type: 'assistant',
-      regularPhrases: [],
-      settings: {}
-    }
-  },
-  getProviderByModel: () => null
-}))
-
-describe('isVisionModel', () => {
-  describe('Gemini Models', () => {
-    it('should return true for gemini 1.5 models', () => {
-      expect(
-        isVisionModel({
-          id: 'gemini-1.5-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-1.5-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini 2.x models', () => {
-      expect(
-        isVisionModel({
-          id: 'gemini-2.0-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-2.0-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-2.5-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-2.5-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini latest models', () => {
-      expect(
-        isVisionModel({
-          id: 'gemini-flash-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-pro-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-flash-lite-latest',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini 3 models', () => {
-      // Preview versions
-      expect(
-        isVisionModel({
-          id: 'gemini-3-pro-preview',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      // Future stable versions
-      expect(
-        isVisionModel({
-          id: 'gemini-3-flash',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-      expect(
-        isVisionModel({
-          id: 'gemini-3-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return true for gemini exp models', () => {
-      expect(
-        isVisionModel({
-          id: 'gemini-exp-1206',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(true)
-    })
-
-    it('should return false for gemini 1.0 models', () => {
-      expect(
-        isVisionModel({
-          id: 'gemini-1.0-pro',
-          name: '',
-          provider: '',
-          group: ''
-        })
-      ).toBe(false)
-    })
-  })
-})

src/renderer/src/config/__test__/websearch.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { GEMINI_SEARCH_REGEX } from '../models/websearch'
-
-vi.mock('@renderer/store', () => ({
-  default: {
-    getState: () => ({
-      llm: {
-        settings: {}
-      }
-    })
-  }
-}))
-
-// FIXME: Idk why it's imported. Maybe circular dependency somewhere
-vi.mock('@renderer/services/AssistantService.ts', () => ({
-  getDefaultAssistant: () => {
-    return {
-      id: 'default',
-      name: 'default',
-      emoji: '😀',
-      prompt: '',
-      topics: [],
-      messages: [],
-      type: 'assistant',
-      regularPhrases: [],
-      settings: {}
-    }
-  },
-  getProviderByModel: () => null
-}))
-
-describe('Gemini Search Models', () => {
-  describe('GEMINI_SEARCH_REGEX', () => {
-    it('should match gemini 2.x models', () => {
-      expect(GEMINI_SEARCH_REGEX.test('gemini-2.0-flash')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-2.0-pro')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-flash')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-pro')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-flash-latest')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-pro-latest')).toBe(true)
-    })
-
-    it('should match gemini latest models', () => {
-      expect(GEMINI_SEARCH_REGEX.test('gemini-flash-latest')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-pro-latest')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-flash-lite-latest')).toBe(true)
-    })
-
-    it('should match gemini 3 models', () => {
-      // Preview versions
-      expect(GEMINI_SEARCH_REGEX.test('gemini-3-pro-preview')).toBe(true)
-      // Future stable versions
-      expect(GEMINI_SEARCH_REGEX.test('gemini-3-flash')).toBe(true)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-3-pro')).toBe(true)
-    })
-
-    it('should not match older gemini models', () => {
-      expect(GEMINI_SEARCH_REGEX.test('gemini-1.5-flash')).toBe(false)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-1.5-pro')).toBe(false)
-      expect(GEMINI_SEARCH_REGEX.test('gemini-1.0-pro')).toBe(false)
-    })
-  })
-})

src/renderer/src/config/models/__tests__/embedding.test.ts

@@ -0,0 +1,101 @@
+import type { Model } from '@renderer/types'
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@renderer/hooks/useStore', () => ({
+  getStoreProviders: vi.fn(() => [])
+}))
+
+vi.mock('@renderer/store', () => ({
+  __esModule: true,
+  default: {
+    getState: () => ({
+      llm: { providers: [] },
+      settings: {}
+    })
+  },
+  useAppDispatch: vi.fn(),
+  useAppSelector: vi.fn()
+}))
+
+vi.mock('@renderer/store/settings', () => {
+  const noop = vi.fn()
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === 'initialState') {
+          return {}
+        }
+        return noop
+      }
+    }
+  )
+})
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  useSettings: vi.fn(() => ({})),
+  useNavbarPosition: vi.fn(() => ({ navbarPosition: 'left' })),
+  useMessageStyle: vi.fn(() => ({ isBubbleStyle: false })),
+  getStoreSetting: vi.fn()
+}))
+
+import { isEmbeddingModel, isRerankModel } from '../embedding'
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'test-model',
+  name: 'Test Model',
+  provider: 'openai',
+  group: 'Test',
+  ...overrides
+})
+
+describe('isEmbeddingModel', () => {
+  it('returns true for ids that match the embedding regex', () => {
+    expect(isEmbeddingModel(createModel({ id: 'Text-Embedding-3-Small' }))).toBe(true)
+  })
+
+  it('returns false for rerank models even if they match embedding patterns', () => {
+    const model = createModel({ id: 'rerank-qa', name: 'rerank-qa' })
+    expect(isRerankModel(model)).toBe(true)
+    expect(isEmbeddingModel(model)).toBe(false)
+  })
+
+  it('honors user overrides for embedding capability', () => {
+    const model = createModel({
+      id: 'text-embedding-3-small',
+      capabilities: [{ type: 'embedding', isUserSelected: false }]
+    })
+    expect(isEmbeddingModel(model)).toBe(false)
+  })
+
+  it('uses the model name when provider is doubao', () => {
+    const model = createModel({
+      id: 'custom-id',
+      name: 'BGE-Large-zh-v1.5',
+      provider: 'doubao'
+    })
+    expect(isEmbeddingModel(model)).toBe(true)
+  })
+
+  it('returns false for anthropic provider models', () => {
+    const model = createModel({
+      id: 'text-embedding-ada-002',
+      provider: 'anthropic'
+    })
+    expect(isEmbeddingModel(model)).toBe(false)
+  })
+})
+
+describe('isRerankModel', () => {
+  it('identifies ids that match rerank regex', () => {
+    expect(isRerankModel(createModel({ id: 'jina-rerank-v2-base' }))).toBe(true)
+  })
+
+  it('honors user overrides for rerank capability', () => {
+    const model = createModel({
+      id: 'jina-rerank-v2-base',
+      capabilities: [{ type: 'rerank', isUserSelected: false }]
+    })
+    expect(isRerankModel(model)).toBe(false)
+  })
+})

src/renderer/src/config/models/__tests__/models.test.ts

@@ -3,31 +3,54 @@ import {
   isPureGenerateImageModel,
   isQwenReasoningModel,
   isSupportedThinkingTokenQwenModel,
-  isVisionModel,
+  isVisionModel
-  isWebSearchModel
 } from '@renderer/config/models'
 import type { Model } from '@renderer/types'
 import { beforeEach, describe, expect, test, vi } from 'vitest'
 
+vi.mock('@renderer/store/llm', () => ({
+  initialState: {}
+}))
+
+vi.mock('@renderer/store', () => ({
+  default: {
+    getState: () => ({
+      llm: {
+        settings: {}
+      }
+    })
+  }
+}))
+
+const getProviderByModelMock = vi.fn()
+const isEmbeddingModelMock = vi.fn()
+const isRerankModelMock = vi.fn()
+
+vi.mock('@renderer/services/AssistantService', () => ({
+  getProviderByModel: (...args: any[]) => getProviderByModelMock(...args),
+  getAssistantSettings: vi.fn(),
+  getDefaultAssistant: vi.fn().mockReturnValue({
+    id: 'default',
+    name: 'Default Assistant',
+    prompt: '',
+    settings: {}
+  })
+}))
+
+vi.mock('@renderer/config/models/embedding', () => ({
+  isEmbeddingModel: (...args: any[]) => isEmbeddingModelMock(...args),
+  isRerankModel: (...args: any[]) => isRerankModelMock(...args)
+}))
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  getProviderByModelMock.mockReturnValue({ type: 'openai-response' } as any)
+  isEmbeddingModelMock.mockReturnValue(false)
+  isRerankModelMock.mockReturnValue(false)
+})
+
 // Suggested test cases
 describe('Qwen Model Detection', () => {
-  beforeEach(() => {
-    vi.mock('@renderer/store/llm', () => ({
-      initialState: {}
-    }))
-    vi.mock('@renderer/services/AssistantService', () => ({
-      getProviderByModel: vi.fn().mockReturnValue({ id: 'cherryai' })
-    }))
-    vi.mock('@renderer/store', () => ({
-      default: {
-        getState: () => ({
-          llm: {
-            settings: {}
-          }
-        })
-      }
-    }))
-  })
   test('isQwenReasoningModel', () => {
     expect(isQwenReasoningModel({ id: 'qwen3-thinking' } as Model)).toBe(true)
     expect(isQwenReasoningModel({ id: 'qwen3-instruct' } as Model)).toBe(false)
@@ -56,14 +79,6 @@ describe('Qwen Model Detection', () => {
 })
 
 describe('Vision Model Detection', () => {
-  beforeEach(() => {
-    vi.mock('@renderer/store/llm', () => ({
-      initialState: {}
-    }))
-    vi.mock('@renderer/services/AssistantService', () => ({
-      getProviderByModel: vi.fn().mockReturnValue({ id: 'cherryai' })
-    }))
-  })
   test('isVisionModel', () => {
     expect(isVisionModel({ id: 'qwen-vl-max' } as Model)).toBe(true)
     expect(isVisionModel({ id: 'qwen-omni-turbo' } as Model)).toBe(true)
@@ -83,17 +98,3 @@ describe('Vision Model Detection', () => {
     expect(isPureGenerateImageModel({ id: 'gpt-4o' } as Model)).toBe(false)
   })
 })
-
-describe('Web Search Model Detection', () => {
-  beforeEach(() => {
-    vi.mock('@renderer/store/llm', () => ({
-      initialState: {}
-    }))
-    vi.mock('@renderer/services/AssistantService', () => ({
-      getProviderByModel: vi.fn().mockReturnValue({ id: 'cherryai' })
-    }))
-  })
-  test('isWebSearchModel', () => {
-    expect(isWebSearchModel({ id: 'grok-2-image-latest' } as Model)).toBe(false)
-  })
-})

src/renderer/src/config/models/__tests__/tooluse.test.ts

@@ -0,0 +1,137 @@
+import type { Model } from '@renderer/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { isEmbeddingModel, isRerankModel } from '../embedding'
+import { isDeepSeekHybridInferenceModel } from '../reasoning'
+import { isFunctionCallingModel } from '../tooluse'
+import { isPureGenerateImageModel, isTextToImageModel } from '../vision'
+
+vi.mock('@renderer/hooks/useStore', () => ({
+  getStoreProviders: vi.fn(() => [])
+}))
+
+vi.mock('@renderer/store', () => ({
+  __esModule: true,
+  default: {
+    getState: () => ({
+      llm: { providers: [] },
+      settings: {}
+    })
+  },
+  useAppDispatch: vi.fn(),
+  useAppSelector: vi.fn()
+}))
+
+vi.mock('@renderer/store/settings', () => {
+  const noop = vi.fn()
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === 'initialState') {
+          return {}
+        }
+        return noop
+      }
+    }
+  )
+})
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  useSettings: vi.fn(() => ({})),
+  useNavbarPosition: vi.fn(() => ({ navbarPosition: 'left' })),
+  useMessageStyle: vi.fn(() => ({ isBubbleStyle: false })),
+  getStoreSetting: vi.fn()
+}))
+
+vi.mock('../embedding', () => ({
+  isEmbeddingModel: vi.fn(),
+  isRerankModel: vi.fn()
+}))
+
+vi.mock('../vision', () => ({
+  isPureGenerateImageModel: vi.fn(),
+  isTextToImageModel: vi.fn()
+}))
+
+vi.mock('../reasoning', () => ({
+  isDeepSeekHybridInferenceModel: vi.fn()
+}))
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'gpt-4o',
+  name: 'gpt-4o',
+  provider: 'openai',
+  group: 'OpenAI',
+  ...overrides
+})
+
+const embeddingMock = vi.mocked(isEmbeddingModel)
+const rerankMock = vi.mocked(isRerankModel)
+const pureImageMock = vi.mocked(isPureGenerateImageModel)
+const textToImageMock = vi.mocked(isTextToImageModel)
+const deepSeekHybridMock = vi.mocked(isDeepSeekHybridInferenceModel)
+
+describe('isFunctionCallingModel', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    embeddingMock.mockReturnValue(false)
+    rerankMock.mockReturnValue(false)
+    pureImageMock.mockReturnValue(false)
+    textToImageMock.mockReturnValue(false)
+    deepSeekHybridMock.mockReturnValue(false)
+  })
+
+  it('returns false when the model is undefined', () => {
+    expect(isFunctionCallingModel(undefined as unknown as Model)).toBe(false)
+  })
+
+  it('returns false when model is classified as embedding/rerank/image', () => {
+    embeddingMock.mockReturnValueOnce(true)
+    expect(isFunctionCallingModel(createModel())).toBe(false)
+  })
+
+  it('respect manual user overrides', () => {
+    const model = createModel({
+      capabilities: [{ type: 'function_calling', isUserSelected: false }]
+    })
+    expect(isFunctionCallingModel(model)).toBe(false)
+    const enabled = createModel({
+      capabilities: [{ type: 'function_calling', isUserSelected: true }]
+    })
+    expect(isFunctionCallingModel(enabled)).toBe(true)
+  })
+
+  it('matches doubao models by name when regex applies', () => {
+    const doubao = createModel({
+      id: 'custom-model',
+      name: 'Doubao-Seed-1.6-251015',
+      provider: 'doubao'
+    })
+    expect(isFunctionCallingModel(doubao)).toBe(true)
+  })
+
+  it('returns true for regex matches on standard providers', () => {
+    expect(isFunctionCallingModel(createModel({ id: 'gpt-5' }))).toBe(true)
+  })
+
+  it('excludes explicitly blocked ids', () => {
+    expect(isFunctionCallingModel(createModel({ id: 'gemini-1.5-flash' }))).toBe(false)
+  })
+
+  it('forces support for trusted providers', () => {
+    for (const provider of ['deepseek', 'anthropic', 'kimi', 'moonshot']) {
+      expect(isFunctionCallingModel(createModel({ provider }))).toBe(true)
+    }
+  })
+
+  it('returns true when identified as deepseek hybrid inference model', () => {
+    deepSeekHybridMock.mockReturnValueOnce(true)
+    expect(isFunctionCallingModel(createModel({ id: 'deepseek-v3-1', provider: 'custom' }))).toBe(true)
+  })
+
+  it('returns false for deepseek hybrid models behind restricted system providers', () => {
+    deepSeekHybridMock.mockReturnValueOnce(true)
+    expect(isFunctionCallingModel(createModel({ id: 'deepseek-v3-1', provider: 'dashscope' }))).toBe(false)
+  })
+})

src/renderer/src/config/models/__tests__/utils.test.ts

@@ -0,0 +1,280 @@
+import { isEmbeddingModel, isRerankModel } from '@renderer/config/models/embedding'
+import type { Model } from '@renderer/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  isGPT5ProModel,
+  isGPT5SeriesModel,
+  isGPT5SeriesReasoningModel,
+  isGPT51SeriesModel,
+  isOpenAIChatCompletionOnlyModel,
+  isOpenAILLMModel,
+  isOpenAIModel,
+  isOpenAIOpenWeightModel,
+  isOpenAIReasoningModel,
+  isSupportVerbosityModel
+} from '../openai'
+import { isQwenMTModel } from '../qwen'
+import {
+  agentModelFilter,
+  getModelSupportedVerbosity,
+  groupQwenModels,
+  isAnthropicModel,
+  isGeminiModel,
+  isGemmaModel,
+  isGenerateImageModels,
+  isMaxTemperatureOneModel,
+  isNotSupportedTextDelta,
+  isNotSupportSystemMessageModel,
+  isNotSupportTemperatureAndTopP,
+  isSupportedFlexServiceTier,
+  isSupportedModel,
+  isSupportFlexServiceTierModel,
+  isVisionModels,
+  isZhipuModel
+} from '../utils'
+import { isGenerateImageModel, isTextToImageModel, isVisionModel } from '../vision'
+import { isOpenAIWebSearchChatCompletionOnlyModel } from '../websearch'
+
+vi.mock('@renderer/hooks/useStore', () => ({
+  getStoreProviders: vi.fn(() => [])
+}))
+
+vi.mock('@renderer/store', () => ({
+  __esModule: true,
+  default: {
+    getState: () => ({
+      llm: { providers: [] },
+      settings: {}
+    })
+  },
+  useAppDispatch: vi.fn(),
+  useAppSelector: vi.fn()
+}))
+
+vi.mock('@renderer/store/settings', () => {
+  const noop = vi.fn()
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === 'initialState') {
+          return {}
+        }
+        return noop
+      }
+    }
+  )
+})
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  useSettings: vi.fn(() => ({})),
+  useNavbarPosition: vi.fn(() => ({ navbarPosition: 'left' })),
+  useMessageStyle: vi.fn(() => ({ isBubbleStyle: false })),
+  getStoreSetting: vi.fn()
+}))
+
+vi.mock('@renderer/config/models/embedding', () => ({
+  isEmbeddingModel: vi.fn(),
+  isRerankModel: vi.fn()
+}))
+
+vi.mock('../vision', () => ({
+  isGenerateImageModel: vi.fn(),
+  isTextToImageModel: vi.fn(),
+  isVisionModel: vi.fn()
+}))
+
+vi.mock(import('../openai'), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    isOpenAIReasoningModel: vi.fn()
+  }
+})
+
+vi.mock('../websearch', () => ({
+  isOpenAIWebSearchChatCompletionOnlyModel: vi.fn()
+}))
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'gpt-4o',
+  name: 'gpt-4o',
+  provider: 'openai',
+  group: 'OpenAI',
+  ...overrides
+})
+
+const embeddingMock = vi.mocked(isEmbeddingModel)
+const rerankMock = vi.mocked(isRerankModel)
+const visionMock = vi.mocked(isVisionModel)
+const textToImageMock = vi.mocked(isTextToImageModel)
+const generateImageMock = vi.mocked(isGenerateImageModel)
+const reasoningMock = vi.mocked(isOpenAIReasoningModel)
+const openAIWebSearchOnlyMock = vi.mocked(isOpenAIWebSearchChatCompletionOnlyModel)
+
+describe('model utils', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    embeddingMock.mockReturnValue(false)
+    rerankMock.mockReturnValue(false)
+    visionMock.mockReturnValue(true)
+    textToImageMock.mockReturnValue(false)
+    generateImageMock.mockReturnValue(true)
+    reasoningMock.mockReturnValue(false)
+    openAIWebSearchOnlyMock.mockReturnValue(false)
+  })
+
+  it('detects OpenAI LLM models through reasoning and GPT prefix', () => {
+    expect(isOpenAILLMModel(undefined as unknown as Model)).toBe(false)
+    expect(isOpenAILLMModel(createModel({ id: 'gpt-4o-image' }))).toBe(false)
+
+    reasoningMock.mockReturnValueOnce(true)
+    expect(isOpenAILLMModel(createModel({ id: 'o1-preview' }))).toBe(true)
+
+    expect(isOpenAILLMModel(createModel({ id: 'GPT-5-turbo' }))).toBe(true)
+  })
+
+  it('detects OpenAI models via GPT prefix or reasoning support', () => {
+    expect(isOpenAIModel(createModel({ id: 'gpt-4.1' }))).toBe(true)
+    reasoningMock.mockReturnValueOnce(true)
+    expect(isOpenAIModel(createModel({ id: 'o3' }))).toBe(true)
+  })
+
+  it('evaluates support for flex service tier and alias helper', () => {
+    expect(isSupportFlexServiceTierModel(createModel({ id: 'o3' }))).toBe(true)
+    expect(isSupportFlexServiceTierModel(createModel({ id: 'o3-mini' }))).toBe(false)
+    expect(isSupportFlexServiceTierModel(createModel({ id: 'o4-mini' }))).toBe(true)
+    expect(isSupportFlexServiceTierModel(createModel({ id: 'gpt-5-preview' }))).toBe(true)
+    expect(isSupportedFlexServiceTier(createModel({ id: 'gpt-4o' }))).toBe(false)
+  })
+
+  it('detects verbosity support for GPT-5+ families', () => {
+    expect(isSupportVerbosityModel(createModel({ id: 'gpt-5' }))).toBe(true)
+    expect(isSupportVerbosityModel(createModel({ id: 'gpt-5-chat' }))).toBe(false)
+    expect(isSupportVerbosityModel(createModel({ id: 'gpt-5.1-preview' }))).toBe(true)
+  })
+
+  it('limits verbosity controls for GPT-5 Pro models', () => {
+    const proModel = createModel({ id: 'gpt-5-pro' })
+    const previewModel = createModel({ id: 'gpt-5-preview' })
+    expect(getModelSupportedVerbosity(proModel)).toEqual([undefined, 'high'])
+    expect(getModelSupportedVerbosity(previewModel)).toEqual([undefined, 'low', 'medium', 'high'])
+    expect(isGPT5ProModel(proModel)).toBe(true)
+    expect(isGPT5ProModel(previewModel)).toBe(false)
+  })
+
+  it('identifies OpenAI chat-completion-only models', () => {
+    expect(isOpenAIChatCompletionOnlyModel(createModel({ id: 'gpt-4o-search-preview' }))).toBe(true)
+    expect(isOpenAIChatCompletionOnlyModel(createModel({ id: 'o1-mini' }))).toBe(true)
+    expect(isOpenAIChatCompletionOnlyModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+  })
+
+  it('filters unsupported OpenAI catalog entries', () => {
+    expect(isSupportedModel({ id: 'gpt-4', object: 'model' } as any)).toBe(true)
+    expect(isSupportedModel({ id: 'tts-1', object: 'model' } as any)).toBe(false)
+  })
+
+  it('calculates temperature/top-p support correctly', () => {
+    const model = createModel({ id: 'o1' })
+    reasoningMock.mockReturnValue(true)
+    expect(isNotSupportTemperatureAndTopP(model)).toBe(true)
+
+    const openWeight = createModel({ id: 'gpt-oss-debug' })
+    expect(isNotSupportTemperatureAndTopP(openWeight)).toBe(false)
+
+    const chatOnly = createModel({ id: 'o1-preview' })
+    reasoningMock.mockReturnValue(false)
+    expect(isNotSupportTemperatureAndTopP(chatOnly)).toBe(true)
+
+    const qwenMt = createModel({ id: 'qwen-mt-large', provider: 'aliyun' })
+    expect(isNotSupportTemperatureAndTopP(qwenMt)).toBe(true)
+  })
+
+  it('handles gemma and gemini detections plus zhipu tagging', () => {
+    expect(isGemmaModel(createModel({ id: 'Gemma-3-27B' }))).toBe(true)
+    expect(isGemmaModel(createModel({ group: 'Gemma' }))).toBe(true)
+    expect(isGemmaModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+
+    expect(isGeminiModel(createModel({ id: 'Gemini-2.0' }))).toBe(true)
+
+    expect(isZhipuModel(createModel({ provider: 'zhipu' }))).toBe(true)
+    expect(isZhipuModel(createModel({ provider: 'openai' }))).toBe(false)
+  })
+
+  it('groups qwen models by prefix', () => {
+    const qwen = createModel({ id: 'Qwen-7B', provider: 'qwen', name: 'Qwen-7B' })
+    const qwenOmni = createModel({ id: 'qwen2.5-omni', name: 'qwen2.5-omni' })
+    const other = createModel({ id: 'deepseek-v3', group: 'DeepSeek' })
+
+    const grouped = groupQwenModels([qwen, qwenOmni, other])
+    expect(Object.keys(grouped)).toContain('qwen-7b')
+    expect(Object.keys(grouped)).toContain('qwen2.5')
+    expect(grouped.DeepSeek).toContain(other)
+  })
+
+  it('aggregates boolean helpers based on regex rules', () => {
+    expect(isAnthropicModel(createModel({ id: 'claude-3.5' }))).toBe(true)
+    expect(isQwenMTModel(createModel({ id: 'qwen-mt-large' }))).toBe(true)
+    expect(isNotSupportedTextDelta(createModel({ id: 'qwen-mt-large' }))).toBe(true)
+    expect(isNotSupportSystemMessageModel(createModel({ id: 'gemma-moe' }))).toBe(true)
+    expect(isOpenAIOpenWeightModel(createModel({ id: 'gpt-oss-free' }))).toBe(true)
+  })
+
+  it('evaluates GPT-5 family helpers', () => {
+    expect(isGPT5SeriesModel(createModel({ id: 'gpt-5-preview' }))).toBe(true)
+    expect(isGPT5SeriesModel(createModel({ id: 'gpt-5.1-preview' }))).toBe(false)
+    expect(isGPT51SeriesModel(createModel({ id: 'gpt-5.1-mini' }))).toBe(true)
+    expect(isGPT5SeriesReasoningModel(createModel({ id: 'gpt-5-prompt' }))).toBe(true)
+    expect(isSupportVerbosityModel(createModel({ id: 'gpt-5-chat' }))).toBe(false)
+  })
+
+  it('wraps generate/vision helpers that operate on arrays', () => {
+    const models = [createModel({ id: 'gpt-4o' }), createModel({ id: 'gpt-4o-mini' })]
+    expect(isVisionModels(models)).toBe(true)
+    visionMock.mockReturnValueOnce(true).mockReturnValueOnce(false)
+    expect(isVisionModels(models)).toBe(false)
+
+    expect(isGenerateImageModels(models)).toBe(true)
+    generateImageMock.mockReturnValueOnce(true).mockReturnValueOnce(false)
+    expect(isGenerateImageModels(models)).toBe(false)
+  })
+
+  it('filters models for agent usage', () => {
+    expect(agentModelFilter(createModel())).toBe(true)
+
+    embeddingMock.mockReturnValueOnce(true)
+    expect(agentModelFilter(createModel({ id: 'text-embedding' }))).toBe(false)
+
+    embeddingMock.mockReturnValue(false)
+    rerankMock.mockReturnValueOnce(true)
+    expect(agentModelFilter(createModel({ id: 'rerank' }))).toBe(false)
+
+    rerankMock.mockReturnValue(false)
+    textToImageMock.mockReturnValueOnce(true)
+    expect(agentModelFilter(createModel({ id: 'gpt-image-1' }))).toBe(false)
+  })
+
+  it('identifies models with maximum temperature of 1.0', () => {
+    // Zhipu models should have max temperature of 1.0
+    expect(isMaxTemperatureOneModel(createModel({ id: 'glm-4' }))).toBe(true)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'GLM-4-Plus' }))).toBe(true)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'glm-3-turbo' }))).toBe(true)
+
+    // Anthropic models should have max temperature of 1.0
+    expect(isMaxTemperatureOneModel(createModel({ id: 'claude-3.5-sonnet' }))).toBe(true)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'Claude-3-opus' }))).toBe(true)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'claude-2.1' }))).toBe(true)
+
+    // Moonshot models should have max temperature of 1.0
+    expect(isMaxTemperatureOneModel(createModel({ id: 'moonshot-1.0' }))).toBe(true)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'kimi-k2-thinking' }))).toBe(true)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'Moonshot-Pro' }))).toBe(true)
+
+    // Other models should return false
+    expect(isMaxTemperatureOneModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'gpt-4-turbo' }))).toBe(false)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'qwen-max' }))).toBe(false)
+    expect(isMaxTemperatureOneModel(createModel({ id: 'gemini-pro' }))).toBe(false)
+  })
+})

src/renderer/src/config/models/__tests__/vision.test.ts

@@ -0,0 +1,310 @@
+import { getProviderByModel } from '@renderer/services/AssistantService'
+import type { Model } from '@renderer/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { isEmbeddingModel, isRerankModel } from '../embedding'
+import {
+  isAutoEnableImageGenerationModel,
+  isDedicatedImageGenerationModel,
+  isGenerateImageModel,
+  isImageEnhancementModel,
+  isPureGenerateImageModel,
+  isTextToImageModel,
+  isVisionModel
+} from '../vision'
+
+vi.mock('@renderer/hooks/useStore', () => ({
+  getStoreProviders: vi.fn(() => [])
+}))
+
+vi.mock('@renderer/store', () => ({
+  __esModule: true,
+  default: {
+    getState: () => ({
+      llm: { providers: [] },
+      settings: {}
+    })
+  },
+  useAppDispatch: vi.fn(),
+  useAppSelector: vi.fn()
+}))
+
+vi.mock('@renderer/store/settings', () => {
+  const noop = vi.fn()
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === 'initialState') {
+          return {}
+        }
+        return noop
+      }
+    }
+  )
+})
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  useSettings: vi.fn(() => ({})),
+  useNavbarPosition: vi.fn(() => ({ navbarPosition: 'left' })),
+  useMessageStyle: vi.fn(() => ({ isBubbleStyle: false })),
+  getStoreSetting: vi.fn()
+}))
+
+vi.mock('@renderer/services/AssistantService', () => ({
+  getProviderByModel: vi.fn()
+}))
+
+vi.mock('../embedding', () => ({
+  isEmbeddingModel: vi.fn(),
+  isRerankModel: vi.fn()
+}))
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'gpt-4o',
+  name: 'gpt-4o',
+  provider: 'openai',
+  group: 'OpenAI',
+  ...overrides
+})
+
+const providerMock = vi.mocked(getProviderByModel)
+const embeddingMock = vi.mocked(isEmbeddingModel)
+const rerankMock = vi.mocked(isRerankModel)
+
+describe('vision helpers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    providerMock.mockReturnValue({ type: 'openai-response' } as any)
+    embeddingMock.mockReturnValue(false)
+    rerankMock.mockReturnValue(false)
+  })
+
+  describe('isGenerateImageModel', () => {
+    it('returns false for embedding/rerank models or missing providers', () => {
+      embeddingMock.mockReturnValueOnce(true)
+      expect(isGenerateImageModel(createModel({ id: 'gpt-image-1' }))).toBe(false)
+
+      embeddingMock.mockReturnValue(false)
+      rerankMock.mockReturnValueOnce(true)
+      expect(isGenerateImageModel(createModel({ id: 'gpt-image-1' }))).toBe(false)
+
+      rerankMock.mockReturnValue(false)
+      providerMock.mockReturnValueOnce(undefined as any)
+      expect(isGenerateImageModel(createModel({ id: 'gpt-image-1' }))).toBe(false)
+    })
+
+    it('detects OpenAI and third-party generative image models', () => {
+      expect(isGenerateImageModel(createModel({ id: 'gpt-4o-mini' }))).toBe(true)
+
+      providerMock.mockReturnValue({ type: 'custom' } as any)
+      expect(isGenerateImageModel(createModel({ id: 'gemini-2.5-flash-image' }))).toBe(true)
+    })
+
+    it('returns false when openai-response model is not on allow list', () => {
+      expect(isGenerateImageModel(createModel({ id: 'gpt-4.2-experimental' }))).toBe(false)
+    })
+  })
+
+  describe('isPureGenerateImageModel', () => {
+    it('requires both generate and text-to-image support', () => {
+      expect(isPureGenerateImageModel(createModel({ id: 'gpt-image-1' }))).toBe(true)
+      expect(isPureGenerateImageModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+    })
+  })
+
+  describe('text-to-image helpers', () => {
+    it('matches predefined keywords', () => {
+      expect(isTextToImageModel(createModel({ id: 'midjourney-v6' }))).toBe(true)
+      expect(isTextToImageModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+    })
+
+    it('detects models with restricted image size support and enhancement', () => {
+      expect(isImageEnhancementModel(createModel({ id: 'qwen-image-edit' }))).toBe(true)
+      expect(isImageEnhancementModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+    })
+
+    it('identifies dedicated and auto-enabled image generation models', () => {
+      expect(isDedicatedImageGenerationModel(createModel({ id: 'grok-2-image-1212' }))).toBe(true)
+      expect(isAutoEnableImageGenerationModel(createModel({ id: 'gemini-2.5-flash-image-ultra' }))).toBe(true)
+    })
+
+    it('returns false when models are not in dedicated or auto-enable sets', () => {
+      expect(isDedicatedImageGenerationModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+      expect(isAutoEnableImageGenerationModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+    })
+  })
+})
+
+describe('isVisionModel', () => {
+  it('returns false for embedding/rerank models and honors overrides', () => {
+    embeddingMock.mockReturnValueOnce(true)
+    expect(isVisionModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+
+    embeddingMock.mockReturnValue(false)
+    const disabled = createModel({
+      id: 'gpt-4o',
+      capabilities: [{ type: 'vision', isUserSelected: false }]
+    })
+    expect(isVisionModel(disabled)).toBe(false)
+
+    const forced = createModel({
+      id: 'gpt-4o',
+      capabilities: [{ type: 'vision', isUserSelected: true }]
+    })
+    expect(isVisionModel(forced)).toBe(true)
+  })
+
+  it('matches doubao models by name and general regexes by id', () => {
+    const doubao = createModel({
+      id: 'custom-id',
+      provider: 'doubao',
+      name: 'Doubao-Seed-1-6-Lite-251015'
+    })
+    expect(isVisionModel(doubao)).toBe(true)
+
+    expect(isVisionModel(createModel({ id: 'gpt-4o-mini' }))).toBe(true)
+  })
+
+  it('leverages image enhancement regex when standard vision regex does not match', () => {
+    expect(isVisionModel(createModel({ id: 'qwen-image-edit' }))).toBe(true)
+  })
+
+  it('returns false for doubao models that fail regex checks', () => {
+    const doubao = createModel({ id: 'doubao-standard', provider: 'doubao', name: 'basic' })
+    expect(isVisionModel(doubao)).toBe(false)
+  })
+  describe('Gemini Models', () => {
+    it('should return true for gemini 1.5 models', () => {
+      expect(
+        isVisionModel({
+          id: 'gemini-1.5-flash',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-1.5-pro',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+    })
+
+    it('should return true for gemini 2.x models', () => {
+      expect(
+        isVisionModel({
+          id: 'gemini-2.0-flash',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-2.0-pro',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-2.5-flash',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-2.5-pro',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+    })
+
+    it('should return true for gemini latest models', () => {
+      expect(
+        isVisionModel({
+          id: 'gemini-flash-latest',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-pro-latest',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-flash-lite-latest',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+    })
+
+    it('should return true for gemini 3 models', () => {
+      // Preview versions
+      expect(
+        isVisionModel({
+          id: 'gemini-3-pro-preview',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      // Future stable versions
+      expect(
+        isVisionModel({
+          id: 'gemini-3-flash',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+      expect(
+        isVisionModel({
+          id: 'gemini-3-pro',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+    })
+
+    it('should return true for gemini exp models', () => {
+      expect(
+        isVisionModel({
+          id: 'gemini-exp-1206',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(true)
+    })
+
+    it('should return false for gemini 1.0 models', () => {
+      expect(
+        isVisionModel({
+          id: 'gemini-1.0-pro',
+          name: '',
+          provider: '',
+          group: ''
+        })
+      ).toBe(false)
+    })
+  })
+})

src/renderer/src/config/models/__tests__/websearch.test.ts

@@ -0,0 +1,382 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const providerMock = vi.mocked(getProviderByModel)
+
+vi.mock('@renderer/services/AssistantService', () => ({
+  getProviderByModel: vi.fn(),
+  getAssistantSettings: vi.fn(),
+  getDefaultAssistant: vi.fn().mockReturnValue({
+    id: 'default',
+    name: 'Default Assistant',
+    prompt: '',
+    settings: {}
+  })
+}))
+
+const isEmbeddingModel = vi.hoisted(() => vi.fn())
+const isRerankModel = vi.hoisted(() => vi.fn())
+vi.mock('../embedding', () => ({
+  isEmbeddingModel: (...args: any[]) => isEmbeddingModel(...args),
+  isRerankModel: (...args: any[]) => isRerankModel(...args)
+}))
+
+const isPureGenerateImageModel = vi.hoisted(() => vi.fn())
+const isTextToImageModel = vi.hoisted(() => vi.fn())
+const isGenerateImageModel = vi.hoisted(() => vi.fn())
+vi.mock('../vision', () => ({
+  isPureGenerateImageModel: (...args: any[]) => isPureGenerateImageModel(...args),
+  isTextToImageModel: (...args: any[]) => isTextToImageModel(...args),
+  isGenerateImageModel: (...args: any[]) => isGenerateImageModel(...args)
+}))
+
+const providerMocks = vi.hoisted(() => ({
+  isGeminiProvider: vi.fn(),
+  isNewApiProvider: vi.fn(),
+  isOpenAICompatibleProvider: vi.fn(),
+  isOpenAIProvider: vi.fn(),
+  isVertexProvider: vi.fn(),
+  isAwsBedrockProvider: vi.fn()
+}))
+
+vi.mock('@renderer/utils/provider', () => providerMocks)
+
+vi.mock('@renderer/hooks/useStore', () => ({
+  getStoreProviders: vi.fn(() => [])
+}))
+
+vi.mock('@renderer/store', () => ({
+  __esModule: true,
+  default: {
+    getState: () => ({
+      llm: { providers: [] },
+      settings: {}
+    })
+  },
+  useAppDispatch: vi.fn(),
+  useAppSelector: vi.fn()
+}))
+
+vi.mock('@renderer/store/settings', () => {
+  const noop = vi.fn()
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (prop === 'initialState') {
+          return {}
+        }
+        return noop
+      }
+    }
+  )
+})
+
+vi.mock('@renderer/hooks/useSettings', () => ({
+  useSettings: vi.fn(() => ({})),
+  useNavbarPosition: vi.fn(() => ({ navbarPosition: 'left' })),
+  useMessageStyle: vi.fn(() => ({ isBubbleStyle: false })),
+  getStoreSetting: vi.fn()
+}))
+
+import { getProviderByModel } from '@renderer/services/AssistantService'
+import type { Model, Provider } from '@renderer/types'
+import { SystemProviderIds } from '@renderer/types'
+
+import { isOpenAIDeepResearchModel } from '../openai'
+import {
+  GEMINI_SEARCH_REGEX,
+  isHunyuanSearchModel,
+  isMandatoryWebSearchModel,
+  isOpenAIWebSearchChatCompletionOnlyModel,
+  isOpenAIWebSearchModel,
+  isOpenRouterBuiltInWebSearchModel,
+  isWebSearchModel
+} from '../websearch'
+
+const createModel = (overrides: Partial<Model> = {}): Model => ({
+  id: 'gpt-4o',
+  name: 'gpt-4o',
+  provider: 'openai',
+  group: 'OpenAI',
+  ...overrides
+})
+
+const createProvider = (overrides: Partial<Provider> = {}): Provider => ({
+  id: 'openai',
+  type: 'openai',
+  name: 'OpenAI',
+  apiKey: '',
+  apiHost: '',
+  models: [],
+  ...overrides
+})
+
+const resetMocks = () => {
+  providerMock.mockReturnValue(createProvider())
+  isEmbeddingModel.mockReturnValue(false)
+  isRerankModel.mockReturnValue(false)
+  isPureGenerateImageModel.mockReturnValue(false)
+  isTextToImageModel.mockReturnValue(false)
+  providerMocks.isGeminiProvider.mockReturnValue(false)
+  providerMocks.isNewApiProvider.mockReturnValue(false)
+  providerMocks.isOpenAICompatibleProvider.mockReturnValue(false)
+  providerMocks.isOpenAIProvider.mockReturnValue(false)
+}
+
+describe('websearch helpers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetMocks()
+  })
+
+  describe('isOpenAIDeepResearchModel', () => {
+    it('detects deep research ids for OpenAI only', () => {
+      expect(isOpenAIDeepResearchModel(createModel({ id: 'openai/deep-research-preview' }))).toBe(true)
+      expect(isOpenAIDeepResearchModel(createModel({ provider: 'openai', id: 'gpt-4o' }))).toBe(false)
+      expect(isOpenAIDeepResearchModel(createModel({ provider: 'openrouter', id: 'deep-research' }))).toBe(false)
+    })
+  })
+
+  describe('isWebSearchModel', () => {
+    it('returns false for embedding/rerank/image models', () => {
+      isEmbeddingModel.mockReturnValueOnce(true)
+      expect(isWebSearchModel(createModel())).toBe(false)
+
+      resetMocks()
+      isRerankModel.mockReturnValueOnce(true)
+      expect(isWebSearchModel(createModel())).toBe(false)
+
+      resetMocks()
+      isTextToImageModel.mockReturnValueOnce(true)
+      expect(isWebSearchModel(createModel())).toBe(false)
+    })
+
+    it('honors user overrides', () => {
+      const enabled = createModel({ capabilities: [{ type: 'web_search', isUserSelected: true }] })
+      expect(isWebSearchModel(enabled)).toBe(true)
+
+      const disabled = createModel({ capabilities: [{ type: 'web_search', isUserSelected: false }] })
+      expect(isWebSearchModel(disabled)).toBe(false)
+    })
+
+    it('returns false when provider lookup fails', () => {
+      providerMock.mockReturnValueOnce(undefined as any)
+      expect(isWebSearchModel(createModel())).toBe(false)
+    })
+
+    it('handles Anthropic providers on unsupported platforms', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds['aws-bedrock'] }))
+      const model = createModel({ id: 'claude-2-sonnet' })
+      expect(isWebSearchModel(model)).toBe(false)
+    })
+
+    it('returns true for first-party Anthropic provider', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: 'anthropic' }))
+      const model = createModel({ id: 'claude-3.5-sonnet-latest', provider: 'anthropic' })
+      expect(isWebSearchModel(model)).toBe(true)
+    })
+
+    it('detects OpenAI preview search models only when supported', () => {
+      providerMocks.isOpenAIProvider.mockReturnValue(true)
+      const model = createModel({ id: 'gpt-4o-search-preview' })
+      expect(isWebSearchModel(model)).toBe(true)
+
+      const nonSearch = createModel({ id: 'gpt-4o-image' })
+      expect(isWebSearchModel(nonSearch)).toBe(false)
+    })
+
+    it('supports Perplexity sonar families including mandatory variants', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds.perplexity }))
+      expect(isWebSearchModel(createModel({ id: 'sonar-deep-research' }))).toBe(true)
+    })
+
+    it('handles AIHubMix Gemini and OpenAI search models', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds.aihubmix }))
+      expect(isWebSearchModel(createModel({ id: 'gemini-2.5-pro-preview' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds.aihubmix }))
+      const openaiSearch = createModel({ id: 'gpt-4o-search-preview' })
+      expect(isWebSearchModel(openaiSearch)).toBe(true)
+    })
+
+    it('supports OpenAI-compatible or new API providers for Gemini/OpenAI models', () => {
+      const model = createModel({ id: 'gemini-2.5-flash-lite-latest' })
+      providerMock.mockReturnValueOnce(createProvider({ id: 'custom' }))
+      providerMocks.isOpenAICompatibleProvider.mockReturnValueOnce(true)
+      expect(isWebSearchModel(model)).toBe(true)
+
+      resetMocks()
+      providerMock.mockReturnValueOnce(createProvider({ id: 'custom' }))
+      providerMocks.isNewApiProvider.mockReturnValueOnce(true)
+      expect(isWebSearchModel(createModel({ id: 'gpt-4o-search-preview' }))).toBe(true)
+    })
+
+    it('falls back to Gemini/Vertex provider regex matching', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds.vertexai }))
+      providerMocks.isGeminiProvider.mockReturnValueOnce(true)
+      expect(isWebSearchModel(createModel({ id: 'gemini-2.0-flash-latest' }))).toBe(true)
+    })
+
+    it('evaluates hunyuan/zhipu/dashscope/openrouter/grok providers', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: 'hunyuan' }))
+      expect(isWebSearchModel(createModel({ id: 'hunyuan-pro' }))).toBe(true)
+      expect(isWebSearchModel(createModel({ id: 'hunyuan-lite', provider: 'hunyuan' }))).toBe(false)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'zhipu' }))
+      expect(isWebSearchModel(createModel({ id: 'glm-4-air' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'dashscope' }))
+      expect(isWebSearchModel(createModel({ id: 'qwen-max-latest' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'openrouter' }))
+      expect(isWebSearchModel(createModel())).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'grok' }))
+      expect(isWebSearchModel(createModel({ id: 'grok-2' }))).toBe(true)
+    })
+  })
+
+  describe('isMandatoryWebSearchModel', () => {
+    it('requires sonar ids for perplexity/openrouter providers', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds.perplexity }))
+      expect(isMandatoryWebSearchModel(createModel({ id: 'sonar-pro' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: SystemProviderIds.openrouter }))
+      expect(isMandatoryWebSearchModel(createModel({ id: 'sonar-reasoning' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'openai' }))
+      expect(isMandatoryWebSearchModel(createModel({ id: 'sonar-pro' }))).toBe(false)
+    })
+
+    it.each([
+      ['perplexity', 'non-sonar'],
+      ['openrouter', 'gpt-4o-search-preview']
+    ])('returns false for %s provider when id is %s', (providerId, modelId) => {
+      providerMock.mockReturnValueOnce(createProvider({ id: providerId }))
+      expect(isMandatoryWebSearchModel(createModel({ id: modelId }))).toBe(false)
+    })
+  })
+
+  describe('isOpenRouterBuiltInWebSearchModel', () => {
+    it('checks for sonar ids or OpenAI chat-completion-only variants', () => {
+      providerMock.mockReturnValueOnce(createProvider({ id: 'openrouter' }))
+      expect(isOpenRouterBuiltInWebSearchModel(createModel({ id: 'sonar-reasoning' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'openrouter' }))
+      expect(isOpenRouterBuiltInWebSearchModel(createModel({ id: 'gpt-4o-search-preview' }))).toBe(true)
+
+      providerMock.mockReturnValueOnce(createProvider({ id: 'custom' }))
+      expect(isOpenRouterBuiltInWebSearchModel(createModel({ id: 'sonar-reasoning' }))).toBe(false)
+    })
+  })
+
+  describe('OpenAI web search helpers', () => {
+    it('detects chat completion only variants and openai search ids', () => {
+      expect(isOpenAIWebSearchChatCompletionOnlyModel(createModel({ id: 'gpt-4o-search-preview' }))).toBe(true)
+      expect(isOpenAIWebSearchChatCompletionOnlyModel(createModel({ id: 'gpt-4o-mini-search-preview' }))).toBe(true)
+      expect(isOpenAIWebSearchChatCompletionOnlyModel(createModel({ id: 'gpt-4o' }))).toBe(false)
+
+      expect(isOpenAIWebSearchModel(createModel({ id: 'gpt-4.1-turbo' }))).toBe(true)
+      expect(isOpenAIWebSearchModel(createModel({ id: 'gpt-4o-image' }))).toBe(false)
+      expect(isOpenAIWebSearchModel(createModel({ id: 'gpt-5.1-chat' }))).toBe(false)
+      expect(isOpenAIWebSearchModel(createModel({ id: 'o3-mini' }))).toBe(true)
+    })
+
+    it.each(['gpt-4.1-preview', 'gpt-4o-2024-05-13', 'o4-mini', 'gpt-5-explorer'])(
+      'treats %s as an OpenAI web search model',
+      (id) => {
+        expect(isOpenAIWebSearchModel(createModel({ id }))).toBe(true)
+      }
+    )
+
+    it.each(['gpt-4o-image-preview', 'gpt-4.1-nano', 'gpt-5.1-chat', 'gpt-image-1'])(
+      'excludes %s from OpenAI web search',
+      (id) => {
+        expect(isOpenAIWebSearchModel(createModel({ id }))).toBe(false)
+      }
+    )
+
+    it.each(['gpt-4o-search-preview', 'gpt-4o-mini-search-preview'])('flags %s as chat-completion-only', (id) => {
+      expect(isOpenAIWebSearchChatCompletionOnlyModel(createModel({ id }))).toBe(true)
+    })
+  })
+
+  describe('isHunyuanSearchModel', () => {
+    it('identifies hunyuan models except lite', () => {
+      expect(isHunyuanSearchModel(createModel({ id: 'hunyuan-pro', provider: 'hunyuan' }))).toBe(true)
+      expect(isHunyuanSearchModel(createModel({ id: 'hunyuan-lite', provider: 'hunyuan' }))).toBe(false)
+      expect(isHunyuanSearchModel(createModel())).toBe(false)
+    })
+
+    it.each(['hunyuan-standard', 'hunyuan-advanced'])('accepts %s', (suffix) => {
+      expect(isHunyuanSearchModel(createModel({ id: suffix, provider: 'hunyuan' }))).toBe(true)
+    })
+  })
+
+  describe('provider-specific regex coverage', () => {
+    it.each(['qwen-turbo', 'qwen-max-0919', 'qwen3-max', 'qwen-plus-2024', 'qwq-32b'])(
+      'dashscope treats %s as searchable',
+      (id) => {
+        providerMock.mockReturnValue(createProvider({ id: 'dashscope' }))
+        expect(isWebSearchModel(createModel({ id }))).toBe(true)
+      }
+    )
+
+    it.each(['qwen-1.5-chat', 'custom-model'])('dashscope ignores %s', (id) => {
+      providerMock.mockReturnValue(createProvider({ id: 'dashscope' }))
+      expect(isWebSearchModel(createModel({ id }))).toBe(false)
+    })
+
+    it.each(['sonar', 'sonar-pro', 'sonar-reasoning-pro', 'sonar-deep-research'])(
+      'perplexity provider supports %s',
+      (id) => {
+        providerMock.mockReturnValue(createProvider({ id: SystemProviderIds.perplexity }))
+        expect(isWebSearchModel(createModel({ id }))).toBe(true)
+      }
+    )
+
+    it.each([
+      'gemini-2.0-flash-latest',
+      'gemini-2.5-flash-lite-latest',
+      'gemini-flash-lite-latest',
+      'gemini-pro-latest'
+    ])('Gemini provider supports %s', (id) => {
+      providerMock.mockReturnValue(createProvider({ id: SystemProviderIds.vertexai }))
+      providerMocks.isGeminiProvider.mockReturnValue(true)
+      expect(isWebSearchModel(createModel({ id }))).toBe(true)
+    })
+  })
+
+  describe('Gemini Search Models', () => {
+    describe('GEMINI_SEARCH_REGEX', () => {
+      it('should match gemini 2.x models', () => {
+        expect(GEMINI_SEARCH_REGEX.test('gemini-2.0-flash')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-2.0-pro')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-flash')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-pro')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-flash-latest')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-2.5-pro-latest')).toBe(true)
+      })
+
+      it('should match gemini latest models', () => {
+        expect(GEMINI_SEARCH_REGEX.test('gemini-flash-latest')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-pro-latest')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-flash-lite-latest')).toBe(true)
+      })
+
+      it('should match gemini 3 models', () => {
+        // Preview versions
+        expect(GEMINI_SEARCH_REGEX.test('gemini-3-pro-preview')).toBe(true)
+        // Future stable versions
+        expect(GEMINI_SEARCH_REGEX.test('gemini-3-flash')).toBe(true)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-3-pro')).toBe(true)
+      })
+
+      it('should not match older gemini models', () => {
+        expect(GEMINI_SEARCH_REGEX.test('gemini-1.5-flash')).toBe(false)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-1.5-pro')).toBe(false)
+        expect(GEMINI_SEARCH_REGEX.test('gemini-1.0-pro')).toBe(false)
+      })
+    })
+  })
+})

src/renderer/src/config/models/index.ts

@@ -1,6 +1,8 @@
 export * from './default'
 export * from './embedding'
 export * from './logo'
+export * from './openai'
+export * from './qwen'
 export * from './reasoning'
 export * from './tooluse'
 export * from './utils'

src/renderer/src/config/models/openai.ts

@@ -0,0 +1,107 @@
+import type { Model } from '@renderer/types'
+import { getLowerBaseModelName } from '@renderer/utils'
+
+export const OPENAI_NO_SUPPORT_DEV_ROLE_MODELS = ['o1-preview', 'o1-mini']
+
+export function isOpenAILLMModel(model: Model): boolean {
+  if (!model) {
+    return false
+  }
+  const modelId = getLowerBaseModelName(model.id)
+
+  if (modelId.includes('gpt-4o-image')) {
+    return false
+  }
+  if (isOpenAIReasoningModel(model)) {
+    return true
+  }
+  if (modelId.includes('gpt')) {
+    return true
+  }
+  return false
+}
+
+export function isOpenAIModel(model: Model): boolean {
+  if (!model) {
+    return false
+  }
+  const modelId = getLowerBaseModelName(model.id)
+
+  return modelId.includes('gpt') || isOpenAIReasoningModel(model)
+}
+
+export const isGPT5ProModel = (model: Model) => {
+  const modelId = getLowerBaseModelName(model.id)
+  return modelId.includes('gpt-5-pro')
+}
+
+export const isOpenAIOpenWeightModel = (model: Model) => {
+  const modelId = getLowerBaseModelName(model.id)
+  return modelId.includes('gpt-oss')
+}
+
+export const isGPT5SeriesModel = (model: Model) => {
+  const modelId = getLowerBaseModelName(model.id)
+  return modelId.includes('gpt-5') && !modelId.includes('gpt-5.1')
+}
+
+export const isGPT5SeriesReasoningModel = (model: Model) => {
+  const modelId = getLowerBaseModelName(model.id)
+  return isGPT5SeriesModel(model) && !modelId.includes('chat')
+}
+
+export const isGPT51SeriesModel = (model: Model) => {
+  const modelId = getLowerBaseModelName(model.id)
+  return modelId.includes('gpt-5.1')
+}
+
+export function isSupportVerbosityModel(model: Model): boolean {
+  const modelId = getLowerBaseModelName(model.id)
+  return (isGPT5SeriesModel(model) || isGPT51SeriesModel(model)) && !modelId.includes('chat')
+}
+
+export function isOpenAIChatCompletionOnlyModel(model: Model): boolean {
+  if (!model) {
+    return false
+  }
+
+  const modelId = getLowerBaseModelName(model.id)
+  return (
+    modelId.includes('gpt-4o-search-preview') ||
+    modelId.includes('gpt-4o-mini-search-preview') ||
+    modelId.includes('o1-mini') ||
+    modelId.includes('o1-preview')
+  )
+}
+
+export function isOpenAIReasoningModel(model: Model): boolean {
+  const modelId = getLowerBaseModelName(model.id, '/')
+  return isSupportedReasoningEffortOpenAIModel(model) || modelId.includes('o1')
+}
+
+export function isSupportedReasoningEffortOpenAIModel(model: Model): boolean {
+  const modelId = getLowerBaseModelName(model.id)
+  return (
+    (modelId.includes('o1') && !(modelId.includes('o1-preview') || modelId.includes('o1-mini'))) ||
+    modelId.includes('o3') ||
+    modelId.includes('o4') ||
+    modelId.includes('gpt-oss') ||
+    ((isGPT5SeriesModel(model) || isGPT51SeriesModel(model)) && !modelId.includes('chat'))
+  )
+}
+
+const OPENAI_DEEP_RESEARCH_MODEL_REGEX = /deep[-_]?research/
+
+export function isOpenAIDeepResearchModel(model?: Model): boolean {
+  if (!model) {
+    return false
+  }
+
+  const providerId = model.provider
+  if (providerId !== 'openai' && providerId !== 'openai-chat') {
+    return false
+  }
+
+  const modelId = getLowerBaseModelName(model.id, '/')
+  return OPENAI_DEEP_RESEARCH_MODEL_REGEX.test(modelId)
+}

src/renderer/src/config/models/qwen.ts

@@ -0,0 +1,7 @@
+import type { Model } from '@renderer/types'
+import { getLowerBaseModelName } from '@renderer/utils'
+
+export const isQwenMTModel = (model: Model): boolean => {
+  const modelId = getLowerBaseModelName(model.id)
+  return modelId.includes('qwen-mt')
+}

src/renderer/src/config/models/reasoning.ts

@@ -8,9 +8,16 @@ import type {
 import { getLowerBaseModelName, isUserSelectedModelType } from '@renderer/utils'
 
 import { isEmbeddingModel, isRerankModel } from './embedding'
-import { isGPT5ProModel, isGPT5SeriesModel, isGPT51SeriesModel } from './utils'
+import {
+  isGPT5ProModel,
+  isGPT5SeriesModel,
+  isGPT51SeriesModel,
+  isOpenAIDeepResearchModel,
+  isOpenAIReasoningModel,
+  isSupportedReasoningEffortOpenAIModel
+} from './openai'
+import { GEMINI_FLASH_MODEL_REGEX } from './utils'
 import { isTextToImageModel } from './vision'
-import { GEMINI_FLASH_MODEL_REGEX, isOpenAIDeepResearchModel } from './websearch'
 
 // Reasoning models
 export const REASONING_REGEX =
@@ -535,22 +542,6 @@ export function isReasoningModel(model?: Model): boolean {
   return REASONING_REGEX.test(modelId) || false
 }
 
-export function isOpenAIReasoningModel(model: Model): boolean {
-  const modelId = getLowerBaseModelName(model.id, '/')
-  return isSupportedReasoningEffortOpenAIModel(model) || modelId.includes('o1')
-}
-
-export function isSupportedReasoningEffortOpenAIModel(model: Model): boolean {
-  const modelId = getLowerBaseModelName(model.id)
-  return (
-    (modelId.includes('o1') && !(modelId.includes('o1-preview') || modelId.includes('o1-mini'))) ||
-    modelId.includes('o3') ||
-    modelId.includes('o4') ||
-    modelId.includes('gpt-oss') ||
-    ((isGPT5SeriesModel(model) || isGPT51SeriesModel(model)) && !modelId.includes('chat'))
-  )
-}
-
 export const THINKING_TOKEN_MAP: Record<string, { min: number; max: number }> = {
   // Gemini models
   'gemini-2\\.5-flash-lite.*$': { min: 512, max: 24576 },

src/renderer/src/config/models/tooluse.ts

@@ -66,10 +66,6 @@ export function isFunctionCallingModel(model?: Model): boolean {
     return isUserSelectedModelType(model, 'function_calling')!
   }
 
-  if (model.provider === 'qiniu') {
-    return ['deepseek-v3-tool', 'deepseek-v3-0324', 'qwq-32b', 'qwen2.5-72b-instruct'].includes(modelId)
-  }
-
   if (model.provider === 'doubao' || modelId.includes('doubao')) {
     return FUNCTION_CALLING_REGEX.test(modelId) || FUNCTION_CALLING_REGEX.test(model.name)
   }

src/renderer/src/config/models/utils.ts

@@ -1,44 +1,14 @@
 import type OpenAI from '@cherrystudio/openai'
 import { isEmbeddingModel, isRerankModel } from '@renderer/config/models/embedding'
-import type { Model } from '@renderer/types'
+import { type Model, SystemProviderIds } from '@renderer/types'
 import type { OpenAIVerbosity, ValidOpenAIVerbosity } from '@renderer/types/aiCoreTypes'
 import { getLowerBaseModelName } from '@renderer/utils'
 
-import { WEB_SEARCH_PROMPT_FOR_OPENROUTER } from '../prompts'
+import { isOpenAIChatCompletionOnlyModel, isOpenAIOpenWeightModel, isOpenAIReasoningModel } from './openai'
-import { getWebSearchTools } from '../tools'
+import { isQwenMTModel } from './qwen'
-import { isOpenAIReasoningModel } from './reasoning'
 import { isGenerateImageModel, isTextToImageModel, isVisionModel } from './vision'
-import { isOpenAIWebSearchChatCompletionOnlyModel } from './websearch'
 export const NOT_SUPPORTED_REGEX = /(?:^tts|whisper|speech)/i
-
+export const GEMINI_FLASH_MODEL_REGEX = new RegExp('gemini.*-flash.*$', 'i')
-export const OPENAI_NO_SUPPORT_DEV_ROLE_MODELS = ['o1-preview', 'o1-mini']
-
-export function isOpenAILLMModel(model: Model): boolean {
-  if (!model) {
-    return false
-  }
-  const modelId = getLowerBaseModelName(model.id)
-
-  if (modelId.includes('gpt-4o-image')) {
-    return false
-  }
-  if (isOpenAIReasoningModel(model)) {
-    return true
-  }
-  if (modelId.includes('gpt')) {
-    return true
-  }
-  return false
-}
-
-export function isOpenAIModel(model: Model): boolean {
-  if (!model) {
-    return false
-  }
-  const modelId = getLowerBaseModelName(model.id)
-
-  return modelId.includes('gpt') || isOpenAIReasoningModel(model)
-}
 
 export function isSupportFlexServiceTierModel(model: Model): boolean {
   if (!model) {
@@ -53,33 +23,6 @@ export function isSupportedFlexServiceTier(model: Model): boolean {
   return isSupportFlexServiceTierModel(model)
 }
 
-export function isSupportVerbosityModel(model: Model): boolean {
-  const modelId = getLowerBaseModelName(model.id)
-  return (isGPT5SeriesModel(model) || isGPT51SeriesModel(model)) && !modelId.includes('chat')
-}
-
-export function isOpenAIChatCompletionOnlyModel(model: Model): boolean {
-  if (!model) {
-    return false
-  }
-
-  const modelId = getLowerBaseModelName(model.id)
-  return (
-    modelId.includes('gpt-4o-search-preview') ||
-    modelId.includes('gpt-4o-mini-search-preview') ||
-    modelId.includes('o1-mini') ||
-    modelId.includes('o1-preview')
-  )
-}
-
-export function isGrokModel(model?: Model): boolean {
-  if (!model) {
-    return false
-  }
-  const modelId = getLowerBaseModelName(model.id)
-  return modelId.includes('grok')
-}
-
 export function isSupportedModel(model: OpenAI.Models.Model): boolean {
   if (!model) {
     return false
@@ -106,53 +49,6 @@ export function isNotSupportTemperatureAndTopP(model: Model): boolean {
   return false
 }
 
-export function getOpenAIWebSearchParams(model: Model, isEnableWebSearch?: boolean): Record<string, any> {
-  if (!isEnableWebSearch) {
-    return {}
-  }
-
-  const webSearchTools = getWebSearchTools(model)
-
-  if (model.provider === 'grok') {
-    return {
-      search_parameters: {
-        mode: 'auto',
-        return_citations: true,
-        sources: [{ type: 'web' }, { type: 'x' }, { type: 'news' }]
-      }
-    }
-  }
-
-  if (model.provider === 'hunyuan') {
-    return { enable_enhancement: true, citation: true, search_info: true }
-  }
-
-  if (model.provider === 'dashscope') {
-    return {
-      enable_search: true,
-      search_options: {
-        forced_search: true
-      }
-    }
-  }
-
-  if (isOpenAIWebSearchChatCompletionOnlyModel(model)) {
-    return {
-      web_search_options: {}
-    }
-  }
-
-  if (model.provider === 'openrouter') {
-    return {
-      plugins: [{ id: 'web', search_prompts: WEB_SEARCH_PROMPT_FOR_OPENROUTER }]
-    }
-  }
-
-  return {
-    tools: webSearchTools
-  }
-}
-
 export function isGemmaModel(model?: Model): boolean {
   if (!model) {
     return false
@@ -162,12 +58,14 @@ export function isGemmaModel(model?: Model): boolean {
   return modelId.includes('gemma-') || model.group === 'Gemma'
 }
 
-export function isZhipuModel(model?: Model): boolean {
+export function isZhipuModel(model: Model): boolean {
-  if (!model) {
+  const modelId = getLowerBaseModelName(model.id)
-    return false
+  return modelId.includes('glm') || model.provider === SystemProviderIds.zhipu
-  }
+}
 
-  return model.provider === 'zhipu'
+export function isMoonshotModel(model: Model): boolean {
+  const modelId = getLowerBaseModelName(model.id)
+  return ['moonshot', 'kimi'].some((m) => modelId.includes(m))
 }
 
 /**
@@ -213,11 +111,6 @@ export const isAnthropicModel = (model?: Model): boolean => {
   return modelId.startsWith('claude')
 }
 
-export const isQwenMTModel = (model: Model): boolean => {
-  const modelId = getLowerBaseModelName(model.id)
-  return modelId.includes('qwen-mt')
-}
-
 export const isNotSupportedTextDelta = (model: Model): boolean => {
   return isQwenMTModel(model)
 }
@@ -226,21 +119,6 @@ export const isNotSupportSystemMessageModel = (model: Model): boolean => {
   return isQwenMTModel(model) || isGemmaModel(model)
 }
 
-export const isGPT5SeriesModel = (model: Model) => {
-  const modelId = getLowerBaseModelName(model.id)
-  return modelId.includes('gpt-5') && !modelId.includes('gpt-5.1')
-}
-
-export const isGPT5SeriesReasoningModel = (model: Model) => {
-  const modelId = getLowerBaseModelName(model.id)
-  return isGPT5SeriesModel(model) && !modelId.includes('chat')
-}
-
-export const isGPT51SeriesModel = (model: Model) => {
-  const modelId = getLowerBaseModelName(model.id)
-  return modelId.includes('gpt-5.1')
-}
-
 // GPT-5 verbosity configuration
 // gpt-5-pro only supports 'high', other GPT-5 models support all levels
 export const MODEL_SUPPORTED_VERBOSITY: Record<string, ValidOpenAIVerbosity[]> = {
@@ -264,11 +142,6 @@ export const isGeminiModel = (model: Model) => {
   return modelId.includes('gemini')
 }
 
-export const isOpenAIOpenWeightModel = (model: Model) => {
-  const modelId = getLowerBaseModelName(model.id)
-  return modelId.includes('gpt-oss')
-}
-
 // zhipu 视觉推理模型用这组 special token 标记推理结果
 export const ZHIPU_RESULT_TOKENS = ['<|begin_of_box|>', '<|end_of_box|>'] as const
 
@@ -276,7 +149,9 @@ export const agentModelFilter = (model: Model): boolean => {
   return !isEmbeddingModel(model) && !isRerankModel(model) && !isTextToImageModel(model)
 }
 
-export const isGPT5ProModel = (model: Model) => {
+export const isMaxTemperatureOneModel = (model: Model): boolean => {
-  const modelId = getLowerBaseModelName(model.id)
+  if (isZhipuModel(model) || isAnthropicModel(model) || isMoonshotModel(model)) {
-  return modelId.includes('gpt-5-pro')
+    return true
+  }
+  return false
 }

src/renderer/src/config/models/websearch.ts

@@ -2,26 +2,26 @@ import { getProviderByModel } from '@renderer/services/AssistantService'
 import type { Model } from '@renderer/types'
 import { SystemProviderIds } from '@renderer/types'
 import { getLowerBaseModelName, isUserSelectedModelType } from '@renderer/utils'
-
 import {
   isGeminiProvider,
   isNewApiProvider,
   isOpenAICompatibleProvider,
   isOpenAIProvider,
-  isVertexAiProvider
+  isVertexProvider
-} from '../providers'
+} from '@renderer/utils/provider'
+
+export { GEMINI_FLASH_MODEL_REGEX } from './utils'
+
 import { isEmbeddingModel, isRerankModel } from './embedding'
 import { isClaude4SeriesModel } from './reasoning'
 import { isAnthropicModel } from './utils'
-import { isPureGenerateImageModel, isTextToImageModel } from './vision'
+import { isGenerateImageModel, isPureGenerateImageModel, isTextToImageModel } from './vision'
 
 const CLAUDE_SUPPORTED_WEBSEARCH_REGEX = new RegExp(
   `\\b(?:claude-3(-|\\.)(7|5)-sonnet(?:-[\\w-]+)|claude-3(-|\\.)5-haiku(?:-[\\w-]+)|claude-(haiku|sonnet|opus)-4(?:-[\\w-]+)?)\\b`,
   'i'
 )
 
-export const GEMINI_FLASH_MODEL_REGEX = new RegExp('gemini.*-flash.*$')
-
 export const GEMINI_SEARCH_REGEX = new RegExp(
   'gemini-(?:2.*(?:-latest)?|3-(?:flash|pro)(?:-preview)?|flash-latest|pro-latest|flash-lite-latest)(?:-[\\w-]+)*$',
   'i'
@@ -35,29 +35,14 @@ export const PERPLEXITY_SEARCH_MODELS = [
   'sonar-deep-research'
 ]
 
-const OPENAI_DEEP_RESEARCH_MODEL_REGEX = /deep[-_]?research/
-
-export function isOpenAIDeepResearchModel(model?: Model): boolean {
-  if (!model) {
-    return false
-  }
-
-  const providerId = model.provider
-  if (providerId !== 'openai' && providerId !== 'openai-chat') {
-    return false
-  }
-
-  const modelId = getLowerBaseModelName(model.id, '/')
-  return OPENAI_DEEP_RESEARCH_MODEL_REGEX.test(modelId)
-}
-
 export function isWebSearchModel(model: Model): boolean {
   if (
     !model ||
     isEmbeddingModel(model) ||
     isRerankModel(model) ||
     isTextToImageModel(model) ||
-    isPureGenerateImageModel(model)
+    isPureGenerateImageModel(model) ||
+    isGenerateImageModel(model)
   ) {
     return false
   }
@@ -76,7 +61,7 @@ export function isWebSearchModel(model: Model): boolean {
 
   // bedrock不支持
   if (isAnthropicModel(model) && !(provider.id === SystemProviderIds['aws-bedrock'])) {
-    if (isVertexAiProvider(provider)) {
+    if (isVertexProvider(provider)) {
       return isClaude4SeriesModel(model)
     }
     return CLAUDE_SUPPORTED_WEBSEARCH_REGEX.test(modelId)
@@ -114,7 +99,7 @@ export function isWebSearchModel(model: Model): boolean {
     }
   }
 
-  if (isGeminiProvider(provider) || isVertexAiProvider(provider)) {
+  if (isGeminiProvider(provider) || isVertexProvider(provider)) {
     return GEMINI_SEARCH_REGEX.test(modelId)
   }
 

src/renderer/src/config/providers.ts

@@ -59,15 +59,8 @@ import VoyageAIProviderLogo from '@renderer/assets/images/providers/voyageai.png
 import XirangProviderLogo from '@renderer/assets/images/providers/xirang.png'
 import ZeroOneProviderLogo from '@renderer/assets/images/providers/zero-one.png'
 import ZhipuProviderLogo from '@renderer/assets/images/providers/zhipu.png'
-import type {
+import type { AtLeast, SystemProvider, SystemProviderId } from '@renderer/types'
-  AtLeast,
+import { OpenAIServiceTiers } from '@renderer/types'
-  AzureOpenAIProvider,
-  Provider,
-  ProviderType,
-  SystemProvider,
-  SystemProviderId
-} from '@renderer/types'
-import { isSystemProvider, OpenAIServiceTiers, SystemProviderIds } from '@renderer/types'
 
 import { TOKENFLUX_HOST } from './constant'
 import { glm45FlashModel, qwen38bModel, SYSTEM_MODELS } from './models'
@@ -1441,153 +1434,3 @@ export const PROVIDER_URLS: Record<SystemProviderId, ProviderUrls> = {
     }
   }
 }
-
-const NOT_SUPPORT_ARRAY_CONTENT_PROVIDERS = [
-  'deepseek',
-  'baichuan',
-  'minimax',
-  'xirang',
-  'poe',
-  'cephalon'
-] as const satisfies SystemProviderId[]
-
-/**
- * 判断提供商是否支持 message 的 content 为数组类型。 Only for OpenAI Chat Completions API.
- */
-export const isSupportArrayContentProvider = (provider: Provider) => {
-  return (
-    provider.apiOptions?.isNotSupportArrayContent !== true &&
-    !NOT_SUPPORT_ARRAY_CONTENT_PROVIDERS.some((pid) => pid === provider.id)
-  )
-}
-
-const NOT_SUPPORT_DEVELOPER_ROLE_PROVIDERS = ['poe', 'qiniu'] as const satisfies SystemProviderId[]
-
-/**
- * 判断提供商是否支持 developer 作为 message role。 Only for OpenAI API.
- */
-export const isSupportDeveloperRoleProvider = (provider: Provider) => {
-  return (
-    provider.apiOptions?.isSupportDeveloperRole === true ||
-    (isSystemProvider(provider) && !NOT_SUPPORT_DEVELOPER_ROLE_PROVIDERS.some((pid) => pid === provider.id))
-  )
-}
-
-const NOT_SUPPORT_STREAM_OPTIONS_PROVIDERS = ['mistral'] as const satisfies SystemProviderId[]
-
-/**
- * 判断提供商是否支持 stream_options 参数。Only for OpenAI API.
- */
-export const isSupportStreamOptionsProvider = (provider: Provider) => {
-  return (
-    provider.apiOptions?.isNotSupportStreamOptions !== true &&
-    !NOT_SUPPORT_STREAM_OPTIONS_PROVIDERS.some((pid) => pid === provider.id)
-  )
-}
-
-const NOT_SUPPORT_QWEN3_ENABLE_THINKING_PROVIDER = [
-  'ollama',
-  'lmstudio',
-  'nvidia'
-] as const satisfies SystemProviderId[]
-
-/**
- * 判断提供商是否支持使用 enable_thinking 参数来控制 Qwen3 等模型的思考。 Only for OpenAI Chat Completions API.
- */
-export const isSupportEnableThinkingProvider = (provider: Provider) => {
-  return (
-    provider.apiOptions?.isNotSupportEnableThinking !== true &&
-    !NOT_SUPPORT_QWEN3_ENABLE_THINKING_PROVIDER.some((pid) => pid === provider.id)
-  )
-}
-
-const NOT_SUPPORT_SERVICE_TIER_PROVIDERS = ['github', 'copilot', 'cerebras'] as const satisfies SystemProviderId[]
-
-/**
- * 判断提供商是否支持 service_tier 设置。 Only for OpenAI API.
- */
-export const isSupportServiceTierProvider = (provider: Provider) => {
-  return (
-    provider.apiOptions?.isSupportServiceTier === true ||
-    (isSystemProvider(provider) && !NOT_SUPPORT_SERVICE_TIER_PROVIDERS.some((pid) => pid === provider.id))
-  )
-}
-
-const SUPPORT_URL_CONTEXT_PROVIDER_TYPES = [
-  'gemini',
-  'vertexai',
-  'anthropic',
-  'new-api'
-] as const satisfies ProviderType[]
-
-export const isSupportUrlContextProvider = (provider: Provider) => {
-  return (
-    SUPPORT_URL_CONTEXT_PROVIDER_TYPES.some((type) => type === provider.type) ||
-    provider.id === SystemProviderIds.cherryin
-  )
-}
-
-const SUPPORT_GEMINI_NATIVE_WEB_SEARCH_PROVIDERS = ['gemini', 'vertexai'] as const satisfies SystemProviderId[]
-
-/** 判断是否是使用 Gemini 原生搜索工具的 provider. 目前假设只有官方 API 使用原生工具 */
-export const isGeminiWebSearchProvider = (provider: Provider) => {
-  return SUPPORT_GEMINI_NATIVE_WEB_SEARCH_PROVIDERS.some((id) => id === provider.id)
-}
-
-export const isNewApiProvider = (provider: Provider) => {
-  return ['new-api', 'cherryin'].includes(provider.id) || provider.type === 'new-api'
-}
-
-export function isCherryAIProvider(provider: Provider): boolean {
-  return provider.id === 'cherryai'
-}
-
-export function isPerplexityProvider(provider: Provider): boolean {
-  return provider.id === 'perplexity'
-}
-
-/**
- * 判断是否为 OpenAI 兼容的提供商
- * @param {Provider} provider 提供商对象
- * @returns {boolean} 是否为 OpenAI 兼容提供商
- */
-export function isOpenAICompatibleProvider(provider: Provider): boolean {
-  return ['openai', 'new-api', 'mistral'].includes(provider.type)
-}
-
-export function isAzureOpenAIProvider(provider: Provider): provider is AzureOpenAIProvider {
-  return provider.type === 'azure-openai'
-}
-
-export function isOpenAIProvider(provider: Provider): boolean {
-  return provider.type === 'openai-response'
-}
-
-export function isAnthropicProvider(provider: Provider): boolean {
-  return provider.type === 'anthropic'
-}
-
-export function isGeminiProvider(provider: Provider): boolean {
-  return provider.type === 'gemini'
-}
-
-export function isVertexAiProvider(provider: Provider): boolean {
-  return provider.type === 'vertexai'
-}
-
-export function isAIGatewayProvider(provider: Provider): boolean {
-  return provider.type === 'ai-gateway'
-}
-
-export function isAwsBedrockProvider(provider: Provider): boolean {
-  return provider.type === 'aws-bedrock'
-}
-
-const NOT_SUPPORT_API_VERSION_PROVIDERS = ['github', 'copilot', 'perplexity'] as const satisfies SystemProviderId[]
-
-export const isSupportAPIVersionProvider = (provider: Provider) => {
-  if (isSystemProvider(provider)) {
-    return !NOT_SUPPORT_API_VERSION_PROVIDERS.some((pid) => pid === provider.id)
-  }
-  return provider.apiOptions?.isNotSupportAPIVersion !== false
-}

src/renderer/src/config/tools.ts

@@ -1,56 +0,0 @@
-import type { ChatCompletionTool } from '@cherrystudio/openai/resources'
-import type { Model } from '@renderer/types'
-
-import { WEB_SEARCH_PROMPT_FOR_ZHIPU } from './prompts'
-
-export function getWebSearchTools(model: Model): ChatCompletionTool[] {
-  if (model?.provider === 'zhipu') {
-    if (model.id === 'glm-4-alltools') {
-      return [
-        {
-          type: 'web_browser',
-          web_browser: {
-            browser: 'auto'
-          }
-        } as unknown as ChatCompletionTool
-      ]
-    }
-    return [
-      {
-        type: 'web_search',
-        web_search: {
-          enable: true,
-          search_result: true,
-          search_prompt: WEB_SEARCH_PROMPT_FOR_ZHIPU
-        }
-      } as unknown as ChatCompletionTool
-    ]
-  }
-
-  if (model?.id.includes('gemini')) {
-    return [
-      {
-        type: 'function',
-        function: {
-          name: 'googleSearch'
-        }
-      }
-    ]
-  }
-  return []
-}
-
-export function getUrlContextTools(model: Model): ChatCompletionTool[] {
-  if (model.id.includes('gemini')) {
-    return [
-      {
-        type: 'function',
-        function: {
-          name: 'urlContext'
-        }
-      }
-    ]
-  }
-
-  return []
-}

src/renderer/src/hooks/useVertexAI.ts

@@ -38,13 +38,6 @@ export function getVertexAIServiceAccount() {
   return store.getState().llm.settings.vertexai.serviceAccount
 }
 
-/**
- * 类型守卫：检查 Provider 是否为 VertexProvider
- */
-export function isVertexProvider(provider: Provider): provider is VertexProvider {
-  return provider.type === 'vertexai'
-}
-
 /**
  * 创建 VertexProvider 对象，整合单独的配置
  * @param baseProvider 基础的 provider 配置

src/renderer/src/pages/home/Inputbar/tools/components/MCPToolsButton.tsx

@@ -2,7 +2,6 @@ import { ActionIconButton } from '@renderer/components/Buttons'
 import type { QuickPanelListItem } from '@renderer/components/QuickPanel'
 import { QuickPanelReservedSymbol, useQuickPanel } from '@renderer/components/QuickPanel'
 import { isGeminiModel } from '@renderer/config/models'
-import { isGeminiWebSearchProvider, isSupportUrlContextProvider } from '@renderer/config/providers'
 import { useAssistant } from '@renderer/hooks/useAssistant'
 import { useMCPServers } from '@renderer/hooks/useMCPServers'
 import { useTimer } from '@renderer/hooks/useTimer'
@@ -11,6 +10,7 @@ import { getProviderByModel } from '@renderer/services/AssistantService'
 import { EventEmitter } from '@renderer/services/EventService'
 import type { MCPPrompt, MCPResource, MCPServer } from '@renderer/types'
 import { isToolUseModeFunction } from '@renderer/utils/assistant'
+import { isGeminiWebSearchProvider, isSupportUrlContextProvider } from '@renderer/utils/provider'
 import { Form, Input, Tooltip } from 'antd'
 import { CircleX, Hammer, Plus } from 'lucide-react'
 import type { FC } from 'react'

src/renderer/src/pages/home/Inputbar/tools/components/WebSearchQuickPanelManager.tsx

@@ -9,7 +9,6 @@ import {
   isOpenAIWebSearchModel,
   isWebSearchModel
 } from '@renderer/config/models'
-import { isGeminiWebSearchProvider } from '@renderer/config/providers'
 import { useAssistant } from '@renderer/hooks/useAssistant'
 import { useTimer } from '@renderer/hooks/useTimer'
 import { useWebSearchProviders } from '@renderer/hooks/useWebSearchProviders'
@@ -19,6 +18,7 @@ import WebSearchService from '@renderer/services/WebSearchService'
 import type { WebSearchProvider, WebSearchProviderId } from '@renderer/types'
 import { hasObjectKey } from '@renderer/utils'
 import { isToolUseModeFunction } from '@renderer/utils/assistant'
+import { isGeminiWebSearchProvider } from '@renderer/utils/provider'
 import { Globe } from 'lucide-react'
 import { useCallback, useEffect, useMemo } from 'react'
 import { useTranslation } from 'react-i18next'

src/renderer/src/pages/home/Inputbar/tools/urlContextTool.tsx

@@ -1,7 +1,7 @@
 import { isAnthropicModel, isGeminiModel } from '@renderer/config/models'
-import { isSupportUrlContextProvider } from '@renderer/config/providers'
 import { defineTool, registerTool, TopicType } from '@renderer/pages/home/Inputbar/types'
 import { getProviderByModel } from '@renderer/services/AssistantService'
+import { isSupportUrlContextProvider } from '@renderer/utils/provider'
 
 import UrlContextButton from './components/UrlContextbutton'
 

src/renderer/src/pages/home/Inputbar/tools/webSearchTool.tsx

@@ -1,4 +1,4 @@
-import { isMandatoryWebSearchModel } from '@renderer/config/models'
+import { isMandatoryWebSearchModel, isWebSearchModel } from '@renderer/config/models'
 import { defineTool, registerTool, TopicType } from '@renderer/pages/home/Inputbar/types'
 
 import WebSearchButton from './components/WebSearchButton'
@@ -15,7 +15,7 @@ const webSearchTool = defineTool({
   label: (t) => t('chat.input.web_search.label'),
 
   visibleInScopes: [TopicType.Chat],
-  condition: ({ model }) => !isMandatoryWebSearchModel(model),
+  condition: ({ model }) => isWebSearchModel(model) && !isMandatoryWebSearchModel(model),
 
   render: function WebSearchToolRender(context) {
     const { assistant, quickPanelController } = context

src/renderer/src/pages/home/Tabs/components/OpenAISettingsGroup.tsx

@@ -5,7 +5,6 @@ import {
   isSupportFlexServiceTierModel,
   isSupportVerbosityModel
 } from '@renderer/config/models'
-import { isSupportServiceTierProvider } from '@renderer/config/providers'
 import { useProvider } from '@renderer/hooks/useProvider'
 import { SettingDivider, SettingRow } from '@renderer/pages/settings'
 import { CollapsibleSettingGroup } from '@renderer/pages/settings/SettingGroup'
@@ -15,6 +14,7 @@ import { setOpenAISummaryText, setOpenAIVerbosity } from '@renderer/store/settin
 import type { GroqServiceTier, Model, OpenAIServiceTier, ServiceTier } from '@renderer/types'
 import { GroqServiceTiers, OpenAIServiceTiers, SystemProviderIds } from '@renderer/types'
 import type { OpenAISummaryText, OpenAIVerbosity } from '@renderer/types/aiCoreTypes'
+import { isSupportServiceTierProvider } from '@renderer/utils/provider'
 import { Tooltip } from 'antd'
 import { CircleHelp } from 'lucide-react'
 import type { FC } from 'react'

src/renderer/src/pages/paintings/NewApiPage.tsx

@@ -6,7 +6,7 @@ import { Navbar, NavbarCenter, NavbarRight } from '@renderer/components/app/Navb
 import Scrollbar from '@renderer/components/Scrollbar'
 import TranslateButton from '@renderer/components/TranslateButton'
 import { isMac } from '@renderer/config/constant'
-import { getProviderLogo, isNewApiProvider, PROVIDER_URLS } from '@renderer/config/providers'
+import { getProviderLogo, PROVIDER_URLS } from '@renderer/config/providers'
 import { LanguagesEnum } from '@renderer/config/translate'
 import { useTheme } from '@renderer/context/ThemeProvider'
 import { usePaintings } from '@renderer/hooks/usePaintings'
@@ -28,6 +28,7 @@ import { setGenerating } from '@renderer/store/runtime'
 import type { PaintingAction, PaintingsState } from '@renderer/types'
 import type { FileMetadata } from '@renderer/types'
 import { getErrorMessage, uuid } from '@renderer/utils'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import { Avatar, Button, Empty, InputNumber, Segmented, Select, Upload } from 'antd'
 import TextArea from 'antd/es/input/TextArea'
 import type { FC } from 'react'

src/renderer/src/pages/paintings/PaintingsRoutePage.tsx

@@ -1,10 +1,10 @@
 import { loggerService } from '@logger'
-import { isNewApiProvider } from '@renderer/config/providers'
 import { useAllProviders } from '@renderer/hooks/useProvider'
 import { useAppDispatch } from '@renderer/store'
 import { setDefaultPaintingProvider } from '@renderer/store/settings'
 import { updateTab } from '@renderer/store/tabs'
 import type { PaintingProvider, SystemProviderId } from '@renderer/types'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import type { FC } from 'react'
 import { useEffect, useMemo, useState } from 'react'
 import { Route, Routes, useParams } from 'react-router-dom'

src/renderer/src/pages/settings/ProviderSettings/EditModelPopup/ModelEditContent.tsx

@@ -17,10 +17,10 @@ import {
   isVisionModel,
   isWebSearchModel
 } from '@renderer/config/models'
-import { isNewApiProvider } from '@renderer/config/providers'
 import { useDynamicLabelWidth } from '@renderer/hooks/useDynamicLabelWidth'
 import type { Model, ModelCapability, ModelType, Provider } from '@renderer/types'
 import { getDefaultGroupName, getDifference, getUnion, uniqueObjectArray } from '@renderer/utils'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import type { ModalProps } from 'antd'
 import { Button, Divider, Flex, Form, Input, InputNumber, message, Modal, Select, Switch, Tooltip } from 'antd'
 import { cloneDeep } from 'lodash'

src/renderer/src/pages/settings/ProviderSettings/ModelList/ManageModelsList.tsx

@@ -3,10 +3,10 @@ import ModelIdWithTags from '@renderer/components/ModelIdWithTags'
 import CustomTag from '@renderer/components/Tags/CustomTag'
 import { DynamicVirtualList } from '@renderer/components/VirtualList'
 import { getModelLogoById } from '@renderer/config/models'
-import { isNewApiProvider } from '@renderer/config/providers'
 import FileItem from '@renderer/pages/files/FileItem'
 import NewApiBatchAddModelPopup from '@renderer/pages/settings/ProviderSettings/ModelList/NewApiBatchAddModelPopup'
 import type { Model, Provider } from '@renderer/types'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import { Button, Flex, Tooltip } from 'antd'
 import { Avatar } from 'antd'
 import { ChevronRight, Minus, Plus } from 'lucide-react'

src/renderer/src/pages/settings/ProviderSettings/ModelList/ManageModelsPopup.tsx

@@ -13,7 +13,6 @@ import {
   isWebSearchModel,
   SYSTEM_MODELS
 } from '@renderer/config/models'
-import { isNewApiProvider } from '@renderer/config/providers'
 import { useProvider } from '@renderer/hooks/useProvider'
 import NewApiAddModelPopup from '@renderer/pages/settings/ProviderSettings/ModelList/NewApiAddModelPopup'
 import NewApiBatchAddModelPopup from '@renderer/pages/settings/ProviderSettings/ModelList/NewApiBatchAddModelPopup'
@@ -21,6 +20,7 @@ import { fetchModels } from '@renderer/services/ApiService'
 import type { Model, Provider } from '@renderer/types'
 import { filterModelsByKeywords, getDefaultGroupName, getFancyProviderName } from '@renderer/utils'
 import { isFreeModel } from '@renderer/utils/model'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import { Button, Empty, Flex, Modal, Spin, Tabs, Tooltip } from 'antd'
 import Input from 'antd/es/input/Input'
 import { groupBy, isEmpty, uniqBy } from 'lodash'

src/renderer/src/pages/settings/ProviderSettings/ModelList/ModelList.tsx

@@ -2,7 +2,7 @@ import CollapsibleSearchBar from '@renderer/components/CollapsibleSearchBar'
 import { LoadingIcon, StreamlineGoodHealthAndWellBeing } from '@renderer/components/Icons'
 import { HStack } from '@renderer/components/Layout'
 import CustomTag from '@renderer/components/Tags/CustomTag'
-import { isNewApiProvider, PROVIDER_URLS } from '@renderer/config/providers'
+import { PROVIDER_URLS } from '@renderer/config/providers'
 import { useProvider } from '@renderer/hooks/useProvider'
 import { getProviderLabel } from '@renderer/i18n/label'
 import { SettingHelpLink, SettingHelpText, SettingHelpTextRow, SettingSubtitle } from '@renderer/pages/settings'
@@ -13,6 +13,7 @@ import ManageModelsPopup from '@renderer/pages/settings/ProviderSettings/ModelLi
 import NewApiAddModelPopup from '@renderer/pages/settings/ProviderSettings/ModelList/NewApiAddModelPopup'
 import type { Model } from '@renderer/types'
 import { filterModelsByKeywords } from '@renderer/utils'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import { Button, Flex, Spin, Tooltip } from 'antd'
 import { groupBy, isEmpty, sortBy, toPairs } from 'lodash'
 import { ListCheck, Plus } from 'lucide-react'

src/renderer/src/pages/settings/ProviderSettings/ModelList/NewApiAddModelPopup.tsx

@@ -1,11 +1,11 @@
 import { TopView } from '@renderer/components/TopView'
 import { endpointTypeOptions } from '@renderer/config/endpointTypes'
 import { isNotSupportedTextDelta } from '@renderer/config/models'
-import { isNewApiProvider } from '@renderer/config/providers'
 import { useDynamicLabelWidth } from '@renderer/hooks/useDynamicLabelWidth'
 import { useProvider } from '@renderer/hooks/useProvider'
 import type { EndpointType, Model, Provider } from '@renderer/types'
 import { getDefaultGroupName } from '@renderer/utils'
+import { isNewApiProvider } from '@renderer/utils/provider'
 import type { FormProps } from 'antd'
 import { Button, Flex, Form, Input, Modal, Select } from 'antd'
 import { find } from 'lodash'

src/renderer/src/pages/settings/ProviderSettings/ProviderSetting.tsx

@@ -4,21 +4,10 @@ import { HStack } from '@renderer/components/Layout'
 import { ApiKeyListPopup } from '@renderer/components/Popups/ApiKeyListPopup'
 import Selector from '@renderer/components/Selector'
 import { isEmbeddingModel, isRerankModel } from '@renderer/config/models'
-import {
+import { PROVIDER_URLS } from '@renderer/config/providers'
-  isAIGatewayProvider,
-  isAnthropicProvider,
-  isAzureOpenAIProvider,
-  isGeminiProvider,
-  isNewApiProvider,
-  isOpenAICompatibleProvider,
-  isOpenAIProvider,
-  isSupportAPIVersionProvider,
-  PROVIDER_URLS
-} from '@renderer/config/providers'
 import { useTheme } from '@renderer/context/ThemeProvider'
 import { useAllProviders, useProvider, useProviders } from '@renderer/hooks/useProvider'
 import { useTimer } from '@renderer/hooks/useTimer'
-import { isVertexProvider } from '@renderer/hooks/useVertexAI'
 import i18n from '@renderer/i18n'
 import AnthropicSettings from '@renderer/pages/settings/ProviderSettings/AnthropicSettings'
 import { ModelList } from '@renderer/pages/settings/ProviderSettings/ModelList'
@@ -39,6 +28,17 @@ import {
   validateApiHost
 } from '@renderer/utils'
 import { formatErrorMessage } from '@renderer/utils/error'
+import {
+  isAIGatewayProvider,
+  isAnthropicProvider,
+  isAzureOpenAIProvider,
+  isGeminiProvider,
+  isNewApiProvider,
+  isOpenAICompatibleProvider,
+  isOpenAIProvider,
+  isSupportAPIVersionProvider,
+  isVertexProvider
+} from '@renderer/utils/provider'
 import { Button, Divider, Flex, Input, Select, Space, Switch, Tooltip } from 'antd'
 import Link from 'antd/es/typography/Link'
 import { debounce, isEmpty } from 'lodash'
@@ -287,7 +287,7 @@ const ProviderSetting: FC<Props> = ({ providerId }) => {
     }
 
     if (isAzureOpenAIProvider(provider)) {
-      const apiVersion = provider.apiVersion
+      const apiVersion = provider.apiVersion || ''
       const path = !['preview', 'v1'].includes(apiVersion)
         ? `/v1/chat/completion?apiVersion=v1`
         : `/v1/responses?apiVersion=v1`

src/renderer/src/services/AssistantService.ts

@@ -6,7 +6,7 @@ import {
   MAX_CONTEXT_COUNT,
   UNLIMITED_CONTEXT_COUNT
 } from '@renderer/config/constant'
-import { isQwenMTModel } from '@renderer/config/models'
+import { isQwenMTModel } from '@renderer/config/models/qwen'
 import { CHERRYAI_PROVIDER } from '@renderer/config/providers'
 import { UNKNOWN } from '@renderer/config/translate'
 import { getStoreProviders } from '@renderer/hooks/useStore'

src/renderer/src/services/KnowledgeService.ts

@@ -4,7 +4,6 @@ import { ModernAiProvider } from '@renderer/aiCore'
 import AiProvider from '@renderer/aiCore/legacy'
 import { DEFAULT_KNOWLEDGE_DOCUMENT_COUNT, DEFAULT_KNOWLEDGE_THRESHOLD } from '@renderer/config/constant'
 import { getEmbeddingMaxContext } from '@renderer/config/embedings'
-import { isAzureOpenAIProvider, isGeminiProvider } from '@renderer/config/providers'
 import { addSpan, endSpan } from '@renderer/services/SpanManagerService'
 import store from '@renderer/store'
 import type {
@@ -18,6 +17,7 @@ import type { Chunk } from '@renderer/types/chunk'
 import { ChunkType } from '@renderer/types/chunk'
 import { routeToEndpoint } from '@renderer/utils'
 import type { ExtractResults } from '@renderer/utils/extract'
+import { isAzureOpenAIProvider, isGeminiProvider } from '@renderer/utils/provider'
 import { isEmpty } from 'lodash'
 
 import { getProviderByModel } from './AssistantService'

src/renderer/src/services/ProviderService.ts

@@ -21,6 +21,7 @@ export function getProviderNameById(pid: string) {
   }
 }
 
+//FIXME: 和 AssistantService.ts 中的同名函数冲突
 export function getProviderByModel(model?: Model) {
   const id = model?.provider
   const provider = getStoreProviders().find((p) => p.id === id)

src/renderer/src/services/__tests__/ApiService.test.ts

@@ -95,9 +95,20 @@ vi.mock('@renderer/services/AssistantService', () => ({
   }))
 }))
 
-vi.mock('@renderer/utils', () => ({
+vi.mock(import('@renderer/utils'), async (importOriginal) => {
-  getLowerBaseModelName: vi.fn((name) => name.toLowerCase())
+  const actual = await importOriginal()
-}))
+  return {
+    ...actual,
+    getLowerBaseModelName: vi.fn((name) => name.toLowerCase())
+  }
+})
+
+vi.mock(import('@renderer/config/providers'), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual
+  }
+})
 
 vi.mock('@renderer/config/prompts', () => ({
   WEB_SEARCH_PROMPT_FOR_OPENROUTER: 'mock-prompt'
@@ -108,10 +119,6 @@ vi.mock('@renderer/config/systemModels', () => ({
   GENERATE_IMAGE_MODELS: []
 }))
 
-vi.mock('@renderer/config/tools', () => ({
-  getWebSearchTools: vi.fn(() => [])
-}))
-
 // Mock store modules
 vi.mock('@renderer/store/assistants', () => ({
   default: (state = { assistants: [] }) => state

src/renderer/src/store/migrate.ts

@@ -10,12 +10,7 @@ import {
 } from '@renderer/config/models'
 import { BUILTIN_OCR_PROVIDERS, BUILTIN_OCR_PROVIDERS_MAP, DEFAULT_OCR_PROVIDER } from '@renderer/config/ocr'
 import { TRANSLATE_PROMPT } from '@renderer/config/prompts'
-import {
+import { SYSTEM_PROVIDERS } from '@renderer/config/providers'
-  isSupportArrayContentProvider,
-  isSupportDeveloperRoleProvider,
-  isSupportStreamOptionsProvider,
-  SYSTEM_PROVIDERS
-} from '@renderer/config/providers'
 import { DEFAULT_SIDEBAR_ICONS } from '@renderer/config/sidebar'
 import db from '@renderer/databases'
 import i18n from '@renderer/i18n'
@@ -32,6 +27,11 @@ import type {
 } from '@renderer/types'
 import { isBuiltinMCPServer, isSystemProvider, SystemProviderIds } from '@renderer/types'
 import { getDefaultGroupName, getLeadingEmoji, runAsyncFunction, uuid } from '@renderer/utils'
+import {
+  isSupportArrayContentProvider,
+  isSupportDeveloperRoleProvider,
+  isSupportStreamOptionsProvider
+} from '@renderer/utils/provider'
 import { defaultByPassRules, UpgradeChannel } from '@shared/config/constant'
 import { isEmpty } from 'lodash'
 import { createMigrate } from 'redux-persist'

src/renderer/src/utils/__tests__/provider.test.ts

@@ -0,0 +1,171 @@
+import { type AzureOpenAIProvider, type Provider, SystemProviderIds } from '@renderer/types'
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  getClaudeSupportedProviders,
+  isAIGatewayProvider,
+  isAnthropicProvider,
+  isAzureOpenAIProvider,
+  isCherryAIProvider,
+  isGeminiProvider,
+  isGeminiWebSearchProvider,
+  isNewApiProvider,
+  isOpenAICompatibleProvider,
+  isOpenAIProvider,
+  isPerplexityProvider,
+  isSupportAPIVersionProvider,
+  isSupportArrayContentProvider,
+  isSupportDeveloperRoleProvider,
+  isSupportEnableThinkingProvider,
+  isSupportServiceTierProvider,
+  isSupportStreamOptionsProvider,
+  isSupportUrlContextProvider
+} from '../provider'
+
+vi.mock('@renderer/store/settings', () => ({
+  default: (state = { settings: {} }) => state
+}))
+
+vi.mock('@renderer/services/AssistantService', () => ({
+  getProviderByModel: vi.fn(),
+  getAssistantSettings: vi.fn(),
+  getDefaultAssistant: vi.fn().mockReturnValue({
+    id: 'default',
+    name: 'Default Assistant',
+    prompt: '',
+    settings: {}
+  })
+}))
+
+const createProvider = (overrides: Partial<Provider> = {}): Provider => ({
+  id: 'custom',
+  type: 'openai',
+  name: 'Custom Provider',
+  apiKey: 'key',
+  apiHost: 'https://api.example.com',
+  models: [],
+  ...overrides
+})
+
+const createSystemProvider = (overrides: Partial<Provider> = {}): Provider =>
+  createProvider({
+    id: SystemProviderIds.openai,
+    isSystem: true,
+    ...overrides
+  })
+
+describe('provider utils', () => {
+  it('filters Claude supported providers', () => {
+    const providers = [
+      createProvider({ id: 'anthropic-official', type: 'anthropic' }),
+      createProvider({ id: 'custom-host', anthropicApiHost: 'https://anthropic.local' }),
+      createProvider({ id: 'aihubmix' }),
+      createProvider({ id: 'other' })
+    ]
+
+    expect(getClaudeSupportedProviders(providers)).toEqual(providers.slice(0, 3))
+  })
+
+  it('evaluates message array content support', () => {
+    expect(isSupportArrayContentProvider(createProvider())).toBe(true)
+
+    expect(isSupportArrayContentProvider(createProvider({ apiOptions: { isNotSupportArrayContent: true } }))).toBe(
+      false
+    )
+
+    expect(isSupportArrayContentProvider(createSystemProvider({ id: SystemProviderIds.deepseek }))).toBe(false)
+  })
+
+  it('evaluates developer role support', () => {
+    expect(isSupportDeveloperRoleProvider(createProvider({ apiOptions: { isSupportDeveloperRole: true } }))).toBe(true)
+    expect(isSupportDeveloperRoleProvider(createSystemProvider())).toBe(true)
+    expect(isSupportDeveloperRoleProvider(createSystemProvider({ id: SystemProviderIds.poe }))).toBe(false)
+  })
+
+  it('checks stream options support', () => {
+    expect(isSupportStreamOptionsProvider(createProvider())).toBe(true)
+    expect(isSupportStreamOptionsProvider(createProvider({ apiOptions: { isNotSupportStreamOptions: true } }))).toBe(
+      false
+    )
+    expect(isSupportStreamOptionsProvider(createSystemProvider({ id: SystemProviderIds.mistral }))).toBe(false)
+  })
+
+  it('checks enable thinking support', () => {
+    expect(isSupportEnableThinkingProvider(createProvider())).toBe(true)
+    expect(isSupportEnableThinkingProvider(createProvider({ apiOptions: { isNotSupportEnableThinking: true } }))).toBe(
+      false
+    )
+    expect(isSupportEnableThinkingProvider(createSystemProvider({ id: SystemProviderIds.nvidia }))).toBe(false)
+  })
+
+  it('determines service tier support', () => {
+    expect(isSupportServiceTierProvider(createProvider({ apiOptions: { isSupportServiceTier: true } }))).toBe(true)
+    expect(isSupportServiceTierProvider(createSystemProvider())).toBe(true)
+    expect(isSupportServiceTierProvider(createSystemProvider({ id: SystemProviderIds.github }))).toBe(false)
+  })
+
+  it('detects URL context capable providers', () => {
+    expect(isSupportUrlContextProvider(createProvider({ type: 'gemini' }))).toBe(true)
+    expect(
+      isSupportUrlContextProvider(
+        createSystemProvider({ id: SystemProviderIds.cherryin, type: 'openai', isSystem: true })
+      )
+    ).toBe(true)
+    expect(isSupportUrlContextProvider(createProvider())).toBe(false)
+  })
+
+  it('identifies Gemini web search providers', () => {
+    expect(isGeminiWebSearchProvider(createSystemProvider({ id: SystemProviderIds.gemini, type: 'gemini' }))).toBe(true)
+    expect(isGeminiWebSearchProvider(createSystemProvider({ id: SystemProviderIds.vertexai, type: 'vertexai' }))).toBe(
+      true
+    )
+    expect(isGeminiWebSearchProvider(createSystemProvider())).toBe(false)
+  })
+
+  it('detects New API providers by id or type', () => {
+    expect(isNewApiProvider(createProvider({ id: SystemProviderIds['new-api'] }))).toBe(true)
+    expect(isNewApiProvider(createProvider({ id: SystemProviderIds.cherryin }))).toBe(true)
+    expect(isNewApiProvider(createProvider({ type: 'new-api' }))).toBe(true)
+    expect(isNewApiProvider(createProvider())).toBe(false)
+  })
+
+  it('detects specific provider ids', () => {
+    expect(isCherryAIProvider(createProvider({ id: 'cherryai' }))).toBe(true)
+    expect(isCherryAIProvider(createProvider())).toBe(false)
+
+    expect(isPerplexityProvider(createProvider({ id: SystemProviderIds.perplexity }))).toBe(true)
+    expect(isPerplexityProvider(createProvider())).toBe(false)
+  })
+
+  it('recognizes OpenAI compatible providers', () => {
+    expect(isOpenAICompatibleProvider(createProvider({ type: 'openai' }))).toBe(true)
+    expect(isOpenAICompatibleProvider(createProvider({ type: 'new-api' }))).toBe(true)
+    expect(isOpenAICompatibleProvider(createProvider({ type: 'mistral' }))).toBe(true)
+    expect(isOpenAICompatibleProvider(createProvider({ type: 'anthropic' }))).toBe(false)
+  })
+
+  it('narrows Azure OpenAI providers', () => {
+    const azureProvider = {
+      ...createProvider({ type: 'azure-openai' }),
+      apiVersion: '2024-06-01'
+    } as AzureOpenAIProvider
+    expect(isAzureOpenAIProvider(azureProvider)).toBe(true)
+    expect(isAzureOpenAIProvider(createProvider())).toBe(false)
+  })
+
+  it('checks provider type helpers', () => {
+    expect(isOpenAIProvider(createProvider({ type: 'openai-response' }))).toBe(true)
+    expect(isOpenAIProvider(createProvider())).toBe(false)
+
+    expect(isAnthropicProvider(createProvider({ type: 'anthropic' }))).toBe(true)
+    expect(isGeminiProvider(createProvider({ type: 'gemini' }))).toBe(true)
+    expect(isAIGatewayProvider(createProvider({ type: 'ai-gateway' }))).toBe(true)
+  })
+
+  it('computes API version support', () => {
+    expect(isSupportAPIVersionProvider(createSystemProvider())).toBe(true)
+    expect(isSupportAPIVersionProvider(createSystemProvider({ id: SystemProviderIds.github }))).toBe(false)
+    expect(isSupportAPIVersionProvider(createProvider())).toBe(true)
+    expect(isSupportAPIVersionProvider(createProvider({ apiOptions: { isNotSupportAPIVersion: false } }))).toBe(false)
+  })
+})

src/renderer/src/utils/__tests__/topicKnowledge.test.ts

@@ -3,6 +3,15 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { CONTENT_TYPES } from '../knowledge'
 
+// Mock modules to prevent circular dependencies during test loading
+vi.mock('@renderer/components/Popups/SaveToKnowledgePopup', () => ({
+  default: {}
+}))
+
+vi.mock('@renderer/pages/home/Messages/MessageMenubar', () => ({
+  default: {}
+}))
+
 // Simple mocks
 vi.mock('@renderer/hooks/useTopic', () => ({
   TopicManager: {

src/renderer/src/utils/provider.ts

@@ -1,6 +1,159 @@
 import { CLAUDE_SUPPORTED_PROVIDERS } from '@renderer/pages/code'
-import type { Provider } from '@renderer/types'
+import type { AzureOpenAIProvider, ProviderType, VertexProvider } from '@renderer/types'
+import { isSystemProvider, type Provider, type SystemProviderId, SystemProviderIds } from '@renderer/types'
 
 export const getClaudeSupportedProviders = (providers: Provider[]) => {
-  return providers.filter((p) => p.type === 'anthropic' || CLAUDE_SUPPORTED_PROVIDERS.includes(p.id))
+  return providers.filter(
+    (p) => p.type === 'anthropic' || !!p.anthropicApiHost || CLAUDE_SUPPORTED_PROVIDERS.includes(p.id)
+  )
+}
+
+const NOT_SUPPORT_ARRAY_CONTENT_PROVIDERS = [
+  'deepseek',
+  'baichuan',
+  'minimax',
+  'xirang',
+  'poe',
+  'cephalon'
+] as const satisfies SystemProviderId[]
+
+/**
+ * 判断提供商是否支持 message 的 content 为数组类型。 Only for OpenAI Chat Completions API.
+ */
+export const isSupportArrayContentProvider = (provider: Provider) => {
+  return (
+    provider.apiOptions?.isNotSupportArrayContent !== true &&
+    !NOT_SUPPORT_ARRAY_CONTENT_PROVIDERS.some((pid) => pid === provider.id)
+  )
+}
+
+const NOT_SUPPORT_DEVELOPER_ROLE_PROVIDERS = ['poe', 'qiniu'] as const satisfies SystemProviderId[]
+
+/**
+ * 判断提供商是否支持 developer 作为 message role。 Only for OpenAI API.
+ */
+export const isSupportDeveloperRoleProvider = (provider: Provider) => {
+  return (
+    provider.apiOptions?.isSupportDeveloperRole === true ||
+    (isSystemProvider(provider) && !NOT_SUPPORT_DEVELOPER_ROLE_PROVIDERS.some((pid) => pid === provider.id))
+  )
+}
+
+const NOT_SUPPORT_STREAM_OPTIONS_PROVIDERS = ['mistral'] as const satisfies SystemProviderId[]
+
+/**
+ * 判断提供商是否支持 stream_options 参数。Only for OpenAI API.
+ */
+export const isSupportStreamOptionsProvider = (provider: Provider) => {
+  return (
+    provider.apiOptions?.isNotSupportStreamOptions !== true &&
+    !NOT_SUPPORT_STREAM_OPTIONS_PROVIDERS.some((pid) => pid === provider.id)
+  )
+}
+
+const NOT_SUPPORT_QWEN3_ENABLE_THINKING_PROVIDER = [
+  'ollama',
+  'lmstudio',
+  'nvidia'
+] as const satisfies SystemProviderId[]
+
+/**
+ * 判断提供商是否支持使用 enable_thinking 参数来控制 Qwen3 等模型的思考。 Only for OpenAI Chat Completions API.
+ */
+export const isSupportEnableThinkingProvider = (provider: Provider) => {
+  return (
+    provider.apiOptions?.isNotSupportEnableThinking !== true &&
+    !NOT_SUPPORT_QWEN3_ENABLE_THINKING_PROVIDER.some((pid) => pid === provider.id)
+  )
+}
+
+const NOT_SUPPORT_SERVICE_TIER_PROVIDERS = ['github', 'copilot', 'cerebras'] as const satisfies SystemProviderId[]
+
+/**
+ * 判断提供商是否支持 service_tier 设置。 Only for OpenAI API.
+ */
+export const isSupportServiceTierProvider = (provider: Provider) => {
+  return (
+    provider.apiOptions?.isSupportServiceTier === true ||
+    (isSystemProvider(provider) && !NOT_SUPPORT_SERVICE_TIER_PROVIDERS.some((pid) => pid === provider.id))
+  )
+}
+
+const SUPPORT_URL_CONTEXT_PROVIDER_TYPES = [
+  'gemini',
+  'vertexai',
+  'anthropic',
+  'new-api'
+] as const satisfies ProviderType[]
+
+export const isSupportUrlContextProvider = (provider: Provider) => {
+  return (
+    SUPPORT_URL_CONTEXT_PROVIDER_TYPES.some((type) => type === provider.type) ||
+    provider.id === SystemProviderIds.cherryin
+  )
+}
+
+const SUPPORT_GEMINI_NATIVE_WEB_SEARCH_PROVIDERS = ['gemini', 'vertexai'] as const satisfies SystemProviderId[]
+
+/** 判断是否是使用 Gemini 原生搜索工具的 provider. 目前假设只有官方 API 使用原生工具 */
+export const isGeminiWebSearchProvider = (provider: Provider) => {
+  return SUPPORT_GEMINI_NATIVE_WEB_SEARCH_PROVIDERS.some((id) => id === provider.id)
+}
+
+export const isNewApiProvider = (provider: Provider) => {
+  return ['new-api', 'cherryin'].includes(provider.id) || provider.type === 'new-api'
+}
+
+export function isCherryAIProvider(provider: Provider): boolean {
+  return provider.id === 'cherryai'
+}
+
+export function isPerplexityProvider(provider: Provider): boolean {
+  return provider.id === 'perplexity'
+}
+
+/**
+ * 判断是否为 OpenAI 兼容的提供商
+ * @param {Provider} provider 提供商对象
+ * @returns {boolean} 是否为 OpenAI 兼容提供商
+ */
+export function isOpenAICompatibleProvider(provider: Provider): boolean {
+  return ['openai', 'new-api', 'mistral'].includes(provider.type)
+}
+
+export function isAzureOpenAIProvider(provider: Provider): provider is AzureOpenAIProvider {
+  return provider.type === 'azure-openai'
+}
+
+export function isOpenAIProvider(provider: Provider): boolean {
+  return provider.type === 'openai-response'
+}
+
+export function isVertexProvider(provider: Provider): provider is VertexProvider {
+  return provider.type === 'vertexai'
+}
+
+export function isAwsBedrockProvider(provider: Provider): boolean {
+  return provider.type === 'aws-bedrock'
+}
+
+export function isAnthropicProvider(provider: Provider): boolean {
+  return provider.type === 'anthropic'
+}
+
+export function isGeminiProvider(provider: Provider): boolean {
+  return provider.type === 'gemini'
+}
+
+export function isAIGatewayProvider(provider: Provider): boolean {
+  return provider.type === 'ai-gateway'
+}
+
+const NOT_SUPPORT_API_VERSION_PROVIDERS = ['github', 'copilot', 'perplexity'] as const satisfies SystemProviderId[]
+
+export const isSupportAPIVersionProvider = (provider: Provider) => {
+  if (isSystemProvider(provider)) {
+    return !NOT_SUPPORT_API_VERSION_PROVIDERS.some((pid) => pid === provider.id)
+  }
+  return provider.apiOptions?.isNotSupportAPIVersion !== false
 }

tests/renderer.setup.ts

@@ -15,8 +15,9 @@ vi.mock('@logger', async () => {
 })
 
 // Mock uuid globally for renderer tests
+let uuidCounter = 0
 vi.mock('uuid', () => ({
-  v4: () => 'test-uuid-' + Date.now()
+  v4: () => 'test-uuid-' + ++uuidCounter
 }))
 
 vi.mock('axios', () => {

yarn.lock

@@ -410,6 +410,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ai-sdk/test-server@npm:^0.0.1":
+  version: 0.0.1
+  resolution: "@ai-sdk/test-server@npm:0.0.1"
+  dependencies:
+    msw: "npm:^2.7.0"
+  checksum: 10c0/465fbb0444825f169333c98b2f0b12fe51914b6525f2d36fd4a2b5b03d2ac736060519fd14e0fcffdcba615d8b563bc39ddeb11fea6b1e6218419693ce62e029
+  languageName: node
+  linkType: hard
+
 "@ai-sdk/xai@npm:^2.0.31":
   version: 2.0.31
   resolution: "@ai-sdk/xai@npm:2.0.31"
@@ -3756,6 +3765,68 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@inquirer/ansi@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "@inquirer/ansi@npm:1.0.2"
+  checksum: 10c0/8e408cc628923aa93402e66657482ccaa2ad5174f9db526d9a8b443f9011e9cd8f70f0f534f5fe3857b8a9df3bce1e25f66c96f666d6750490bd46e2b4f3b829
+  languageName: node
+  linkType: hard
+
+"@inquirer/confirm@npm:^5.0.0":
+  version: 5.1.20
+  resolution: "@inquirer/confirm@npm:5.1.20"
+  dependencies:
+    "@inquirer/core": "npm:^10.3.1"
+    "@inquirer/type": "npm:^3.0.10"
+  peerDependencies:
+    "@types/node": ">=18"
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+  checksum: 10c0/390cca939f9e9f21cb785624302d4cfa4c009ae67d77a899c71fbe25ec06ee5658a6007559ac78e5c07726b0d4256ab1da8d3549ce677fa111d3ab8a8d1737ff
+  languageName: node
+  linkType: hard
+
+"@inquirer/core@npm:^10.3.1":
+  version: 10.3.1
+  resolution: "@inquirer/core@npm:10.3.1"
+  dependencies:
+    "@inquirer/ansi": "npm:^1.0.2"
+    "@inquirer/figures": "npm:^1.0.15"
+    "@inquirer/type": "npm:^3.0.10"
+    cli-width: "npm:^4.1.0"
+    mute-stream: "npm:^3.0.0"
+    signal-exit: "npm:^4.1.0"
+    wrap-ansi: "npm:^6.2.0"
+    yoctocolors-cjs: "npm:^2.1.3"
+  peerDependencies:
+    "@types/node": ">=18"
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+  checksum: 10c0/077626de567236c67e15947f02fa4266d56aa47f2778b2a3b3637c541752c00ef78ad9bd3614de50d5a8501eb442807f75a0864101ca786df8f39c00b1b6c86d
+  languageName: node
+  linkType: hard
+
+"@inquirer/figures@npm:^1.0.15":
+  version: 1.0.15
+  resolution: "@inquirer/figures@npm:1.0.15"
+  checksum: 10c0/6e39a040d260ae234ae220180b7994ff852673e20be925f8aa95e78c7934d732b018cbb4d0ec39e600a410461bcb93dca771e7de23caa10630d255692e440f69
+  languageName: node
+  linkType: hard
+
+"@inquirer/type@npm:^3.0.10":
+  version: 3.0.10
+  resolution: "@inquirer/type@npm:3.0.10"
+  peerDependencies:
+    "@types/node": ">=18"
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+  checksum: 10c0/a846c7a570e3bf2657d489bcc5dcdc3179d24c7323719de1951dcdb722400ac76e5b2bfe9765d0a789bc1921fac810983d7999f021f30a78a6a174c23fc78dc9
+  languageName: node
+  linkType: hard
+
 "@isaacs/balanced-match@npm:^4.0.1":
   version: 4.0.1
   resolution: "@isaacs/balanced-match@npm:4.0.1"
@@ -4741,6 +4812,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@mswjs/interceptors@npm:^0.40.0":
+  version: 0.40.0
+  resolution: "@mswjs/interceptors@npm:0.40.0"
+  dependencies:
+    "@open-draft/deferred-promise": "npm:^2.2.0"
+    "@open-draft/logger": "npm:^0.3.0"
+    "@open-draft/until": "npm:^2.0.0"
+    is-node-process: "npm:^1.2.0"
+    outvariant: "npm:^1.4.3"
+    strict-event-emitter: "npm:^0.5.1"
+  checksum: 10c0/4500f17b65910b2633182fdb15a81ccb6ccd4488a8c45bc2f7acdaaff4621c3cce5362e6b59ddc4fa28d315d0efb0608fd1f0d536bc5345141f8ac03fd7fab22
+  languageName: node
+  linkType: hard
+
 "@mux/mux-data-google-ima@npm:0.2.8":
   version: 0.2.8
   resolution: "@mux/mux-data-google-ima@npm:0.2.8"
@@ -4973,6 +5058,30 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@open-draft/deferred-promise@npm:^2.2.0":
+  version: 2.2.0
+  resolution: "@open-draft/deferred-promise@npm:2.2.0"
+  checksum: 10c0/eafc1b1d0fc8edb5e1c753c5e0f3293410b40dde2f92688211a54806d4136887051f39b98c1950370be258483deac9dfd17cf8b96557553765198ef2547e4549
+  languageName: node
+  linkType: hard
+
+"@open-draft/logger@npm:^0.3.0":
+  version: 0.3.0
+  resolution: "@open-draft/logger@npm:0.3.0"
+  dependencies:
+    is-node-process: "npm:^1.2.0"
+    outvariant: "npm:^1.4.0"
+  checksum: 10c0/90010647b22e9693c16258f4f9adb034824d1771d3baa313057b9a37797f571181005bc50415a934eaf7c891d90ff71dcd7a9d5048b0b6bb438f31bef2c7c5c1
+  languageName: node
+  linkType: hard
+
+"@open-draft/until@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "@open-draft/until@npm:2.1.0"
+  checksum: 10c0/61d3f99718dd86bb393fee2d7a785f961dcaf12f2055f0c693b27f4d0cd5f7a03d498a6d9289773b117590d794a43cd129366fd8e99222e4832f67b1653d54cf
+  languageName: node
+  linkType: hard
+
 "@openrouter/ai-sdk-provider@npm:^1.2.0":
   version: 1.2.0
   resolution: "@openrouter/ai-sdk-provider@npm:1.2.0"
@@ -8835,6 +8944,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/statuses@npm:^2.0.4":
+  version: 2.0.6
+  resolution: "@types/statuses@npm:2.0.6"
+  checksum: 10c0/dd88c220b0e2c6315686289525fd61472d2204d2e4bef4941acfb76bda01d3066f749ac74782aab5b537a45314fcd7d6261eefa40b6ec872691f5803adaa608d
+  languageName: node
+  linkType: hard
+
 "@types/stylis@npm:4.2.5":
   version: 4.2.5
   resolution: "@types/stylis@npm:4.2.5"
@@ -9912,6 +10028,7 @@ __metadata:
     "@ai-sdk/mistral": "npm:^2.0.23"
     "@ai-sdk/openai": "patch:@ai-sdk/openai@npm%3A2.0.64#~/.yarn/patches/@ai-sdk-openai-npm-2.0.64-48f99f5bf3.patch"
     "@ai-sdk/perplexity": "npm:^2.0.17"
+    "@ai-sdk/test-server": "npm:^0.0.1"
     "@ant-design/v5-patch-for-react-19": "npm:^1.0.3"
     "@anthropic-ai/claude-agent-sdk": "patch:@anthropic-ai/claude-agent-sdk@npm%3A0.1.30#~/.yarn/patches/@anthropic-ai-claude-agent-sdk-npm-0.1.30-b50a299674.patch"
     "@anthropic-ai/sdk": "npm:^0.41.0"
@@ -11656,6 +11773,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cli-width@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "cli-width@npm:4.1.0"
+  checksum: 10c0/1fbd56413578f6117abcaf858903ba1f4ad78370a4032f916745fa2c7e390183a9d9029cf837df320b0fdce8137668e522f60a30a5f3d6529ff3872d265a955f
+  languageName: node
+  linkType: hard
+
 "cliui@npm:^8.0.1":
   version: 8.0.1
   resolution: "cliui@npm:8.0.1"
@@ -12093,6 +12217,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cookie@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "cookie@npm:1.0.2"
+  checksum: 10c0/fd25fe79e8fbcfcaf6aa61cd081c55d144eeeba755206c058682257cb38c4bd6795c6620de3f064c740695bb65b7949ebb1db7a95e4636efb8357a335ad3f54b
+  languageName: node
+  linkType: hard
+
 "copy-to-clipboard@npm:^3.3.3":
   version: 3.3.3
   resolution: "copy-to-clipboard@npm:3.3.3"
@@ -15631,6 +15762,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"graphql@npm:^16.8.1":
+  version: 16.12.0
+  resolution: "graphql@npm:16.12.0"
+  checksum: 10c0/b6fffa4e8a4e4a9933ebe85e7470b346dbf49050c1a482fac5e03e4a1a7bed2ecd3a4c97e29f04457af929464bc5e4f2aac991090c2f320111eef26e902a5c75
+  languageName: node
+  linkType: hard
+
 "gray-matter@npm:^4.0.3":
   version: 4.0.3
   resolution: "gray-matter@npm:4.0.3"
@@ -15928,6 +16066,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"headers-polyfill@npm:^4.0.2":
+  version: 4.0.3
+  resolution: "headers-polyfill@npm:4.0.3"
+  checksum: 10c0/53e85b2c6385f8d411945fb890c5369f1469ce8aa32a6e8d28196df38568148de640c81cf88cbc7c67767103dd9acba48f4f891982da63178fc6e34560022afe
+  languageName: node
+  linkType: hard
+
 "hls-video-element@npm:^1.5.6":
   version: 1.5.7
   resolution: "hls-video-element@npm:1.5.7"
@@ -16507,6 +16652,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-node-process@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "is-node-process@npm:1.2.0"
+  checksum: 10c0/5b24fda6776d00e42431d7bcd86bce81cb0b6cabeb944142fe7b077a54ada2e155066ad06dbe790abdb397884bdc3151e04a9707b8cd185099efbc79780573ed
+  languageName: node
+  linkType: hard
+
 "is-number@npm:^7.0.0":
   version: 7.0.0
   resolution: "is-number@npm:7.0.0"
@@ -19299,6 +19451,39 @@ __metadata:
   languageName: node
   linkType: hard
 
+"msw@npm:^2.7.0":
+  version: 2.12.1
+  resolution: "msw@npm:2.12.1"
+  dependencies:
+    "@inquirer/confirm": "npm:^5.0.0"
+    "@mswjs/interceptors": "npm:^0.40.0"
+    "@open-draft/deferred-promise": "npm:^2.2.0"
+    "@types/statuses": "npm:^2.0.4"
+    cookie: "npm:^1.0.2"
+    graphql: "npm:^16.8.1"
+    headers-polyfill: "npm:^4.0.2"
+    is-node-process: "npm:^1.2.0"
+    outvariant: "npm:^1.4.3"
+    path-to-regexp: "npm:^6.3.0"
+    picocolors: "npm:^1.1.1"
+    rettime: "npm:^0.7.0"
+    statuses: "npm:^2.0.2"
+    strict-event-emitter: "npm:^0.5.1"
+    tough-cookie: "npm:^6.0.0"
+    type-fest: "npm:^4.26.1"
+    until-async: "npm:^3.0.2"
+    yargs: "npm:^17.7.2"
+  peerDependencies:
+    typescript: ">= 4.8.x"
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  bin:
+    msw: cli/index.js
+  checksum: 10c0/822f4fc0cb2bdade39a67045d56b32fc7b15f30814a64c637a3c55d99358a4c1d61ed00d21fafafbbee320ad600e5a048d938b195e0cef5c59e016a040595176
+  languageName: node
+  linkType: hard
+
 "mustache@npm:^4.2.0":
   version: 4.2.0
   resolution: "mustache@npm:4.2.0"
@@ -19308,6 +19493,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"mute-stream@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "mute-stream@npm:3.0.0"
+  checksum: 10c0/12cdb36a101694c7a6b296632e6d93a30b74401873cf7507c88861441a090c71c77a58f213acadad03bc0c8fa186639dec99d68a14497773a8744320c136e701
+  languageName: node
+  linkType: hard
+
 "mux-embed@npm:5.9.0":
   version: 5.9.0
   resolution: "mux-embed@npm:5.9.0"
@@ -19919,6 +20111,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"outvariant@npm:^1.4.0, outvariant@npm:^1.4.3":
+  version: 1.4.3
+  resolution: "outvariant@npm:1.4.3"
+  checksum: 10c0/5976ca7740349cb8c71bd3382e2a762b1aeca6f33dc984d9d896acdf3c61f78c3afcf1bfe9cc633a7b3c4b295ec94d292048f83ea2b2594fae4496656eba992c
+  languageName: node
+  linkType: hard
+
 "oxlint-tsgolint@npm:^0.2.0":
   version: 0.2.0
   resolution: "oxlint-tsgolint@npm:0.2.0"
@@ -20318,6 +20517,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"path-to-regexp@npm:^6.3.0":
+  version: 6.3.0
+  resolution: "path-to-regexp@npm:6.3.0"
+  checksum: 10c0/73b67f4638b41cde56254e6354e46ae3a2ebc08279583f6af3d96fe4664fc75788f74ed0d18ca44fa4a98491b69434f9eee73b97bb5314bd1b5adb700f5c18d6
+  languageName: node
+  linkType: hard
+
 "path-to-regexp@npm:^8.0.0":
   version: 8.2.0
   resolution: "path-to-regexp@npm:8.2.0"
@@ -22489,6 +22695,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"rettime@npm:^0.7.0":
+  version: 0.7.0
+  resolution: "rettime@npm:0.7.0"
+  checksum: 10c0/1460539d49415c37e46884bf1db7a5da974b239c1bd6976e1cf076fad169067dc8f55cd2572aec504433162f3627b6d8123eea977d110476258045d620bd051b
+  languageName: node
+  linkType: hard
+
 "reusify@npm:^1.0.4":
   version: 1.1.0
   resolution: "reusify@npm:1.1.0"
@@ -23500,6 +23713,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"statuses@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "statuses@npm:2.0.2"
+  checksum: 10c0/a9947d98ad60d01f6b26727570f3bcceb6c8fa789da64fe6889908fe2e294d57503b14bf2b5af7605c2d36647259e856635cd4c49eab41667658ec9d0080ec3f
+  languageName: node
+  linkType: hard
+
 "std-env@npm:^3.9.0":
   version: 3.9.0
   resolution: "std-env@npm:3.9.0"
@@ -23541,6 +23761,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"strict-event-emitter@npm:^0.5.1":
+  version: 0.5.1
+  resolution: "strict-event-emitter@npm:0.5.1"
+  checksum: 10c0/f5228a6e6b6393c57f52f62e673cfe3be3294b35d6f7842fc24b172ae0a6e6c209fa83241d0e433fc267c503bc2f4ffdbe41a9990ff8ffd5ac425ec0489417f7
+  languageName: node
+  linkType: hard
+
 "strict-url-sanitise@npm:^0.0.1":
   version: 0.0.1
   resolution: "strict-url-sanitise@npm:0.0.1"
@@ -24249,6 +24476,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tldts-core@npm:^7.0.17":
+  version: 7.0.17
+  resolution: "tldts-core@npm:7.0.17"
+  checksum: 10c0/39dd6f5852f241c88391dc462dd236fa8241309a76dbf2486afdba0f172358260b16b98c126d1d06e1d9ee9015d83448ed7c4e2885e5e5c06c368f6503bb6a97
+  languageName: node
+  linkType: hard
+
 "tldts@npm:^6.1.32":
   version: 6.1.86
   resolution: "tldts@npm:6.1.86"
@@ -24260,6 +24494,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tldts@npm:^7.0.5":
+  version: 7.0.17
+  resolution: "tldts@npm:7.0.17"
+  dependencies:
+    tldts-core: "npm:^7.0.17"
+  bin:
+    tldts: bin/cli.js
+  checksum: 10c0/0ef2a40058a11c27a5b310489009002e57cd0789c2cf383c04ecf808e1523d442d9d9688ac0337c64b261609478b7fd85ddcd692976c8f763747a5e1c7c1c451
+  languageName: node
+  linkType: hard
+
 "tmp-promise@npm:^3.0.2":
   version: 3.0.3
   resolution: "tmp-promise@npm:3.0.3"
@@ -24349,6 +24594,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tough-cookie@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "tough-cookie@npm:6.0.0"
+  dependencies:
+    tldts: "npm:^7.0.5"
+  checksum: 10c0/7b17a461e9c2ac0d0bea13ab57b93b4346d0b8c00db174c963af1e46e4ea8d04148d2a55f2358fc857db0c0c65208a98e319d0c60693e32e0c559a9d9cf20cb5
+  languageName: node
+  linkType: hard
+
 "tr46@npm:^5.1.0":
   version: 5.1.0
   resolution: "tr46@npm:5.1.0"
@@ -24635,6 +24889,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"type-fest@npm:^4.26.1":
+  version: 4.41.0
+  resolution: "type-fest@npm:4.41.0"
+  checksum: 10c0/f5ca697797ed5e88d33ac8f1fec21921839871f808dc59345c9cf67345bfb958ce41bd821165dbf3ae591cedec2bf6fe8882098dfdd8dc54320b859711a2c1e4
+  languageName: node
+  linkType: hard
+
 "type-fest@npm:^4.39.1":
   version: 4.40.0
   resolution: "type-fest@npm:4.40.0"
@@ -24996,6 +25257,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"until-async@npm:^3.0.2":
+  version: 3.0.2
+  resolution: "until-async@npm:3.0.2"
+  checksum: 10c0/61c8b03895dbe18fe3d90316d0a1894e0c131ea4b1673f6ce78eed993d0bb81bbf4b7adf8477e9ff7725782a76767eed9d077561cfc9f89b4a1ebe61f7c9828e
+  languageName: node
+  linkType: hard
+
 "unzip-crx-3@npm:^0.2.0":
   version: 0.2.0
   resolution: "unzip-crx-3@npm:0.2.0"
@@ -25768,6 +26036,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"wrap-ansi@npm:^6.2.0":
+  version: 6.2.0
+  resolution: "wrap-ansi@npm:6.2.0"
+  dependencies:
+    ansi-styles: "npm:^4.0.0"
+    string-width: "npm:^4.1.0"
+    strip-ansi: "npm:^6.0.0"
+  checksum: 10c0/baad244e6e33335ea24e86e51868fe6823626e3a3c88d9a6674642afff1d34d9a154c917e74af8d845fd25d170c4ea9cf69a47133c3f3656e1252b3d462d9f6c
+  languageName: node
+  linkType: hard
+
 "wrap-ansi@npm:^8.1.0":
   version: 8.1.0
   resolution: "wrap-ansi@npm:8.1.0"
@@ -26009,7 +26288,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:17.7.2, yargs@npm:^17.0.1, yargs@npm:^17.5.1, yargs@npm:^17.6.2":
+"yargs@npm:17.7.2, yargs@npm:^17.0.1, yargs@npm:^17.5.1, yargs@npm:^17.6.2, yargs@npm:^17.7.2":
   version: 17.7.2
   resolution: "yargs@npm:17.7.2"
   dependencies:
@@ -26050,6 +26329,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"yoctocolors-cjs@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "yoctocolors-cjs@npm:2.1.3"
+  checksum: 10c0/584168ef98eb5d913473a4858dce128803c4a6cd87c0f09e954fa01126a59a33ab9e513b633ad9ab953786ed16efdd8c8700097a51635aafaeed3fef7712fa79
+  languageName: node
+  linkType: hard
+
 "youtube-video-element@npm:^1.6.1":
   version: 1.6.2
   resolution: "youtube-video-element@npm:1.6.2"