Merge remote-tracking branch 'origin/main' into feat/ai-sdk-package

fix: refine experimental_transform handling and improve chunking logic
- Updated PluginEnabledAiClient to streamline the handling of experimental_transform parameters. - Adjusted ModernAiProvider's smoothStream configuration for better chunking of text, enhancing processing efficiency. - Re-enabled block updates in messageThunk for improved state management.
2025-06-20 18:44:26 +08:00 · 2025-06-20 17:36:39 +08:00 · 2025-06-20 16:40:46 +08:00 · 2025-06-20 16:33:30 +08:00 · 2025-06-20 16:31:16 +08:00 · 2025-06-20 16:19:55 +08:00
32 changed files with 7970 additions and 342 deletions
--- a/package.json
+++ b/package.json
@@ -73,6 +73,7 @@
    "@agentic/tavily": "^7.3.3",
    "@ant-design/v5-patch-for-react-19": "^1.0.3",
    "@anthropic-ai/sdk": "^0.41.0",
+    "@cherrystudio/ai-core": "workspace:*",
    "@cherrystudio/embedjs": "^0.1.31",
    "@cherrystudio/embedjs-libsql": "^0.1.31",
    "@cherrystudio/embedjs-loader-csv": "^0.1.31",
--- a/packages/aiCore/AI_SDK_ARCHITECTURE.md
+++ b/packages/aiCore/AI_SDK_ARCHITECTURE.md
@@ -0,0 +1,622 @@
+# Cherry Studio AI Core 基于 Vercel AI SDK 的技术架构
+
+## 1. 架构设计理念
+
+### 1.1 设计目标
+
+- **统一接口**：使用 Vercel AI SDK 统一不同 AI Provider 的接口差异
+- **动态导入**：通过动态导入实现按需加载，减少打包体积
+- **最小包装**：直接使用 AI SDK 的类型和接口，避免重复定义
+- **插件系统**：基于钩子的插件架构，支持请求全生命周期扩展
+- **类型安全**：利用 TypeScript 和 AI SDK 的类型系统确保类型安全
+- **轻量级**：专注核心功能，保持包的轻量和高效
+- **包级独立**：作为独立包管理，便于复用和维护
+
+### 1.2 核心优势
+
+- **标准化**：AI SDK 提供统一的模型接口，减少适配工作
+- **简化维护**：废弃复杂的 XxxApiClient，统一为工厂函数模式
+- **更好的开发体验**：完整的 TypeScript 支持和丰富的生态系统
+- **性能优化**：AI SDK 内置优化和最佳实践
+- **模块化设计**：独立包结构，支持跨项目复用
+- **可扩展插件**：基于钩子的插件系统，支持灵活的功能扩展和流转换
+
+## 2. 整体架构图
+
+```mermaid
+graph TD
+    subgraph "Cherry Studio 主应用"
+        UI["用户界面"]
+        Components["React 组件"]
+    end
+
+    subgraph "packages/aiCore (AI Core 包)"
+        ApiClientFactory["ApiClientFactory (工厂类)"]
+        UniversalClient["UniversalAiSdkClient (统一客户端)"]
+        ProviderRegistry["Provider 注册表"]
+        PluginManager["插件管理器"]
+    end
+
+    subgraph "动态导入层"
+        DynamicImport["动态导入"]
+    end
+
+    subgraph "Vercel AI SDK"
+        AICore["ai (核心库)"]
+        OpenAI["@ai-sdk/openai"]
+        Anthropic["@ai-sdk/anthropic"]
+        Google["@ai-sdk/google"]
+        XAI["@ai-sdk/xai"]
+        Others["其他 19+ Providers"]
+    end
+
+    subgraph "插件生态"
+        FirstHooks["First Hooks (resolveModel, loadTemplate)"]
+        SequentialHooks["Sequential Hooks (transformParams, transformResult)"]
+        ParallelHooks["Parallel Hooks (onRequestStart, onRequestEnd, onError)"]
+        StreamHooks["Stream Hooks (transformStream)"]
+    end
+
+    UI --> ApiClientFactory
+    Components --> ApiClientFactory
+    ApiClientFactory --> UniversalClient
+    UniversalClient --> PluginManager
+    PluginManager --> ProviderRegistry
+    ProviderRegistry --> DynamicImport
+    DynamicImport --> OpenAI
+    DynamicImport --> Anthropic
+    DynamicImport --> Google
+    DynamicImport --> XAI
+    DynamicImport --> Others
+
+    UniversalClient --> AICore
+    AICore --> streamText
+    AICore --> generateText
+
+    PluginManager --> FirstHooks
+    PluginManager --> SequentialHooks
+    PluginManager --> ParallelHooks
+    PluginManager --> StreamHooks
+```
+
+## 3. 包结构设计
+
+### 3.1 包级文件结构（当前简化版 + 规划）
+
+```
+packages/aiCore/
+├── src/
+│   ├── providers/
+│   │   ├── registry.ts              # Provider 注册表 ✅
+│   │   └── types.ts                 # 核心类型定义 ✅
+│   ├── clients/
+│   │   ├── UniversalAiSdkClient.ts  # 统一AI SDK客户端 ✅
+│   │   └── ApiClientFactory.ts     # 客户端工厂 ✅
+│   ├── middleware/                  # 插件系统 ✅
+│   │   ├── types.ts                 # 插件类型定义 ✅
+│   │   ├── manager.ts               # 插件管理器 ✅
+│   │   ├── examples/                # 示例插件 ✅
+│   │   │   ├── example-plugins.ts   # 示例插件实现 ✅
+│   │   │   └── example-usage.ts     # 使用示例 ✅
+│   │   ├── README.md                # 插件系统文档 ✅
+│   │   └── index.ts                 # 插件模块入口 ✅
+│   ├── services/                    # 高级服务 (规划中)
+│   │   ├── AiCoreService.ts         # 统一服务入口
+│   │   ├── CompletionsService.ts    # 文本生成服务
+│   │   ├── EmbeddingService.ts      # 嵌入服务
+│   │   └── ImageService.ts          # 图像生成服务
+│   └── index.ts                     # 包主入口文件 ✅
+├── package.json                     # 包配置文件 ✅
+├── tsconfig.json                    # TypeScript 配置 ✅
+├── README.md                        # 包说明文档 ✅
+└── AI_SDK_ARCHITECTURE.md           # 本文档 ✅
+```
+
+**图例：**
+
+- ✅ 已实现
+- 规划中：设计完成，待实现
+
+## 4. 核心组件详解
+
+### 4.1 Provider 注册表 (`providers/registry.ts`)
+
+统一管理所有 AI Provider 的注册和动态导入。
+
+**主要功能：**
+
+- 动态导入 AI SDK providers
+- 提供统一的 Provider 创建接口
+- 支持 19+ 官方 AI SDK providers
+- 类型安全的 Provider 配置
+
+**核心 API：**
+
+```typescript
+export interface ProviderConfig {
+  id: string
+  name: string
+  import: () => Promise<any>
+  creatorFunctionName: string
+}
+
+export class AiProviderRegistry {
+  getProvider(id: string): ProviderConfig | undefined
+  getAllProviders(): ProviderConfig[]
+  isSupported(id: string): boolean
+  registerProvider(config: ProviderConfig): void
+}
+```
+
+**支持的 Providers：**
+
+- OpenAI, Anthropic, Google, XAI
+- Azure OpenAI, Amazon Bedrock, Google Vertex
+- Groq, Together.ai, Fireworks, DeepSeek
+- Cerebras, DeepInfra, Replicate, Perplexity
+- Cohere, Fal AI, Vercel (19+ providers)
+
+### 4.2 统一AI SDK客户端 (`clients/UniversalAiSdkClient.ts`)
+
+将不同 AI providers 包装为统一接口。
+
+**主要功能：**
+
+- 异步初始化和动态加载
+- 统一的 stream() 和 generate() 方法
+- 直接使用 AI SDK 的 streamText() 和 generateText()
+- 配置验证和错误处理
+
+**核心 API：**
+
+```typescript
+export class UniversalAiSdkClient {
+  async initialize(): Promise<void>
+  isInitialized(): boolean
+  async stream(request: any): Promise<any>
+  async generate(request: any): Promise<any>
+  validateConfig(): boolean
+  getProviderInfo(): { id: string; name: string; isInitialized: boolean }
+}
+```
+
+### 4.3 客户端工厂 (`clients/ApiClientFactory.ts`)
+
+统一创建和管理 AI SDK 客户端。
+
+**主要功能：**
+
+- 统一的客户端创建接口
+- 智能缓存和复用机制
+- 批量创建和健康检查
+- 错误处理和重试
+
+**核心 API：**
+
+```typescript
+export class ApiClientFactory {
+  static async createAiSdkClient(providerId: string, options: any): Promise<UniversalAiSdkClient>
+  static getCachedClient(providerId: string, options: any): UniversalAiSdkClient | undefined
+  static clearCache(): void
+  static async healthCheck(): Promise<HealthCheckResult>
+  static getSupportedProviders(): ProviderInfo[]
+}
+```
+
+### 4.4 钩子风格插件系统 ✅
+
+基于钩子机制的插件架构设计，提供灵活的扩展系统。
+
+**钩子类型：**
+
+1. **First Hooks**：执行到第一个有效结果就停止
+2. **Sequential Hooks**：按序链式执行，可变换数据
+3. **Parallel Hooks**：并发执行，用于副作用
+4. **Stream Hooks**：流转换，直接传递给 AI SDK
+
+**优先级系统：**
+
+- `pre`：前置处理（-100 到 -1）
+- `normal`：标准处理（0 到 99）
+- `post`：后置处理（100 到 199）
+
+**核心钩子：**
+
+**First Hooks (第一个有效结果)：**
+
+- `resolveModel`：模型解析，返回第一个匹配的模型
+- `loadTemplate`：模板加载，返回第一个找到的模板
+
+**Sequential Hooks (链式变换)：**
+
+- `transformParams`：参数转换，依次变换请求参数
+- `transformResult`：结果转换，依次变换响应结果
+
+**Parallel Hooks (并发副作用)：**
+
+- `onRequestStart`：请求开始时触发
+- `onRequestEnd`：请求结束时触发
+- `onError`：错误发生时触发
+
+**Stream Hooks (流转换)：**
+
+- `transformStream`：流转换，返回 AI SDK 转换函数
+
+**插件 API 设计：**
+
+```typescript
+export interface Plugin {
+  name: string
+  enforce?: 'pre' | 'normal' | 'post'
+
+  // First hooks - 执行到第一个有效结果
+  resolveModel?(params: ResolveModelParams): Promise<string | null>
+  loadTemplate?(params: LoadTemplateParams): Promise<Template | null>
+
+  // Sequential hooks - 链式变换
+  transformParams?(params: any, context: PluginContext): Promise<any>
+  transformResult?(result: any, context: PluginContext): Promise<any>
+
+  // Parallel hooks - 并发副作用
+  onRequestStart?(context: PluginContext): Promise<void>
+  onRequestEnd?(context: PluginContext): Promise<void>
+  onError?(error: Error, context: PluginContext): Promise<void>
+
+  // Stream hooks - AI SDK 流转换
+  transformStream?(context: PluginContext): Promise<(readable: ReadableStream) => ReadableStream>
+}
+
+export interface PluginContext {
+  request: any
+  response?: any
+  metadata: Record<string, any>
+  provider: string
+  model: string
+}
+
+export class PluginManager {
+  use(plugin: Plugin): this
+  executeFirstHook<T>(hookName: string, ...args: any[]): Promise<T | null>
+  executeSequentialHook<T>(hookName: string, initialValue: T, context: PluginContext): Promise<T>
+  executeParallelHook(hookName: string, ...args: any[]): Promise<void>
+  collectStreamTransforms(context: PluginContext): Promise<Array<(readable: ReadableStream) => ReadableStream>>
+}
+```
+
+### 4.5 统一服务接口 (规划中)
+
+作为包的主要对外接口，提供高级 AI 功能。
+
+**服务方法：**
+
+- `completions()`: 文本生成
+- `streamCompletions()`: 流式文本生成
+- `generateObject()`: 结构化数据生成
+- `generateImage()`: 图像生成
+- `embed()`: 文本嵌入
+
+**API 设计：**
+
+```typescript
+export class AiCoreService {
+  constructor(middlewares?: Middleware[])
+
+  async completions(request: CompletionRequest): Promise<CompletionResponse>
+  async streamCompletions(request: CompletionRequest): Promise<StreamCompletionResponse>
+  async generateObject<T>(request: ObjectGenerationRequest): Promise<T>
+  async generateImage(request: ImageGenerationRequest): Promise<ImageResponse>
+  async embed(request: EmbeddingRequest): Promise<EmbeddingResponse>
+
+  use(middleware: Middleware): this
+  configure(config: AiCoreConfig): this
+}
+```
+
+## 5. 使用方式
+
+### 5.1 多 Provider 支持
+
+```typescript
+import { createAiSdkClient, AiCore } from '@cherrystudio/ai-core'
+
+// 检查支持的 providers
+const providers = AiCore.getSupportedProviders()
+console.log(`支持 ${providers.length} 个 AI providers`)
+
+// 创建多个 provider 客户端
+const openai = await createAiSdkClient('openai', { apiKey: 'openai-key' })
+const anthropic = await createAiSdkClient('anthropic', { apiKey: 'anthropic-key' })
+const google = await createAiSdkClient('google', { apiKey: 'google-key' })
+const xai = await createAiSdkClient('xai', { apiKey: 'xai-key' })
+```
+
+### 5.2 在 Cherry Studio 中集成
+
+```typescript
+// 替换现有的 XxxApiClient
+// 之前：
+// const openaiClient = new OpenAIApiClient(config)
+// const anthropicClient = new AnthropicApiClient(config)
+
+// 现在：
+import { createAiSdkClient } from '@cherrystudio/ai-core'
+
+const createProviderClient = async (provider: CherryProvider) => {
+  return await createAiSdkClient(provider.id, {
+    apiKey: provider.apiKey,
+    baseURL: provider.baseURL
+  })
+}
+```
+
+### 5.6 完整的工作流示例 (规划中)
+
+```typescript
+import {
+  createAiSdkClient,
+  AiCoreService,
+  MiddlewareChain,
+  PreRequestMiddleware,
+  StreamProcessingMiddleware,
+  PostResponseMiddleware
+} from '@cherrystudio/ai-core'
+
+// 创建完整的工作流
+const createEnhancedAiService = async () => {
+  // 创建中间件链
+  const middlewareChain = new MiddlewareChain()
+    .use(
+      new PreRequestMiddleware({
+        validateApiKey: true,
+        checkRateLimit: true
+      })
+    )
+    .use(
+      new StreamProcessingMiddleware({
+        enableProgressTracking: true,
+        chunkTransform: (chunk) => ({
+          ...chunk,
+          timestamp: Date.now()
+        })
+      })
+    )
+    .use(
+      new PostResponseMiddleware({
+        saveToHistory: true,
+        calculateMetrics: true
+      })
+    )
+
+  // 创建服务实例
+  const service = new AiCoreService(middlewareChain.middlewares)
+
+  return service
+}
+
+// 使用增强服务
+const enhancedService = await createEnhancedAiService()
+
+const response = await enhancedService.completions({
+  provider: 'anthropic',
+  model: 'claude-3-sonnet',
+  messages: [{ role: 'user', content: 'Write a technical blog post about AI middleware' }],
+  options: {
+    temperature: 0.7,
+    maxTokens: 2000
+  },
+  middleware: {
+    // 中间件特定配置
+    thinking: { recordSteps: true },
+    cache: { enabled: true, ttl: 1800 },
+    logging: { level: 'debug' }
+  }
+})
+```
+
+## 6. 简化设计原则
+
+### 6.1 最小包装原则
+
+- 直接使用 AI SDK 的类型，不重复定义
+- 避免过度抽象和复杂的中间层
+- 保持与 AI SDK 原生 API 的一致性
+
+### 6.2 动态导入优化
+
+```typescript
+// 按需加载，减少打包体积
+const module = await import('@ai-sdk/openai')
+const createOpenAI = module.createOpenAI
+```
+
+### 6.3 类型安全
+
+```typescript
+// 直接使用 AI SDK 类型
+import { streamText, generateText } from 'ai'
+
+// 避免重复定义，直接传递参数
+return streamText({ model, ...request })
+```
+
+### 6.4 配置简化
+
+```typescript
+// 简化的 Provider 配置
+interface ProviderConfig {
+  id: string // provider 标识
+  name: string // 显示名称
+  import: () => Promise<any> // 动态导入函数
+  creatorFunctionName: string // 创建函数名
+}
+```
+
+## 7. 技术要点
+
+### 7.1 动态导入策略
+
+- **按需加载**：只加载用户实际使用的 providers
+- **缓存机制**：避免重复导入和初始化
+- **错误处理**：优雅处理导入失败的情况
+
+### 7.2 依赖管理策略
+
+- **核心依赖**：`ai` 库作为必需依赖
+- **可选依赖**：所有 `@ai-sdk/*` 包都是可选的
+- **版本兼容**：支持 AI SDK v3-v5 版本
+
+### 7.3 缓存策略
+
+- **客户端缓存**：基于 provider + options 的智能缓存
+- **配置哈希**：安全的 API key 哈希处理
+- **生命周期管理**：支持缓存清理和验证
+
+## 8. 迁移策略
+
+### 8.1 阶段一：包基础搭建 (Week 1) ✅ 已完成
+
+1. ✅ 创建简化的包结构
+2. ✅ 实现 Provider 注册表
+3. ✅ 创建统一客户端和工厂
+4. ✅ 配置构建和类型系统
+
+### 8.2 阶段二：核心功能完善 (Week 2) ✅ 已完成
+
+1. ✅ 支持 19+ 官方 AI SDK providers
+2. ✅ 实现缓存和错误处理
+3. ✅ 完善类型安全和 API 设计
+4. ✅ 添加便捷函数和工具
+
+### 8.3 阶段三：集成测试 (Week 3) 🔄 进行中
+
+1. 在 Cherry Studio 中集成测试
+2. 功能完整性验证
+3. 性能基准测试
+4. 兼容性问题修复
+
+### 8.4 阶段四：插件系统实现 ✅ 已完成
+
+1. **插件核心架构** ✅
+
+   - 实现 `PluginManager` 和 `PluginContext`
+   - 创建钩子风格插件接口和类型系统
+   - 建立四种钩子类型执行机制
+
+2. **钩子系统** ✅
+
+   - `First Hooks`：第一个有效结果执行
+   - `Sequential Hooks`：链式数据变换
+   - `Parallel Hooks`：并发副作用处理
+   - `Stream Hooks`：AI SDK 流转换集成
+
+3. **优先级和排序** ✅
+
+   - `pre`/`normal`/`post` 优先级系统
+   - 插件注册顺序维护
+   - 错误处理和插件隔离
+
+4. **集成到现有架构** ✅
+   - 在 `UniversalAiSdkClient` 中集成插件管理器
+   - 更新 `ApiClientFactory` 支持插件配置
+   - 创建示例插件和使用文档
+
+### 8.5 阶段五：特性插件扩展 (规划中)
+
+1. **Cherry Studio 特性插件**
+
+   - `ThinkingPlugin`：思考过程记录和提取
+   - `ToolCallPlugin`：工具调用处理和增强
+   - `WebSearchPlugin`：网络搜索集成
+
+2. **高级功能**
+   - 插件组合和条件执行
+   - 动态插件加载系统
+   - 插件配置管理和持久化
+
+### 8.6 阶段六：文档和发布 (Week 7) 📋 规划中
+
+1. 完善使用文档和示例
+2. 插件开发指南和最佳实践
+3. 准备发布到 npm
+4. 建立维护流程
+
+### 8.7 阶段七：生态系统扩展 (Week 8+) 🚀 未来规划
+
+1. 社区插件生态系统
+2. 可视化插件编排工具
+3. 性能监控和分析
+4. 高级缓存和优化策略
+
+## 9. 预期收益
+
+### 9.1 开发效率提升
+
+- **90%** 减少新 Provider 接入时间（只需添加注册表配置）
+- **70%** 减少维护工作量
+- **95%** 提升开发体验（统一接口 + 类型安全）
+- **独立开发**：可以独立于主应用开发和测试
+
+### 9.2 代码质量改善
+
+- 完整的 TypeScript 类型安全
+- 统一的错误处理机制
+- 标准化的 AI SDK 接口
+- 更好的测试覆盖率
+
+### 9.3 架构优势
+
+- **轻量级**：最小化的包装层
+- **可复用**：其他项目可以直接使用
+- **可维护**：独立版本管理和发布
+- **可扩展**：新 provider 只需配置即可
+
+### 9.4 生态系统价值
+
+- 支持 AI SDK 的完整生态系统
+- 可以独立发布到 npm
+- 为开源社区贡献价值
+- 建立统一的 AI 基础设施
+
+## 10. 风险评估与应对
+
+### 10.1 技术风险
+
+- **AI SDK 版本兼容**：支持多版本兼容策略
+- **依赖管理**：合理使用 peerDependencies
+- **类型一致性**：直接使用 AI SDK 类型
+- **性能影响**：最小化包装层开销
+
+### 10.2 迁移风险
+
+- **功能对等性**：确保所有现有功能都能实现
+- **API 兼容性**：提供平滑的迁移路径
+- **集成复杂度**：保持简单的集成方式
+- **学习成本**：提供清晰的使用文档
+
+## 11. 总结
+
+简化的 AI Core 架构专注于核心价值：
+
+### 11.1 核心价值
+
+- **统一接口**：一套 API 支持 19+ AI providers
+- **按需加载**：只打包用户实际使用的 providers
+- **类型安全**：完整的 TypeScript 支持
+- **轻量高效**：最小化的包装层
+
+### 11.2 设计哲学
+
+- **直接使用 AI SDK**：避免重复造轮子，充分利用原生能力
+- **最小包装**：只在必要时添加抽象层，保持轻量高效
+- **开发者友好**：简单易用的 API 设计，熟悉的钩子风格
+- **生态兼容**：充分利用 AI SDK 生态系统和原生流转换
+- **插件优先**：基于钩子的扩展模式，支持灵活组合
+
+### 11.3 成功关键
+
+1. **保持简单**：专注核心功能，避免过度设计
+2. **充分测试**：确保功能完整性和稳定性
+3. **渐进迁移**：平滑过渡，降低风险
+4. **文档完善**：支持快速上手和深度使用
+
+这个基于钩子的插件系统架构为 Cherry Studio 提供了一个轻量、高效、可维护的 AI 基础设施，通过熟悉的钩子模式和原生 AI SDK 集成，为开发者提供了强大而简洁的扩展能力，同时为社区贡献了一个高质量的开源包。
--- a/packages/aiCore/README.md
+++ b/packages/aiCore/README.md
@@ -0,0 +1,222 @@
+# @cherrystudio/ai-core
+
+Cherry Studio AI Core 是一个基于 Vercel AI SDK 的统一 AI Provider 接口包。
+
+## 特性
+
+- 🚀 统一的 AI Provider 接口
+- 🔄 动态导入支持
+- 💾 智能缓存机制
+- 🛠️ TypeScript 支持
+- 📦 轻量级设计
+
+## 支持的 Providers
+
+基于 [AI SDK 官方支持的 providers](https://ai-sdk.dev/providers/ai-sdk-providers)：
+
+**核心 Providers:**
+
+- OpenAI
+- Anthropic
+- Google Generative AI
+- Google Vertex AI
+- Mistral AI
+- xAI (Grok)
+- Azure OpenAI
+- Amazon Bedrock
+
+**扩展 Providers:**
+
+- Cohere
+- Groq
+- Together.ai
+- Fireworks
+- DeepSeek
+- Cerebras
+- DeepInfra
+- Replicate
+- Perplexity
+- Fal AI
+- Vercel
+
+## 安装
+
+```bash
+npm install @cherrystudio/ai-core ai
+```
+
+还需要安装你要使用的 AI SDK provider:
+
+```bash
+npm install @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/google
+```
+
+## 使用示例
+
+### 基础用法
+
+```typescript
+import { createAiSdkClient } from '@cherrystudio/ai-core'
+
+// 创建 OpenAI 客户端
+const client = await createAiSdkClient('openai', {
+  apiKey: 'your-api-key'
+})
+
+// 流式生成
+const result = await client.stream({
+  modelId: 'gpt-4',
+  messages: [{ role: 'user', content: 'Hello!' }]
+})
+
+// 非流式生成
+const response = await client.generate({
+  modelId: 'gpt-4',
+  messages: [{ role: 'user', content: 'Hello!' }]
+})
+```
+
+### 便捷函数
+
+```typescript
+import { createOpenAIClient, streamGeneration } from '@cherrystudio/ai-core'
+
+// 快速创建 OpenAI 客户端
+const client = await createOpenAIClient({
+  apiKey: 'your-api-key'
+})
+
+// 便捷流式生成
+const result = await streamGeneration('openai', 'gpt-4', [{ role: 'user', content: 'Hello!' }], {
+  apiKey: 'your-api-key'
+})
+```
+
+### 多 Provider 支持
+
+```typescript
+import { createAiSdkClient } from '@cherrystudio/ai-core'
+
+// 支持多种 AI providers
+const openaiClient = await createAiSdkClient('openai', { apiKey: 'openai-key' })
+const anthropicClient = await createAiSdkClient('anthropic', { apiKey: 'anthropic-key' })
+const googleClient = await createAiSdkClient('google', { apiKey: 'google-key' })
+const xaiClient = await createAiSdkClient('xai', { apiKey: 'xai-key' })
+```
+
+### 使用 AI SDK 原生 Provider 注册表
+
+> https://ai-sdk.dev/docs/reference/ai-sdk-core/provider-registry
+
+除了使用内建的 provider 管理，你还可以使用 AI SDK 原生的 `createProviderRegistry` 来构建自己的 provider 注册表。
+
+#### 基本用法示例
+
+```typescript
+import { createClient } from '@cherrystudio/ai-core'
+import { createProviderRegistry } from 'ai'
+import { createOpenAI } from '@ai-sdk/openai'
+import { anthropic } from '@ai-sdk/anthropic'
+
+// 1. 创建 AI SDK 原生注册表
+export const registry = createProviderRegistry({
+  // register provider with prefix and default setup:
+  anthropic,
+
+  // register provider with prefix and custom setup:
+  openai: createOpenAI({
+    apiKey: process.env.OPENAI_API_KEY
+  })
+})
+
+// 2. 创建client,'openai'可以传空或者传providerId(内建的provider)
+const client = PluginEnabledAiClient.create('openai', {
+  apiKey: process.env.OPENAI_API_KEY
+})
+
+// 3. 方式1：使用内建逻辑（传统方式）
+const result1 = await client.streamText('gpt-4', {
+  messages: [{ role: 'user', content: 'Hello with built-in logic!' }]
+})
+
+// 4. 方式2：使用自定义注册表（灵活方式）
+const result2 = await client.streamText({
+  model: registry.languageModel('openai:gpt-4'),
+  messages: [{ role: 'user', content: 'Hello with custom registry!' }]
+})
+
+// 5. 支持的重载方法
+await client.generateObject({
+  model: registry.languageModel('openai:gpt-4'),
+  schema: z.object({ name: z.string() }),
+  messages: [{ role: 'user', content: 'Generate a user' }]
+})
+
+await client.streamObject({
+  model: registry.languageModel('anthropic:claude-3-opus-20240229'),
+  schema: z.object({ items: z.array(z.string()) }),
+  messages: [{ role: 'user', content: 'Generate a list' }]
+})
+```
+
+#### 与插件系统配合使用
+
+更强大的是，你还可以将自定义注册表与 Cherry Studio 的插件系统结合使用：
+
+```typescript
+import { PluginEnabledAiClient } from '@cherrystudio/ai-core'
+import { createProviderRegistry } from 'ai'
+import { createOpenAI } from '@ai-sdk/openai'
+import { anthropic } from '@ai-sdk/anthropic'
+
+// 1. 创建带插件的客户端
+const client = PluginEnabledAiClient.create(
+  'openai',
+  {
+    apiKey: process.env.OPENAI_API_KEY
+  },
+  [LoggingPlugin, RetryPlugin]
+)
+
+// 2. 创建自定义注册表
+const registry = createProviderRegistry({
+  openai: createOpenAI({ apiKey: process.env.OPENAI_API_KEY }),
+  anthropic: anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
+})
+
+// 3. 方式1：使用内建逻辑 + 完整插件系统
+await client.streamText('gpt-4', {
+  messages: [{ role: 'user', content: 'Hello with plugins!' }]
+})
+
+// 4. 方式2：使用自定义注册表 + 有限插件支持
+await client.streamText({
+  model: registry.languageModel('anthropic:claude-3-opus-20240229'),
+  messages: [{ role: 'user', content: 'Hello from Claude!' }]
+})
+
+// 5. 支持的方法
+await client.generateObject({
+  model: registry.languageModel('openai:gpt-4'),
+  schema: z.object({ name: z.string() }),
+  messages: [{ role: 'user', content: 'Generate a user' }]
+})
+
+await client.streamObject({
+  model: registry.languageModel('openai:gpt-4'),
+  schema: z.object({ items: z.array(z.string()) }),
+  messages: [{ role: 'user', content: 'Generate a list' }]
+})
+```
+
+#### 混合使用的优势
+
+- **灵活性**：可以根据需要选择使用内建逻辑或自定义注册表
+- **兼容性**：完全兼容 AI SDK 的 `createProviderRegistry` API
+- **渐进式**：可以逐步迁移现有代码，无需一次性重构
+- **插件支持**：自定义注册表仍可享受 Cherry Studio 插件系统的部分功能
+- **最佳实践**：结合两种方式的优点，既有动态加载的性能优势，又有统一注册表的便利性
+
+## License
+
+MIT
--- a/packages/aiCore/package.json
+++ b/packages/aiCore/package.json
@@ -0,0 +1,124 @@
+{
+  "name": "@cherrystudio/ai-core",
+  "version": "1.0.0",
+  "description": "Cherry Studio AI Core - Unified AI Provider Interface Based on Vercel AI SDK",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsc -w",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "ai",
+    "sdk",
+    "openai",
+    "anthropic",
+    "google",
+    "cherry-studio",
+    "vercel-ai-sdk"
+  ],
+  "author": "Cherry Studio",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/amazon-bedrock": "^2.2.10",
+    "@ai-sdk/anthropic": "^1.2.12",
+    "@ai-sdk/azure": "^1.3.23",
+    "@ai-sdk/cerebras": "^0.2.14",
+    "@ai-sdk/cohere": "^1.2.10",
+    "@ai-sdk/deepinfra": "^0.2.15",
+    "@ai-sdk/deepseek": "^0.2.14",
+    "@ai-sdk/fal": "^0.1.12",
+    "@ai-sdk/fireworks": "^0.2.14",
+    "@ai-sdk/google": "^1.2.19",
+    "@ai-sdk/google-vertex": "^2.2.24",
+    "@ai-sdk/groq": "^1.2.9",
+    "@ai-sdk/mistral": "^1.2.8",
+    "@ai-sdk/openai": "^1.3.22",
+    "@ai-sdk/openai-compatible": "^0.2.14",
+    "@ai-sdk/perplexity": "^1.1.9",
+    "@ai-sdk/replicate": "^0.2.8",
+    "@ai-sdk/togetherai": "^0.2.14",
+    "@ai-sdk/vercel": "^0.0.1",
+    "@ai-sdk/xai": "^1.2.16",
+    "@openrouter/ai-sdk-provider": "^0.1.0",
+    "ai": "^4.3.16",
+    "anthropic-vertex-ai": "^1.0.2",
+    "ollama-ai-provider": "^1.2.0",
+    "qwen-ai-provider": "^0.1.0",
+    "zhipu-ai-provider": "^0.1.1"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/amazon-bedrock": {
+      "optional": true
+    },
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/azure": {
+      "optional": true
+    },
+    "@ai-sdk/cerebras": {
+      "optional": true
+    },
+    "@ai-sdk/cohere": {
+      "optional": true
+    },
+    "@ai-sdk/deepinfra": {
+      "optional": true
+    },
+    "@ai-sdk/deepseek": {
+      "optional": true
+    },
+    "@ai-sdk/fal": {
+      "optional": true
+    },
+    "@ai-sdk/fireworks": {
+      "optional": true
+    },
+    "@ai-sdk/google": {
+      "optional": true
+    },
+    "@ai-sdk/google-vertex": {
+      "optional": true
+    },
+    "@ai-sdk/groq": {
+      "optional": true
+    },
+    "@ai-sdk/mistral": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@ai-sdk/perplexity": {
+      "optional": true
+    },
+    "@ai-sdk/replicate": {
+      "optional": true
+    },
+    "@ai-sdk/together": {
+      "optional": true
+    },
+    "@ai-sdk/vercel": {
+      "optional": true
+    },
+    "@ai-sdk/xai": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsdown": "^0.12.8",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "require": "./src/index.ts"
+    }
+  }
+}
--- a/packages/aiCore/pnpm-lock.yaml
+++ b/packages/aiCore/pnpm-lock.yaml
--- a/packages/aiCore/src/clients/ApiClientFactory.ts
+++ b/packages/aiCore/src/clients/ApiClientFactory.ts
@@ -0,0 +1,223 @@
+/**
+ * API Client Factory
+ * 整合现有实现的改进版API客户端工厂
+ */
+
+import type { ImageModelV1 } from '@ai-sdk/provider'
+import { type LanguageModelV1, LanguageModelV1Middleware, wrapLanguageModel } from 'ai'
+
+import { aiProviderRegistry } from '../providers/registry'
+import { type ProviderId, type ProviderSettingsMap } from './types'
+
+// 客户端配置接口
+export interface ClientConfig {
+  providerId: string
+  options?: any
+}
+
+// 错误类型
+export class ClientFactoryError extends Error {
+  constructor(
+    message: string,
+    public providerId?: string,
+    public cause?: Error
+  ) {
+    super(message)
+    this.name = 'ClientFactoryError'
+  }
+}
+
+/**
+ * API Client Factory
+ * 统一管理和创建AI SDK客户端
+ */
+export class ApiClientFactory {
+  /**
+   * 创建 AI SDK 模型实例
+   * 对于已知的 Provider 使用严格类型检查，未知的 Provider 默认使用 openai-compatible
+   */
+  static async createClient<T extends ProviderId>(
+    providerId: T,
+    modelId: string,
+    options: ProviderSettingsMap[T],
+    middlewares?: LanguageModelV1Middleware[]
+  ): Promise<LanguageModelV1>
+
+  static async createClient(
+    providerId: string,
+    modelId: string,
+    options: ProviderSettingsMap['openai-compatible'],
+    middlewares?: LanguageModelV1Middleware[]
+  ): Promise<LanguageModelV1>
+
+  static async createClient(
+    providerId: string,
+    modelId: string = 'default',
+    options: any,
+    middlewares?: LanguageModelV1Middleware[]
+  ): Promise<LanguageModelV1> {
+    try {
+      // 对于不在注册表中的 provider，默认使用 openai-compatible
+      const effectiveProviderId = aiProviderRegistry.isSupported(providerId) ? providerId : 'openai-compatible'
+
+      // 获取Provider配置
+      const providerConfig = aiProviderRegistry.getProvider(effectiveProviderId)
+      if (!providerConfig) {
+        throw new ClientFactoryError(`Provider "${effectiveProviderId}" is not registered`, providerId)
+      }
+
+      // 动态导入模块
+      const module = await providerConfig.import()
+
+      // 获取创建函数
+      const creatorFunction = module[providerConfig.creatorFunctionName]
+
+      if (typeof creatorFunction !== 'function') {
+        throw new ClientFactoryError(
+          `Creator function "${providerConfig.creatorFunctionName}" not found in the imported module for provider "${effectiveProviderId}"`
+        )
+      }
+      // 创建provider实例
+      const provider = creatorFunction(options)
+
+      // 返回模型实例
+      if (typeof provider === 'function') {
+        let model: LanguageModelV1 = provider(modelId)
+
+        // 应用 AI SDK 中间件
+        if (middlewares && middlewares.length > 0) {
+          model = wrapLanguageModel({
+            model: model,
+            middleware: middlewares
+          })
+        }
+
+        return model
+      } else {
+        throw new ClientFactoryError(`Unknown model access pattern for provider "${effectiveProviderId}"`)
+      }
+    } catch (error) {
+      if (error instanceof ClientFactoryError) {
+        throw error
+      }
+      throw new ClientFactoryError(
+        `Failed to create client for provider "${providerId}": ${error instanceof Error ? error.message : 'Unknown error'}`,
+        providerId,
+        error instanceof Error ? error : undefined
+      )
+    }
+  }
+
+  static async createImageClient<T extends ProviderId>(
+    providerId: T,
+    modelId: string,
+    options: ProviderSettingsMap[T]
+  ): Promise<ImageModelV1>
+
+  static async createImageClient(
+    providerId: string,
+    modelId: string,
+    options: ProviderSettingsMap['openai-compatible']
+  ): Promise<ImageModelV1>
+
+  static async createImageClient(providerId: string, modelId: string = 'default', options: any): Promise<ImageModelV1> {
+    try {
+      if (!aiProviderRegistry.isSupported(providerId)) {
+        throw new ClientFactoryError(`Provider "${providerId}" is not supported`, providerId)
+      }
+
+      const providerConfig = aiProviderRegistry.getProvider(providerId)
+      if (!providerConfig) {
+        throw new ClientFactoryError(`Provider "${providerId}" is not registered`, providerId)
+      }
+
+      if (!providerConfig.supportsImageGeneration) {
+        throw new ClientFactoryError(`Provider "${providerId}" does not support image generation`, providerId)
+      }
+
+      const module = await providerConfig.import()
+
+      const creatorFunction = module[providerConfig.creatorFunctionName]
+
+      if (typeof creatorFunction !== 'function') {
+        throw new ClientFactoryError(
+          `Creator function "${providerConfig.creatorFunctionName}" not found in the imported module for provider "${providerId}"`
+        )
+      }
+
+      const provider = creatorFunction(options)
+
+      if (provider && typeof provider.image === 'function') {
+        return provider.image(modelId)
+      } else {
+        throw new ClientFactoryError(`Image model function not found for provider "${providerId}"`)
+      }
+    } catch (error) {
+      if (error instanceof ClientFactoryError) {
+        throw error
+      }
+      throw new ClientFactoryError(
+        `Failed to create image client for provider "${providerId}": ${error instanceof Error ? error.message : 'Unknown error'}`,
+        providerId,
+        error instanceof Error ? error : undefined
+      )
+    }
+  }
+
+  /**
+   * 获取支持的 Providers 列表
+   */
+  static getSupportedProviders(): Array<{
+    id: string
+    name: string
+  }> {
+    return aiProviderRegistry.getAllProviders().map((provider) => ({
+      id: provider.id,
+      name: provider.name
+    }))
+  }
+
+  /**
+   * 获取 Provider 信息
+   */
+  static getClientInfo(providerId: string): {
+    id: string
+    name: string
+    isSupported: boolean
+    effectiveProvider: string
+  } {
+    const effectiveProviderId = aiProviderRegistry.isSupported(providerId) ? providerId : 'openai-compatible'
+    const provider = aiProviderRegistry.getProvider(effectiveProviderId)
+
+    return {
+      id: providerId,
+      name: provider?.name || providerId,
+      isSupported: aiProviderRegistry.isSupported(providerId),
+      effectiveProvider: effectiveProviderId
+    }
+  }
+}
+
+// 便捷导出函数
+export function createClient<T extends ProviderId>(
+  providerId: T,
+  modelId: string,
+  options: ProviderSettingsMap[T]
+): Promise<LanguageModelV1>
+
+export function createClient(
+  providerId: string,
+  modelId: string,
+  options: ProviderSettingsMap['openai-compatible']
+): Promise<LanguageModelV1>
+
+export function createClient(providerId: string, modelId: string = 'default', options: any): Promise<LanguageModelV1> {
+  return ApiClientFactory.createClient(providerId, modelId, options)
+}
+
+export const createImageClient = (providerId: string, modelId: string, options: any): Promise<ImageModelV1> =>
+  ApiClientFactory.createImageClient(providerId, modelId, options)
+
+export const getSupportedProviders = () => ApiClientFactory.getSupportedProviders()
+
+export const getClientInfo = (providerId: string) => ApiClientFactory.getClientInfo(providerId)
--- a/packages/aiCore/src/clients/PluginEnabledAiClient.ts
+++ b/packages/aiCore/src/clients/PluginEnabledAiClient.ts
@@ -0,0 +1,381 @@
+/**
+ * AI Client - Cherry Studio AI Core 的主要客户端接口
+ * 默认集成插件系统，提供完整的 AI 调用能力
+ *
+ * ## 使用方式
+ *
+ * ```typescript
+ * import { AiClient } from '@cherrystudio/ai-core'
+ *
+ * // 创建客户端（默认带插件系统）
+ * const client = AiClient.create('openai', {
+ *   name: 'openai',
+ *   apiKey: process.env.OPENAI_API_KEY
+ * }, [LoggingPlugin, ContentFilterPlugin])
+ *
+ * // 使用方式与 UniversalAiSdkClient 完全相同
+ * const result = await client.generateText('gpt-4', {
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * })
+ * ```
+ */
+import { generateObject, generateText, LanguageModelV1Middleware, streamObject, streamText } from 'ai'
+
+import { AiPlugin, createContext, PluginManager } from '../plugins'
+import { isProviderSupported } from '../providers/registry'
+import { ApiClientFactory } from './ApiClientFactory'
+import { type ProviderId, type ProviderSettingsMap } from './types'
+import { UniversalAiSdkClient } from './UniversalAiSdkClient'
+
+/**
+ * Cherry Studio AI Core 的主要客户端
+ * 默认集成插件系统，提供完整的 AI 调用能力
+ */
+export class PluginEnabledAiClient<T extends ProviderId = ProviderId> {
+  private pluginManager: PluginManager
+  private baseClient: UniversalAiSdkClient<T>
+  private middlewares: LanguageModelV1Middleware[] = []
+
+  constructor(
+    private readonly providerId: T,
+    private readonly options: ProviderSettingsMap[T],
+    plugins: AiPlugin[] = []
+  ) {
+    this.pluginManager = new PluginManager(plugins)
+    this.baseClient = UniversalAiSdkClient.create(providerId, options)
+    this.updateMiddlewares()
+  }
+
+  /**
+   * 添加单个插件
+   */
+  use(plugin: AiPlugin): this {
+    this.pluginManager.use(plugin)
+    this.updateMiddlewares()
+    return this
+  }
+
+  /**
+   * 批量添加插件
+   */
+  usePlugins(plugins: AiPlugin[]): this {
+    plugins.forEach((plugin) => this.pluginManager.use(plugin))
+    this.updateMiddlewares()
+    return this
+  }
+
+  /**
+   * 移除插件
+   */
+  removePlugin(pluginName: string): this {
+    this.pluginManager.remove(pluginName)
+    this.updateMiddlewares()
+    return this
+  }
+
+  /**
+   * 重新计算并更新中间件列表
+   * 这是一个原子操作，以确保中间件列表总是最新的
+   */
+  private updateMiddlewares(): void {
+    const pluginMiddlewares = this.pluginManager.collectAiSdkMiddlewares()
+    this.middlewares = pluginMiddlewares
+  }
+
+  /**
+   * 获取插件统计信息
+   */
+  getPluginStats() {
+    return this.pluginManager.getStats()
+  }
+
+  /**
+   * 获取插件列表
+   */
+  getPlugins() {
+    return this.pluginManager.getPlugins()
+  }
+
+  /**
+   * 执行插件处理的通用逻辑
+   * 1-5步骤的通用处理
+   */
+  private async executeWithPlugins<TParams, TResult>(
+    methodName: string,
+    modelId: string,
+    params: TParams,
+    executor: (finalModelId: string, transformedParams: TParams) => Promise<TResult>
+  ): Promise<TResult> {
+    // 创建请求上下文
+    const context = createContext(this.providerId, modelId, params)
+
+    try {
+      // 1. 触发请求开始事件
+      await this.pluginManager.executeParallel('onRequestStart', context)
+
+      // 2. 解析模型别名
+      const resolvedModelId = await this.pluginManager.executeFirst<string>('resolveModel', modelId, context)
+      const finalModelId = resolvedModelId || modelId
+
+      // 3. 转换请求参数
+      const transformedParams = await this.pluginManager.executeSequential('transformParams', params, context)
+
+      // 4. 执行具体的 API 调用
+      const result = await executor(finalModelId, transformedParams)
+
+      // 5. 转换结果（对于非流式调用）
+      const transformedResult = await this.pluginManager.executeSequential('transformResult', result, context)
+
+      // 6. 触发完成事件
+      await this.pluginManager.executeParallel('onRequestEnd', context, transformedResult)
+
+      return transformedResult
+    } catch (error) {
+      // 7. 触发错误事件
+      await this.pluginManager.executeParallel('onError', context, undefined, error as Error)
+      throw error
+    }
+  }
+
+  /**
+   * 执行流式调用的通用逻辑
+   * 流式调用的特殊处理（支持流转换器）
+   */
+  private async executeStreamWithPlugins<TParams, TResult>(
+    methodName: string,
+    modelId: string,
+    params: TParams,
+    executor: (finalModelId: string, transformedParams: TParams, streamTransforms: any[]) => Promise<TResult>
+  ): Promise<TResult> {
+    // 创建请求上下文
+    const context = createContext(this.providerId, modelId, params)
+
+    try {
+      // 1. 触发请求开始事件
+      await this.pluginManager.executeParallel('onRequestStart', context)
+
+      // 2. 解析模型别名
+      const resolvedModelId = await this.pluginManager.executeFirst<string>('resolveModel', modelId, context)
+      const finalModelId = resolvedModelId || modelId
+
+      // 3. 转换请求参数
+      const transformedParams = await this.pluginManager.executeSequential('transformParams', params, context)
+
+      // 4. 收集流转换器
+      const streamTransforms = this.pluginManager.collectStreamTransforms()
+
+      // 5. 执行流式 API 调用
+      const result = await executor(finalModelId, transformedParams, streamTransforms)
+
+      // 6. 触发完成事件（注意：对于流式调用，这里触发的是开始流式响应的事件）
+      await this.pluginManager.executeParallel('onRequestEnd', context, { stream: true })
+
+      return result
+    } catch (error) {
+      // 7. 触发错误事件
+      await this.pluginManager.executeParallel('onError', context, undefined, error as Error)
+      throw error
+    }
+  }
+
+  /**
+   * 获取注入了中间件的 AI SDK 模型实例
+   * 这是应用原生中间件的关键
+   */
+  private async getModelWithMiddlewares(modelId: string) {
+    const middlewares = this.middlewares
+    // 3. 如果有中间件，创建一个新的、注入了中间件的客户端实例
+    return await ApiClientFactory.createClient(
+      this.providerId,
+      modelId,
+      this.options,
+      middlewares.length > 0 ? middlewares : undefined
+    )
+  }
+
+  /**
+   * 流式文本生成
+   */
+  async streamText(
+    modelId: string,
+    params: Omit<Parameters<typeof streamText>[0], 'model'>
+  ): Promise<ReturnType<typeof streamText>>
+  async streamText(params: Parameters<typeof streamText>[0]): Promise<ReturnType<typeof streamText>>
+  async streamText(
+    modelIdOrParams: string | Parameters<typeof streamText>[0],
+    params?: Omit<Parameters<typeof streamText>[0], 'model'>
+  ): Promise<ReturnType<typeof streamText>> {
+    if (typeof modelIdOrParams === 'string') {
+      // 传统方式：使用内建逻辑
+      return this.executeStreamWithPlugins(
+        'streamText',
+        modelIdOrParams,
+        params!,
+        async (finalModelId, transformedParams, streamTransforms) => {
+          const model = await this.getModelWithMiddlewares(finalModelId)
+          const experimental_transform =
+            params?.experimental_transform ?? (streamTransforms.length > 0 ? streamTransforms : undefined)
+
+          return await streamText({
+            model,
+            ...transformedParams,
+            experimental_transform
+          })
+        }
+      )
+    } else {
+      // 外部 registry 方式：直接使用用户提供的 model
+      return await streamText(modelIdOrParams)
+    }
+  }
+
+  /**
+   * 生成文本
+   * 可能不需要了，因为内置模拟非流中间件
+   */
+  async generateText(
+    modelId: string,
+    params: Omit<Parameters<typeof generateText>[0], 'model'>
+  ): Promise<ReturnType<typeof generateText>> {
+    return this.executeWithPlugins('generateText', modelId, params, async (finalModelId, transformedParams) => {
+      const model = await this.getModelWithMiddlewares(finalModelId)
+      return await generateText({ model, ...transformedParams })
+    })
+  }
+
+  /**
+   * 生成结构化对象
+   */
+  async generateObject(
+    modelId: string,
+    params: Omit<Parameters<typeof generateObject>[0], 'model'>
+  ): Promise<ReturnType<typeof generateObject>>
+  async generateObject(params: Parameters<typeof generateObject>[0]): Promise<ReturnType<typeof generateObject>>
+  async generateObject(
+    modelIdOrParams: string | Parameters<typeof generateObject>[0],
+    params?: Omit<Parameters<typeof generateObject>[0], 'model'>
+  ): Promise<ReturnType<typeof generateObject>> {
+    if (typeof modelIdOrParams === 'string') {
+      // 传统方式：使用内建逻辑
+      return this.executeWithPlugins(
+        'generateObject',
+        modelIdOrParams,
+        params!,
+        async (finalModelId, transformedParams) => {
+          const model = await this.getModelWithMiddlewares(finalModelId)
+          return await generateObject({ model, ...transformedParams })
+        }
+      )
+    } else {
+      // 外部 registry 方式：直接使用用户提供的 model
+      return await generateObject(modelIdOrParams)
+    }
+  }
+
+  /**
+   * 流式生成结构化对象
+   */
+  async streamObject(
+    modelId: string,
+    params: Omit<Parameters<typeof streamObject>[0], 'model'>
+  ): Promise<ReturnType<typeof streamObject>>
+  async streamObject(params: Parameters<typeof streamObject>[0]): Promise<ReturnType<typeof streamObject>>
+  async streamObject(
+    modelIdOrParams: string | Parameters<typeof streamObject>[0],
+    params?: Omit<Parameters<typeof streamObject>[0], 'model'>
+  ): Promise<ReturnType<typeof streamObject>> {
+    if (typeof modelIdOrParams === 'string') {
+      // 传统方式：使用内建逻辑
+      return this.executeWithPlugins(
+        'streamObject',
+        modelIdOrParams,
+        params!,
+        async (finalModelId, transformedParams) => {
+          return await this.baseClient.streamObject(finalModelId, transformedParams)
+        }
+      )
+    } else {
+      // 外部 registry 方式：直接使用用户提供的 model
+      return await streamObject(modelIdOrParams)
+    }
+  }
+
+  /**
+   * 获取客户端信息
+   */
+  getClientInfo() {
+    return this.baseClient.getClientInfo()
+  }
+
+  /**
+   * 获取底层客户端实例（用于高级用法）
+   */
+  getBaseClient(): UniversalAiSdkClient<T> {
+    return this.baseClient
+  }
+
+  // === 静态工厂方法 ===
+
+  /**
+   * 创建 OpenAI Compatible 客户端
+   */
+  static createOpenAICompatible(
+    config: ProviderSettingsMap['openai-compatible'],
+    plugins: AiPlugin[] = []
+  ): PluginEnabledAiClient<'openai-compatible'> {
+    return new PluginEnabledAiClient('openai-compatible', config, plugins)
+  }
+
+  /**
+   * 创建标准提供商客户端
+   */
+  static create<T extends ProviderId>(
+    providerId: T,
+    options: ProviderSettingsMap[T],
+    plugins?: AiPlugin[]
+  ): PluginEnabledAiClient<T>
+
+  static create(
+    providerId: string,
+    options: ProviderSettingsMap['openai-compatible'],
+    plugins?: AiPlugin[]
+  ): PluginEnabledAiClient<'openai-compatible'>
+
+  static create(providerId: string, options: any, plugins: AiPlugin[] = []): PluginEnabledAiClient {
+    if (isProviderSupported(providerId)) {
+      return new PluginEnabledAiClient(providerId as ProviderId, options, plugins)
+    } else {
+      // 对于未知 provider，使用 openai-compatible
+      return new PluginEnabledAiClient('openai-compatible', options, plugins)
+    }
+  }
+}
+
+/**
+ * 创建 AI 客户端的工厂函数（默认带插件系统）
+ */
+export function createClient<T extends ProviderId>(
+  providerId: T,
+  options: ProviderSettingsMap[T],
+  plugins?: AiPlugin[]
+): PluginEnabledAiClient<T>
+
+export function createClient(
+  providerId: string,
+  options: ProviderSettingsMap['openai-compatible'],
+  plugins?: AiPlugin[]
+): PluginEnabledAiClient<'openai-compatible'>
+
+export function createClient(providerId: string, options: any, plugins: AiPlugin[] = []): PluginEnabledAiClient {
+  return PluginEnabledAiClient.create(providerId, options, plugins)
+}
+
+/**
+ * 创建 OpenAI Compatible 客户端的便捷函数
+ */
+export function createCompatibleClient(
+  config: ProviderSettingsMap['openai-compatible'],
+  plugins: AiPlugin[] = []
+): PluginEnabledAiClient<'openai-compatible'> {
+  return PluginEnabledAiClient.createOpenAICompatible(config, plugins)
+}
--- a/packages/aiCore/src/clients/UniversalAiSdkClient.ts
+++ b/packages/aiCore/src/clients/UniversalAiSdkClient.ts
@@ -0,0 +1,228 @@
+/**
+ * Universal AI SDK Client
+ * 统一的AI SDK客户端实现
+ *
+ * ## 使用方式
+ *
+ * ### 1. 官方提供商
+ * ```typescript
+ * import { UniversalAiSdkClient } from '@cherrystudio/ai-core'
+ *
+ * // OpenAI
+ * const openai = UniversalAiSdkClient.create('openai', {
+ *   name: 'openai',
+ *   apiHost: 'https://api.openai.com/v1',
+ *   apiKey: process.env.OPENAI_API_KEY
+ * })
+ *
+ * // Anthropic
+ * const anthropic = UniversalAiSdkClient.create('anthropic', {
+ *   name: 'anthropic',
+ *   apiHost: 'https://api.anthropic.com',
+ *   apiKey: process.env.ANTHROPIC_API_KEY
+ * })
+ * ```
+ *
+ * ### 2. OpenAI Compatible 第三方提供商
+ * ```typescript
+ * // LM Studio (本地运行)
+ * const lmStudio = UniversalAiSdkClient.createOpenAICompatible({
+ *   name: 'lm-studio',
+ *   baseURL: 'http://localhost:1234/v1'
+ * })
+ *
+ * // Ollama (本地运行)
+ * const ollama = UniversalAiSdkClient.createOpenAICompatible({
+ *   name: 'ollama',
+ *   baseURL: 'http://localhost:11434/v1'
+ * })
+ *
+ * // 自定义第三方 API
+ * const customProvider = UniversalAiSdkClient.createOpenAICompatible({
+ *   name: 'my-provider',
+ *   apiKey: process.env.CUSTOM_API_KEY,
+ *   baseURL: 'https://api.customprovider.com/v1',
+ *   headers: {
+ *     'X-Custom-Header': 'value',
+ *     'User-Agent': 'MyApp/1.0'
+ *   },
+ *   queryParams: {
+ *     'api-version': '2024-01'
+ *   }
+ * })
+ * ```
+ *
+ * ### 3. 使用客户端进行 AI 调用
+ * ```typescript
+ * // 流式文本生成
+ * const stream = await client.streamText('gpt-4', {
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * })
+ *
+ * // 生成文本
+ * const { text } = await client.generateText('gpt-4', {
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * })
+ *
+ * // 生成结构化对象
+ * const { object } = await client.generateObject('gpt-4', {
+ *   messages: [{ role: 'user', content: 'Generate a user profile' }],
+ *   schema: z.object({
+ *     name: z.string(),
+ *     age: z.number()
+ *   })
+ * })
+ * ```
+ */
+
+import { experimental_generateImage as generateImage, generateObject, generateText, streamObject, streamText } from 'ai'
+
+import { ApiClientFactory } from './ApiClientFactory'
+import { type ProviderId, type ProviderSettingsMap } from './types'
+
+/**
+ * 通用 AI SDK 客户端
+ * 为特定 AI 提供商创建的客户端实例
+ */
+export class UniversalAiSdkClient<T extends ProviderId = ProviderId> {
+  constructor(
+    private readonly providerId: T,
+    private readonly options: ProviderSettingsMap[T]
+  ) {}
+
+  /**
+   * 流式文本生成
+   * 直接使用 AI SDK 的 streamText 参数类型
+   */
+  async streamText(
+    modelId: string,
+    params: Omit<Parameters<typeof streamText>[0], 'model'>
+  ): Promise<ReturnType<typeof streamText>> {
+    const model = await ApiClientFactory.createClient(this.providerId, modelId, this.options)
+    return streamText({
+      model,
+      ...params
+    })
+  }
+
+  /**
+   * 生成文本
+   * 直接使用 AI SDK 的 generateText 参数类型
+   */
+  async generateText(
+    modelId: string,
+    params: Omit<Parameters<typeof generateText>[0], 'model'>
+  ): Promise<ReturnType<typeof generateText>> {
+    const model = await ApiClientFactory.createClient(this.providerId, modelId, this.options)
+    return generateText({
+      model,
+      ...params
+    })
+  }
+
+  /**
+   * 生成结构化对象
+   * 直接使用 AI SDK 的 generateObject 参数类型
+   */
+  async generateObject(
+    modelId: string,
+    params: Omit<Parameters<typeof generateObject>[0], 'model'>
+  ): Promise<ReturnType<typeof generateObject>> {
+    const model = await ApiClientFactory.createClient(this.providerId, modelId, this.options)
+    return await generateObject({
+      model,
+      ...params
+    })
+  }
+
+  /**
+   * 流式生成结构化对象
+   * 直接使用 AI SDK 的 streamObject 参数类型
+   */
+  async streamObject(
+    modelId: string,
+    params: Omit<Parameters<typeof streamObject>[0], 'model'>
+  ): Promise<ReturnType<typeof streamObject>> {
+    const model = await ApiClientFactory.createClient(this.providerId, modelId, this.options)
+    return streamObject({
+      model,
+      ...params
+    })
+  }
+
+  async generateImage(
+    modelId: string,
+    params: Omit<Parameters<typeof generateImage>[0], 'model'>
+  ): Promise<ReturnType<typeof generateImage>> {
+    const model = await ApiClientFactory.createImageClient(this.providerId, modelId, this.options)
+    return generateImage({
+      model,
+      ...params
+    })
+  }
+
+  /**
+   * 获取客户端信息
+   */
+  getClientInfo() {
+    return ApiClientFactory.getClientInfo(this.providerId)
+  }
+
+  // === 静态工厂方法 ===
+
+  /**
+   * 创建 OpenAI Compatible 客户端
+   * 用于那些实现 OpenAI API 的第三方提供商
+   */
+  static createOpenAICompatible(
+    config: ProviderSettingsMap['openai-compatible']
+  ): UniversalAiSdkClient<'openai-compatible'> {
+    return new UniversalAiSdkClient('openai-compatible', config)
+  }
+
+  /**
+   * 创建标准提供商客户端
+   * 对于已知的 Provider 使用严格类型检查，未知的 Provider 默认使用 openai-compatible
+   */
+  static create<T extends ProviderId>(providerId: T, options: ProviderSettingsMap[T]): UniversalAiSdkClient<T>
+
+  static create(
+    providerId: string,
+    options: ProviderSettingsMap['openai-compatible']
+  ): UniversalAiSdkClient<'openai-compatible'>
+
+  static create(providerId: string, options: any): UniversalAiSdkClient {
+    if (providerId in ({} as ProviderSettingsMap)) {
+      return new UniversalAiSdkClient(providerId as ProviderId, options)
+    } else {
+      // 对于未知 provider，使用 openai-compatible
+      return new UniversalAiSdkClient('openai-compatible', options)
+    }
+  }
+}
+
+/**
+ * 创建客户端实例的工厂函数
+ */
+export function createUniversalClient<T extends ProviderId>(
+  providerId: T,
+  options: ProviderSettingsMap[T]
+): UniversalAiSdkClient<T>
+
+export function createUniversalClient(
+  providerId: string,
+  options: ProviderSettingsMap['openai-compatible']
+): UniversalAiSdkClient<'openai-compatible'>
+
+export function createUniversalClient(providerId: string, options: any): UniversalAiSdkClient {
+  return UniversalAiSdkClient.create(providerId, options)
+}
+
+/**
+ * 创建 OpenAI Compatible 客户端的便捷函数
+ */
+export function createOpenAICompatibleClient(
+  config: ProviderSettingsMap['openai-compatible']
+): UniversalAiSdkClient<'openai-compatible'> {
+  return UniversalAiSdkClient.createOpenAICompatible(config)
+}
--- a/packages/aiCore/src/clients/types.ts
+++ b/packages/aiCore/src/clients/types.ts
@@ -0,0 +1,42 @@
+import { generateObject, generateText, streamObject, streamText } from 'ai'
+
+import type { ProviderSettingsMap } from '../providers/registry'
+
+// ProviderSettings 是所有 Provider Settings 的联合类型
+export type ProviderSettings = ProviderSettingsMap[keyof ProviderSettingsMap]
+
+export type StreamTextParams = Omit<Parameters<typeof streamText>[0], 'model'>
+export type GenerateTextParams = Omit<Parameters<typeof generateText>[0], 'model'>
+export type StreamObjectParams = Omit<Parameters<typeof streamObject>[0], 'model'>
+export type GenerateObjectParams = Omit<Parameters<typeof generateObject>[0], 'model'>
+
+// 重新导出 ProviderSettingsMap 中的所有类型
+export type {
+  AmazonBedrockProviderSettings,
+  AnthropicProviderSettings,
+  AnthropicVertexProviderSettings,
+  AzureOpenAIProviderSettings,
+  CerebrasProviderSettings,
+  CohereProviderSettings,
+  DeepInfraProviderSettings,
+  DeepSeekProviderSettings,
+  FalProviderSettings,
+  FireworksProviderSettings,
+  GoogleGenerativeAIProviderSettings,
+  GoogleVertexProviderSettings,
+  GroqProviderSettings,
+  MistralProviderSettings,
+  OllamaProviderSettings,
+  OpenAICompatibleProviderSettings,
+  OpenAIProviderSettings,
+  OpenRouterProviderSettings,
+  PerplexityProviderSettings,
+  ProviderId,
+  ProviderSettingsMap,
+  QwenProviderSettings,
+  ReplicateProviderSettings,
+  TogetherAIProviderSettings,
+  VercelProviderSettings,
+  XaiProviderSettings,
+  ZhipuProviderSettings
+} from '../providers/registry'
--- a/packages/aiCore/src/index.ts
+++ b/packages/aiCore/src/index.ts
@@ -0,0 +1,214 @@
+/**
+ * Cherry Studio AI Core Package
+ * 基于 Vercel AI SDK 的统一 AI Provider 接口
+ */
+
+// 导入内部使用的类和函数
+import { ApiClientFactory } from './clients/ApiClientFactory'
+import { createClient } from './clients/PluginEnabledAiClient'
+import { type ProviderSettingsMap } from './clients/types'
+import { createUniversalClient } from './clients/UniversalAiSdkClient'
+import { aiProviderRegistry, isProviderSupported } from './providers/registry'
+
+// ==================== 主要客户端接口 ====================
+// 默认使用集成插件系统的客户端
+export {
+  PluginEnabledAiClient as AiClient,
+  createClient,
+  createCompatibleClient
+} from './clients/PluginEnabledAiClient'
+
+// 为了向后兼容，也导出原名称
+export { PluginEnabledAiClient } from './clients/PluginEnabledAiClient'
+
+// ==================== 插件系统 ====================
+export type { AiPlugin, AiRequestContext, HookResult, HookType, PluginManagerConfig } from './plugins'
+export { createContext, definePlugin, PluginManager } from './plugins'
+
+// ==================== 底层客户端（高级用法） ====================
+// 不带插件系统的基础客户端，用于需要绕过插件系统的场景
+export {
+  createOpenAICompatibleClient as createBasicOpenAICompatibleClient,
+  createUniversalClient,
+  UniversalAiSdkClient
+} from './clients/UniversalAiSdkClient'
+
+// ==================== 低级 API ====================
+export { ApiClientFactory } from './clients/ApiClientFactory'
+export { aiProviderRegistry } from './providers/registry'
+
+// ==================== 类型定义 ====================
+export type { ClientFactoryError } from './clients/ApiClientFactory'
+export type {
+  GenerateObjectParams,
+  GenerateTextParams,
+  ProviderSettings,
+  StreamObjectParams,
+  StreamTextParams
+} from './clients/types'
+export type { ProviderConfig } from './providers/registry'
+export type { ProviderError } from './providers/types'
+export * as aiSdk from 'ai'
+
+// ==================== AI SDK 常用类型导出 ====================
+// 直接导出 AI SDK 的常用类型，方便使用
+export type {
+  CoreAssistantMessage,
+  // 消息相关类型
+  CoreMessage,
+  CoreSystemMessage,
+  CoreToolMessage,
+  CoreUserMessage,
+  // 通用类型
+  FinishReason,
+  GenerateObjectResult,
+  // 生成相关类型
+  GenerateTextResult,
+  InvalidToolArgumentsError,
+  LanguageModelUsage, // AI SDK 4.0 中 TokenUsage 改名为 LanguageModelUsage
+  LanguageModelV1Middleware,
+  LanguageModelV1StreamPart,
+  // 错误类型
+  NoSuchToolError,
+  StreamTextResult,
+  // 流相关类型
+  TextStreamPart,
+  // 工具相关类型
+  Tool,
+  ToolCall,
+  ToolExecutionError,
+  ToolResult
+} from 'ai'
+export { defaultSettingsMiddleware, extractReasoningMiddleware, simulateStreamingMiddleware, smoothStream } from 'ai'
+
+// 重新导出所有 Provider Settings 类型
+export type {
+  AmazonBedrockProviderSettings,
+  AnthropicProviderSettings,
+  AnthropicVertexProviderSettings,
+  AzureOpenAIProviderSettings,
+  CerebrasProviderSettings,
+  CohereProviderSettings,
+  DeepInfraProviderSettings,
+  DeepSeekProviderSettings,
+  FalProviderSettings,
+  FireworksProviderSettings,
+  GoogleGenerativeAIProviderSettings,
+  GoogleVertexProviderSettings,
+  GroqProviderSettings,
+  MistralProviderSettings,
+  OllamaProviderSettings,
+  OpenAICompatibleProviderSettings,
+  OpenAIProviderSettings,
+  OpenRouterProviderSettings,
+  PerplexityProviderSettings,
+  ProviderId,
+  ProviderSettingsMap,
+  QwenProviderSettings,
+  ReplicateProviderSettings,
+  TogetherAIProviderSettings,
+  VercelProviderSettings,
+  XaiProviderSettings,
+  ZhipuProviderSettings
+} from './clients/types'
+
+// ==================== 工具函数 ====================
+export { createClient as createApiClient, getClientInfo, getSupportedProviders } from './clients/ApiClientFactory'
+export { getAllProviders, getProvider, isProviderSupported, registerProvider } from './providers/registry'
+
+// ==================== 包信息 ====================
+export const AI_CORE_VERSION = '1.0.0'
+export const AI_CORE_NAME = '@cherrystudio/ai-core'
+
+// ==================== 便捷 API ====================
+// 主要的便捷工厂类
+export const AiCore = {
+  version: AI_CORE_VERSION,
+  name: AI_CORE_NAME,
+
+  // 创建主要客户端（默认带插件系统）
+  create(providerId: string, options: any = {}, plugins: any[] = []) {
+    return createClient(providerId, options, plugins)
+  },
+
+  // 创建基础客户端（不带插件系统）
+  createBasic(providerId: string, options: any = {}) {
+    return createUniversalClient(providerId, options)
+  },
+
+  // 获取支持的providers
+  getSupportedProviders() {
+    return ApiClientFactory.getSupportedProviders()
+  },
+
+  // 检查provider支持
+  isSupported(providerId: string) {
+    return isProviderSupported(providerId)
+  },
+
+  // 获取客户端信息
+  getClientInfo(providerId: string) {
+    return ApiClientFactory.getClientInfo(providerId)
+  }
+}
+
+export const createOpenAIClient = (options: ProviderSettingsMap['openai'], plugins?: any[]) => {
+  return createClient('openai', options, plugins)
+}
+
+export const createAnthropicClient = (options: ProviderSettingsMap['anthropic'], plugins?: any[]) => {
+  return createClient('anthropic', options, plugins)
+}
+
+export const createGoogleClient = (options: ProviderSettingsMap['google'], plugins?: any[]) => {
+  return createClient('google', options, plugins)
+}
+
+export const createXAIClient = (options: ProviderSettingsMap['xai'], plugins?: any[]) => {
+  return createClient('xai', options, plugins)
+}
+
+// ==================== 调试和开发工具 ====================
+export const DevTools = {
+  // 列出所有注册的providers
+  listProviders() {
+    return aiProviderRegistry.getAllProviders().map((p) => ({
+      id: p.id,
+      name: p.name
+    }))
+  },
+
+  // 测试provider连接
+  async testProvider(providerId: string, options: any) {
+    try {
+      const client = createClient(providerId, options)
+      const info = client.getClientInfo()
+      return {
+        success: true,
+        providerId: info.id,
+        name: info.name,
+        isSupported: info.isSupported
+      }
+    } catch (error) {
+      return {
+        success: false,
+        providerId,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }
+  },
+
+  // 获取provider详细信息
+  getProviderDetails() {
+    const providers = aiProviderRegistry.getAllProviders()
+
+    return {
+      supportedProviders: providers.length,
+      registeredProviders: providers.length,
+      providers: providers.map((p) => ({
+        id: p.id,
+        name: p.name
+      }))
+    }
+  }
+}
--- a/packages/aiCore/src/plugins/README.md
+++ b/packages/aiCore/src/plugins/README.md
@@ -0,0 +1,259 @@
+# AI Core 插件系统
+
+支持四种钩子类型：**First**、**Sequential**、**Parallel** 和 **Stream**。
+
+## 🎯 设计理念
+
+借鉴 Rollup/Vite 的成熟插件思想：
+
+- **语义清晰**：不同钩子有不同的执行语义
+- **类型安全**：TypeScript 完整支持
+- **性能优化**：First 短路、Parallel 并发、Sequential 链式
+- **易于扩展**：`enforce` 排序 + 功能分类
+
+## 📋 钩子类型
+
+### 🥇 First 钩子 - 首个有效结果
+
+```typescript
+// 只执行第一个返回值的插件，用于解析和查找
+resolveModel?: (modelId: string, context: AiRequestContext) => string | null
+loadTemplate?: (templateName: string, context: AiRequestContext) => any | null
+```
+
+### 🔄 Sequential 钩子 - 链式数据转换
+
+```typescript
+// 按顺序链式执行，每个插件可以修改数据
+transformParams?: (params: any, context: AiRequestContext) => any
+transformResult?: (result: any, context: AiRequestContext) => any
+```
+
+### ⚡ Parallel 钩子 - 并行副作用
+
+```typescript
+// 并发执行，用于日志、监控等副作用
+onRequestStart?: (context: AiRequestContext) => void
+onRequestEnd?: (context: AiRequestContext, result: any) => void
+onError?: (error: Error, context: AiRequestContext) => void
+```
+
+### 🌊 Stream 钩子 - 流处理
+
+```typescript
+// 直接使用 AI SDK 的 TransformStream
+transformStream?: () => (options) => TransformStream<TextStreamPart, TextStreamPart>
+```
+
+## 🚀 快速开始
+
+### 基础用法
+
+```typescript
+import { PluginManager, createContext, definePlugin } from '@cherrystudio/ai-core/middleware'
+
+// 创建插件管理器
+const pluginManager = new PluginManager()
+
+// 添加插件
+pluginManager.use({
+  name: 'my-plugin',
+  async transformParams(params, context) {
+    return { ...params, temperature: 0.7 }
+  }
+})
+
+// 使用插件
+const context = createContext('openai', 'gpt-4', { messages: [] })
+const transformedParams = await pluginManager.executeSequential(
+  'transformParams',
+  { messages: [{ role: 'user', content: 'Hello' }] },
+  context
+)
+```
+
+### 完整示例
+
+```typescript
+import {
+  PluginManager,
+  ModelAliasPlugin,
+  LoggingPlugin,
+  ParamsValidationPlugin,
+  createContext
+} from '@cherrystudio/ai-core/middleware'
+
+// 创建插件管理器
+const manager = new PluginManager([
+  ModelAliasPlugin, // 模型别名解析
+  ParamsValidationPlugin, // 参数验证
+  LoggingPlugin // 日志记录
+])
+
+// AI 请求流程
+async function aiRequest(providerId: string, modelId: string, params: any) {
+  const context = createContext(providerId, modelId, params)
+
+  try {
+    // 1. 【并行】触发请求开始事件
+    await manager.executeParallel('onRequestStart', context)
+
+    // 2. 【首个】解析模型别名
+    const resolvedModel = await manager.executeFirst('resolveModel', modelId, context)
+    context.modelId = resolvedModel || modelId
+
+    // 3. 【串行】转换请求参数
+    const transformedParams = await manager.executeSequential('transformParams', params, context)
+
+    // 4. 【流处理】收集流转换器（AI SDK 原生支持数组）
+    const streamTransforms = manager.collectStreamTransforms()
+
+    // 5. 调用 AI SDK（这里省略具体实现）
+    const result = await callAiSdk(transformedParams, streamTransforms)
+
+    // 6. 【串行】转换响应结果
+    const transformedResult = await manager.executeSequential('transformResult', result, context)
+
+    // 7. 【并行】触发请求完成事件
+    await manager.executeParallel('onRequestEnd', context, transformedResult)
+
+    return transformedResult
+  } catch (error) {
+    // 8. 【并行】触发错误事件
+    await manager.executeParallel('onError', context, undefined, error)
+    throw error
+  }
+}
+```
+
+## 🔧 自定义插件
+
+### 模型别名插件
+
+```typescript
+const ModelAliasPlugin = definePlugin({
+  name: 'model-alias',
+  enforce: 'pre', // 最先执行
+
+  async resolveModel(modelId) {
+    const aliases = {
+      gpt4: 'gpt-4-turbo-preview',
+      claude: 'claude-3-sonnet-20240229'
+    }
+    return aliases[modelId] || null
+  }
+})
+```
+
+### 参数验证插件
+
+```typescript
+const ValidationPlugin = definePlugin({
+  name: 'validation',
+
+  async transformParams(params) {
+    if (!params.messages) {
+      throw new Error('messages is required')
+    }
+
+    return {
+      ...params,
+      temperature: params.temperature ?? 0.7,
+      max_tokens: params.max_tokens ?? 4096
+    }
+  }
+})
+```
+
+### 监控插件
+
+```typescript
+const MonitoringPlugin = definePlugin({
+  name: 'monitoring',
+  enforce: 'post', // 最后执行
+
+  async onRequestEnd(context, result) {
+    const duration = Date.now() - context.startTime
+    console.log(`请求耗时: ${duration}ms`)
+  }
+})
+```
+
+### 内容过滤插件
+
+```typescript
+const FilterPlugin = definePlugin({
+  name: 'content-filter',
+
+  transformStream() {
+    return () =>
+      new TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type === 'text-delta') {
+            const filtered = chunk.textDelta.replace(/敏感词/g, '***')
+            controller.enqueue({ ...chunk, textDelta: filtered })
+          } else {
+            controller.enqueue(chunk)
+          }
+        }
+      })
+  }
+})
+```
+
+## 📊 执行顺序
+
+### 插件排序
+
+```
+enforce: 'pre' → normal → enforce: 'post'
+```
+
+### 钩子执行流程
+
+```mermaid
+graph TD
+    A[请求开始] --> B[onRequestStart 并行执行]
+    B --> C[resolveModel 首个有效]
+    C --> D[loadTemplate 首个有效]
+    D --> E[transformParams 串行执行]
+    E --> F[collectStreamTransforms]
+    F --> G[AI SDK 调用]
+    G --> H[transformResult 串行执行]
+    H --> I[onRequestEnd 并行执行]
+
+    G --> J[异常处理]
+    J --> K[onError 并行执行]
+```
+
+## 💡 最佳实践
+
+1. **功能单一**：每个插件专注一个功能
+2. **幂等性**：插件应该是幂等的，重复执行不会产生副作用
+3. **错误处理**：插件内部处理异常，不要让异常向上传播
+4. **性能优化**：使用合适的钩子类型（First vs Sequential vs Parallel）
+5. **命名规范**：使用语义化的插件名称
+
+## 🔍 调试工具
+
+```typescript
+// 查看插件统计信息
+const stats = manager.getStats()
+console.log('插件统计:', stats)
+
+// 查看所有插件
+const plugins = manager.getPlugins()
+console.log(
+  '已注册插件:',
+  plugins.map((p) => p.name)
+)
+```
+
+## ⚡ 性能优势
+
+- **First 钩子**：一旦找到结果立即停止，避免无效计算
+- **Parallel 钩子**：真正并发执行，不阻塞主流程
+- **Sequential 钩子**：保证数据转换的顺序性
+- **Stream 钩子**：直接集成 AI SDK，零开销
+
+这个设计兼顾了简洁性和强大功能，为 AI Core 提供了灵活而高效的扩展机制。
--- a/packages/aiCore/src/plugins/examples/example-plugins.ts
+++ b/packages/aiCore/src/plugins/examples/example-plugins.ts
@@ -0,0 +1,192 @@
+import type { AiPlugin } from '../types'
+
+/**
+ * 【First 钩子示例】模型别名解析插件
+ */
+export const ModelAliasPlugin: AiPlugin = {
+  name: 'model-alias',
+  enforce: 'pre',
+
+  async resolveModel(modelId) {
+    const aliases: Record<string, string> = {
+      gpt4: 'gpt-4-turbo-preview',
+      claude: 'claude-3-sonnet-20240229',
+      gemini: 'gemini-pro'
+    }
+
+    return aliases[modelId] || null
+  }
+}
+
+/**
+ * 【Sequential 钩子示例】参数验证和转换插件
+ */
+export const ParamsValidationPlugin: AiPlugin = {
+  name: 'params-validation',
+
+  async transformParams(params) {
+    // 参数验证
+    if (!params.messages || !Array.isArray(params.messages)) {
+      throw new Error('Invalid messages parameter')
+    }
+
+    // 参数转换：添加默认配置
+    return {
+      ...params,
+      temperature: params.temperature ?? 0.7,
+      max_tokens: params.max_tokens ?? 4096,
+      stream: params.stream ?? true
+    }
+  },
+
+  async transformResult(result, context) {
+    // 结果后处理：添加元数据
+    return {
+      ...result,
+      metadata: {
+        ...result.metadata,
+        processedAt: new Date().toISOString(),
+        provider: context.providerId,
+        model: context.modelId
+      }
+    }
+  }
+}
+
+/**
+ * 【Parallel 钩子示例】日志记录插件
+ */
+export const LoggingPlugin: AiPlugin = {
+  name: 'logging',
+
+  async onRequestStart(context) {
+    console.log(`🚀 AI请求开始: ${context.providerId}/${context.modelId}`, {
+      requestId: context.requestId,
+      timestamp: new Date().toISOString()
+    })
+  },
+
+  async onRequestEnd(context, result) {
+    const duration = Date.now() - context.startTime
+    console.log(`✅ AI请求完成: ${context.requestId} (${duration}ms)`, {
+      provider: context.providerId,
+      model: context.modelId,
+      hasResult: !!result
+    })
+  },
+
+  async onError(error, context) {
+    const duration = Date.now() - context.startTime
+    console.error(`❌ AI请求失败: ${context.requestId} (${duration}ms)`, {
+      provider: context.providerId,
+      model: context.modelId,
+      error: error.message,
+      stack: error.stack
+    })
+  }
+}
+
+/**
+ * 【Parallel 钩子示例】性能监控插件
+ */
+export const PerformancePlugin: AiPlugin = {
+  name: 'performance',
+  enforce: 'post',
+
+  async onRequestEnd(context) {
+    const duration = Date.now() - context.startTime
+
+    // 记录性能指标
+    const metrics = {
+      requestId: context.requestId,
+      provider: context.providerId,
+      model: context.modelId,
+      duration,
+      timestamp: context.startTime,
+      success: true
+    }
+
+    // 发送到监控系统（这里只是示例）
+    // await sendMetrics(metrics)
+    console.log('📊 性能指标:', metrics)
+  },
+
+  async onError(error, context) {
+    const duration = Date.now() - context.startTime
+
+    const metrics = {
+      requestId: context.requestId,
+      provider: context.providerId,
+      model: context.modelId,
+      duration,
+      timestamp: context.startTime,
+      success: false,
+      errorType: error.constructor.name
+    }
+
+    console.log('📊 错误指标:', metrics)
+  }
+}
+
+/**
+ * 【Stream 钩子示例】内容过滤插件
+ */
+export const ContentFilterPlugin: AiPlugin = {
+  name: 'content-filter',
+
+  transformStream() {
+    return () =>
+      new TransformStream({
+        transform(chunk, controller) {
+          // 过滤敏感内容
+          if (chunk.type === 'text-delta') {
+            const filtered = chunk.textDelta.replace(/\b(敏感词|违禁词)\b/g, '***')
+            controller.enqueue({
+              ...chunk,
+              textDelta: filtered
+            })
+          } else {
+            controller.enqueue(chunk)
+          }
+        }
+      })
+  }
+}
+
+/**
+ * 【First 钩子示例】模板加载插件
+ */
+export const TemplatePlugin: AiPlugin = {
+  name: 'template-loader',
+
+  async loadTemplate(templateName) {
+    const templates: Record<string, any> = {
+      chat: {
+        systemPrompt: '你是一个有用的AI助手',
+        temperature: 0.7
+      },
+      coding: {
+        systemPrompt: '你是一个专业的编程助手，请提供清晰、高质量的代码',
+        temperature: 0.3
+      },
+      creative: {
+        systemPrompt: '你是一个创意写作助手，请发挥想象力',
+        temperature: 0.9
+      }
+    }
+
+    return templates[templateName] || null
+  }
+}
+
+/**
+ * 示例插件组合
+ */
+export const defaultPlugins: AiPlugin[] = [
+  ModelAliasPlugin,
+  TemplatePlugin,
+  ParamsValidationPlugin,
+  LoggingPlugin,
+  PerformancePlugin,
+  ContentFilterPlugin
+]
--- a/packages/aiCore/src/plugins/examples/example-usage.ts
+++ b/packages/aiCore/src/plugins/examples/example-usage.ts
@@ -0,0 +1,255 @@
+import { openai } from '@ai-sdk/openai'
+import { streamText } from 'ai'
+
+import { PluginEnabledAiClient } from '../../clients/PluginEnabledAiClient'
+import { createContext, PluginManager } from '../'
+import { ContentFilterPlugin, LoggingPlugin } from './example-plugins'
+
+/**
+ * 使用 PluginEnabledAiClient 的推荐方式
+ * 这是最简单直接的使用方法
+ */
+export async function exampleWithPluginEnabledClient() {
+  console.log('=== 使用 PluginEnabledAiClient 示例 ===')
+
+  // 1. 创建带插件的客户端 - 链式调用方式
+  const client = PluginEnabledAiClient.create('openai-compatible', {
+    name: 'openai',
+    baseURL: 'https://api.openai.com/v1',
+    apiKey: process.env.OPENAI_API_KEY || 'sk-test'
+  })
+    .use(LoggingPlugin)
+    .use(ContentFilterPlugin)
+
+  // 2. 或者在创建时传入插件（也可以这样使用）
+  // const clientWithPlugins = PluginEnabledAiClient.create(
+  //   'openai-compatible',
+  //   {
+  //     name: 'openai',
+  //     baseURL: 'https://api.openai.com/v1',
+  //     apiKey: process.env.OPENAI_API_KEY || 'sk-test'
+  //   },
+  //   [LoggingPlugin, ContentFilterPlugin]
+  // )
+
+  // 3. 查看插件统计信息
+  console.log('插件统计:', client.getPluginStats())
+
+  try {
+    // 4. 使用客户端进行 AI 调用（插件会自动生效）
+    console.log('开始生成文本...')
+    const result = await client.generateText('gpt-4', {
+      messages: [{ role: 'user', content: 'Hello, world!' }],
+      temperature: 0.7
+    })
+
+    console.log('生成的文本:', result.text)
+
+    // 5. 流式调用（支持流转换器）
+    console.log('开始流式生成...')
+    const streamResult = await client.streamText('gpt-4', {
+      messages: [{ role: 'user', content: 'Tell me a short story about AI' }]
+    })
+
+    console.log('开始流式响应...')
+    for await (const textPart of streamResult.textStream) {
+      process.stdout.write(textPart)
+    }
+    console.log('\n流式响应完成')
+
+    return result
+  } catch (error) {
+    console.error('调用失败:', error)
+    throw error
+  }
+}
+
+/**
+ * 创建 OpenAI Compatible 客户端的示例
+ */
+export function exampleOpenAICompatible() {
+  console.log('=== OpenAI Compatible 示例 ===')
+
+  // Ollama 示例
+  const ollama = PluginEnabledAiClient.createOpenAICompatible(
+    {
+      name: 'ollama',
+      baseURL: 'http://localhost:11434/v1'
+    },
+    [LoggingPlugin]
+  )
+
+  // LM Studio 示例
+  const lmStudio = PluginEnabledAiClient.createOpenAICompatible({
+    name: 'lm-studio',
+    baseURL: 'http://localhost:1234/v1'
+  }).use(ContentFilterPlugin)
+
+  console.log('Ollama 插件统计:', ollama.getPluginStats())
+  console.log('LM Studio 插件统计:', lmStudio.getPluginStats())
+
+  return { ollama, lmStudio }
+}
+
+/**
+ * 动态插件管理示例
+ */
+export function exampleDynamicPlugins() {
+  console.log('=== 动态插件管理示例 ===')
+
+  const client = PluginEnabledAiClient.create('openai-compatible', {
+    name: 'openai',
+    baseURL: 'https://api.openai.com/v1',
+    apiKey: 'your-api-key'
+  })
+
+  console.log('初始状态:', client.getPluginStats())
+
+  // 动态添加插件
+  client.use(LoggingPlugin)
+  console.log('添加 LoggingPlugin 后:', client.getPluginStats())
+
+  client.usePlugins([ContentFilterPlugin])
+  console.log('添加 ContentFilterPlugin 后:', client.getPluginStats())
+
+  // 移除插件
+  client.removePlugin('content-filter')
+  console.log('移除 content-filter 后:', client.getPluginStats())
+
+  return client
+}
+
+/**
+ * 完整的低级 API 示例（原有的 example-usage.ts 的方式）
+ * 这种方式适合需要精细控制插件生命周期的场景
+ */
+export async function exampleLowLevelApi() {
+  console.log('=== 低级 API 示例 ===')
+
+  // 1. 创建插件管理器
+  const pluginManager = new PluginManager([LoggingPlugin, ContentFilterPlugin])
+
+  // 2. 创建请求上下文
+  const context = createContext('openai', 'gpt-4', {
+    messages: [{ role: 'user', content: 'Hello!' }]
+  })
+
+  try {
+    // 3. 触发请求开始事件
+    await pluginManager.executeParallel('onRequestStart', context)
+
+    // 4. 解析模型别名
+    const resolvedModel = await pluginManager.executeFirst('resolveModel', 'gpt-4', context)
+    console.log('Resolved model:', resolvedModel || 'gpt-4')
+
+    // 5. 转换请求参数
+    const params = {
+      messages: [{ role: 'user' as const, content: 'Hello, AI!' }],
+      temperature: 0.7
+    }
+    const transformedParams = await pluginManager.executeSequential('transformParams', params, context)
+
+    // 6. 收集流转换器（关键：AI SDK 原生支持数组！）
+    const streamTransforms = pluginManager.collectStreamTransforms()
+
+    // 7. 调用 AI SDK，直接传入转换器工厂数组
+    const result = await streamText({
+      model: openai('gpt-4'),
+      ...transformedParams,
+      experimental_transform: streamTransforms // 直接传入工厂函数数组
+    })
+
+    // 8. 处理结果
+    let fullText = ''
+    for await (const textPart of result.textStream) {
+      fullText += textPart
+      console.log('Streaming:', textPart)
+    }
+
+    // 9. 转换最终结果
+    const finalResult = { text: fullText, usage: await result.usage }
+    const transformedResult = await pluginManager.executeSequential('transformResult', finalResult, context)
+
+    // 10. 触发完成事件
+    await pluginManager.executeParallel('onRequestEnd', context, transformedResult)
+
+    return transformedResult
+  } catch (error) {
+    // 11. 触发错误事件
+    await pluginManager.executeParallel('onError', context, undefined, error as Error)
+    throw error
+  }
+}
+
+/**
+ * 流转换器数组的其他使用方式
+ */
+export function demonstrateStreamTransforms() {
+  console.log('=== 流转换器示例 ===')
+
+  const pluginManager = new PluginManager([
+    ContentFilterPlugin,
+    {
+      name: 'text-replacer',
+      transformStream() {
+        return () =>
+          new TransformStream({
+            transform(chunk, controller) {
+              if (chunk.type === 'text-delta') {
+                const replaced = chunk.textDelta.replace(/hello/gi, 'hi')
+                controller.enqueue({ ...chunk, textDelta: replaced })
+              } else {
+                controller.enqueue(chunk)
+              }
+            }
+          })
+      }
+    }
+  ])
+
+  // 获取所有流转换器
+  const transforms = pluginManager.collectStreamTransforms()
+  console.log(`收集到 ${transforms.length} 个流转换器`)
+
+  // 可以单独使用每个转换器
+  transforms.forEach((factory, index) => {
+    console.log(`转换器 ${index + 1} 已准备就绪`)
+    const transform = factory({ stopStream: () => {} })
+    console.log('Transform created:', transform)
+  })
+
+  return transforms
+}
+
+/**
+ * 运行所有示例
+ */
+export async function runAllExamples() {
+  console.log('🚀 开始运行所有示例...\n')
+
+  try {
+    // 1. PluginEnabledAiClient 示例（推荐）
+    await exampleWithPluginEnabledClient()
+    console.log('✅ PluginEnabledAiClient 示例完成\n')
+
+    // 2. OpenAI Compatible 示例
+    exampleOpenAICompatible()
+    console.log('✅ OpenAI Compatible 示例完成\n')
+
+    // 3. 动态插件管理示例
+    exampleDynamicPlugins()
+    console.log('✅ 动态插件管理示例完成\n')
+
+    // 4. 流转换器示例
+    demonstrateStreamTransforms()
+    console.log('✅ 流转换器示例完成\n')
+
+    // 5. 低级 API 示例
+    // await exampleLowLevelApi()
+    console.log('✅ 低级 API 示例完成\n')
+
+    console.log('🎉 所有示例运行完成！')
+  } catch (error) {
+    console.error('❌ 示例运行失败:', error)
+  }
+}
--- a/packages/aiCore/src/plugins/index.ts
+++ b/packages/aiCore/src/plugins/index.ts
@@ -0,0 +1,23 @@
+// 核心类型和接口
+export type { AiPlugin, AiRequestContext, HookResult, HookType, PluginManagerConfig } from './types'
+import type { AiPlugin, AiRequestContext } from './types'
+
+// 插件管理器
+export { PluginManager } from './manager'
+
+// 工具函数
+export function createContext(providerId: string, modelId: string, originalParams: any): AiRequestContext {
+  return {
+    providerId,
+    modelId,
+    originalParams,
+    metadata: {},
+    startTime: Date.now(),
+    requestId: `${providerId}-${modelId}-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  }
+}
+
+// 插件构建器 - 便于创建插件
+export function definePlugin(plugin: AiPlugin): AiPlugin {
+  return plugin
+}
--- a/packages/aiCore/src/plugins/manager.ts
+++ b/packages/aiCore/src/plugins/manager.ts
@@ -0,0 +1,189 @@
+import type { LanguageModelV1Middleware, TextStreamPart, ToolSet } from 'ai'
+
+import { AiPlugin, AiRequestContext } from './types'
+
+/**
+ * 插件管理器 - 基于 Rollup 钩子分类设计
+ */
+export class PluginManager {
+  private plugins: AiPlugin[] = []
+
+  constructor(plugins: AiPlugin[] = []) {
+    this.plugins = this.sortPlugins(plugins)
+  }
+
+  /**
+   * 添加插件
+   */
+  use(plugin: AiPlugin): this {
+    this.plugins = this.sortPlugins([...this.plugins, plugin])
+    return this
+  }
+
+  /**
+   * 移除插件
+   */
+  remove(pluginName: string): this {
+    this.plugins = this.plugins.filter((p) => p.name !== pluginName)
+    return this
+  }
+
+  /**
+   * 插件排序：pre -> normal -> post
+   */
+  private sortPlugins(plugins: AiPlugin[]): AiPlugin[] {
+    const pre: AiPlugin[] = []
+    const normal: AiPlugin[] = []
+    const post: AiPlugin[] = []
+
+    plugins.forEach((plugin) => {
+      if (plugin.enforce === 'pre') {
+        pre.push(plugin)
+      } else if (plugin.enforce === 'post') {
+        post.push(plugin)
+      } else {
+        normal.push(plugin)
+      }
+    })
+
+    return [...pre, ...normal, ...post]
+  }
+
+  /**
+   * 执行 First 钩子 - 返回第一个有效结果
+   */
+  async executeFirst<T>(
+    hookName: 'resolveModel' | 'loadTemplate',
+    arg: string,
+    context: AiRequestContext
+  ): Promise<T | null> {
+    for (const plugin of this.plugins) {
+      const hook = plugin[hookName]
+      if (hook) {
+        const result = await hook(arg, context)
+        if (result !== null && result !== undefined) {
+          return result as T
+        }
+      }
+    }
+    return null
+  }
+
+  /**
+   * 执行 Sequential 钩子 - 链式数据转换
+   */
+  async executeSequential<T>(
+    hookName: 'transformParams' | 'transformResult',
+    initialValue: T,
+    context: AiRequestContext
+  ): Promise<T> {
+    let result = initialValue
+
+    for (const plugin of this.plugins) {
+      const hook = plugin[hookName]
+      if (hook) {
+        result = await hook(result, context)
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * 执行 Parallel 钩子 - 并行副作用
+   */
+  async executeParallel(
+    hookName: 'onRequestStart' | 'onRequestEnd' | 'onError',
+    context: AiRequestContext,
+    result?: any,
+    error?: Error
+  ): Promise<void> {
+    const promises = this.plugins
+      .map((plugin) => {
+        const hook = plugin[hookName]
+        if (!hook) return null
+
+        if (hookName === 'onError' && error) {
+          return (hook as any)(error, context)
+        } else if (hookName === 'onRequestEnd' && result !== undefined) {
+          return (hook as any)(context, result)
+        } else if (hookName === 'onRequestStart') {
+          return (hook as any)(context)
+        }
+        return null
+      })
+      .filter(Boolean)
+
+    // 使用 Promise.all 而不是 allSettled，让插件错误能够抛出
+    await Promise.all(promises)
+  }
+
+  /**
+   * 收集所有流转换器（返回数组，AI SDK 原生支持）
+   */
+  collectStreamTransforms<TOOLS extends ToolSet>(): Array<
+    (options: {
+      tools?: TOOLS
+      stopStream: () => void
+    }) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>
+  > {
+    return this.plugins.map((plugin) => plugin.transformStream?.()).filter(Boolean) as Array<
+      (options: {
+        tools?: TOOLS
+        stopStream: () => void
+      }) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>
+    >
+  }
+
+  /**
+   * 收集所有 AI SDK 原生中间件
+   */
+  collectAiSdkMiddlewares(): LanguageModelV1Middleware[] {
+    return this.plugins.flatMap((plugin) => plugin.aiSdkMiddlewares || [])
+  }
+
+  /**
+   * 获取所有插件信息
+   */
+  getPlugins(): AiPlugin[] {
+    return [...this.plugins]
+  }
+
+  /**
+   * 获取插件统计信息
+   */
+  getStats() {
+    const stats = {
+      total: this.plugins.length,
+      pre: 0,
+      normal: 0,
+      post: 0,
+      hooks: {
+        resolveModel: 0,
+        loadTemplate: 0,
+        transformParams: 0,
+        transformResult: 0,
+        onRequestStart: 0,
+        onRequestEnd: 0,
+        onError: 0,
+        transformStream: 0
+      }
+    }
+
+    this.plugins.forEach((plugin) => {
+      // 统计 enforce 类型
+      if (plugin.enforce === 'pre') stats.pre++
+      else if (plugin.enforce === 'post') stats.post++
+      else stats.normal++
+
+      // 统计钩子数量
+      Object.keys(stats.hooks).forEach((hookName) => {
+        if (plugin[hookName as keyof AiPlugin]) {
+          stats.hooks[hookName as keyof typeof stats.hooks]++
+        }
+      })
+    })
+
+    return stats
+  }
+}
--- a/packages/aiCore/src/plugins/types.ts
+++ b/packages/aiCore/src/plugins/types.ts
@@ -0,0 +1,87 @@
+import type { LanguageModelV1Middleware, TextStreamPart, ToolSet } from 'ai'
+
+/**
+ * 生命周期阶段定义
+ */
+export enum LifecycleStage {
+  PRE_REQUEST = 'pre-request', // 请求预处理
+  REQUEST_EXECUTION = 'execution', // 请求执行
+  STREAM_PROCESSING = 'stream', // 流式处理（仅流模式）
+  POST_RESPONSE = 'post-response', // 响应后处理
+  ERROR_HANDLING = 'error' // 错误处理
+}
+
+/**
+ * 生命周期上下文
+ */
+export interface LifecycleContext {
+  currentStage: LifecycleStage
+  startTime: number
+  stageStartTime: number
+  completedStages: Set<LifecycleStage>
+  stageDurations: Map<LifecycleStage, number>
+  metadata: Record<string, any>
+}
+
+/**
+ * AI 请求上下文
+ */
+export interface AiRequestContext {
+  providerId: string
+  modelId: string
+  originalParams: any
+  metadata: Record<string, any>
+  startTime: number
+  requestId: string
+}
+
+/**
+ * 借鉴 Rollup 的钩子分类设计
+ */
+export interface AiPlugin {
+  name: string
+  enforce?: 'pre' | 'post'
+
+  // 【First】首个钩子 - 只执行第一个返回值的插件
+  resolveModel?: (modelId: string, context: AiRequestContext) => string | null | Promise<string | null>
+  loadTemplate?: (templateName: string, context: AiRequestContext) => any | null | Promise<any | null>
+
+  // 【Sequential】串行钩子 - 链式执行，支持数据转换
+  transformParams?: (params: any, context: AiRequestContext) => any | Promise<any>
+  transformResult?: (result: any, context: AiRequestContext) => any | Promise<any>
+
+  // 【Parallel】并行钩子 - 不依赖顺序，用于副作用
+  onRequestStart?: (context: AiRequestContext) => void | Promise<void>
+  onRequestEnd?: (context: AiRequestContext, result: any) => void | Promise<void>
+  onError?: (error: Error, context: AiRequestContext) => void | Promise<void>
+
+  // 【Stream】流处理 - 直接使用 AI SDK
+  transformStream?: <TOOLS extends ToolSet>() => (options: {
+    tools?: TOOLS
+    stopStream: () => void
+  }) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>
+
+  // AI SDK 原生中间件
+  aiSdkMiddlewares?: LanguageModelV1Middleware[]
+}
+
+/**
+ * 插件管理器配置
+ */
+export interface PluginManagerConfig {
+  plugins: AiPlugin[]
+  context: Partial<AiRequestContext>
+}
+
+/**
+ * 钩子执行器类型
+ */
+export type HookType = 'first' | 'sequential' | 'parallel' | 'stream'
+
+/**
+ * 钩子执行结果
+ */
+export interface HookResult<T = any> {
+  value: T
+  stop?: boolean
+}
--- a/packages/aiCore/src/providers/registry.ts
+++ b/packages/aiCore/src/providers/registry.ts
@@ -0,0 +1,376 @@
+/**
+ * AI Provider 注册表
+ * 静态类型 + 动态导入模式：所有类型静态导入，所有实现动态导入
+ */
+
+// 静态导入所有 AI SDK 类型
+import { type AmazonBedrockProviderSettings } from '@ai-sdk/amazon-bedrock'
+import { type AnthropicProviderSettings } from '@ai-sdk/anthropic'
+import { type AzureOpenAIProviderSettings } from '@ai-sdk/azure'
+import { type CerebrasProviderSettings } from '@ai-sdk/cerebras'
+import { type CohereProviderSettings } from '@ai-sdk/cohere'
+import { type DeepInfraProviderSettings } from '@ai-sdk/deepinfra'
+import { type DeepSeekProviderSettings } from '@ai-sdk/deepseek'
+import { type FalProviderSettings } from '@ai-sdk/fal'
+import { type FireworksProviderSettings } from '@ai-sdk/fireworks'
+import { type GoogleGenerativeAIProviderSettings } from '@ai-sdk/google'
+import { type GoogleVertexProviderSettings } from '@ai-sdk/google-vertex'
+import { type GroqProviderSettings } from '@ai-sdk/groq'
+import { type MistralProviderSettings } from '@ai-sdk/mistral'
+import { type OpenAIProviderSettings } from '@ai-sdk/openai'
+import { type OpenAICompatibleProviderSettings } from '@ai-sdk/openai-compatible'
+import { type PerplexityProviderSettings } from '@ai-sdk/perplexity'
+import { type ReplicateProviderSettings } from '@ai-sdk/replicate'
+import { type TogetherAIProviderSettings } from '@ai-sdk/togetherai'
+import { type VercelProviderSettings } from '@ai-sdk/vercel'
+import { type XaiProviderSettings } from '@ai-sdk/xai'
+import { type OpenRouterProviderSettings } from '@openrouter/ai-sdk-provider'
+import { type AnthropicVertexProviderSettings } from 'anthropic-vertex-ai'
+import { type OllamaProviderSettings } from 'ollama-ai-provider'
+import { type QwenProviderSettings } from 'qwen-ai-provider'
+import { type ZhipuProviderSettings } from 'zhipu-ai-provider'
+
+// 类型安全的 Provider Settings 映射
+export type ProviderSettingsMap = {
+  openai: OpenAIProviderSettings
+  'openai-compatible': OpenAICompatibleProviderSettings
+  anthropic: AnthropicProviderSettings
+  google: GoogleGenerativeAIProviderSettings
+  'google-vertex': GoogleVertexProviderSettings
+  mistral: MistralProviderSettings
+  xai: XaiProviderSettings
+  azure: AzureOpenAIProviderSettings
+  bedrock: AmazonBedrockProviderSettings
+  cohere: CohereProviderSettings
+  groq: GroqProviderSettings
+  together: TogetherAIProviderSettings
+  fireworks: FireworksProviderSettings
+  deepseek: DeepSeekProviderSettings
+  cerebras: CerebrasProviderSettings
+  deepinfra: DeepInfraProviderSettings
+  replicate: ReplicateProviderSettings
+  perplexity: PerplexityProviderSettings
+  fal: FalProviderSettings
+  vercel: VercelProviderSettings
+  ollama: OllamaProviderSettings
+  qwen: QwenProviderSettings
+  zhipu: ZhipuProviderSettings
+  'anthropic-vertex': AnthropicVertexProviderSettings
+  openrouter: OpenRouterProviderSettings
+}
+
+export type ProviderId = keyof ProviderSettingsMap
+
+// 统一的 Provider 配置接口（所有都使用动态导入）
+export interface ProviderConfig {
+  id: string
+  name: string
+  // 动态导入函数
+  import: () => Promise<any>
+  // 创建函数名称
+  creatorFunctionName: string
+  // 是否支持图片生成
+  supportsImageGeneration?: boolean
+}
+
+/**
+ * AI SDK Provider 注册表
+ * 管理所有支持的 AI Providers 及其动态导入
+ */
+export class AiProviderRegistry {
+  private static instance: AiProviderRegistry
+  private registry = new Map<string, ProviderConfig>()
+
+  private constructor() {
+    this.initializeProviders()
+  }
+
+  public static getInstance(): AiProviderRegistry {
+    if (!AiProviderRegistry.instance) {
+      AiProviderRegistry.instance = new AiProviderRegistry()
+    }
+    return AiProviderRegistry.instance
+  }
+
+  /**
+   * 初始化所有支持的 Providers
+   * 基于 AI SDK 官方文档: https://ai-sdk.dev/providers/ai-sdk-providers
+   */
+  private initializeProviders(): void {
+    const providers: ProviderConfig[] = [
+      // 官方 AI SDK Providers (19个)
+      {
+        id: 'openai',
+        name: 'OpenAI',
+        import: () => import('@ai-sdk/openai'),
+        creatorFunctionName: 'createOpenAI',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'openai-compatible',
+        name: 'OpenAI Compatible',
+        import: () => import('@ai-sdk/openai-compatible'),
+        creatorFunctionName: 'createOpenAICompatible'
+      },
+      {
+        id: 'anthropic',
+        name: 'Anthropic',
+        import: () => import('@ai-sdk/anthropic'),
+        creatorFunctionName: 'createAnthropic',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'google',
+        name: 'Google Generative AI',
+        import: () => import('@ai-sdk/google'),
+        creatorFunctionName: 'createGoogleGenerativeAI',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'google-vertex',
+        name: 'Google Vertex AI',
+        import: () => import('@ai-sdk/google-vertex'),
+        creatorFunctionName: 'createVertex',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'mistral',
+        name: 'Mistral AI',
+        import: () => import('@ai-sdk/mistral'),
+        creatorFunctionName: 'createMistral',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'xai',
+        name: 'xAI (Grok)',
+        import: () => import('@ai-sdk/xai'),
+        creatorFunctionName: 'createXai',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'azure',
+        name: 'Azure OpenAI',
+        import: () => import('@ai-sdk/azure'),
+        creatorFunctionName: 'createAzure',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'bedrock',
+        name: 'Amazon Bedrock',
+        import: () => import('@ai-sdk/amazon-bedrock'),
+        creatorFunctionName: 'createAmazonBedrock',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'cohere',
+        name: 'Cohere',
+        import: () => import('@ai-sdk/cohere'),
+        creatorFunctionName: 'createCohere',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'groq',
+        name: 'Groq',
+        import: () => import('@ai-sdk/groq'),
+        creatorFunctionName: 'createGroq',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'together',
+        name: 'Together.ai',
+        import: () => import('@ai-sdk/togetherai'),
+        creatorFunctionName: 'createTogetherAI',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'fireworks',
+        name: 'Fireworks',
+        import: () => import('@ai-sdk/fireworks'),
+        creatorFunctionName: 'createFireworks',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'deepseek',
+        name: 'DeepSeek',
+        import: () => import('@ai-sdk/deepseek'),
+        creatorFunctionName: 'createDeepSeek',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'cerebras',
+        name: 'Cerebras',
+        import: () => import('@ai-sdk/cerebras'),
+        creatorFunctionName: 'createCerebras',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'deepinfra',
+        name: 'DeepInfra',
+        import: () => import('@ai-sdk/deepinfra'),
+        creatorFunctionName: 'createDeepInfra',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'replicate',
+        name: 'Replicate',
+        import: () => import('@ai-sdk/replicate'),
+        creatorFunctionName: 'createReplicate',
+        supportsImageGeneration: true
+      },
+      {
+        id: 'perplexity',
+        name: 'Perplexity',
+        import: () => import('@ai-sdk/perplexity'),
+        creatorFunctionName: 'createPerplexity',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'fal',
+        name: 'Fal AI',
+        import: () => import('@ai-sdk/fal'),
+        creatorFunctionName: 'createFal',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'vercel',
+        name: 'Vercel',
+        import: () => import('@ai-sdk/vercel'),
+        creatorFunctionName: 'createVercel'
+      },
+
+      // 社区 Providers (5个)
+      {
+        id: 'ollama',
+        name: 'Ollama',
+        import: () => import('ollama-ai-provider'),
+        creatorFunctionName: 'createOllama',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'qwen',
+        name: 'Qwen',
+        import: () => import('qwen-ai-provider'),
+        creatorFunctionName: 'createQwen',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'zhipu',
+        name: 'Zhipu AI',
+        import: () => import('zhipu-ai-provider'),
+        creatorFunctionName: 'createZhipu',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'anthropic-vertex',
+        name: 'Anthropic Vertex AI',
+        import: () => import('anthropic-vertex-ai'),
+        creatorFunctionName: 'createAnthropicVertex',
+        supportsImageGeneration: false
+      },
+      {
+        id: 'openrouter',
+        name: 'OpenRouter',
+        import: () => import('@openrouter/ai-sdk-provider'),
+        creatorFunctionName: 'createOpenRouter',
+        supportsImageGeneration: false
+      }
+    ]
+
+    // 注册所有 providers (总计24个)
+    providers.forEach((config) => {
+      this.registry.set(config.id, config)
+    })
+  }
+
+  /**
+   * 获取所有已注册的 Providers
+   */
+  public getAllProviders(): ProviderConfig[] {
+    return Array.from(this.registry.values())
+  }
+
+  /**
+   * 根据 ID 获取 Provider 配置
+   */
+  public getProvider(id: string): ProviderConfig | undefined {
+    return this.registry.get(id)
+  }
+
+  /**
+   * 检查 Provider 是否支持（是否已注册）
+   */
+  public isSupported(id: string): boolean {
+    return this.registry.has(id)
+  }
+
+  /**
+   * 注册新的 Provider（用于扩展）
+   */
+  public registerProvider(config: ProviderConfig): void {
+    this.registry.set(config.id, config)
+  }
+
+  /**
+   * 清理资源
+   */
+  public cleanup(): void {
+    this.registry.clear()
+  }
+
+  /**
+   * 获取兼容现有实现的注册表格式
+   */
+  public getCompatibleRegistry(): Record<string, { import: () => Promise<any>; creatorFunctionName: string }> {
+    const compatibleRegistry: Record<string, { import: () => Promise<any>; creatorFunctionName: string }> = {}
+
+    this.getAllProviders().forEach((provider) => {
+      compatibleRegistry[provider.id] = {
+        import: provider.import,
+        creatorFunctionName: provider.creatorFunctionName
+      }
+    })
+
+    return compatibleRegistry
+  }
+}
+
+// 导出单例实例
+export const aiProviderRegistry = AiProviderRegistry.getInstance()
+
+// 便捷函数
+export const getProvider = (id: string) => aiProviderRegistry.getProvider(id)
+export const getAllProviders = () => aiProviderRegistry.getAllProviders()
+export const isProviderSupported = (id: string) => aiProviderRegistry.isSupported(id)
+export const registerProvider = (config: ProviderConfig) => aiProviderRegistry.registerProvider(config)
+
+// 兼容现有实现的导出
+export const PROVIDER_REGISTRY = aiProviderRegistry.getCompatibleRegistry()
+
+// 重新导出所有类型供外部使用
+export type {
+  AmazonBedrockProviderSettings,
+  AnthropicProviderSettings,
+  AnthropicVertexProviderSettings,
+  AzureOpenAIProviderSettings,
+  CerebrasProviderSettings,
+  CohereProviderSettings,
+  DeepInfraProviderSettings,
+  DeepSeekProviderSettings,
+  FalProviderSettings,
+  FireworksProviderSettings,
+  GoogleGenerativeAIProviderSettings,
+  GoogleVertexProviderSettings,
+  GroqProviderSettings,
+  MistralProviderSettings,
+  OllamaProviderSettings,
+  OpenAICompatibleProviderSettings,
+  OpenAIProviderSettings,
+  OpenRouterProviderSettings,
+  PerplexityProviderSettings,
+  QwenProviderSettings,
+  ReplicateProviderSettings,
+  TogetherAIProviderSettings,
+  VercelProviderSettings,
+  XaiProviderSettings,
+  ZhipuProviderSettings
+}
--- a/packages/aiCore/src/providers/types.ts
+++ b/packages/aiCore/src/providers/types.ts
@@ -0,0 +1,47 @@
+/**
+ * Provider 相关核心类型定义
+ * 只定义必要的接口，其他类型直接使用 AI SDK
+ */
+
+// Provider 配置接口（简化版）
+export interface ProviderConfig {
+  id: string
+  name: string
+  import: () => Promise<any>
+  creatorFunctionName: string
+}
+
+// API 客户端工厂接口
+export interface ApiClientFactory {
+  createAiSdkClient(providerId: string, options?: any): Promise<any>
+  getCachedClient(providerId: string, options?: any): any
+  clearCache(): void
+}
+
+// 客户端配置
+export interface ClientConfig {
+  providerId: string
+  apiKey?: string
+  baseURL?: string
+  [key: string]: any
+}
+
+// 错误类型
+export class ProviderError extends Error {
+  constructor(
+    message: string,
+    public providerId: string,
+    public code?: string,
+    public cause?: Error
+  ) {
+    super(message)
+    this.name = 'ProviderError'
+  }
+}
+
+// 缓存统计信息
+export interface CacheStats {
+  size: number
+  keys: string[]
+  lastCleanup?: Date
+}
--- a/packages/aiCore/tsconfig.json
+++ b/packages/aiCore/tsconfig.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "noEmitOnError": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+} 
--- a/src/renderer/src/aiCore/AiSdkToChunkAdapter.ts
+++ b/src/renderer/src/aiCore/AiSdkToChunkAdapter.ts
@@ -0,0 +1,284 @@
+/**
+ * AI SDK 到 Cherry Studio Chunk 适配器
+ * 用于将 AI SDK 的 fullStream 转换为 Cherry Studio 的 chunk 格式
+ */
+
+import { TextStreamPart } from '@cherrystudio/ai-core'
+import { Chunk, ChunkType } from '@renderer/types/chunk'
+
+export interface CherryStudioChunk {
+  type: 'text-delta' | 'text-complete' | 'tool-call' | 'tool-result' | 'finish' | 'error'
+  text?: string
+  toolCall?: any
+  toolResult?: any
+  finishReason?: string
+  usage?: any
+  error?: any
+}
+
+/**
+ * AI SDK 到 Cherry Studio Chunk 适配器类
+ * 处理 fullStream 到 Cherry Studio chunk 的转换
+ */
+export class AiSdkToChunkAdapter {
+  constructor(private onChunk: (chunk: Chunk) => void) {}
+
+  /**
+   * 处理 AI SDK 流结果
+   * @param aiSdkResult AI SDK 的流结果对象
+   * @returns 最终的文本内容
+   */
+  async processStream(aiSdkResult: any): Promise<string> {
+    // 如果是流式且有 fullStream
+    if (aiSdkResult.fullStream) {
+      await this.readFullStream(aiSdkResult.fullStream)
+    }
+
+    // 使用 streamResult.text 获取最终结果
+    return await aiSdkResult.text
+  }
+
+  /**
+   * 读取 fullStream 并转换为 Cherry Studio chunks
+   * @param fullStream AI SDK 的 fullStream (ReadableStream)
+   */
+  private async readFullStream(fullStream: ReadableStream<TextStreamPart<any>>) {
+    const reader = fullStream.getReader()
+    const final = {
+      text: '',
+      reasoning_content: ''
+    }
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+
+        if (done) {
+          break
+        }
+
+        // 转换并发送 chunk
+        this.convertAndEmitChunk(value, final)
+      }
+    } finally {
+      reader.releaseLock()
+    }
+  }
+
+  /**
+   * 转换 AI SDK chunk 为 Cherry Studio chunk 并调用回调
+   * @param chunk AI SDK 的 chunk 数据
+   */
+  private convertAndEmitChunk(chunk: any, final: { text: string; reasoning_content: string }) {
+    console.log('AI SDK chunk type:', chunk.type, chunk)
+    switch (chunk.type) {
+      // === 文本相关事件 ===
+      case 'text-delta':
+        final.text += chunk.textDelta || ''
+        this.onChunk({
+          type: ChunkType.TEXT_DELTA,
+          text: chunk.textDelta || ''
+        })
+        break
+
+      case 'reasoning':
+        this.onChunk({
+          type: ChunkType.THINKING_DELTA,
+          text: chunk.textDelta || ''
+        })
+        break
+      case 'redacted-reasoning':
+        this.onChunk({
+          type: ChunkType.THINKING_DELTA,
+          text: chunk.data || ''
+        })
+        break
+      case 'reasoning-signature':
+        this.onChunk({
+          type: ChunkType.THINKING_COMPLETE,
+          text: chunk.text || '',
+          thinking_millsec: chunk.thinking_millsec || 0
+        })
+        break
+
+      // === 工具调用相关事件 ===
+      case 'tool-call-streaming-start':
+        // 开始流式工具调用
+        this.onChunk({
+          type: ChunkType.MCP_TOOL_CREATED,
+          tool_calls: [
+            {
+              id: chunk.toolCallId,
+              name: chunk.toolName,
+              args: {}
+            }
+          ]
+        })
+        break
+
+      case 'tool-call-delta':
+        // 工具调用参数的增量更新
+        this.onChunk({
+          type: ChunkType.MCP_TOOL_IN_PROGRESS,
+          responses: [
+            {
+              id: chunk.toolCallId,
+              tool: {
+                id: chunk.toolName,
+                // TODO: serverId,serverName
+                serverId: 'ai-sdk',
+                serverName: 'AI SDK',
+                name: chunk.toolName,
+                description: '',
+                inputSchema: {
+                  type: 'object',
+                  title: chunk.toolName,
+                  properties: {}
+                }
+              },
+              arguments: {},
+              status: 'invoking',
+              response: chunk.argsTextDelta,
+              toolCallId: chunk.toolCallId
+            }
+          ]
+        })
+        break
+
+      case 'tool-call':
+        // 完整的工具调用
+        this.onChunk({
+          type: ChunkType.MCP_TOOL_CREATED,
+          tool_calls: [
+            {
+              id: chunk.toolCallId,
+              name: chunk.toolName,
+              args: chunk.args
+            }
+          ]
+        })
+        break
+
+      case 'tool-result':
+        // 工具调用结果
+        this.onChunk({
+          type: ChunkType.MCP_TOOL_COMPLETE,
+          responses: [
+            {
+              id: chunk.toolCallId,
+              tool: {
+                id: chunk.toolName,
+                // TODO: serverId,serverName
+                serverId: 'ai-sdk',
+                serverName: 'AI SDK',
+                name: chunk.toolName,
+                description: '',
+                inputSchema: {
+                  type: 'object',
+                  title: chunk.toolName,
+                  properties: {}
+                }
+              },
+              arguments: chunk.args || {},
+              status: 'done',
+              response: chunk.result,
+              toolCallId: chunk.toolCallId
+            }
+          ]
+        })
+        break
+
+      // === 步骤相关事件 ===
+      //   case 'step-start':
+      //     this.onChunk({
+      //       type: ChunkType.LLM_RESPONSE_CREATED
+      //     })
+      //     break
+      case 'step-finish':
+        this.onChunk({
+          type: ChunkType.BLOCK_COMPLETE,
+          response: {
+            text: final.text || '',
+            reasoning_content: final.reasoning_content || '',
+            usage: {
+              completion_tokens: chunk.usage.completionTokens || 0,
+              prompt_tokens: chunk.usage.promptTokens || 0,
+              total_tokens: chunk.usage.totalTokens || 0
+            },
+            metrics: chunk.usage
+              ? {
+                  completion_tokens: chunk.usage.completionTokens || 0,
+                  time_completion_millsec: 0
+                }
+              : undefined
+          }
+        })
+        break
+
+      case 'finish':
+        this.onChunk({
+          type: ChunkType.TEXT_COMPLETE,
+          text: final.text || '' // TEXT_COMPLETE 需要 text 字段
+        })
+        this.onChunk({
+          type: ChunkType.LLM_RESPONSE_COMPLETE,
+          response: {
+            text: final.text || '',
+            reasoning_content: final.reasoning_content || '',
+            usage: {
+              completion_tokens: chunk.usage.completionTokens || 0,
+              prompt_tokens: chunk.usage.promptTokens || 0,
+              total_tokens: chunk.usage.totalTokens || 0
+            },
+            metrics: chunk.usage
+              ? {
+                  completion_tokens: chunk.usage.completionTokens || 0,
+                  time_completion_millsec: 0
+                }
+              : undefined
+          }
+        })
+        break
+
+      // === 源和文件相关事件 ===
+      case 'source':
+        // 源信息，可以映射到知识搜索完成
+        this.onChunk({
+          type: ChunkType.KNOWLEDGE_SEARCH_COMPLETE,
+          knowledge: [
+            {
+              id: Number(chunk.source.id) || Date.now(),
+              content: chunk.source.title || '',
+              sourceUrl: chunk.source.url || '',
+              type: 'url'
+            }
+          ]
+        })
+        break
+
+      case 'file':
+        // 文件相关事件，可能是图片生成
+        this.onChunk({
+          type: ChunkType.IMAGE_COMPLETE,
+          image: {
+            type: 'base64',
+            images: [chunk.base64]
+          }
+        })
+        break
+      case 'error':
+        this.onChunk({
+          type: ChunkType.ERROR,
+          error: {
+            message: chunk.error || 'Unknown error'
+          }
+        })
+        break
+
+      default:
+        // 其他类型的 chunk 可以忽略或记录日志
+        console.log('Unhandled AI SDK chunk type:', chunk.type, chunk)
+    }
+  }
+}
+
+export default AiSdkToChunkAdapter
--- a/src/renderer/src/aiCore/index_new.ts
+++ b/src/renderer/src/aiCore/index_new.ts
@@ -0,0 +1,229 @@
+/**
+ * Cherry Studio AI Core - 新版本入口
+ * 集成 @cherrystudio/ai-core 库的渐进式重构方案
+ *
+ * 融合方案：简化实现，专注于核心功能
+ * 1. 优先使用新AI SDK
+ * 2. 失败时fallback到原有实现
+ * 3. 暂时保持接口兼容性
+ */
+
+import {
+  AiClient,
+  AiCore,
+  createClient,
+  type OpenAICompatibleProviderSettings,
+  type ProviderId,
+  smoothStream,
+  StreamTextParams
+} from '@cherrystudio/ai-core'
+import { isDedicatedImageGenerationModel } from '@renderer/config/models'
+import type { GenerateImageParams, Model, Provider } from '@renderer/types'
+
+// 引入适配器
+import AiSdkToChunkAdapter from './AiSdkToChunkAdapter'
+// 引入原有的AiProvider作为fallback
+import LegacyAiProvider from './index'
+import { AiSdkMiddlewareConfig, buildAiSdkMiddlewares } from './middleware/aisdk/AiSdkMiddlewareBuilder'
+import { CompletionsResult } from './middleware/schemas'
+// 引入参数转换模块
+
+/**
+ * 将现有 Provider 类型映射到 AI SDK 的 Provider ID
+ * 根据 registry.ts 中的支持列表进行映射
+ */
+function mapProviderTypeToAiSdkId(providerType: string): string {
+  // Cherry Studio Provider Type -> AI SDK Provider ID 映射表
+  const typeMapping: Record<string, string> = {
+    // 需要转换的映射
+    grok: 'xai', // grok -> xai
+    'azure-openai': 'azure', // azure-openai -> azure
+    gemini: 'google', // gemini -> google
+    vertexai: 'google-vertex' // vertexai -> google-vertex
+  }
+
+  return typeMapping[providerType]
+}
+
+/**
+ * 将 Provider 配置转换为新 AI SDK 格式
+ */
+function providerToAiSdkConfig(provider: Provider): {
+  providerId: ProviderId | 'openai-compatible'
+  options: any
+} {
+  console.log('provider', provider)
+  // 1. 先映射 provider 类型到 AI SDK ID
+  const mappedProviderId = mapProviderTypeToAiSdkId(provider.id)
+
+  // 2. 检查映射后的 provider ID 是否在 AI SDK 注册表中
+  const isSupported = AiCore.isSupported(mappedProviderId)
+
+  console.log(`Provider mapping: ${provider.type} -> ${mappedProviderId}, supported: ${isSupported}`)
+
+  // 3. 如果映射的 provider 不支持，则使用 openai-compatible
+  if (isSupported) {
+    return {
+      providerId: mappedProviderId as ProviderId,
+      options: {
+        apiKey: provider.apiKey
+      }
+    }
+  } else {
+    console.log(`Using openai-compatible fallback for provider: ${provider.type}`)
+    const compatibleConfig: OpenAICompatibleProviderSettings = {
+      name: provider.name || provider.type,
+      apiKey: provider.apiKey,
+      baseURL: provider.apiHost
+    }
+
+    return {
+      providerId: 'openai-compatible',
+      options: compatibleConfig
+    }
+  }
+}
+
+/**
+ * 检查是否支持使用新的AI SDK
+ */
+function isModernSdkSupported(provider: Provider, model?: Model): boolean {
+  // 目前支持主要的providers
+  const supportedProviders = ['openai', 'anthropic', 'gemini', 'azure-openai', 'vertexai']
+
+  // 检查provider类型
+  if (!supportedProviders.includes(provider.type)) {
+    return false
+  }
+
+  // 检查是否为图像生成模型（暂时不支持）
+  if (model && isDedicatedImageGenerationModel(model)) {
+    return false
+  }
+
+  return true
+}
+
+export default class ModernAiProvider {
+  private modernClient?: AiClient
+  private legacyProvider: LegacyAiProvider
+  private provider: Provider
+
+  constructor(provider: Provider) {
+    this.provider = provider
+    this.legacyProvider = new LegacyAiProvider(provider)
+
+    // 初始化时不构建中间件，等到需要时再构建
+    const config = providerToAiSdkConfig(provider)
+    this.modernClient = createClient(config.providerId, config.options)
+  }
+
+  public async completions(
+    modelId: string,
+    params: StreamTextParams,
+    middlewareConfig: AiSdkMiddlewareConfig
+  ): Promise<CompletionsResult> {
+    // const model = params.assistant.model
+
+    // 检查是否应该使用现代化客户端
+    // if (this.modernClient && model && isModernSdkSupported(this.provider, model)) {
+    // try {
+    return await this.modernCompletions(modelId, params, middlewareConfig)
+    // } catch (error) {
+    // console.warn('Modern client failed, falling back to legacy:', error)
+    // fallback到原有实现
+    // }
+    // }
+
+    // 使用原有实现
+    // return this.legacyProvider.completions(params, options)
+  }
+
+  /**
+   * 使用现代化AI SDK的completions实现
+   * 使用建造者模式动态构建中间件
+   */
+  private async modernCompletions(
+    modelId: string,
+    params: StreamTextParams,
+    middlewareConfig: AiSdkMiddlewareConfig
+  ): Promise<CompletionsResult> {
+    if (!this.modernClient) {
+      throw new Error('Modern AI SDK client not initialized')
+    }
+
+    try {
+      // 合并传入的配置和实例配置
+      const finalConfig: AiSdkMiddlewareConfig = {
+        ...middlewareConfig,
+        provider: this.provider,
+        // 工具相关信息从 params 中获取
+        enableTool: params.tools !== undefined && Array.isArray(params.tools) && params.tools.length > 0
+      }
+
+      // 动态构建中间件数组
+      const middlewares = buildAiSdkMiddlewares(finalConfig)
+      console.log(
+        '构建的中间件:',
+        middlewares.map((m) => m.name)
+      )
+
+      // 创建带有中间件的客户端
+      const config = providerToAiSdkConfig(this.provider)
+      const clientWithMiddlewares = createClient(config.providerId, config.options, middlewares)
+
+      if (middlewareConfig.onChunk) {
+        // 流式处理 - 使用适配器
+        const adapter = new AiSdkToChunkAdapter(middlewareConfig.onChunk)
+        const streamResult = await clientWithMiddlewares.streamText(modelId, {
+          ...params,
+          experimental_transform: smoothStream({
+            delayInMs: 80,
+            // 中文3个字符一个chunk,英文一个单词一个chunk
+            chunking: /([\u4E00-\u9FFF]{3})|\S+\s+/
+          })
+        })
+        const finalText = await adapter.processStream(streamResult)
+
+        return {
+          getText: () => finalText
+        }
+      } else {
+        // 流式处理但没有 onChunk 回调
+        const streamResult = await clientWithMiddlewares.streamText(modelId, params)
+        const finalText = await streamResult.text
+
+        return {
+          getText: () => finalText
+        }
+      }
+    } catch (error) {
+      console.error('Modern AI SDK error:', error)
+      throw error
+    }
+  }
+
+  // 代理其他方法到原有实现
+  public async models() {
+    return this.legacyProvider.models()
+  }
+
+  public async getEmbeddingDimensions(model: Model): Promise<number> {
+    return this.legacyProvider.getEmbeddingDimensions(model)
+  }
+
+  public async generateImage(params: GenerateImageParams): Promise<string[]> {
+    return this.legacyProvider.generateImage(params)
+  }
+
+  public getBaseURL(): string {
+    return this.legacyProvider.getBaseURL()
+  }
+
+  public getApiKey(): string {
+    return this.legacyProvider.getApiKey()
+  }
+}
+
+// 为了方便调试，导出一些工具函数
+export { isModernSdkSupported, providerToAiSdkConfig }
--- a/src/renderer/src/aiCore/middleware/aisdk/AiSdkMiddlewareBuilder.ts
+++ b/src/renderer/src/aiCore/middleware/aisdk/AiSdkMiddlewareBuilder.ts
@@ -0,0 +1,188 @@
+import { AiPlugin, simulateStreamingMiddleware } from '@cherrystudio/ai-core'
+import { isReasoningModel } from '@renderer/config/models'
+import type { Model, Provider } from '@renderer/types'
+import type { Chunk } from '@renderer/types/chunk'
+
+import thinkingTimeMiddleware from './ThinkingTimeMiddleware'
+
+/**
+ * AI SDK 中间件配置项
+ */
+export interface AiSdkMiddlewareConfig {
+  streamOutput?: boolean
+  onChunk?: (chunk: Chunk) => void
+  model?: Model
+  provider?: Provider
+  enableReasoning?: boolean
+  enableTool?: boolean
+  enableWebSearch?: boolean
+}
+
+/**
+ * 具名的 AI SDK 中间件
+ */
+export type NamedAiSdkMiddleware = AiPlugin
+
+/**
+ * AI SDK 中间件建造者
+ * 用于根据不同条件动态构建中间件数组
+ */
+export class AiSdkMiddlewareBuilder {
+  private middlewares: NamedAiSdkMiddleware[] = []
+
+  /**
+   * 添加具名中间件
+   */
+  public add(namedMiddleware: NamedAiSdkMiddleware): this {
+    this.middlewares.push(namedMiddleware)
+    return this
+  }
+
+  /**
+   * 在指定位置插入中间件
+   */
+  public insertAfter(targetName: string, middleware: NamedAiSdkMiddleware): this {
+    const index = this.middlewares.findIndex((m) => m.name === targetName)
+    if (index !== -1) {
+      this.middlewares.splice(index + 1, 0, middleware)
+    } else {
+      console.warn(`AiSdkMiddlewareBuilder: 未找到名为 '${targetName}' 的中间件，无法插入`)
+    }
+    return this
+  }
+
+  /**
+   * 检查是否包含指定名称的中间件
+   */
+  public has(name: string): boolean {
+    return this.middlewares.some((m) => m.name === name)
+  }
+
+  /**
+   * 移除指定名称的中间件
+   */
+  public remove(name: string): this {
+    this.middlewares = this.middlewares.filter((m) => m.name !== name)
+    return this
+  }
+
+  /**
+   * 构建最终的中间件数组
+   */
+  public build(): NamedAiSdkMiddleware[] {
+    return [...this.middlewares]
+  }
+
+  /**
+   * 清空所有中间件
+   */
+  public clear(): this {
+    this.middlewares = []
+    return this
+  }
+
+  /**
+   * 获取中间件总数
+   */
+  public get length(): number {
+    return this.middlewares.length
+  }
+}
+
+/**
+ * 根据配置构建AI SDK中间件的工厂函数
+ * 这里要注意构建顺序，因为有些中间件需要依赖其他中间件的结果
+ */
+export function buildAiSdkMiddlewares(config: AiSdkMiddlewareConfig): NamedAiSdkMiddleware[] {
+  const builder = new AiSdkMiddlewareBuilder()
+
+  // 1. 思考模型且有onChunk回调时添加思考时间中间件
+  if (config.onChunk && config.model && isReasoningModel(config.model)) {
+    builder.add({
+      name: 'thinking-time',
+      aiSdkMiddlewares: [thinkingTimeMiddleware()]
+    })
+  }
+
+  // 2. 可以在这里根据其他条件添加更多中间件
+  // 例如：工具调用、Web搜索等相关中间件
+
+  // 3. 根据provider添加特定中间件
+  if (config.provider) {
+    addProviderSpecificMiddlewares(builder, config)
+  }
+
+  // 4. 根据模型类型添加特定中间件
+  if (config.model) {
+    addModelSpecificMiddlewares(builder, config)
+  }
+
+  // 5. 非流式输出时添加模拟流中间件
+  if (config.streamOutput === false) {
+    builder.add({
+      name: 'simulate-streaming',
+      aiSdkMiddlewares: [simulateStreamingMiddleware()]
+    })
+  }
+
+  return builder.build()
+}
+
+/**
+ * 添加provider特定的中间件
+ */
+function addProviderSpecificMiddlewares(builder: AiSdkMiddlewareBuilder, config: AiSdkMiddlewareConfig): void {
+  if (!config.provider) return
+
+  // 根据不同provider添加特定中间件
+  switch (config.provider.type) {
+    case 'anthropic':
+      // Anthropic特定中间件
+      break
+    case 'openai':
+      // OpenAI特定中间件
+      break
+    case 'gemini':
+      // Gemini特定中间件
+      break
+    default:
+      // 其他provider的通用处理
+      break
+  }
+}
+
+/**
+ * 添加模型特定的中间件
+ */
+function addModelSpecificMiddlewares(builder: AiSdkMiddlewareBuilder, config: AiSdkMiddlewareConfig): void {
+  if (!config.model) return
+
+  // 可以根据模型ID或特性添加特定中间件
+  // 例如：图像生成模型、多模态模型等
+
+  // 示例：某些模型需要特殊处理
+  if (config.model.id.includes('dalle') || config.model.id.includes('midjourney')) {
+    // 图像生成相关中间件
+  }
+}
+
+/**
+ * 创建一个预配置的中间件建造者
+ */
+export function createAiSdkMiddlewareBuilder(): AiSdkMiddlewareBuilder {
+  return new AiSdkMiddlewareBuilder()
+}
+
+/**
+ * 创建一个带有默认中间件的建造者
+ */
+export function createDefaultAiSdkMiddlewareBuilder(config: AiSdkMiddlewareConfig): AiSdkMiddlewareBuilder {
+  const builder = new AiSdkMiddlewareBuilder()
+  const defaultMiddlewares = buildAiSdkMiddlewares(config)
+
+  defaultMiddlewares.forEach((middleware) => {
+    builder.add(middleware)
+  })
+
+  return builder
+}
--- a/src/renderer/src/aiCore/middleware/aisdk/README.md
+++ b/src/renderer/src/aiCore/middleware/aisdk/README.md
@@ -0,0 +1,140 @@
+# AI SDK 中间件建造者
+
+## 概述
+
+`AiSdkMiddlewareBuilder` 是一个用于动态构建 AI SDK 中间件数组的建造者模式实现。它可以根据不同的条件（如流式输出、思考模型、provider类型等）自动构建合适的中间件组合。
+
+## 使用方式
+
+### 基本用法
+
+```typescript
+import { buildAiSdkMiddlewares, type AiSdkMiddlewareConfig } from './AiSdkMiddlewareBuilder'
+
+// 配置中间件参数
+const config: AiSdkMiddlewareConfig = {
+  streamOutput: false, // 非流式输出
+  onChunk: chunkHandler, // chunk回调函数
+  model: currentModel, // 当前模型
+  provider: currentProvider, // 当前provider
+  enableReasoning: true, // 启用推理
+  enableTool: false, // 禁用工具
+  enableWebSearch: false // 禁用网页搜索
+}
+
+// 构建中间件数组
+const middlewares = buildAiSdkMiddlewares(config)
+
+// 创建带有中间件的客户端
+const client = createClient(providerId, options, middlewares)
+```
+
+### 手动构建
+
+```typescript
+import { AiSdkMiddlewareBuilder, createAiSdkMiddlewareBuilder } from './AiSdkMiddlewareBuilder'
+
+const builder = createAiSdkMiddlewareBuilder()
+
+// 添加特定中间件
+builder.add({
+  name: 'custom-middleware',
+  aiSdkMiddlewares: [customMiddleware()]
+})
+
+// 检查是否包含某个中间件
+if (builder.has('thinking-time')) {
+  console.log('已包含思考时间中间件')
+}
+
+// 移除不需要的中间件
+builder.remove('simulate-streaming')
+
+// 构建最终数组
+const middlewares = builder.build()
+```
+
+## 支持的条件
+
+### 1. 流式输出控制
+
+- **streamOutput = false**: 自动添加 `simulateStreamingMiddleware`
+- **streamOutput = true**: 使用原生流式处理
+
+### 2. 思考模型处理
+
+- **条件**: `onChunk` 存在 && `isReasoningModel(model)` 为 true
+- **效果**: 自动添加 `thinkingTimeMiddleware`
+
+### 3. Provider 特定中间件
+
+根据不同的 provider 类型添加特定中间件：
+
+- **anthropic**: Anthropic 特定处理
+- **openai**: OpenAI 特定处理
+- **gemini**: Gemini 特定处理
+
+### 4. 模型特定中间件
+
+根据模型特性添加中间件：
+
+- **图像生成模型**: 添加图像处理相关中间件
+- **多模态模型**: 添加多模态处理中间件
+
+## 扩展指南
+
+### 添加新的条件判断
+
+在 `buildAiSdkMiddlewares` 函数中添加新的条件：
+
+```typescript
+// 例如：添加缓存中间件
+if (config.enableCache) {
+  builder.add({
+    name: 'cache',
+    aiSdkMiddlewares: [cacheMiddleware(config.cacheOptions)]
+  })
+}
+```
+
+### 添加 Provider 特定处理
+
+在 `addProviderSpecificMiddlewares` 函数中添加：
+
+```typescript
+case 'custom-provider':
+  builder.add({
+    name: 'custom-provider-middleware',
+    aiSdkMiddlewares: [customProviderMiddleware()]
+  })
+  break
+```
+
+### 添加模型特定处理
+
+在 `addModelSpecificMiddlewares` 函数中添加：
+
+```typescript
+if (config.model.id.includes('custom-model')) {
+  builder.add({
+    name: 'custom-model-middleware',
+    aiSdkMiddlewares: [customModelMiddleware()]
+  })
+}
+```
+
+## 中间件执行顺序
+
+中间件按照添加顺序执行：
+
+1. **simulate-streaming** (如果 streamOutput = false)
+2. **thinking-time** (如果是思考模型且有 onChunk)
+3. **provider-specific** (根据 provider 类型)
+4. **model-specific** (根据模型类型)
+
+## 注意事项
+
+1. 中间件的执行顺序很重要，确保按正确顺序添加
+2. 避免添加冲突的中间件
+3. 某些中间件可能有依赖关系，需要确保依赖的中间件先添加
+4. 建议在开发环境下启用日志，以便调试中间件构建过程
--- a/src/renderer/src/aiCore/middleware/aisdk/ThinkingTimeMiddleware.ts
+++ b/src/renderer/src/aiCore/middleware/aisdk/ThinkingTimeMiddleware.ts
@@ -0,0 +1,67 @@
+import { LanguageModelV1Middleware, LanguageModelV1StreamPart } from '@cherrystudio/ai-core'
+import { ChunkType, ThinkingCompleteChunk } from '@renderer/types/chunk'
+
+/**
+ * 一个用于统计 LLM "思考时间"（Time to First Token）的 AI SDK 中间件。
+ *
+ * 工作原理:
+ * 1. 在 `stream` 方法被调用时，记录一个起始时间。
+ * 2. 它会创建一个新的 `TransformStream` 来代理原始的流。
+ * 3. 当第一个数据块 (chunk) 从原始流中到达时，记录结束时间。
+ * 4. 计算两者之差，即为 "思考时间"
+ * 这里只处理了thinking_complete
+ */
+export default function thinkingTimeMiddleware(): LanguageModelV1Middleware {
+  return {
+    wrapStream: async ({ doStream }) => {
+      let hasThinkingContent = false
+      let thinkingStartTime = 0
+      let accumulatedThinkingContent = ''
+      const { stream, ...reset } = await doStream()
+      const transformStream = new TransformStream<LanguageModelV1StreamPart, any>({
+        transform(chunk, controller) {
+          if (chunk.type === 'reasoning' || chunk.type === 'redacted-reasoning') {
+            if (!hasThinkingContent) {
+              hasThinkingContent = true
+              thinkingStartTime = Date.now()
+            }
+            accumulatedThinkingContent += chunk.textDelta || ''
+          } else {
+            if (hasThinkingContent && thinkingStartTime > 0) {
+              const thinkingTime = Date.now() - thinkingStartTime
+              const thinkingCompleteChunk = {
+                type: 'reasoning-signature',
+                text: accumulatedThinkingContent,
+                thinking_millsec: thinkingTime
+              }
+              controller.enqueue(thinkingCompleteChunk)
+              hasThinkingContent = false
+              thinkingStartTime = 0
+              accumulatedThinkingContent = ''
+            }
+          }
+          // 将所有 chunk 原样传递下去
+          controller.enqueue(chunk)
+        },
+        flush(controller) {
+          // 如果流的末尾都是 reasoning，也需要发送 complete 事件
+          if (hasThinkingContent && thinkingStartTime > 0) {
+            const thinkingTime = Date.now() - thinkingStartTime
+            const thinkingCompleteChunk: ThinkingCompleteChunk = {
+              type: ChunkType.THINKING_COMPLETE,
+              text: accumulatedThinkingContent,
+              thinking_millsec: thinkingTime
+            }
+            controller.enqueue(thinkingCompleteChunk)
+          }
+          controller.terminate()
+        }
+      })
+
+      return {
+        stream: stream.pipeThrough(transformStream),
+        ...reset
+      }
+    }
+  }
+}
--- a/src/renderer/src/aiCore/plugins/cherryStudioTransformPlugin.ts
+++ b/src/renderer/src/aiCore/plugins/cherryStudioTransformPlugin.ts
@@ -0,0 +1,110 @@
+/**
+ * Cherry Studio 参数转换插件
+ * 专门处理 Cherry Studio 特有的消息格式、文件处理、Assistant 设置等
+ */
+
+import { definePlugin } from '@cherrystudio/ai-core'
+import type { Assistant, MCPTool, Message, Model } from '@renderer/types'
+
+import {
+  buildStreamTextParams,
+  convertMessagesToSdkMessages,
+  getCustomParameters,
+  getTemperature,
+  getTopP
+} from '../transformParameters'
+
+/**
+ * Cherry Studio 核心转换插件
+ * 负责将 Cherry Studio 的数据结构转换为 AI SDK 兼容格式
+ */
+export const cherryStudioTransformPlugin = definePlugin({
+  name: 'cherry-studio-transform',
+
+  /**
+   * 转换请求参数
+   * 将 Cherry Studio 的 Assistant + Messages 转换为 AI SDK 格式
+   */
+  transformParams: async (params: any, context) => {
+    // 检查是否有 Cherry Studio 特有的数据结构
+    const cherryData = context.metadata?.cherryStudio
+    if (!cherryData) {
+      return params // 不是 Cherry Studio 调用，直接返回
+    }
+
+    const { assistant, messages, mcpTools, enableTools } = cherryData
+
+    try {
+      // 1. 转换 Cherry Studio 消息为 AI SDK 消息
+      const sdkMessages = await convertMessagesToSdkMessages(messages as Message[], assistant.model as Model)
+
+      // 2. 构建完整的 AI SDK 参数
+      const { params: transformedParams } = await buildStreamTextParams(sdkMessages, assistant as Assistant, {
+        mcpTools: mcpTools as MCPTool[],
+        enableTools,
+        requestOptions: {
+          signal: params.abortSignal,
+          headers: params.headers
+        }
+      })
+
+      // 3. 合并原始参数和转换后的参数
+      return {
+        ...params,
+        ...transformedParams,
+        // 保留原始的一些关键参数
+        abortSignal: params.abortSignal,
+        headers: params.headers
+      }
+    } catch (error) {
+      console.error('Cherry Studio 参数转换失败:', error)
+      return params // 转换失败时返回原始参数
+    }
+  }
+})
+
+/**
+ * Cherry Studio Assistant 设置插件
+ * 专门处理 Assistant 的温度、TopP、自定义参数等设置
+ */
+export const cherryStudioSettingsPlugin = definePlugin({
+  name: 'cherry-studio-settings',
+
+  transformParams: async (params: any, context) => {
+    const cherryData = context.metadata?.cherryStudio
+    if (!cherryData?.assistant) {
+      return params
+    }
+
+    const { assistant } = cherryData
+    const model = assistant.model as Model
+
+    return {
+      ...params,
+      temperature: getTemperature(assistant as Assistant, model),
+      topP: getTopP(assistant as Assistant, model),
+      ...getCustomParameters(assistant as Assistant)
+    }
+  }
+})
+
+/**
+ * 便捷函数：为 Cherry Studio 调用准备上下文元数据
+ */
+export function createCherryStudioContext(
+  assistant: Assistant,
+  messages: Message[],
+  options: {
+    mcpTools?: MCPTool[]
+    enableTools?: boolean
+  } = {}
+) {
+  return {
+    cherryStudio: {
+      assistant,
+      messages,
+      mcpTools: options.mcpTools,
+      enableTools: options.enableTools
+    }
+  }
+}
--- a/src/renderer/src/aiCore/transformParameters.ts
+++ b/src/renderer/src/aiCore/transformParameters.ts
@@ -0,0 +1,311 @@
+/**
+ * AI SDK 参数转换模块
+ * 统一管理从各个 apiClient 提取的参数处理和转换功能
+ */
+
+import type { CoreMessage, StreamTextParams } from '@cherrystudio/ai-core'
+import {
+  isGenerateImageModel,
+  isNotSupportTemperatureAndTopP,
+  isOpenRouterBuiltInWebSearchModel,
+  isReasoningModel,
+  isSupportedDisableGenerationModel,
+  isSupportedFlexServiceTier,
+  isSupportedReasoningEffortModel,
+  isSupportedThinkingTokenModel,
+  isWebSearchModel
+} from '@renderer/config/models'
+import { getAssistantSettings, getDefaultModel } from '@renderer/services/AssistantService'
+import type { Assistant, MCPTool, Message, Model } from '@renderer/types'
+import { FileTypes } from '@renderer/types'
+import { findFileBlocks, findImageBlocks, getMainTextContent } from '@renderer/utils/messageUtils/find'
+import { buildSystemPrompt } from '@renderer/utils/prompt'
+import { defaultTimeout } from '@shared/config/constant'
+
+/**
+ * 获取温度参数
+ */
+export function getTemperature(assistant: Assistant, model: Model): number | undefined {
+  return isNotSupportTemperatureAndTopP(model) ? undefined : assistant.settings?.temperature
+}
+
+/**
+ * 获取 TopP 参数
+ */
+export function getTopP(assistant: Assistant, model: Model): number | undefined {
+  return isNotSupportTemperatureAndTopP(model) ? undefined : assistant.settings?.topP
+}
+
+/**
+ * 获取超时设置
+ */
+export function getTimeout(model: Model): number {
+  if (isSupportedFlexServiceTier(model)) {
+    return 15 * 1000 * 60
+  }
+  return defaultTimeout
+}
+
+/**
+ * 构建系统提示词
+ */
+export async function buildSystemPromptWithTools(
+  prompt: string,
+  mcpTools?: MCPTool[],
+  assistant?: Assistant
+): Promise<string> {
+  return await buildSystemPrompt(prompt, mcpTools, assistant)
+}
+
+// /**
+//  * 转换 MCP 工具为 AI SDK 工具格式
+//  * 注意：这里返回通用格式，实际使用时需要根据具体 provider 转换
+// TODO: 需要使用ai-sdk的mcp
+//  */
+// export function convertMcpToolsToSdkTools(mcpTools: MCPTool[]): Pick<StreamTextParams, 'tools'> {
+//   return mcpTools.map((tool) => ({
+//     type: 'function',
+//     function: {
+//       name: tool.id,
+//       description: tool.description,
+//       parameters: tool.inputSchema || {}
+//     }
+//   }))
+// }
+
+/**
+ * 提取文件内容
+ */
+export async function extractFileContent(message: Message): Promise<string> {
+  const fileBlocks = findFileBlocks(message)
+  if (fileBlocks.length > 0) {
+    const textFileBlocks = fileBlocks.filter(
+      (fb) => fb.file && [FileTypes.TEXT, FileTypes.DOCUMENT].includes(fb.file.type)
+    )
+
+    if (textFileBlocks.length > 0) {
+      let text = ''
+      const divider = '\n\n---\n\n'
+
+      for (const fileBlock of textFileBlocks) {
+        const file = fileBlock.file
+        const fileContent = (await window.api.file.read(file.id + file.ext)).trim()
+        const fileNameRow = 'file: ' + file.origin_name + '\n\n'
+        text = text + fileNameRow + fileContent + divider
+      }
+
+      return text
+    }
+  }
+
+  return ''
+}
+
+/**
+ * 转换消息为 AI SDK 参数格式
+ * 基于 OpenAI 格式的通用转换，支持文本、图片和文件
+ */
+export async function convertMessageToSdkParam(message: Message, isVisionModel = false): Promise<any> {
+  const content = getMainTextContent(message)
+  const fileBlocks = findFileBlocks(message)
+  const imageBlocks = findImageBlocks(message)
+
+  // 简单消息（无文件无图片）
+  if (fileBlocks.length === 0 && imageBlocks.length === 0) {
+    return {
+      role: message.role === 'system' ? 'user' : message.role,
+      content
+    }
+  }
+
+  // 复杂消息（包含文件或图片）
+  const parts: any[] = []
+
+  if (content) {
+    parts.push({ type: 'text', text: content })
+  }
+
+  // 处理图片（仅在支持视觉的模型中）
+  if (isVisionModel) {
+    for (const imageBlock of imageBlocks) {
+      if (imageBlock.file) {
+        try {
+          const image = await window.api.file.base64Image(imageBlock.file.id + imageBlock.file.ext)
+          parts.push({
+            type: 'image_url',
+            image_url: { url: image.data }
+          })
+        } catch (error) {
+          console.warn('Failed to load image:', error)
+        }
+      } else if (imageBlock.url && imageBlock.url.startsWith('data:')) {
+        parts.push({
+          type: 'image_url',
+          image_url: { url: imageBlock.url }
+        })
+      }
+    }
+  }
+
+  // 处理文件
+  for (const fileBlock of fileBlocks) {
+    const file = fileBlock.file
+    if (!file) continue
+
+    if ([FileTypes.TEXT, FileTypes.DOCUMENT].includes(file.type)) {
+      try {
+        const fileContent = await window.api.file.read(file.id + file.ext)
+        parts.push({
+          type: 'text',
+          text: `${file.origin_name}\n${fileContent.trim()}`
+        })
+      } catch (error) {
+        console.warn('Failed to read file:', error)
+      }
+    }
+  }
+
+  return {
+    role: message.role === 'system' ? 'user' : message.role,
+    content: parts.length === 1 && parts[0].type === 'text' ? parts[0].text : parts
+  }
+}
+
+/**
+ * 转换 Cherry Studio 消息数组为 AI SDK 消息数组
+ */
+export async function convertMessagesToSdkMessages(
+  messages: Message[],
+  model: Model
+): Promise<StreamTextParams['messages']> {
+  const sdkMessages: StreamTextParams['messages'] = []
+  const isVision = model.id.includes('vision') || model.id.includes('gpt-4') // 简单的视觉模型检测
+
+  for (const message of messages) {
+    const sdkMessage = await convertMessageToSdkParam(message, isVision)
+    sdkMessages.push(sdkMessage)
+  }
+
+  return sdkMessages
+}
+
+/**
+ * 构建 AI SDK 流式参数
+ * 这是主要的参数构建函数，整合所有转换逻辑
+ */
+export async function buildStreamTextParams(
+  sdkMessages: StreamTextParams['messages'],
+  assistant: Assistant,
+  options: {
+    mcpTools?: MCPTool[]
+    enableTools?: boolean
+    requestOptions?: {
+      signal?: AbortSignal
+      timeout?: number
+      headers?: Record<string, string>
+    }
+  } = {}
+): Promise<{ params: StreamTextParams; modelId: string }> {
+  const { mcpTools, enableTools = false } = options
+
+  const model = assistant.model || getDefaultModel()
+
+  const { maxTokens, reasoning_effort } = getAssistantSettings(assistant)
+
+  const enableReasoning =
+    ((isSupportedThinkingTokenModel(model) || isSupportedReasoningEffortModel(model)) &&
+      reasoning_effort !== undefined) ||
+    (isReasoningModel(model) && (!isSupportedThinkingTokenModel(model) || !isSupportedReasoningEffortModel(model)))
+
+  const enableWebSearch =
+    (assistant.enableWebSearch && isWebSearchModel(model)) ||
+    isOpenRouterBuiltInWebSearchModel(model) ||
+    model.id.includes('sonar') ||
+    false
+
+  const enableGenerateImage =
+    isGenerateImageModel(model) &&
+    (isSupportedDisableGenerationModel(model) ? assistant.enableGenerateImage || false : true)
+
+  // 构建系统提示
+  let systemPrompt = assistant.prompt || ''
+  if (mcpTools && mcpTools.length > 0) {
+    systemPrompt = await buildSystemPromptWithTools(systemPrompt, mcpTools, assistant)
+  }
+
+  // 构建基础参数
+  const params: StreamTextParams = {
+    messages: sdkMessages,
+    maxTokens: maxTokens || 1000,
+    temperature: getTemperature(assistant, model),
+    topP: getTopP(assistant, model),
+    system: systemPrompt || undefined,
+    abortSignal: options.requestOptions?.signal,
+    headers: options.requestOptions?.headers,
+    // 随便填着，后面再改
+    providerOptions: {
+      reasoning: {
+        enabled: enableReasoning
+      },
+      webSearch: {
+        enabled: enableWebSearch
+      },
+      generateImage: {
+        enabled: enableGenerateImage
+      }
+    },
+    ...getCustomParameters(assistant)
+  }
+
+  // 添加工具（如果启用且有工具）
+  if (enableTools && mcpTools && mcpTools.length > 0) {
+    // TODO: 暂时注释掉工具支持，等类型问题解决后再启用
+    // params.tools = convertMcpToolsToSdkTools(mcpTools)
+  }
+
+  return { params, modelId: model.id }
+}
+
+/**
+ * 构建非流式的 generateText 参数
+ */
+export async function buildGenerateTextParams(
+  messages: CoreMessage[],
+  assistant: Assistant,
+  options: {
+    mcpTools?: MCPTool[]
+    enableTools?: boolean
+  } = {}
+): Promise<any> {
+  // 复用流式参数的构建逻辑
+  return await buildStreamTextParams(messages, assistant, options)
+}
+
+/**
+ * 获取自定义参数
+ * 从 assistant 设置中提取自定义参数
+ */
+export function getCustomParameters(assistant: Assistant): Record<string, any> {
+  return (
+    assistant?.settings?.customParameters?.reduce((acc, param) => {
+      if (!param.name?.trim()) {
+        return acc
+      }
+      if (param.type === 'json') {
+        const value = param.value as string
+        if (value === 'undefined') {
+          return { ...acc, [param.name]: undefined }
+        }
+        try {
+          return { ...acc, [param.name]: JSON.parse(value) }
+        } catch {
+          return { ...acc, [param.name]: value }
+        }
+      }
+      return {
+        ...acc,
+        [param.name]: param.value
+      }
+    }, {}) || {}
+  )
+}
--- a/src/renderer/src/services/ApiService.ts
+++ b/src/renderer/src/services/ApiService.ts
@@ -1,255 +1,252 @@
+/**
+ * 职责：提供原子化的、无状态的API调用函数
+ */
+
+import { StreamTextParams } from '@cherrystudio/ai-core'
+import { AiSdkMiddlewareConfig } from '@renderer/aiCore/middleware/aisdk/AiSdkMiddlewareBuilder'
 import { CompletionsParams } from '@renderer/aiCore/middleware/schemas'
-import Logger from '@renderer/config/logger'
+import { buildStreamTextParams } from '@renderer/aiCore/transformParameters'
 import {
  isEmbeddingModel,
-  isGenerateImageModel,
-  isOpenRouterBuiltInWebSearchModel,
  isReasoningModel,
-  isSupportedDisableGenerationModel,
  isSupportedReasoningEffortModel,
-  isSupportedThinkingTokenModel,
-  isWebSearchModel
+  isSupportedThinkingTokenModel
 } from '@renderer/config/models'
-import {
-  SEARCH_SUMMARY_PROMPT,
-  SEARCH_SUMMARY_PROMPT_KNOWLEDGE_ONLY,
-  SEARCH_SUMMARY_PROMPT_WEB_ONLY
-} from '@renderer/config/prompts'
 import { getStoreSetting } from '@renderer/hooks/useSettings'
 import i18n from '@renderer/i18n'
-import {
-  Assistant,
-  ExternalToolResult,
-  KnowledgeReference,
-  MCPTool,
-  Model,
-  Provider,
-  WebSearchResponse,
-  WebSearchSource
-} from '@renderer/types'
+import { Assistant, MCPTool, Model, Provider } from '@renderer/types'
 import { type Chunk, ChunkType } from '@renderer/types/chunk'
 import { Message } from '@renderer/types/newMessage'
 import { SdkModel } from '@renderer/types/sdk'
 import { removeSpecialCharactersForTopicName } from '@renderer/utils'
-import { isAbortError } from '@renderer/utils/error'
-import { extractInfoFromXML, ExtractResults } from '@renderer/utils/extract'
 import { findFileBlocks, getMainTextContent } from '@renderer/utils/messageUtils/find'
-import { findLast, isEmpty, takeRight } from 'lodash'
+import { isEmpty, takeRight } from 'lodash'

 import AiProvider from '../aiCore'
+import AiProviderNew from '../aiCore/index_new'
 import store from '../store'
 import {
  getAssistantProvider,
-  getAssistantSettings,
  getDefaultModel,
  getProviderByModel,
  getTopNamingModel,
  getTranslateModel
 } from './AssistantService'
 import { getDefaultAssistant } from './AssistantService'
-import { processKnowledgeSearch } from './KnowledgeService'
-import {
-  filterContextMessages,
-  filterEmptyMessages,
-  filterUsefulMessages,
-  filterUserRoleStartMessages
-} from './MessagesService'
-import WebSearchService from './WebSearchService'

-// TODO：考虑拆开
-async function fetchExternalTool(
-  lastUserMessage: Message,
-  assistant: Assistant,
-  onChunkReceived: (chunk: Chunk) => void,
-  lastAnswer?: Message
-): Promise<ExternalToolResult> {
-  // 可能会有重复？
-  const knowledgeBaseIds = assistant.knowledge_bases?.map((base) => base.id)
-  const hasKnowledgeBase = !isEmpty(knowledgeBaseIds)
-  const knowledgeRecognition = assistant.knowledgeRecognition || 'on'
-  const webSearchProvider = WebSearchService.getWebSearchProvider(assistant.webSearchProviderId)
+// // TODO：考虑拆开
+// async function fetchExternalTool(
+//   lastUserMessage: Message,
+//   assistant: Assistant,
+//   onChunkReceived: (chunk: Chunk) => void,
+//   lastAnswer?: Message
+// ) {
+//   // 可能会有重复？
+//   const knowledgeBaseIds = assistant.knowledge_bases?.map((base) => base.id)
+//   const hasKnowledgeBase = !isEmpty(knowledgeBaseIds)
+//   const knowledgeRecognition = assistant.knowledgeRecognition || 'on'
+//   const webSearchProvider = WebSearchService.getWebSearchProvider(assistant.webSearchProviderId)

-  // 使用外部搜索工具
-  const shouldWebSearch = !!assistant.webSearchProviderId && webSearchProvider !== null
-  const shouldKnowledgeSearch = hasKnowledgeBase
+//   // 使用外部搜索工具
+//   const shouldWebSearch = !!assistant.webSearchProviderId && webSearchProvider !== null
+//   const shouldKnowledgeSearch = hasKnowledgeBase

-  // 在工具链开始时发送进度通知
-  const willUseTools = shouldWebSearch || shouldKnowledgeSearch
-  if (willUseTools) {
-    onChunkReceived({ type: ChunkType.EXTERNEL_TOOL_IN_PROGRESS })
-  }
+//   // 在工具链开始时发送进度通知
+//   const willUseTools = shouldWebSearch || shouldKnowledgeSearch
+//   if (willUseTools) {
+//     onChunkReceived({ type: ChunkType.EXTERNEL_TOOL_IN_PROGRESS })
+//   }

-  // --- Keyword/Question Extraction Function ---
-  const extract = async (): Promise<ExtractResults | undefined> => {
-    if (!lastUserMessage) return undefined
+//   // --- Keyword/Question Extraction Function ---
+//   const extract = async (): Promise<ExtractResults | undefined> => {
+//     if (!lastUserMessage) return undefined

-    // 根据配置决定是否需要提取
-    const needWebExtract = shouldWebSearch
-    const needKnowledgeExtract = hasKnowledgeBase && knowledgeRecognition === 'on'
+//     // 根据配置决定是否需要提取
+//     const needWebExtract = shouldWebSearch
+//     const needKnowledgeExtract = hasKnowledgeBase && knowledgeRecognition === 'on'

-    if (!needWebExtract && !needKnowledgeExtract) return undefined
+//     if (!needWebExtract && !needKnowledgeExtract) return undefined

-    let prompt: string
-    if (needWebExtract && !needKnowledgeExtract) {
-      prompt = SEARCH_SUMMARY_PROMPT_WEB_ONLY
-    } else if (!needWebExtract && needKnowledgeExtract) {
-      prompt = SEARCH_SUMMARY_PROMPT_KNOWLEDGE_ONLY
-    } else {
-      prompt = SEARCH_SUMMARY_PROMPT
-    }
+//     let prompt: string
+//     if (needWebExtract && !needKnowledgeExtract) {
+//       prompt = SEARCH_SUMMARY_PROMPT_WEB_ONLY
+//     } else if (!needWebExtract && needKnowledgeExtract) {
+//       prompt = SEARCH_SUMMARY_PROMPT_KNOWLEDGE_ONLY
+//     } else {
+//       prompt = SEARCH_SUMMARY_PROMPT
+//     }

-    const summaryAssistant = getDefaultAssistant()
-    summaryAssistant.model = assistant.model || getDefaultModel()
-    summaryAssistant.prompt = prompt
+//     const summaryAssistant = getDefaultAssistant()
+//     summaryAssistant.model = assistant.model || getDefaultModel()
+//     summaryAssistant.prompt = prompt

-    try {
-      const result = await fetchSearchSummary({
-        messages: lastAnswer ? [lastAnswer, lastUserMessage] : [lastUserMessage],
-        assistant: summaryAssistant
-      })
+//     try {
+//       const result = await fetchSearchSummary({
+//         messages: lastAnswer ? [lastAnswer, lastUserMessage] : [lastUserMessage],
+//         assistant: summaryAssistant
+//       })

-      if (!result) return getFallbackResult()
+//       if (!result) return getFallbackResult()

-      const extracted = extractInfoFromXML(result.getText())
-      // 根据需求过滤结果
-      return {
-        websearch: needWebExtract ? extracted?.websearch : undefined,
-        knowledge: needKnowledgeExtract ? extracted?.knowledge : undefined
-      }
-    } catch (e: any) {
-      console.error('extract error', e)
-      if (isAbortError(e)) throw e
-      return getFallbackResult()
-    }
-  }
+//       const extracted = extractInfoFromXML(result.getText())
+//       // 根据需求过滤结果
+//       return {
+//         websearch: needWebExtract ? extracted?.websearch : undefined,
+//         knowledge: needKnowledgeExtract ? extracted?.knowledge : undefined
+//       }
+//     } catch (e: any) {
+//       console.error('extract error', e)
+//       if (isAbortError(e)) throw e
+//       return getFallbackResult()
+//     }
+//   }

-  const getFallbackResult = (): ExtractResults => {
-    const fallbackContent = getMainTextContent(lastUserMessage)
-    return {
-      websearch: shouldWebSearch ? { question: [fallbackContent || 'search'] } : undefined,
-      knowledge: shouldKnowledgeSearch
-        ? {
-            question: [fallbackContent || 'search'],
-            rewrite: fallbackContent
-          }
-        : undefined
-    }
-  }
+//   const getFallbackResult = (): ExtractResults => {
+//     const fallbackContent = getMainTextContent(lastUserMessage)
+//     return {
+//       websearch: shouldWebSearch ? { question: [fallbackContent || 'search'] } : undefined,
+//       knowledge: shouldKnowledgeSearch
+//         ? {
+//             question: [fallbackContent || 'search'],
+//             rewrite: fallbackContent
+//           }
+//         : undefined
+//     }
+//   }

-  // --- Web Search Function ---
-  const searchTheWeb = async (extractResults: ExtractResults | undefined): Promise<WebSearchResponse | undefined> => {
-    if (!shouldWebSearch) return
+//   // --- Web Search Function ---
+//   const searchTheWeb = async (extractResults: ExtractResults | undefined): Promise<WebSearchResponse | undefined> => {
+//     if (!shouldWebSearch) return

-    // Add check for extractResults existence early
-    if (!extractResults?.websearch) {
-      console.warn('searchTheWeb called without valid extractResults.websearch')
-      return
-    }
+//     // Add check for extractResults existence early
+//     if (!extractResults?.websearch) {
+//       console.warn('searchTheWeb called without valid extractResults.websearch')
+//       return
+//     }

-    if (extractResults.websearch.question[0] === 'not_needed') return
+//     if (extractResults.websearch.question[0] === 'not_needed') return

-    // Add check for assistant.model before using it
-    if (!assistant.model) {
-      console.warn('searchTheWeb called without assistant.model')
-      return undefined
-    }
+//     // Add check for assistant.model before using it
+//     if (!assistant.model) {
+//       console.warn('searchTheWeb called without assistant.model')
+//       return undefined
+//     }

-    try {
-      // Use the consolidated processWebsearch function
-      WebSearchService.createAbortSignal(lastUserMessage.id)
-      return {
-        results: await WebSearchService.processWebsearch(webSearchProvider!, extractResults),
-        source: WebSearchSource.WEBSEARCH
-      }
-    } catch (error) {
-      if (isAbortError(error)) throw error
-      console.error('Web search failed:', error)
-      return
-    }
-  }
+//     try {
+//       // Use the consolidated processWebsearch function
+//       WebSearchService.createAbortSignal(lastUserMessage.id)
+//       return {
+//         results: await WebSearchService.processWebsearch(webSearchProvider!, extractResults),
+//         source: WebSearchSource.WEBSEARCH
+//       }
+//     } catch (error) {
+//       if (isAbortError(error)) throw error
+//       console.error('Web search failed:', error)
+//       return
+//     }
+//   }

-  // --- Knowledge Base Search Function ---
-  const searchKnowledgeBase = async (
-    extractResults: ExtractResults | undefined
-  ): Promise<KnowledgeReference[] | undefined> => {
-    if (!hasKnowledgeBase) return
+//   // --- Knowledge Base Search Function ---
+//   const searchKnowledgeBase = async (
+//     extractResults: ExtractResults | undefined
+//   ): Promise<KnowledgeReference[] | undefined> => {
+//     if (!hasKnowledgeBase) return

-    // 知识库搜索条件
-    let searchCriteria: { question: string[]; rewrite: string }
-    if (knowledgeRecognition === 'off') {
-      const directContent = getMainTextContent(lastUserMessage)
-      searchCriteria = { question: [directContent || 'search'], rewrite: directContent }
-    } else {
-      // auto mode
-      if (!extractResults?.knowledge) {
-        console.warn('searchKnowledgeBase: No valid search criteria in auto mode')
-        return
-      }
-      searchCriteria = extractResults.knowledge
-    }
+//     // 知识库搜索条件
+//     let searchCriteria: { question: string[]; rewrite: string }
+//     if (knowledgeRecognition === 'off') {
+//       const directContent = getMainTextContent(lastUserMessage)
+//       searchCriteria = { question: [directContent || 'search'], rewrite: directContent }
+//     } else {
+//       // auto mode
+//       if (!extractResults?.knowledge) {
+//         console.warn('searchKnowledgeBase: No valid search criteria in auto mode')
+//         return
+//       }
+//       searchCriteria = extractResults.knowledge
+//     }

-    if (searchCriteria.question[0] === 'not_needed') return
+//     if (searchCriteria.question[0] === 'not_needed') return

-    try {
-      const tempExtractResults: ExtractResults = {
-        websearch: undefined,
-        knowledge: searchCriteria
-      }
-      // Attempt to get knowledgeBaseIds from the main text block
-      // NOTE: This assumes knowledgeBaseIds are ONLY on the main text block
-      // NOTE: processKnowledgeSearch needs to handle undefined ids gracefully
-      // const mainTextBlock = mainTextBlocks
-      //   ?.map((blockId) => store.getState().messageBlocks.entities[blockId])
-      //   .find((block) => block?.type === MessageBlockType.MAIN_TEXT) as MainTextMessageBlock | undefined
-      return await processKnowledgeSearch(tempExtractResults, knowledgeBaseIds)
-    } catch (error) {
-      console.error('Knowledge base search failed:', error)
-      return
-    }
-  }
+//     try {
+//       const tempExtractResults: ExtractResults = {
+//         websearch: undefined,
+//         knowledge: searchCriteria
+//       }
+//       // Attempt to get knowledgeBaseIds from the main text block
+//       // NOTE: This assumes knowledgeBaseIds are ONLY on the main text block
+//       // NOTE: processKnowledgeSearch needs to handle undefined ids gracefully
+//       // const mainTextBlock = mainTextBlocks
+//       //   ?.map((blockId) => store.getState().messageBlocks.entities[blockId])
+//       //   .find((block) => block?.type === MessageBlockType.MAIN_TEXT) as MainTextMessageBlock | undefined
+//       return await processKnowledgeSearch(tempExtractResults, knowledgeBaseIds)
+//     } catch (error) {
+//       console.error('Knowledge base search failed:', error)
+//       return
+//     }
+//   }

-  // --- Execute Extraction and Searches ---
-  let extractResults: ExtractResults | undefined
+//   // --- Execute Extraction and Searches ---
+//   let extractResults: ExtractResults | undefined

-  try {
-    // 根据配置决定是否需要提取
-    if (shouldWebSearch || hasKnowledgeBase) {
-      extractResults = await extract()
-      Logger.log('[fetchExternalTool] Extraction results:', extractResults)
-    }
+//   try {
+//     // 根据配置决定是否需要提取
+//     if (shouldWebSearch || hasKnowledgeBase) {
+//       extractResults = await extract()
+//       Logger.log('[fetchExternalTool] Extraction results:', extractResults)
+//     }

-    let webSearchResponseFromSearch: WebSearchResponse | undefined
-    let knowledgeReferencesFromSearch: KnowledgeReference[] | undefined
+//     let webSearchResponseFromSearch: WebSearchResponse | undefined
+//     let knowledgeReferencesFromSearch: KnowledgeReference[] | undefined

-    // 并行执行搜索
-    if (shouldWebSearch || shouldKnowledgeSearch) {
-      ;[webSearchResponseFromSearch, knowledgeReferencesFromSearch] = await Promise.all([
-        searchTheWeb(extractResults),
-        searchKnowledgeBase(extractResults)
-      ])
-    }
+//     // 并行执行搜索
+//     if (shouldWebSearch || shouldKnowledgeSearch) {
+//       ;[webSearchResponseFromSearch, knowledgeReferencesFromSearch] = await Promise.all([
+//         searchTheWeb(extractResults),
+//         searchKnowledgeBase(extractResults)
+//       ])
+//     }

-    // 存储搜索结果
-    if (lastUserMessage) {
-      if (webSearchResponseFromSearch) {
-        window.keyv.set(`web-search-${lastUserMessage.id}`, webSearchResponseFromSearch)
-      }
-      if (knowledgeReferencesFromSearch) {
-        window.keyv.set(`knowledge-search-${lastUserMessage.id}`, knowledgeReferencesFromSearch)
-      }
-    }
+//     // 存储搜索结果
+//     if (lastUserMessage) {
+//       if (webSearchResponseFromSearch) {
+//         window.keyv.set(`web-search-${lastUserMessage.id}`, webSearchResponseFromSearch)
+//       }
+//       if (knowledgeReferencesFromSearch) {
+//         window.keyv.set(`knowledge-search-${lastUserMessage.id}`, knowledgeReferencesFromSearch)
+//       }
+//     }

-    // 发送工具执行完成通知
-    if (willUseTools) {
-      onChunkReceived({
-        type: ChunkType.EXTERNEL_TOOL_COMPLETE,
-        external_tool: {
-          webSearch: webSearchResponseFromSearch,
-          knowledge: knowledgeReferencesFromSearch
-        }
-      })
-    }
+//     // 发送工具执行完成通知
+//     if (willUseTools) {
+//       onChunkReceived({
+//         type: ChunkType.EXTERNEL_TOOL_COMPLETE,
+//         external_tool: {
+//           webSearch: webSearchResponseFromSearch,
+//           knowledge: knowledgeReferencesFromSearch
+//         }
+//       })
+//     }
+//   } catch (error) {
+//     if (isAbortError(error)) throw error
+//     console.error('Tool execution failed:', error)

+//     // 发送错误状态
+//     if (willUseTools) {
+//       onChunkReceived({
+//         type: ChunkType.EXTERNEL_TOOL_COMPLETE,
+//         external_tool: {
+//           webSearch: undefined,
+//           knowledge: undefined
+//         }
+//       })
+//     }
+
+//     return { mcpTools: [] }
+//   }
+// }
+
+export async function fetchMcpTools(assistant: Assistant) {
  // Get MCP tools (Fix duplicate declaration)
  let mcpTools: MCPTool[] = [] // Initialize as empty array
  const allMcpServers = store.getState().mcp.servers || []
@@ -279,101 +276,46 @@ async function fetchExternalTool(
    }
  }

-    return { mcpTools }
-  } catch (error) {
-    if (isAbortError(error)) throw error
-    console.error('Tool execution failed:', error)
-
-    // 发送错误状态
-    if (willUseTools) {
-      onChunkReceived({
-        type: ChunkType.EXTERNEL_TOOL_COMPLETE,
-        external_tool: {
-          webSearch: undefined,
-          knowledge: undefined
-        }
-      })
-    }
-
-    return { mcpTools: [] }
-  }
+  return mcpTools
 }

 export async function fetchChatCompletion({
  messages,
  assistant,
+  options,
  onChunkReceived
 }: {
-  messages: Message[]
+  messages: StreamTextParams['messages']
  assistant: Assistant
-  onChunkReceived: (chunk: Chunk) => void
-  // TODO
-  // onChunkStatus: (status: 'searching' | 'processing' | 'success' | 'error') => void
-}) {
-  console.log('fetchChatCompletion', messages, assistant)
-
-  const provider = getAssistantProvider(assistant)
-  const AI = new AiProvider(provider)
-
-  // Make sure that 'Clear Context' works for all scenarios including external tool and normal chat.
-  messages = filterContextMessages(messages)
-
-  const lastUserMessage = findLast(messages, (m) => m.role === 'user')
-  const lastAnswer = findLast(messages, (m) => m.role === 'assistant')
-  if (!lastUserMessage) {
-    console.error('fetchChatCompletion returning early: Missing lastUserMessage or lastAnswer')
-    return
+  options: {
+    signal?: AbortSignal
+    timeout?: number
+    headers?: Record<string, string>
  }
-  // try {
-  // NOTE: The search results are NOT added to the messages sent to the AI here.
-  // They will be retrieved and used by the messageThunk later to create CitationBlocks.
-  const { mcpTools } = await fetchExternalTool(lastUserMessage, assistant, onChunkReceived, lastAnswer)
-  const model = assistant.model || getDefaultModel()
+  onChunkReceived: (chunk: Chunk) => void
+}) {
+  const provider = getAssistantProvider(assistant)
+  const AI = new AiProviderNew(provider)

-  const { maxTokens, contextCount } = getAssistantSettings(assistant)
+  const mcpTools = await fetchMcpTools(assistant)

-  const filteredMessages = filterUsefulMessages(messages)
+  // 使用 transformParameters 模块构建参数
+  const { params: aiSdkParams, modelId } = await buildStreamTextParams(messages, assistant, {
+    mcpTools: mcpTools,
+    requestOptions: options
+  })

-  const _messages = filterUserRoleStartMessages(
-    filterEmptyMessages(filterContextMessages(takeRight(filteredMessages, contextCount + 2))) // 取原来几个provider的最大值
-  )
-
-  const enableReasoning =
-    ((isSupportedThinkingTokenModel(model) || isSupportedReasoningEffortModel(model)) &&
-      assistant.settings?.reasoning_effort !== undefined) ||
-    (isReasoningModel(model) && (!isSupportedThinkingTokenModel(model) || !isSupportedReasoningEffortModel(model)))
-
-  const enableWebSearch =
-    (assistant.enableWebSearch && isWebSearchModel(model)) ||
-    isOpenRouterBuiltInWebSearchModel(model) ||
-    model.id.includes('sonar') ||
-    false
-
-  const enableGenerateImage =
-    isGenerateImageModel(model) && (isSupportedDisableGenerationModel(model) ? assistant.enableGenerateImage : true)
+  const middlewareConfig: AiSdkMiddlewareConfig = {
+    streamOutput: assistant.settings?.streamOutput ?? true,
+    onChunk: onChunkReceived,
+    model: assistant.model,
+    provider: provider,
+    enableReasoning: assistant.settings?.reasoning_effort !== undefined
+  }

  // --- Call AI Completions ---
  onChunkReceived({ type: ChunkType.LLM_RESPONSE_CREATED })
-  if (enableWebSearch) {
-    onChunkReceived({ type: ChunkType.LLM_WEB_SEARCH_IN_PROGRESS })
-  }
-  await AI.completions(
-    {
-      callType: 'chat',
-      messages: _messages,
-      assistant,
-      onChunk: onChunkReceived,
-      mcpTools: mcpTools,
-      maxTokens,
-      streamOutput: assistant.settings?.streamOutput || false,
-      enableReasoning,
-      enableWebSearch,
-      enableGenerateImage
-    },
-    {
-      streamOutput: assistant.settings?.streamOutput || false
-    }
-  )
+  await AI.completions(modelId, aiSdkParams, middlewareConfig)
 }

 interface FetchTranslateProps {
--- a/src/renderer/src/services/ConversationService.ts
+++ b/src/renderer/src/services/ConversationService.ts
@@ -0,0 +1,34 @@
+import { StreamTextParams } from '@cherrystudio/ai-core'
+import { convertMessagesToSdkMessages } from '@renderer/aiCore/transformParameters'
+import { Assistant, Message } from '@renderer/types'
+import { isEmpty, takeRight } from 'lodash'
+
+import { getAssistantSettings, getDefaultModel } from './AssistantService'
+import {
+  filterContextMessages,
+  filterEmptyMessages,
+  filterUsefulMessages,
+  filterUserRoleStartMessages
+} from './MessagesService'
+
+export class ConversationService {
+  static async prepareMessagesForLlm(messages: Message[], assistant: Assistant): Promise<StreamTextParams['messages']> {
+    const { contextCount } = getAssistantSettings(assistant)
+    // This logic is extracted from the original ApiService.fetchChatCompletion
+    const contextMessages = filterContextMessages(messages)
+    const filteredMessages = filterUsefulMessages(contextMessages)
+    // Take the last `contextCount` messages, plus 2 to allow for a final user/assistant exchange.
+    const finalMessages = filterUserRoleStartMessages(
+      filterEmptyMessages(takeRight(filteredMessages, contextCount + 2))
+    )
+    return await convertMessagesToSdkMessages(finalMessages, assistant.model || getDefaultModel())
+  }
+
+  static needsWebSearch(assistant: Assistant): boolean {
+    return !!assistant.webSearchProviderId
+  }
+
+  static needsKnowledgeSearch(assistant: Assistant): boolean {
+    return !isEmpty(assistant.knowledge_bases)
+  }
+}
--- a/src/renderer/src/services/OrchestrateService.ts
+++ b/src/renderer/src/services/OrchestrateService.ts
@@ -0,0 +1,54 @@
+import { Assistant, Message } from '@renderer/types'
+import { Chunk, ChunkType } from '@renderer/types/chunk'
+
+import { fetchChatCompletion } from './ApiService'
+import { ConversationService } from './ConversationService'
+
+/**
+ * The request object for handling a user message.
+ */
+export interface OrchestrationRequest {
+  messages: Message[]
+  assistant: Assistant
+  options: {
+    signal?: AbortSignal
+    timeout?: number
+    headers?: Record<string, string>
+  }
+}
+
+/**
+ * The OrchestrationService is responsible for orchestrating the different services
+ * to handle a user's message. It contains the core logic of the application.
+ */
+export class OrchestrationService {
+  constructor() {
+    // In the future, this could be a singleton, but for now, a new instance is fine.
+    // this.conversationService = new ConversationService()
+  }
+
+  /**
+   * This is the core method to handle user messages.
+   * It takes the message context and an events object for callbacks,
+   * and orchestrates the call to the LLM.
+   * The logic is moved from `messageThunk.ts`.
+   * @param request The orchestration request containing messages and assistant info.
+   * @param events A set of callbacks to report progress and results to the UI layer.
+   */
+  async handleUserMessage(request: OrchestrationRequest, onChunkReceived: (chunk: Chunk) => void) {
+    const { messages, assistant } = request
+
+    try {
+      const llmMessages = await ConversationService.prepareMessagesForLlm(messages, assistant)
+
+      await fetchChatCompletion({
+        messages: llmMessages,
+        assistant: assistant,
+        options: request.options,
+        onChunkReceived
+      })
+    } catch (error: any) {
+      onChunkReceived({ type: ChunkType.ERROR, error })
+    }
+  }
+}
--- a/src/renderer/src/store/thunk/messageThunk.ts
+++ b/src/renderer/src/store/thunk/messageThunk.ts
@@ -1,9 +1,9 @@
 import db from '@renderer/databases'
 import { autoRenameTopic } from '@renderer/hooks/useTopic'
-import { fetchChatCompletion } from '@renderer/services/ApiService'
 import { EVENT_NAMES, EventEmitter } from '@renderer/services/EventService'
 import FileManager from '@renderer/services/FileManager'
 import { NotificationService } from '@renderer/services/NotificationService'
+import { OrchestrationService } from '@renderer/services/OrchestrateService'
 import { createStreamProcessor, type StreamProcessorCallbacks } from '@renderer/services/StreamProcessingService'
 import { estimateMessagesUsage } from '@renderer/services/TokenService'
 import store from '@renderer/store'
@@ -147,7 +147,7 @@ const getBlockThrottler = (id: string) => {
      }

      const rafId = requestAnimationFrame(() => {
-        store.dispatch(updateOneBlock({ id, changes: blockUpdate }))
+        // store.dispatch(updateOneBlock({ id, changes: blockUpdate }))
        blockUpdateRafs.delete(id)
      })

@@ -166,6 +166,7 @@ const getBlockThrottler = (id: string) => {
 */
 const throttledBlockUpdate = (id: string, blockUpdate: any) => {
  const throttler = getBlockThrottler(id)
+  store.dispatch(updateOneBlock({ id, changes: blockUpdate }))
  throttler(blockUpdate)
 }

@@ -829,15 +830,26 @@ const fetchAndProcessAssistantResponseImpl = async (
    const streamProcessorCallbacks = createStreamProcessor(callbacks)

    const startTime = Date.now()
-    await fetchChatCompletion({
+    const orchestrationService = new OrchestrationService()
+    await orchestrationService.handleUserMessage(
+      {
        messages: messagesForContext,
-      assistant: assistant,
-      onChunkReceived: streamProcessorCallbacks
-    })
+        assistant,
+        options: {
+          timeout: 30000
+        }
+      },
+      streamProcessorCallbacks
+    )
  } catch (error: any) {
-    console.error('Error fetching chat completion:', error)
-    if (assistantMessage) {
-      callbacks.onError?.(error)
+    console.error('Error in fetchAndProcessAssistantResponseImpl:', error)
+    // The main error handling is now delegated to OrchestrationService,
+    // which calls the `onError` callback. This catch block is for
+    // any errors that might occur outside of that orchestration flow.
+    if (assistantMessage && callbacks.onError) {
+      callbacks.onError(error)
+    } else {
+      // Fallback if callbacks are not even defined yet
      throw error
    }
  }
--- a/tsconfig.web.json
+++ b/tsconfig.web.json
@@ -4,7 +4,8 @@
    "src/renderer/src/**/*",
    "src/preload/*.d.ts",
    "local/src/renderer/**/*",
-    "packages/shared/**/*"
+    "packages/shared/**/*",
+    "packages/aiCore/src/**/*"
  ],
  "compilerOptions": {
    "composite": true,
@@ -14,7 +15,8 @@
    "paths": {
      "@renderer/*": ["src/renderer/src/*"],
      "@shared/*": ["packages/shared/*"],
-      "@types": ["src/renderer/src/types/index.ts"]
+      "@types": ["src/renderer/src/types/index.ts"],
+      "@cherrystudio/ai-core": ["packages/aiCore/src/"]
    }
  }
 }
--- a/yarn.lock
+++ b/yarn.lock