🔖 chore(release): v1.136.0 [skip ci]

## [Version 1.136.0](https://github.com/lobehub/lobe-chat/compare/v1.135.6...v1.136.0)
<sup>Released on **2025-10-09**</sup>

#### ✨ Features

- **misc**: Add new provider Cerebras.

#### 🐛 Bug Fixes

- **misc**: Fix standalone plugin rerender issue.

<br/>

<details>
<summary><kbd>Improvements and Fixes</kbd></summary>

#### What's improved

* **misc**: Add new provider Cerebras, closes [#9559](https://github.com/lobehub/lobe-chat/issues/9559) ([9cceaad](https://github.com/lobehub/lobe-chat/commit/9cceaad))

#### What's fixed

* **misc**: Fix standalone plugin rerender issue, closes [#9611](https://github.com/lobehub/lobe-chat/issues/9611) [#9396](https://github.com/lobehub/lobe-chat/issues/9396) ([7ab30fc](https://github.com/lobehub/lobe-chat/commit/7ab30fc))

</details>

<div align="right">

[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)

</div>

.cursor/rules/backend-architecture.mdc

@@ -1,176 +0,0 @@
----
-description:
-globs: src/services/**/*,src/database/**/*,src/server/**/*
-alwaysApply: false
----
-
-# LobeChat 后端技术架构指南
-
-本指南旨在阐述 LobeChat 项目的后端分层架构，重点介绍各核心目录的职责以及它们之间的协作方式。
-
-## 目录结构映射
-
-```
-src/
-├── server/
-│   ├── routers/          # tRPC API 路由定义
-│   └── services/         # 业务逻辑服务层
-│       └── */impls/      # 平台特定实现
-├── database/
-│   ├── models/           # 数据模型 (单表 CRUD)
-│   ├── repositories/     # 仓库层 (复杂查询/聚合)
-│   └── schemas/          # Drizzle ORM 表定义
-└── services/             # 客户端服务 (调用 tRPC 或直接访问 Model)
-```
-
-## 核心架构分层
-
-LobeChat 的后端设计注重模块化、可测试性和灵活性，以适应不同的运行环境（如浏览器端 PGLite、服务端远程 PostgreSQL 以及 Electron 桌面应用）。
-
-其主要分层如下：
-
-1.  客户端服务层 (`src/services`):
-    - 位于 src/services/。
-    - 这是客户端业务逻辑的核心层，负责封装各种业务操作和数据处理逻辑。
-    - 环境适配: 根据不同的运行环境，服务层会选择合适的数据访问方式：
-      - 本地数据库模式: 直接调用 `Model` 层进行数据操作，适用于浏览器 PGLite 和本地 Electron 应用。
-      - 远程数据库模式: 通过 `tRPC` 客户端调用服务端 API，适用于需要云同步的场景。
-    - 类型转换: 对于简单的数据类型转换，直接在此层进行类型断言，如 `this.pluginModel.query() as Promise<LobeTool[]>`
-    - 每个服务模块通常包含 `client.ts`（本地模式）、`server.ts`（远程模式）和 `type.ts`（接口定义）文件，在实现时应该确保本地模式和远程模式业务逻辑实现一致，只是数据库不同。
-
-2.  API 接口层 (`TRPC`):
-    - 位于 src/server/routers/
-    - 使用 `tRPC` 构建类型安全的 API。Router 根据运行时环境（如 Edge Functions, Node.js Lambda）进行组织。
-    - 负责接收客户端请求，并将其路由到相应的 `Service` 层进行处理。
-    - 新建 lambda 端点时可以参考 src/server/routers/lambda/\_template.ts
-
-3.  仓库层 (`Repositories`):
-    - 位于 src/database/repositories/。
-    - 主要处理复杂的跨表查询和数据聚合逻辑，特别是当需要从多个 `Model` 获取数据并进行组合时。
-    - 与 `Model` 层不同，`Repository` 层专注于复杂的业务查询场景，而不涉及简单的领域模型转换。
-    - 当业务逻辑涉及多表关联、复杂的数据统计或需要事务处理时，会使用 `Repository` 层。
-    - 如果数据操作简单（仅涉及单个 `Model`），则通常直接在 `src/services` 层调用 `Model` 并进行简单的类型断言。
-
-4.  模型层 (`Models`):
-    - 位于 src/database/models/ (例如 src/database/models/plugin.ts 和 src/database/models/document.ts)。
-    - 提供对数据库中各个表（由 src/database/schemas/ 中的 Drizzle ORM schema 定义）的基本 CRUD (创建、读取、更新、删除) 操作和简单的查询能力。
-    - `Model` 类专注于单个数据表的直接操作，不涉及复杂的领域模型转换，这些转换通常在上层的 `src/services` 中通过类型断言完成。
-    - model（例如 Topic） 层接口经常需要从对应的 schema 层导入 NewTopic 和 TopicItem
-    - 创建新的 model 时可以参考 src/database/models/\_template.ts
-
-5.  数据库 (`Database`):
-    - 客户端模式 (浏览器/PWA): 使用 PGLite (基于 WASM 的 PostgreSQL)，数据存储在用户浏览器本地。
-    - 服务端模式 (云部署): 使用远程 PostgreSQL 数据库。
-    - Electron 桌面应用:
-      - Electron 客户端会启动一个本地 Node.js 服务。
-      - 本地服务通过 `tRPC` 与 Electron 的渲染进程通信。
-      - 数据库选择依赖于是否开启云同步功能：
-        - 云同步开启: 连接到远程 PostgreSQL 数据库。
-        - 云同步关闭: 使用 PGLite (通过 Node.js 的 WASM 实现) 在本地存储数据。
-
-## 数据流向说明
-
-### 浏览器/PWA 模式
-
-```
-UI (React) → Zustand action -> Client Service → Model Layer → PGLite (本地数据库)
-```
-
-### 服务端模式
-
-```
-UI (React) → Zustand action → Client Service -> TRPC Client → TRPC Routers  → Repositories/Models → Remote PostgreSQL
-```
-
-### Electron 桌面应用模式
-
-```
-UI (Electron Renderer) → Zustand action → Client Service -> TRPC Client → 本地 Node.js 服务 → TRPC Routers → Repositories/Models → PGLite/Remote PostgreSQL (取决于云同步设置)
-```
-
-## 服务层 (Server Services)
-
-- 位于 src/server/services/。
-- 核心职责是封装独立的、可复用的业务逻辑单元。这些服务应易于测试。
-- 平台差异抽象: 一个关键特性是通过其内部的 `impls` 子目录（例如 src/server/services/file/impls 包含 s3.ts 和 local.ts）来抹平不同运行环境带来的差异（例如云端使用 S3 存储，桌面版使用本地文件系统）。这使得上层（如 `tRPC` routers）无需关心底层具体实现。
-- 目标是使 `tRPC` router 层的逻辑尽可能纯粹，专注于请求处理和业务流程编排。
-- 服务可能会调用 `Repository` 层或直接调用 `Model` 层进行数据持久化和检索，也可能调用其他服务。
-
-## 最佳实践 (Best Practices)
-
-### 数据库操作封装原则
-
-**连续的数据库操作应该封装到 Model 层**
-
-当业务逻辑涉及多个相关的数据库操作时，建议将这些操作封装到 Model 层中，而不是在上层（Service 或 Router 层）中进行多次数据库调用。
-
-**优势：**
-
-- **代码复用**: Client DB 环境的 service 实现和 Server DB 的 lambda 层实现可以复用相同的 Model 方法
-- **事务一致性**: 相关的数据库操作可以在同一个方法中管理，便于维护数据一致性
-- **性能优化**: 减少数据库连接次数，提高查询效率
-- **职责清晰**: Model 层专注数据访问，上层专注业务协调
-
-**示例：**
-
-```typescript
-// ✅ 推荐：在 Model 层封装连续的数据库操作
-class GenerationBatchModel {
-  async delete(id: string): Promise<{ deletedBatch: BatchItem; thumbnailUrls: string[] }> {
-    // 1. 查询相关数据
-    const batchWithGenerations = await this.db.query.generationBatches.findFirst({...});
-
-    // 2. 收集需要处理的数据
-    const thumbnailUrls = [...];
-
-    // 3. 执行删除操作
-    const [deletedBatch] = await this.db.delete(generationBatches)...;
-
-    return { deletedBatch, thumbnailUrls };
-  }
-}
-
-// ✅ 上层使用简洁
-const { thumbnailUrls } = await model.delete(id);
-await fileService.deleteFiles(thumbnailUrls);
-```
-
-### 文件操作与数据库操作的执行顺序
-
-**删除操作原则：数据库删除在前，文件删除在后**
-
-当业务逻辑同时涉及数据库记录和文件系统操作时，应该遵循"数据库优先"的原则。
-
-**原因：**
-
-- **用户体验优先**: 如果先删除文件再删除数据库记录，可能出现文件已删除但数据库记录仍存在的情况，用户访问时会遇到文件不存在的错误
-- **影响程度较小**: 如果先删除数据库记录再删除文件，即使文件删除失败，用户也看不到这个记录，只是造成一些存储空间浪费，对用户体验影响更小
-- **数据一致性**: 数据库记录是业务逻辑的核心，应该优先保证其一致性
-
-**示例：**
-
-```typescript
-// ✅ 推荐：先删除数据库记录，再删除文件
-async deleteGeneration(id: string) {
-  // 1. 先删除数据库记录
-  const deletedGeneration = await generationModel.delete(id);
-
-  // 2. 再删除相关文件
-  if (deletedGeneration.asset?.thumbnailUrl) {
-    await fileService.deleteFile(deletedGeneration.asset.thumbnailUrl);
-  }
-}
-
-// ❌ 不推荐：先删除文件
-async deleteGeneration(id: string) {
-  const generation = await generationModel.findById(id);
-
-  // 如果这里删除成功，但后面数据库删除失败，用户会遇到访问错误
-  await fileService.deleteFile(generation.asset.thumbnailUrl);
-  await generationModel.delete(id); // 可能失败
-}
-```
-
-**创建操作原则：数据库创建在前，文件操作在后**
-
-创建操作同样应该优先处理数据库记录，确保数据的一致性和完整性。

.cursor/rules/code-review.mdc

@@ -1,58 +0,0 @@
----
-description: How to code review
-globs:
-alwaysApply: false
----
-
-# Role Description
-
-- You are a senior full-stack engineer skilled in performance optimization, security, and design systems.
-- You excel at reviewing code and providing constructive feedback.
-- Your task is to review submitted Git diffs **in Chinese** and return a structured review report.
-- Review style: concise, direct, focused on what matters most, with actionable suggestions.
-
-## Before the Review
-
-Gather the modified code and context. Please strictly follow the process below:
-
-1. Use `read_file` to read [package.json](mdc:package.json)
-2. Use terminal to run command `git diff HEAD | cat` to obtain the diff and list the changed files. If you recieived empty result, run the same command once more.
-3. Use `read_file` to open each changed file.
-4. Use `read_file` to read [rules-attach.mdc](mdc:.cursor/rules/rules-attach.mdc). Even if you think it's unnecessary, you must read it.
-5. combine changed files, step3 and `agent_requestable_workspace_rules`, list the rules which need to read
-6. Use `read_file` to read the rules list in step 5
-
-## Review
-
-### Code Style
-
-read [typescript.mdc](mdc:.cursor/rules/typescript.mdc) for the consolidated project code style and optimization rules.
-
-### Code Optimization
-
-The optimization checklist has been consolidated into [typescript.mdc](mdc:.cursor/rules/typescript.mdc): loops, debouncing/throttling, design system components, theming tokens, concurrency with `Promise.*`, minimal DB column selection, and package reuse.
-
-### Obvious Bugs
-
-- Do not silently swallow errors in `catch` blocks; at minimum, log them.
-- Revert temporary code used only for testing (e.g., debug logs, temporary configs).
-- Remove empty handlers (e.g., an empty `onClick`).
-- Confirm the UI degrades gracefully for unauthenticated users.
-- Don't leave any debug logs in the code (except when using the `debug` module properly).
-  - When using the `debug` module, avoid `import { log } from 'debug'` as it logs directly to console. Use proper debug namespaces instead.
-- Check logs for sensitive information like api key, etc
-
-## After the Review: output
-
-1. Summary
-   - Start with a brief explanation of what the change set does.
-   - Summarize the changes for each modified file (or logical group).
-2. Comments Issues
-   - List the most critical issues first.
-   - Use an ordered list, which will be convenient for me to reference later.
-   - For each issue:
-     - Mark severity tag (`❌ Must fix`, `⚠️ Should fix`, `💅 Nitpick`)
-     - Provode file path to the relevant file.
-     - Provide recommended fix
-   - End with a **git commit** command, instruct the author to run it.
-     - We use gitmoji to label commit messages, format: [emoji] <type>(<scope>): <subject>

.cursor/rules/cursor-ux.mdc

@@ -1,32 +0,0 @@
----
-description:
-globs:
-alwaysApply: true
----
-
-# Guide to Optimize Output(Response) Rendering
-
-## File Path and Code Symbol Rendering
-
-- When rendering file paths, use backtick wrapping instead of markdown links so they can be parsed as clickable links in Cursor IDE.
-  - Good: `src/components/Button.tsx`
-  - Bad: [src/components/Button.tsx](src/components/Button.tsx)
-
-- Don't use line and column number in file path, this will make file path not clickable in Cursor IDE.
-  - Good: `src/components/Button.tsx` `10:20` (add a space between the file path and the line and column number)
-  - Bad: `src/components/Button.tsx:10:20`
-
-- When rendering functions, variables, or other code symbols, use backtick wrapping so they can be parsed as navigable links in Cursor IDE
-  - Good: The `useState` hook in `MyComponent`
-  - Bad: The useState hook in MyComponent
-
-## Markdown Render
-
-- don't use br tag to wrap in table cell
-
-## Terminal Command Output
-
-- If terminal commands don't produce output, it's likely due to paging issues. Try piping the command to `cat` to ensure full output is displayed.
-  - Good: `git show commit_hash -- file.txt | cat`
-  - Good: `git log --oneline | cat`
-  - Reason: Some git commands use pagers by default, which may prevent output from being captured properly

.cursor/rules/define-database-model.mdc

@@ -1,8 +0,0 @@
----
-description: 
-globs: src/database/models/**/*
-alwaysApply: false
----
-1. first read [lobe-chat-backend-architecture.mdc](mdc:.cursor/rules/lobe-chat-backend-architecture.mdc)
-2. refer to the [_template.ts](mdc:src/database/models/_template.ts) to create new model
-3. if an operation involves multiple models or complex queries, consider defining it in the `repositories` layer under `src/database/repositories/`

.cursor/rules/project-introduce.mdc

@@ -4,41 +4,33 @@ alwaysApply: true
 
 ## Project Description
 
-You are developing an open-source, modern-design AI chat framework: lobe chat.
+You are developing an open-source, modern-design AI chat framework: lobehub(previous lobe-chat).
 
-Emoji logo: 🤯
+Supported platforms:
+
+- web desktop/mobile
+- desktop(electron)
+- mobile app(react native), coming soon
+
+logo emoji: 🤯
 
 ## Project Technologies Stack
 
-read [package.json](mdc:package.json) to know all npm packages you can use.
-
-The project uses the following technologies:
-
-- pnpm as package manager
-- Next.js 15 for frontend and backend, using app router instead of pages router
-- react 19, using hooks, functional components, react server components
-- TypeScript programming language
-- antd, `@lobehub/ui` for component framework
+- Next.js 15
+- react 19
+- TypeScript
+- `@lobehub/ui`, antd for component framework
 - antd-style for css-in-js framework
-- react-layout-kit for flex layout
-- react-i18next for i18n
 - lucide-react, `@ant-design/icons` for icons
-- `@lobehub/icons` for AI provider/model logo icon
-- `@formkit/auto-animate` for react list animation
-- zustand for global state management
-- nuqs for type-safe search params state manager
-- SWR for react data fetch
+- react-layout-kit for flex layout component
+- react-i18next for i18n
+- zustand for state management
+- nuqs for search params management
+- SWR for data fetch
 - aHooks for react hooks library
-- dayjs for date and time library
+- dayjs for time library
 - lodash-es for utility library
-- fast-deep-equal for deep comparison of JavaScript objects
-- zod for data validation
 - TRPC for type safe backend
-- PGLite for client DB and PostgreSQL for backend DB
+- PGLite for client DB and Neon PostgreSQL for backend DB
 - Drizzle ORM
-- Vitest for testing, testing-library for react component test
-- Prettier for code formatting
-- ESLint for code linting
-- Cursor AI for code editing and AI coding assistance
-
-Note: All tools and libraries used are the latest versions. The application only needs to be compatible with the latest browsers;
+- Vitest for testing

.cursor/rules/project-structure.mdc

@@ -5,235 +5,118 @@ alwaysApply: false
 
 # LobeChat Project Structure
 
-## Directory Structure
+## Complete Project Structure
 
-note: some files are not shown for simplicity.
+This project uses common monorepo structure. The workspace packages name use `@lobechat/` namespace.
+
+**note**: some not very important files are not shown for simplicity.
 
 ```plaintext
 lobe-chat/
-├── apps/                           # Applications directory
-│   └── desktop/                    # Electron desktop application
-│       ├── src/                    # Desktop app source code
-│       └── resources/              # Desktop app resources
-├── docs/                           # Project documentation
-│   ├── development/                # Development docs
-│   ├── self-hosting/               # Self-hosting docs
-│   └── usage/                      # Usage guides
-├── locales/                        # Internationalization files (multiple locales)
-│   ├── en-US/                      # English (example)
-│   └── zh-CN/                      # Simplified Chinese (example)
-├── packages/                       # Monorepo packages directory
-│   ├── const/                      # Constants definition package
-│   ├── database/                   # Database related package
-│   ├── electron-client-ipc/        # Electron renderer ↔ main IPC client
-│   ├── electron-server-ipc/        # Electron main process IPC server
-│   ├── model-bank/                 # Built-in model presets/catalog exports
-│   ├── model-runtime/              # AI model runtime package
-│   ├── types/                      # TypeScript type definitions
-│   ├── utils/                      # Utility functions package
-│   ├── file-loaders/               # File processing packages
-│   ├── prompts/                    # AI prompt management
-│   └── web-crawler/                # Web crawling functionality
-├── public/                         # Static assets
-│   ├── icons/                      # Application icons
-│   ├── images/                     # Image resources
-│   └── screenshots/                # Application screenshots
-├── scripts/                        # Build and tool scripts
-├── src/                            # Main application source code (see below)
-├── .cursor/                        # Cursor AI configuration
-├── docker-compose/                 # Docker configuration
-├── package.json                    # Project dependencies
-├── pnpm-workspace.yaml            # pnpm monorepo configuration
-├── next.config.ts                  # Next.js configuration
-├── drizzle.config.ts              # Drizzle ORM configuration
-└── tsconfig.json                   # TypeScript configuration
-```
-
-## Core Source Directory (`src/`)
-
-```plaintext
-src/
-├── app/                            # Next.js App Router routes
-│   ├── (backend)/                  # Backend API routes
-│   │   ├── api/                    # REST API endpoints
-│   │   │   ├── auth/               # Authentication endpoints
-│   │   │   └── webhooks/           # Webhook handlers for various auth providers
-│   │   ├── middleware/             # Request middleware
-│   │   ├── oidc/                   # OpenID Connect endpoints
-│   │   ├── trpc/                   # tRPC API routes
-│   │   │   ├── async/              # Async tRPC endpoints
-│   │   │   ├── desktop/            # Desktop runtime endpoints
-│   │   │   ├── edge/               # Edge runtime endpoints
-│   │   │   ├── lambda/             # Lambda runtime endpoints
-│   │   │   └── tools/              # Tools-specific endpoints
-│   │   └── webapi/                 # Web API endpoints
-│   │       ├── chat/               # Chat-related APIs for various providers
-│   │       ├── models/             # Model management APIs
-│   │       ├── plugin/             # Plugin system APIs
-│   │       ├── stt/                # Speech-to-text APIs
-│   │       ├── text-to-image/      # Image generation APIs
-│   │       └── tts/                # Text-to-speech APIs
-│   ├── [variants]/                 # Page route variants
-│   │   ├── (main)/                 # Main application routes
-│   │   │   ├── chat/               # Chat interface and workspace
-│   │   │   ├── discover/           # Discover page (assistants, models, providers)
-│   │   │   ├── files/              # File management interface
-│   │   │   ├── image/              # Image generation interface
-│   │   │   ├── profile/            # User profile and stats
-│   │   │   ├── repos/              # Knowledge base repositories
-│   │   │   └── settings/           # Application settings
-│   │   └── @modal/                 # Modal routes
-│   └── manifest.ts                 # PWA configuration
-├── components/                     # Global shared components
-│   ├── Analytics/                  # Analytics tracking components
-│   ├── Error/                      # Error handling components
-│   └── Loading/                    # Loading state components
-├── config/                         # Application configuration
-│   ├── featureFlags/               # Feature flags & experiments
-│   └── modelProviders/             # Model provider configurations
-├── features/                       # Feature components (UI Layer)
-│   ├── AgentSetting/               # Agent configuration and management
-│   ├── ChatInput/                  # Chat input with file upload and tools
-│   ├── Conversation/               # Message display and interaction
-│   ├── FileManager/                # File upload and knowledge base
-│   └── PluginStore/                # Plugin marketplace and management
-├── hooks/                          # Custom React hooks
-├── layout/                         # Global layout components
-│   ├── AuthProvider/               # Authentication provider
-│   └── GlobalProvider/             # Global state provider
-├── libs/                           # External library integrations
-│   ├── analytics/                  # Analytics services integration
-│   ├── next-auth/                  # NextAuth.js configuration
-│   └── oidc-provider/              # OIDC provider implementation
-├── locales/                        # Internationalization resources
-│   └── default/                    # Default language definitions
-├── migrations/                     # Client-side data migrations
-├── server/                         # Server-side code
-│   ├── modules/                    # Server modules
-│   ├── routers/                    # tRPC routers
-│   └── services/                   # Server services
-├── services/                       # Service layer (per-domain, client/server split)
-│   ├── user/                       # User services
-│   │   ├── client.ts               # Client DB (PGLite) implementation
-│   │   └── server.ts               # Server DB implementation (via tRPC)
-│   ├── aiModel/                    # AI model services
-│   ├── session/                    # Session services
-│   └── message/                    # Message services
-├── store/                          # Zustand state management
-│   ├── agent/                      # Agent state
-│   ├── chat/                       # Chat state
-│   └── user/                       # User state
-├── styles/                         # Global styles
-├── tools/                          # Built-in tool system
-│   ├── artifacts/                  # Code artifacts and preview
-│   └── web-browsing/               # Web search and browsing
-├── types/                          # TypeScript type definitions
-└── utils/                          # Utility functions
-    ├── client/                     # Client-side utilities
-    └── server/                     # Server-side utilities
-```
-
-## Key Monorepo Packages
-
-```plaintext
-packages/
-├── const/                          # Global constants and configurations
-├── database/                       # Database schemas and models
-│   ├── src/models/                 # Data models (CRUD operations)
-│   ├── src/schemas/                # Drizzle database schemas
-│   ├── src/repositories/           # Complex query layer
-│   └── migrations/                 # Database migration files
-├── model-runtime/                  # AI model runtime
-│   └── src/
-│       ├── openai/                 # OpenAI provider integration
-│       ├── anthropic/              # Anthropic provider integration
-│       ├── google/                 # Google AI provider integration
-│       ├── ollama/                 # Ollama local model integration
-│       ├── types/                  # Runtime type definitions
-│       └── utils/                  # Runtime utilities
-├── types/                          # Shared TypeScript type definitions
-│   └── src/
-│       ├── agent/                  # Agent-related types
-│       ├── message/                # Message and chat types
-│       ├── user/                   # User and session types
-│       └── tool/                   # Tool and plugin types
-├── utils/                          # Shared utility functions
-│   └── src/
-│       ├── client/                 # Client-side utilities
-│       ├── server/                 # Server-side utilities
-│       ├── fetch/                  # HTTP request utilities
-│       └── tokenizer/              # Token counting utilities
-├── file-loaders/                   # File loaders (PDF, DOCX, etc.)
-├── prompts/                        # AI prompt management
-└── web-crawler/                    # Web crawling functionality
+├── apps/
+│   └── desktop/
+├── docs/
+├── locales/
+│   ├── en-US/
+│   └── zh-CN/
+├── packages/
+│   ├── const/
+│   ├── context-engine/
+│   ├── database/
+│   │   ├── src/
+│   │   │   ├── models/
+│   │   │   ├── schemas/
+│   │   │   └── repositories/
+│   ├── model-bank/
+│   │   └── src/
+│   │       └── aiModels/
+│   ├── model-runtime/
+│   │   └── src/
+│   │       ├── core/
+│   │       └── providers/
+│   ├── types/
+│   │   └── src/
+│   │       ├── message/
+│   │       └── user/
+│   └── utils/
+├── public/
+├── scripts/
+├── src/
+│   ├── app/
+│   │   ├── (backend)/
+│   │   │   ├── api/
+│   │   │   │   ├── auth/
+│   │   │   │   └── webhooks/
+│   │   │   ├── middleware/
+│   │   │   ├── oidc/
+│   │   │   ├── trpc/
+│   │   │   └── webapi/
+│   │   │       ├── chat/
+│   │   │       └── tts/
+│   │   ├── [variants]/
+│   │   │   ├── (main)/
+│   │   │   │   ├── chat/
+│   │   │   │   └── settings/
+│   │   │   └── @modal/
+│   │   └── manifest.ts
+│   ├── components/
+│   ├── config/
+│   ├── features/
+│   │   └── ChatInput/
+│   ├── hooks/
+│   ├── layout/
+│   │   ├── AuthProvider/
+│   │   └── GlobalProvider/
+│   ├── libs/
+│   │   └── oidc-provider/
+│   ├── locales/
+│   │   └── default/
+│   ├── server/
+│   │   ├── modules/
+│   │   ├── routers/
+│   │   │   ├── async/
+│   │   │   ├── desktop/
+│   │   │   ├── edge/
+│   │   │   └── lambda/
+│   │   └── services/
+│   ├── services/
+│   │   ├── user/
+│   │   │   ├── client.ts
+│   │   │   └── server.ts
+│   │   └── message/
+│   ├── store/
+│   │   ├── agent/
+│   │   ├── chat/
+│   │   └── user/
+│   ├── styles/
+│   └── utils/
+└── package.json
 ```
 
 ## Architecture Map
 
-- Presentation: `src/features`, `src/components`, `src/layout` — UI composition, global providers
-- State: `src/store` — Zustand slices, selectors, middleware
-- Client Services: `src/services/<domain>/{client|server}.ts` — client: PGLite; server: tRPC bridge
-- API Routers: `src/app/(backend)/webapi` (REST), `src/app/(backend)/trpc/{edge|lambda|async|desktop|tools}`; Lambda router triggers Async router for long-running tasks (e.g., image)
-- Server Services: `src/server/services` (business logic), `src/server/modules` (infra adapters)
-- Data Access: `packages/database/src/{schemas,models,repositories}` — Schema (Drizzle), Model (CRUD), Repository (complex queries)
-- Integrations: `src/libs` — analytics, auth, trpc, logging, runtime helpers
+- UI Components: `src/components`, `src/features`
+- Global providers: `src/layout`
+- Zustand stores: `src/store`
+- Client Services: `src/services/` cross-platform services
+  - clientDB: `src/services/<domain>/client.ts`
+  - serverDB: `src/services/<domain>/server.ts`
+- API Routers:
+  - `src/app/(backend)/webapi` (REST)
+  - `src/server/routers/{edge|lambda|async|desktop|tools}` (tRPC)
+- Server:
+  - Services(can access serverDB): `src/server/services` server-used-only services
+  - Modules(can't access db): `src/server/modules` (Server only Third-party Service Module)
+- Database:
+  - Schema (Drizzle): `packages/database/src/schemas`
+  - Model (CRUD): `packages/database/src/models`
+  - Repository (bff-queries): `packages/database/src/repositories`
+- Third-party Integrations: `src/libs` — analytics, oidc etc.
 
 ## Data Flow Architecture
 
-### Unified Flow Pattern
-
-```
-UI Layer → State Management → Client Service → [Environment Branch] → Database
-   ↓              ↓               ↓                    ↓                ↓
- React         Zustand     Environment         Local/Remote        PGLite/
-Components      Store      Adaptation            Routing          PostgreSQL
-```
-
-### Environment-Specific Routing
-
-| Mode            | UI       | Service Route          | Database            |
-| --------------- | -------- | ---------------------- | ------------------- |
-| **Browser/PWA** | React    | Direct Model Access    | PGLite (Local)      |
-| **Server**      | React    | tRPC → Server Services | PostgreSQL (Remote) |
-| **Desktop**     | Electron | tRPC → Local Node.js   | PGLite/PostgreSQL\* |
-
-_\*Depends on cloud sync configuration_
-
-### Key Characteristics
-
-- **Type Safety**: End-to-end type safety via tRPC and Drizzle ORM
-- **Local/Remote Dual Mode**: PGLite enables user data ownership and local control
-
-## Quick Map
-
-- App Routes: `src/app` — UI routes (App Router) and backend routes under `(backend)`
-- Web API: `src/app/(backend)/webapi` — REST-like endpoints
-- tRPC Routers: `src/server/routers` — typed RPC endpoints by runtime
-- Client Services: `src/services` — environment-adaptive client-side business logic
-- Server Services: `src/server/services` — platform-agnostic business logic
-- Database: `packages/database` — schemas/models/repositories/migrations
-- State: `src/store` — Zustand stores and slices
-- Integrations: `src/libs` — analytics/auth/trpc/logging/runtime helpers
-- Tools: `src/tools` — built-in tool system
-
-## Common Tasks
-
-- Add Web API route: `src/app/(backend)/webapi/<module>/route.ts`
-- Add tRPC endpoint: `src/server/routers/{edge|lambda|desktop}/...`
-- Add client/server service: `src/services/<domain>/{client|server}.ts` (client: PGLite; server: tRPC)
-- Add server service: `src/server/services/<domain>`
-- Add a new model/provider: `src/config/modelProviders/<provider>.ts` + `packages/model-bank/src/aiModels/<provider>.ts` + `packages/model-runtime/src/<provider>/index.ts`
-- Add DB schema/model/repository: `packages/database/src/{schemas|models|repositories}`
-- Add Zustand slice: `src/store/<domain>/slices`
-
-## Env Modes
-
-- `NEXT_PUBLIC_CLIENT_DB`: selects client DB mode (e.g., `pglite`) vs server-backed
-- `NEXT_PUBLIC_IS_DESKTOP_APP`: enables desktop-specific routes and behavior
-- `NEXT_PUBLIC_SERVICE_MODE`: controls service routing preference (client/server)
-
-## Boundaries
-
-- Keep client logic in `src/services`; server-only logic stays in `src/server/services`
-- Don’t mix Web API (`webapi/`) with tRPC (`src/server/routers/`)
-- Place business UI under `src/features`, global reusable UI under `src/components`
+- **Web with ClientDB**: React UI → Client Service → Direct Model Access → PGLite (Web WASM)
+- **Web with ServerDB**: React UI → Client Service → tRPC Lambda → Server Services → PostgreSQL (Remote)
+- **Desktop**:
+  - Cloud sync disabled: Electron UI → Client Service → tRPC Lambda → Local Server Services → PGLite (Node WASM)
+  - Cloud sync enabled: Electron UI → Client Service → tRPC Lambda → Cloud Server Services → PostgreSQL (Remote)

.cursor/rules/rules-index.mdc

@@ -4,20 +4,12 @@ globs:
 alwaysApply: true
 ---
 
-# 📋 Available Rules Index
+# Available project rules index
 
-The following rules are available via `read_file` from the `.cursor/rules/` directory:
-
-## General
-
-- `project-introduce.mdc` – Project description and tech stack
-- `cursor-rules.mdc` – Cursor rules authoring and optimization guide
-- `code-review.mdc` – How to code review
+All following rules are saved under `.cursor/rules/` directory:
 
 ## Backend
 
-- `backend-architecture.mdc` – Backend layer architecture and design guidelines
-- `define-database-model.mdc` – Database model definition guidelines
 - `drizzle-schema-style-guide.mdc` – Style guide for defining Drizzle ORM schemas
 
 ## Frontend
@@ -42,7 +34,6 @@ The following rules are available via `read_file` from the `.cursor/rules/` dire
 
 ## Debugging
 
-- `debug.mdc` – General debugging guide
 - `debug-usage.mdc` – Using the debug package and namespace conventions
 
 ## Testing

.cursor/rules/system-role.mdc

@@ -1,31 +0,0 @@
----
-description:
-globs:
-alwaysApply: true
----
-
-## System Role
-
-You are an expert in full-stack Web development, proficient in JavaScript, TypeScript, CSS, React, Node.js, Next.js, Postgresql, Redis, S3, all kinds of network protocols.
-
-You are an LLM expert, you are familiar with all kinds of LLM models, ai agents, ai workflow, prompt engineering and context engineering.
-
-You are an expert in Ai art. In Ai image generation, you are proficient in Stable Diffusion and ComfyUI's architectural principles, workflows, model structures, parameter configurations, training methods, and inference optimization.
-
-You are an expert in UI/UX design, proficient in web interaction patterns, responsive design, accessibility, and user behavior optimization. You excel at improving user retention and paid conversion rates through various interaction details.
-
-## Problem Solving
-
-- When modifying existing code, clearly describe the differences and reasons for the changes
-- Provide alternative solutions that may be better overall or superior in specific aspects
-- Provide optimization suggestions for deprecated API usage
-- Cite sources whenever possible at the end, not inline
-- When you provide multiple solutions, provide the recommended solution first, and note it as `Recommended`
-- Express uncertainty when there might not be a correct answer, instead of take action by guessing and assuming
-
-## Code Implementation
-
-- Focus on maintainable over being performant
-- Be sure to reference file path
-- If doc links or required files are missing, ask for them before proceeding with the task rather than making assumptions
-- If you're unable to get valid result when using tools, please clearly state in the output

.cursor/rules/typescript.mdc

@@ -10,61 +10,11 @@ alwaysApply: false
 
 - avoid explicit type annotations when TypeScript can infer types.
 - avoid implicitly `any` variables; explicitly type when necessary (e.g., `let a: number` instead of `let a`).
-- use the most accurate type possible (e.g., prefer `Record<PropertyKey, unknown>` over `object`).
+- use the most accurate type possible (e.g., prefer `Record<PropertyKey, unknown>` over `object` and `any`).
 - prefer `interface` over `type` for object shapes (e.g., React component props). Keep `type` for unions, intersections, and utility types.
 - prefer `as const satisfies XyzInterface` over plain `as const` when suitable.
-- prefer `@ts-expect-error` over `@ts-ignore`
-- prefer `Record<string, any>` over `any`
-
-- **Avoid unnecessary null checks**: Before adding `xxx !== null`, `?.`, `??`, or `!.`, read the type definition to confirm the necessary. **Example:**
-
-  ```typescript
-  // ❌ Wrong: budget.spend and budget.maxBudget is number, not number | null
-  if (budget.spend !== null && budget.maxBudget !== null && budget.spend >= budget.maxBudget) {
-    // ...
-  }
-
-  // ✅ Right
-  if (budget.spend >= budget.maxBudget) {
-    // ...
-  }
-  ```
-
-- **Avoid redundant runtime checks**: Don't add runtime validation for conditions already guaranteed by types or previous checks. Trust the type system and calling contract. **Example:**
-
-  ```typescript
-  // ❌ Wrong: Adding impossible-to-fail checks
-  const due = await db.query.budgets.findMany({
-    where: and(isNotNull(budgets.budgetDuration)), // Already filtered non-null
-  });
-  const result = due.map(b => {
-    const nextReset = computeNextResetAt(b.budgetResetAt!, b.budgetDuration!);
-    if (!nextReset) { // This check is impossible to fail
-      throw new Error(`Unexpected null nextResetAt`);
-    }
-    return nextReset;
-  });
-
-  // ✅ Right: Trust the contract
-  const due = await db.query.budgets.findMany({
-    where: and(isNotNull(budgets.budgetDuration)),
-  });
-  const result = due.map(b => computeNextResetAt(b.budgetResetAt!, b.budgetDuration!));
-  ```
-
-- **Avoid meaningless null/undefined parameters**: Don't accept null/undefined for parameters that have no business meaning when null. Design strict function contracts. **Example:**
-
-  ```typescript
-  // ❌ Wrong: Function accepts meaningless null input
-  function computeNextResetAt(currentResetAt: Date, durationStr: string | null): Date | null {
-    if (!durationStr) return null; // Why accept null if it just returns null?
-  }
-
-  // ✅ Right: Strict contract, clear responsibility
-  function computeNextResetAt(currentResetAt: Date, durationStr: string): Date {
-    // Function has single clear purpose, caller ensures valid input
-  }
-  ```
+- prefer `@ts-expect-error` over `@ts-ignore` over `as any`
+- Avoid meaningless null/undefined parameters; design strict function contracts.
 
 ## Imports and Modules
 
@@ -79,16 +29,11 @@ alwaysApply: false
 
 ## Code Structure and Readability
 
-- Refactor repeated logic into reusable functions.
 - Prefer object destructuring when accessing and using properties.
 - Use consistent, descriptive naming; avoid obscure abbreviations.
 - Use semantically meaningful variable, function, and class names.
 - Replace magic numbers or strings with well-named constants.
-- Keep meaningful code comments; do not remove them when applying edits. Update comments when behavior changes.
-- Ensure JSDoc comments accurately reflect the implementation.
-- Look for opportunities to simplify or modernize code with the latest JavaScript/TypeScript features where it improves clarity.
 - Defer formatting to tooling; ignore purely formatting-only issues and autofixable lint problems.
-- Respect project Prettier settings.
 
 ## UI and Theming
 
@@ -100,15 +45,14 @@ alwaysApply: false
 ## Performance
 
 - Prefer `for…of` loops to index-based `for` loops when feasible.
-- Decide whether callbacks should be debounced or throttled based on UX and performance needs.
-- Reuse existing npm packages rather than reinventing the wheel (e.g., `lodash-es/omit`).
+- Reuse existing utils inside `packages/utils` or installed npm packages rather than reinventing the wheel.
 - Query only the required columns from a database rather than selecting entire rows.
 
 ## Time and Consistency
 
 - Instead of calling `Date.now()` multiple times, assign it to a constant once and reuse it to ensure consistency and improve readability.
 
-## Some logging rules
+## Logging
 
 - Never log user private information like api key, etc
 - Don't use `import { log } from 'debug'` to log messages, because it will directly log the message to the console.

.github/ISSUE_TEMPLATE/1_bug_report_cn.yml

@@ -1,87 +0,0 @@
-name: '🐛 反馈缺陷'
-description: '反馈一个问题缺陷'
-labels: ['unconfirm']
-type: Bug
-body:
-  - type: markdown
-    attributes:
-      value: |
-        在创建新的 Issue 之前，请先[搜索已有问题](https://github.com/lobehub/lobe-chat/issues)，如果发现已有类似的问题，请给它 **👍 点赞**，这样可以帮助我们更快地解决问题。  
-        如果你在使用过程中遇到问题，可以尝试以下方式获取帮助：  
-        - 在 [GitHub Discussions](https://github.com/lobehub/lobe-chat/discussions) 的版块发起讨论。  
-        - 在 [LobeChat 社区](https://discord.gg/AYFPHvv2jT) 提问，与其他用户交流。 
-  - type: dropdown
-    attributes:
-      label: '📦 部署环境'
-      multiple: true
-      options:
-        - 'Official Preview'
-        - 'Official Cloud'
-        - 'Vercel'
-        - 'Zeabur'
-        - 'Sealos'
-        - 'Netlify'
-        - 'Docker'
-        - 'Other'
-    validations:
-      required: true
-  - type: dropdown
-    attributes:
-      label: '📦 部署模式'
-      multiple: true
-      options:
-        - '客户端模式(lobe-chat 镜像)'
-        - '客户端 Pglite 模式(lobe-chat-pglite 镜像)'
-        - '服务端模式(lobe-chat-database 镜像)'
-    validations:
-      required: true
-  - type: input
-    attributes:
-      label: '📌 软件版本'
-    validations:
-      required: true
-
-  - type: dropdown
-    attributes:
-      label: '💻 系统环境'
-      multiple: true
-      options:
-        - 'Windows'
-        - 'macOS'
-        - 'Ubuntu'
-        - 'Other Linux'
-        - 'iOS'
-        - 'Android'
-        - 'Other'
-    validations:
-      required: true
-  - type: dropdown
-    attributes:
-      label: '🌐 浏览器'
-      multiple: true
-      options:
-        - 'Chrome'
-        - 'Edge'
-        - 'Safari'
-        - 'Firefox'
-        - 'Other'
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: '🐛 问题描述'
-      description: 请提供一个清晰且简洁的问题描述，若上述选项为`Other`，也请详细说明。
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: '📷 复现步骤'
-      description: 请提供一个清晰且简洁的描述，说明如何复现问题。
-  - type: textarea
-    attributes:
-      label: '🚦 期望结果'
-      description: 请提供一个清晰且简洁的描述，说明您期望发生什么。
-  - type: textarea
-    attributes:
-      label: '📝 补充信息'
-      description: 如果您的问题需要进一步说明，或者您遇到的问题无法在一个简单的示例中复现，请在这里添加更多信息。

.github/ISSUE_TEMPLATE/2_feature_request_cn.yml

@@ -1,21 +0,0 @@
-name: '🌠 功能需求'
-description: '提出需求或建议'
-title: '[Request] '
-type: Feature
-body:
-  - type: textarea
-    attributes:
-      label: '🥰 需求描述'
-      description: 请添加一个清晰且简洁的问题描述，阐述您希望通过这个功能需求解决的问题。
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: '🧐 解决方案'
-      description: 请清晰且简洁地描述您想要的解决方案。
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: '📝 补充信息'
-      description: 在这里添加关于问题的任何其他背景信息。

.github/ISSUE_TEMPLATE/config.yml

@@ -1,7 +1,7 @@
 contact_links:
-  - name: Ask a question for self-hosting | 咨询自部署问题
+  - name: Ask a question for self-hosting
     url: https://github.com/lobehub/lobe-chat/discussions/new?category=self-hosting-%E7%A7%81%E6%9C%89%E5%8C%96%E9%83%A8%E7%BD%B2
-    about: Please post questions, and ideas in discussions. | 请在讨论区发布问题和想法。
-  - name: Questions and ideas | 其他问题和想法
+    about: Please post questions, and ideas in discussions.
+  - name: Questions and ideas
     url: https://github.com/lobehub/lobe-chat/discussions/new/choose
-    about: Please post questions, and ideas in discussions. | 请在讨论区发布问题和想法。
+    about: Please post questions, and ideas in discussions.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,4 +1,4 @@
-#### 💻 变更类型 | Change Type
+#### 💻 Change Type
 
 <!-- For change type, change [ ] to [x]. -->
 
@@ -12,10 +12,10 @@
 - [ ] 📝 docs
 - [ ] 🔨 chore
 
-#### 🔀 变更说明 | Description of Change
+#### 🔀 Description of Change
 
 <!-- Thank you for your Pull Request. Please provide a description above. -->
 
-#### 📝 补充信息 | Additional Information
+#### 📝 Additional Information
 
 <!-- Add any other context about the Pull Request here. -->

.github/scripts/lock-closed-issues.js

@@ -0,0 +1,78 @@
+// @ts-check
+/**
+ * Lock closed issues after 7 days of inactivity
+ * @param {object} github - GitHub API client
+ * @param {object} context - GitHub Actions context
+ */
+module.exports = async ({ github, context }) => {
+  const sevenDaysAgo = new Date();
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+
+  const lockComment = `This issue has been automatically locked since it was closed and has not had any activity for 7 days. If you're experiencing a similar issue, please file a new issue and reference this one if it's relevant.`;
+
+  let page = 1;
+  let hasMore = true;
+  let totalLocked = 0;
+
+  while (hasMore) {
+    // Get closed issues (pagination)
+    const { data: issues } = await github.rest.issues.listForRepo({
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      state: 'closed',
+      sort: 'updated',
+      direction: 'asc',
+      per_page: 100,
+      page: page,
+    });
+
+    if (issues.length === 0) {
+      hasMore = false;
+      break;
+    }
+
+    for (const issue of issues) {
+      // Skip if already locked
+      if (issue.locked) continue;
+
+      // Skip pull requests
+      if (issue.pull_request) continue;
+
+      // Check if updated more than 7 days ago
+      const updatedAt = new Date(issue.updated_at);
+      if (updatedAt > sevenDaysAgo) {
+        // Since issues are sorted by updated_at ascending,
+        // once we hit a recent issue, all remaining will be recent too
+        hasMore = false;
+        break;
+      }
+
+      try {
+        // Add comment before locking
+        await github.rest.issues.createComment({
+          owner: context.repo.owner,
+          repo: context.repo.repo,
+          issue_number: issue.number,
+          body: lockComment,
+        });
+
+        // Lock the issue
+        await github.rest.issues.lock({
+          owner: context.repo.owner,
+          repo: context.repo.repo,
+          issue_number: issue.number,
+          lock_reason: 'resolved',
+        });
+
+        totalLocked++;
+        console.log(`Locked issue #${issue.number}: ${issue.title}`);
+      } catch (error) {
+        console.error(`Failed to lock issue #${issue.number}: ${error.message}`);
+      }
+    }
+
+    page++;
+  }
+
+  console.log(`Total issues locked: ${totalLocked}`);
+};

.github/workflows/claude-translator.yml

@@ -0,0 +1,108 @@
+name: Claude Translator
+concurrency:
+  group: translator-${{ github.event.comment.id || github.event.issue.number || github.event.review.id }}
+  cancel-in-progress: false
+
+on:
+  issues:
+    types: [opened]
+  issue_comment:
+    types: [created, edited]
+  pull_request_review:
+    types: [submitted, edited]
+  pull_request_review_comment:
+    types: [created, edited]
+
+jobs:
+  translate:
+    if: |
+      (github.event_name == 'issues') ||
+      (github.event_name == 'issue_comment' && github.event.sender.type != 'Bot') ||
+      (github.event_name == 'pull_request_review' && github.event.sender.type != 'Bot') ||
+      (github.event_name == 'pull_request_review_comment' && github.event.sender.type != 'Bot')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      # update issues/comments
+      issues: write
+      pull-requests: write
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude for translation
+        uses: anthropics/claude-code-action@main
+        id: claude
+        with:
+          # Warning: Permissions should have been controlled by workflow permission.
+          # Now `contents: read` is safe for files, but we could make a fine-grained token to control it.
+          # See: https://github.com/anthropics/claude-code-action/blob/main/docs/security.md
+          github_token: ${{ secrets.GH_TOKEN }}
+          allowed_non_write_users: "*"
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          claude_args: "--allowed-tools Bash(gh issue:*),Bash(gh api:repos/*/issues:*),Bash(gh api:repos/*/pulls/*/reviews/*),Bash(gh api:repos/*/pulls/comments/*)"
+          prompt: |
+            You are a multilingual translation assistant. You need to respond to the following four types of GitHub Webhook events:
+
+            - issues
+            - issue_comment
+            - pull_request_review
+            - pull_request_review_comment
+
+            Please complete the following tasks:
+
+            1. Retrieve complete information for the current event.
+
+               - If the current event is 'issues', get the issue information.
+               - If the current event is 'issue_comment', get the comment information.
+               - If the current event is 'pull_request_review', get the review information.
+               - If the current event is 'pull_request_review_comment', get the comment information.
+
+            2. Intelligently detect content.
+
+                - If the retrieved information is already translated content following the format requirements, check if the translation matches the original content. If not, retranslate to match and follow the format requirements.
+                - If the retrieved information is untranslated content, check its language. If not in English, translate to English.
+                - If the retrieved information is partially translated to English, translate it completely to English.
+                - If the retrieved information contains references to already translated content, clean the referenced content to contain only English. Referenced content should not include "This xxx was translated by Claude" and "Original Content" etc.
+                - If the retrieved information contains other types of references (i.e., references to non-Claude translated content), keep them as-is without translation.
+                - If the retrieved information is email reply content, place email content references at the end during translation. Include only the reply content itself in both original and translated content, without email content references.
+                - If the retrieved information doesn't need any processing, skip the task.
+
+            3. Format requirements:
+
+               - Title: English translation (if non-English)
+               - Content format:
+                 [Translated content]
+
+                 ---
+                 > This issue/comment/review was translated by Claude.
+
+                 <details>
+                 <summary>Original Content</summary>
+                 [Original content]
+                 </details>
+
+            4. Update using gh tool:
+
+               - Choose the correct command based on the Event type in environment information:
+                 - If Event is 'issues': gh issue edit [ISSUE_NUMBER] --title "[English title]" --body "[Translated content + Original content]"
+                 - If Event is 'issue_comment': gh api -X PATCH /repos/${{ github.repository }}/issues/comments/${{ github.event.comment.id }} -f body="[Translated content + Original content]"
+                 - If Event is 'pull_request_review': gh api -X PUT /repos/${{ github.repository }}/pulls/${{ github.event.pull_request.number }}/reviews/${{ github.event.review.id }} -f body="[Translated content]"
+                 - If Event is 'pull_request_review_comment': gh api -X PATCH /repos/${{ github.repository }}/pulls/comments/${{ github.event.comment.id }} -f body="[Translated content + Original content]"
+
+            <environment_context>
+            - Event: ${{ github.event_name }}
+            - Issue Number: ${{ github.event.issue.number }}
+            - Repository: ${{ github.repository }}
+            - (Review) Comment ID: ${{ github.event.comment.id || 'N/A' }}
+            - Pull Request Number: ${{ github.event.pull_request.number || 'N/A' }}
+            - Review ID: ${{ github.event.review.id || 'N/A' }}
+            </environment_context>
+
+
+            Use the following command to get complete information:
+            gh issue view ${{ github.event.issue.number }} --json title,body,comments

.github/workflows/desktop-pr-build.yml

@@ -95,7 +95,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, macos-13, windows-2025, ubuntu-latest]
+        os: [macos-latest, macos-15-intel, windows-2025, ubuntu-latest]
     steps:
       - uses: actions/checkout@v5
         with:
@@ -129,11 +129,11 @@ jobs:
         run: npm run desktop:build
         env:
           # 设置更新通道，PR构建为nightly，否则为stable
-          UPDATE_CHANNEL: 'nightly'
+          UPDATE_CHANNEL: "nightly"
           APP_URL: http://localhost:3015
-          DATABASE_URL: 'postgresql://postgres@localhost:5432/postgres'
+          DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
           # 默认添加一个加密 SECRET
-          KEY_VAULTS_SECRET: 'oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE='
+          KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
           # macOS 签名和公证配置
           CSC_LINK: ${{ secrets.APPLE_CERTIFICATE_BASE64 }}
           CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
@@ -152,10 +152,10 @@ jobs:
         run: npm run desktop:build
         env:
           # 设置更新通道，PR构建为nightly，否则为stable
-          UPDATE_CHANNEL: 'nightly'
+          UPDATE_CHANNEL: "nightly"
           APP_URL: http://localhost:3015
-          DATABASE_URL: 'postgresql://postgres@localhost:5432/postgres'
-          KEY_VAULTS_SECRET: 'oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE='
+          DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
+          KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
           NEXT_PUBLIC_DESKTOP_PROJECT_ID: ${{ secrets.UMAMI_NIGHTLY_DESKTOP_PROJECT_ID }}
           NEXT_PUBLIC_DESKTOP_UMAMI_BASE_URL: ${{ secrets.UMAMI_NIGHTLY_DESKTOP_BASE_URL }}
           # 将 TEMP 和 TMP 目录设置到 C 盘
@@ -168,10 +168,10 @@ jobs:
         run: npm run desktop:build
         env:
           # 设置更新通道，PR构建为nightly，否则为stable
-          UPDATE_CHANNEL: 'nightly'
+          UPDATE_CHANNEL: "nightly"
           APP_URL: http://localhost:3015
-          DATABASE_URL: 'postgresql://postgres@localhost:5432/postgres'
-          KEY_VAULTS_SECRET: 'oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE='
+          DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
+          KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
           NEXT_PUBLIC_DESKTOP_PROJECT_ID: ${{ secrets.UMAMI_NIGHTLY_DESKTOP_PROJECT_ID }}
           NEXT_PUBLIC_DESKTOP_UMAMI_BASE_URL: ${{ secrets.UMAMI_NIGHTLY_DESKTOP_BASE_URL }}
 

.github/workflows/docker-database.yml

@@ -1,4 +1,6 @@
 name: Publish Database Docker Image
+permissions:
+  contents: read
 
 on:
   workflow_dispatch:

.github/workflows/docker-pglite.yml

@@ -1,4 +1,6 @@
 name: Publish Docker Pglite Image
+permissions:
+  contents: read
 
 on:
   workflow_dispatch:

.github/workflows/docker.yml

@@ -1,4 +1,6 @@
 name: Publish Docker Image
+permissions:
+  contents: read
 
 on:
   workflow_dispatch:

.github/workflows/issue-auto-comments.yml

@@ -28,8 +28,7 @@ jobs:
             👀 @{{ author }}
 
             Thank you for raising an issue. We will investigate into the matter and get back to you as soon as possible.
-            Please make sure you have given us as much context as possible.\
-            非常感谢您提交 issue。我们会尽快调查此事，并尽快回复您。 请确保您已经提供了尽可能多的背景信息。
+            Please make sure you have given us as much context as possible.
       - name: Auto Comment on Issues Closed
         uses: wow-actions/auto-comment@v1
         with:
@@ -37,8 +36,7 @@ jobs:
           issuesClosed: |
             ✅ @{{ author }}
 
-            This issue is closed, If you have any questions, you can comment and reply.\
-            此问题已经关闭。如果您有任何问题，可以留言并回复。
+            This issue is closed, If you have any questions, you can comment and reply.
       - name: Auto Comment on Pull Request Opened
         uses: wow-actions/auto-comment@v1
         with:
@@ -48,9 +46,7 @@ jobs:
 
             Thank you for raising your pull request and contributing to our Community
             Please make sure you have followed our contributing guidelines. We will review it as soon as possible.
-            If you encounter any problems, please feel free to connect with us.\
-            非常感谢您提出拉取请求并为我们的社区做出贡献，请确保您已经遵循了我们的贡献指南，我们会尽快审查它。
-            如果您遇到任何问题，请随时与我们联系。
+            If you encounter any problems, please feel free to connect with us.
       - name: Auto Comment on Pull Request Merged
         uses: actions-cool/pr-welcome@main
         if: github.event.pull_request.merged == true
@@ -59,8 +55,7 @@ jobs:
           comment: |
             ❤️ Great PR @${{ github.event.pull_request.user.login }} ❤️
 
-            The growth of project is inseparable from user feedback and contribution, thanks for your contribution! If you are interesting with the lobehub developer community, please join our [discord](https://discord.com/invite/AYFPHvv2jT) and then dm @arvinxx or @canisminor1990. They will invite you to our private developer channel. We are talking about the lobe-chat development or sharing ai newsletter around the world.\
-            项目的成长离不开用户反馈和贡献，感谢您的贡献! 如果您对 LobeHub 开发者社区感兴趣，请加入我们的 [discord](https://discord.com/invite/AYFPHvv2jT)，然后私信 @arvinxx 或 @canisminor1990。他们会邀请您加入我们的私密开发者频道。我们将会讨论关于 Lobe Chat 的开发，分享和讨论全球范围内的 AI 消息。
+            The growth of project is inseparable from user feedback and contribution, thanks for your contribution! If you are interesting with the lobehub developer community, please join our [discord](https://discord.com/invite/AYFPHvv2jT) and then dm @arvinxx or @canisminor1990. They will invite you to our private developer channel. We are talking about the lobe-chat development or sharing ai newsletter around the world.
           emoji: 'hooray'
           pr-emoji: '+1, heart'
       - name: Remove inactive

.github/workflows/issue-close-require.yml

@@ -38,8 +38,7 @@ jobs:
           body: |
             👋 @{{ author }}
             <br/>
-            Since the issue was labeled with `✅ Fixed`, but no response in 3 days. This issue will be closed. If you have any questions, you can comment and reply.\
-            由于该 issue 被标记为已修复，同时 3 天未收到回应。现关闭 issue，若有任何问题，可评论回复。
+            Since the issue was labeled with `✅ Fixed`, but no response in 3 days. This issue will be closed. If you have any questions, you can comment and reply.
       - name: need reproduce
         uses: actions-cool/issues-helper@v3
         with:
@@ -50,8 +49,7 @@ jobs:
           body: |
             👋 @{{ author }}
             <br/>
-            Since the issue was labeled with `🤔 Need Reproduce`, but no response in 3 days. This issue will be closed. If you have any questions, you can comment and reply.\
-            由于该 issue 被标记为需要更多信息，却 3 天未收到回应。现关闭 issue，若有任何问题，可评论回复。
+            Since the issue was labeled with `🤔 Need Reproduce`, but no response in 3 days. This issue will be closed. If you have any questions, you can comment and reply.
       - name: need reproduce
         uses: actions-cool/issues-helper@v3
         with:
@@ -62,5 +60,4 @@ jobs:
           body: |
             👋 @{{ github.event.issue.user.login }}
             <br/>
-            Since the issue was labeled with `🙅🏻‍♀️ WON'T DO`, and no response in 3 days. This issue will be closed. If you have any questions, you can comment and reply.\
-            由于该 issue 被标记为暂不处理，同时 3 天未收到回应。现关闭 issue，若有任何问题，可评论回复。
+            Since the issue was labeled with `🙅🏻‍♀️ WON'T DO`, and no response in 3 days. This issue will be closed. If you have any questions, you can comment and reply.

.github/workflows/issues-translate.yml

@@ -1,14 +0,0 @@
-name: Issue Translate
-on:
-  issue_comment:
-    types: [created]
-  issues:
-    types: [opened]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: usthe/issues-translate-action@v2.7
-        with:
-          BOT_GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}

.github/workflows/lock-closed-issues.yml

@@ -0,0 +1,26 @@
+name: "Lock Stale Issues"
+
+on:
+  schedule:
+    - cron: "0 1 * * *"
+  workflow_dispatch:
+
+permissions:
+  issues: write
+
+concurrency:
+  group: lock-threads
+
+jobs:
+  lock-closed-issues:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Lock closed issues after 7 days of inactivity
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const lockScript = require('./.github/scripts/lock-closed-issues.js');
+            await lockScript({ github, context });

.github/workflows/release-desktop-beta.yml

@@ -82,7 +82,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, macos-13, windows-2025, ubuntu-latest]
+        os: [macos-latest, macos-15-intel, windows-2025, ubuntu-latest]
     steps:
       - uses: actions/checkout@v5
         with:
@@ -116,9 +116,9 @@ jobs:
         run: npm run desktop:build
         env:
           APP_URL: http://localhost:3015
-          DATABASE_URL: 'postgresql://postgres@localhost:5432/postgres'
+          DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
           # 默认添加一个加密 SECRET
-          KEY_VAULTS_SECRET: 'oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE='
+          KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
           # macOS 签名和公证配置
           CSC_LINK: ${{ secrets.APPLE_CERTIFICATE_BASE64 }}
           CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
@@ -137,8 +137,8 @@ jobs:
         run: npm run desktop:build
         env:
           APP_URL: http://localhost:3015
-          DATABASE_URL: 'postgresql://postgres@localhost:5432/postgres'
-          KEY_VAULTS_SECRET: 'oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE='
+          DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
+          KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
           NEXT_PUBLIC_DESKTOP_PROJECT_ID: ${{ secrets.UMAMI_BETA_DESKTOP_PROJECT_ID }}
           NEXT_PUBLIC_DESKTOP_UMAMI_BASE_URL: ${{ secrets.UMAMI_BETA_DESKTOP_BASE_URL }}
 
@@ -152,8 +152,8 @@ jobs:
         run: npm run desktop:build
         env:
           APP_URL: http://localhost:3015
-          DATABASE_URL: 'postgresql://postgres@localhost:5432/postgres'
-          KEY_VAULTS_SECRET: 'oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE='
+          DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
+          KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
           NEXT_PUBLIC_DESKTOP_PROJECT_ID: ${{ secrets.UMAMI_BETA_DESKTOP_PROJECT_ID }}
           NEXT_PUBLIC_DESKTOP_UMAMI_BASE_URL: ${{ secrets.UMAMI_BETA_DESKTOP_BASE_URL }}
 

.github/workflows/release.yml

@@ -1,4 +1,10 @@
 name: Release CI
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
 on:
   push:
     branches:

.github/workflows/sync-database-schema.yml

@@ -1,4 +1,6 @@
 name: Database Schema Visualization CI
+permissions:
+  contents: read
 
 on:
   push:

.github/workflows/test.yml

@@ -18,6 +18,7 @@ jobs:
           - web-crawler
           - electron-server-ipc
           - utils
+          - python-interpreter
           - context-engine
           - agent-runtime
 
@@ -44,7 +45,7 @@ jobs:
         run: bun run --filter @lobechat/${{ matrix.package }} test:coverage
 
       - name: Upload ${{ matrix.package }} coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./packages/${{ matrix.package }}/coverage/lcov.info
@@ -79,7 +80,7 @@ jobs:
         run: bun run --filter ${{ matrix.package }} test:coverage
 
       - name: Upload ${{ matrix.package }} coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./packages/${{ matrix.package }}/coverage/lcov.info
@@ -112,7 +113,7 @@ jobs:
         run: bun run test-app:coverage
 
       - name: Upload App Coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./coverage/app/lcov.info
@@ -173,7 +174,7 @@ jobs:
           APP_URL: https://home.com
 
       - name: Upload Database coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./packages/database/coverage/lcov.info

.i18nrc.js

@@ -25,7 +25,7 @@ module.exports = defineConfig({
   ],
   temperature: 0,
   saveImmediately: true,
-  modelName: 'gpt-4.1-mini',
+  modelName: 'chatgpt-4o-latest',
   experimental: {
     jsonMode: true,
   },

.vscode/settings.json

@@ -11,6 +11,7 @@
     { "rule": "prettier/prettier", "severity": "off" },
     { "rule": "react/jsx-sort-props", "severity": "off" },
     { "rule": "sort-keys-fix/sort-keys-fix", "severity": "off" },
+    { "rule": "simple-import-sort/exports", "severity": "off" },
     { "rule": "typescript-sort-keys/interface", "severity": "off" }
   ],
   "eslint.validate": [
@@ -81,7 +82,7 @@
 
     "**/src/config/modelProviders/*.ts": "${filename} • provider",
     "**/packages/model-bank/src/aiModels/*.ts": "${filename} • model",
-    "**/packages/model-runtime/src/*/index.ts": "${dirname} • runtime",
+    "**/packages/model-runtime/src/providers/*/index.ts": "${dirname} • runtime",
 
     "**/src/server/services/*/index.ts": "${dirname} • server/service",
     "**/src/server/routers/lambda/*.ts": "${filename} • lambda",

AGENTS.md

@@ -44,21 +44,7 @@ The project follows a well-organized monorepo structure:
 
 #### TypeScript
 
-- Follow strict TypeScript practices for type safety and code quality
-- Use proper type annotations
 - Prefer interfaces over types for object shapes
-- Use generics for reusable components
-
-#### React Components
-
-- Use functional components with hooks
-
-#### Database Schema
-
-- Follow Drizzle ORM naming conventions
-- Use plural snake_case for table names
-- Implement proper foreign key relationships
-- Follow the schema style guide
 
 ### Testing Strategy
 
@@ -67,64 +53,57 @@ The project follows a well-organized monorepo structure:
 **Commands**:
 
 - Web: `bunx vitest run --silent='passed-only' '[file-path-pattern]'`
-- Packages: `cd packages/[package-name] && bunx vitest run --silent='passed-only' '[file-path-pattern]'`
+- Packages: `cd packages/[package-name] && bunx vitest run --silent='passed-only' '[file-path-pattern]'` (each subpackage contains its own vitest.config.mts)
 
 **Important Notes**:
 
 - Wrap file paths in single quotes to avoid shell expansion
-- Never run `bun run test` - this runs all tests and takes ~10 minutes
-- If a test fails twice, stop and ask for help
-- Always add tests for new code
+- Never run `bun run test` - this runs all tests and takes \~10 minutes
 
 ### Type Checking
 
 - Use `bun run type-check` to check for type errors
-- Ensure all TypeScript errors are resolved before committing
 
-### Internationalization
+### i18n
 
-- Add new keys to `src/locales/default/namespace.ts`
-- Translate at least `zh-CN` files for development preview
-- Use hierarchical nested objects, not flat keys
-- Don't run `pnpm i18n` manually (handled by CI)
+- **Keys**: Add to `src/locales/default/namespace.ts`
+- **Dev**: Translate `locales/zh-CN/namespace.json` locale file only for preview
+- DON'T run `pnpm i18n`, let CI auto handle it
 
-## Available Development Rules
+## Project Rules Index
 
-The project provides comprehensive rules in `.cursor/rules/` directory:
+All following rules are saved under `.cursor/rules/` directory:
 
-### Core Development
+### Backend
 
-- `backend-architecture.mdc` - Three-layer architecture and data flow
-- `react-component.mdc` - Component patterns and UI library usage
-- `drizzle-schema-style-guide.mdc` - Database schema conventions
-- `define-database-model.mdc` - Model templates and CRUD patterns
-- `i18n.mdc` - Internationalization workflow
+- `drizzle-schema-style-guide.mdc` – Style guide for defining Drizzle ORM schemas
 
-### State Management & UI
+### Frontend
 
-- `zustand-slice-organization.mdc` - Store organization patterns
-- `zustand-action-patterns.mdc` - Action implementation patterns
-- `packages/react-layout-kit.mdc` - Flex layout component usage
+- `react-component.mdc` – React component style guide and conventions
+- `i18n.mdc` – Internationalization guide using react-i18next
+- `typescript.mdc` – TypeScript code style guide
+- `packages/react-layout-kit.mdc` – Usage guide for react-layout-kit
 
-### Testing & Quality
+### State Management
 
-- `testing-guide/testing-guide.mdc` - Comprehensive testing strategy
-- `code-review.mdc` - Code review process and standards
+- `zustand-action-patterns.mdc` – Recommended patterns for organizing Zustand actions
+- `zustand-slice-organization.mdc` – Best practices for structuring Zustand slices
 
 ### Desktop (Electron)
 
-- `desktop-feature-implementation.mdc` - Main/renderer process patterns
-- `desktop-local-tools-implement.mdc` - Tool integration workflow
-- `desktop-menu-configuration.mdc` - Menu system configuration
-- `desktop-window-management.mdc` - Window management patterns
-- `desktop-controller-tests.mdc` - Controller testing guide
+- `desktop-feature-implementation.mdc` – Implementing new Electron desktop features
+- `desktop-controller-tests.mdc` – Desktop controller unit testing guide
+- `desktop-local-tools-implement.mdc` – Workflow to add new desktop local tools
+- `desktop-menu-configuration.mdc` – Desktop menu configuration guide
+- `desktop-window-management.mdc` – Desktop window management guide
 
-## Best Practices
+### Debugging
 
-- **Conservative for existing code, modern approaches for new features**
-- **Code Language**: Use Chinese for files with existing Chinese comments, American English for new files
-- Always add tests for new functionality
-- Follow the established patterns in the codebase
-- Use proper error handling and logging
-- Implement proper accessibility features
-- Consider internationalization from the start
+- `debug-usage.mdc` – Using the debug package and namespace conventions
+
+### Testing
+
+- `testing-guide/testing-guide.mdc` – Comprehensive testing guide for Vitest
+- `testing-guide/electron-ipc-test.mdc` – Electron IPC interface testing strategy
+- `testing-guide/db-model-test.mdc` – Database Model testing guide

CHANGELOG.md

@@ -2,6 +2,731 @@
 
 # Changelog
 
+## [Version 1.136.0](https://github.com/lobehub/lobe-chat/compare/v1.135.6...v1.136.0)
+
+<sup>Released on **2025-10-09**</sup>
+
+#### ✨ Features
+
+- **misc**: Add new provider Cerebras.
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix standalone plugin rerender issue.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Add new provider Cerebras, closes [#9559](https://github.com/lobehub/lobe-chat/issues/9559) ([9cceaad](https://github.com/lobehub/lobe-chat/commit/9cceaad))
+
+#### What's fixed
+
+- **misc**: Fix standalone plugin rerender issue, closes [#9611](https://github.com/lobehub/lobe-chat/issues/9611) [#9396](https://github.com/lobehub/lobe-chat/issues/9396) ([7ab30fc](https://github.com/lobehub/lobe-chat/commit/7ab30fc))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.135.6](https://github.com/lobehub/lobe-chat/compare/v1.135.5...v1.135.6)
+
+<sup>Released on **2025-10-08**</sup>
+
+#### 🐛 Bug Fixes
+
+- **desktop**: Macos26 small icon.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **desktop**: Macos26 small icon, closes [#9421](https://github.com/lobehub/lobe-chat/issues/9421) ([ca03342](https://github.com/lobehub/lobe-chat/commit/ca03342))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.135.5](https://github.com/lobehub/lobe-chat/compare/v1.135.4...v1.135.5)
+
+<sup>Released on **2025-10-08**</sup>
+
+#### 💄 Styles
+
+- **misc**: Update i18n.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Update i18n, closes [#9602](https://github.com/lobehub/lobe-chat/issues/9602) ([ed267a4](https://github.com/lobehub/lobe-chat/commit/ed267a4))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.135.4](https://github.com/lobehub/lobe-chat/compare/v1.135.3...v1.135.4)
+
+<sup>Released on **2025-10-07**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor chat item.
+
+#### 💄 Styles
+
+- **misc**: Add GPT-5 pro model.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor chat item, closes [#9599](https://github.com/lobehub/lobe-chat/issues/9599) ([1f36158](https://github.com/lobehub/lobe-chat/commit/1f36158))
+
+#### Styles
+
+- **misc**: Add GPT-5 pro model, closes [#9594](https://github.com/lobehub/lobe-chat/issues/9594) ([775f30b](https://github.com/lobehub/lobe-chat/commit/775f30b))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.135.3](https://github.com/lobehub/lobe-chat/compare/v1.135.2...v1.135.3)
+
+<sup>Released on **2025-10-07**</sup>
+
+#### 💄 Styles
+
+- **misc**: Improve Korean translate.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Improve Korean translate, closes [#9597](https://github.com/lobehub/lobe-chat/issues/9597) ([319fbfb](https://github.com/lobehub/lobe-chat/commit/319fbfb))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.135.2](https://github.com/lobehub/lobe-chat/compare/v1.135.1...v1.135.2)
+
+<sup>Released on **2025-10-06**</sup>
+
+#### 💄 Styles
+
+- **image**: Optimize UX and fix fal pricing.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **image**: Optimize UX and fix fal pricing, closes [#9592](https://github.com/lobehub/lobe-chat/issues/9592) ([dddbfcd](https://github.com/lobehub/lobe-chat/commit/dddbfcd))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.135.1](https://github.com/lobehub/lobe-chat/compare/v1.135.0...v1.135.1)
+
+<sup>Released on **2025-10-06**</sup>
+
+#### 💄 Styles
+
+- **misc**: Improve styles and fix tools calling condition.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Improve styles and fix tools calling condition, closes [#9591](https://github.com/lobehub/lobe-chat/issues/9591) ([1695f2f](https://github.com/lobehub/lobe-chat/commit/1695f2f))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 1.135.0](https://github.com/lobehub/lobe-chat/compare/v1.134.7...v1.135.0)
+
+<sup>Released on **2025-10-06**</sup>
+
+#### ✨ Features
+
+- **misc**: Huanyuan text-to-image 3.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Huanyuan text-to-image 3, closes [#9589](https://github.com/lobehub/lobe-chat/issues/9589) ([1dd0e5e](https://github.com/lobehub/lobe-chat/commit/1dd0e5e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.7](https://github.com/lobehub/lobe-chat/compare/v1.134.6...v1.134.7)
+
+<sup>Released on **2025-10-06**</sup>
+
+#### 🐛 Bug Fixes
+
+- **security**: Sanitize Azure provider error responses to prevent API key exposure.
+
+#### 💄 Styles
+
+- **misc**: Update i18n.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **security**: Sanitize Azure provider error responses to prevent API key exposure, closes [#9583](https://github.com/lobehub/lobe-chat/issues/9583) ([af59bfe](https://github.com/lobehub/lobe-chat/commit/af59bfe))
+
+#### Styles
+
+- **misc**: Update i18n, closes [#9580](https://github.com/lobehub/lobe-chat/issues/9580) ([c0974ea](https://github.com/lobehub/lobe-chat/commit/c0974ea))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.6](https://github.com/lobehub/lobe-chat/compare/v1.134.5...v1.134.6)
+
+<sup>Released on **2025-10-05**</sup>
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.5](https://github.com/lobehub/lobe-chat/compare/v1.134.4...v1.134.5)
+
+<sup>Released on **2025-10-05**</sup>
+
+#### 🐛 Bug Fixes
+
+- **database**: Prevent empty array insertion in aiModel batch operations.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **database**: Prevent empty array insertion in aiModel batch operations, closes [#9491](https://github.com/lobehub/lobe-chat/issues/9491) [#9429](https://github.com/lobehub/lobe-chat/issues/9429) [#9429](https://github.com/lobehub/lobe-chat/issues/9429) ([eb50c8b](https://github.com/lobehub/lobe-chat/commit/eb50c8b))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.4](https://github.com/lobehub/lobe-chat/compare/v1.134.3...v1.134.4)
+
+<sup>Released on **2025-10-05**</sup>
+
+#### 💄 Styles
+
+- **misc**: Add promptfoo to improve prompts quality.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Add promptfoo to improve prompts quality, closes [#9568](https://github.com/lobehub/lobe-chat/issues/9568) ([33874c2](https://github.com/lobehub/lobe-chat/commit/33874c2))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.3](https://github.com/lobehub/lobe-chat/compare/v1.134.2...v1.134.3)
+
+<sup>Released on **2025-10-05**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Type not preserved when model is sorted.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Type not preserved when model is sorted, closes [#9561](https://github.com/lobehub/lobe-chat/issues/9561) ([5fe2518](https://github.com/lobehub/lobe-chat/commit/5fe2518))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.2](https://github.com/lobehub/lobe-chat/compare/v1.134.1...v1.134.2)
+
+<sup>Released on **2025-10-05**</sup>
+
+#### 💄 Styles
+
+- **misc**: Allow switching model `type`.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Allow switching model `type`, closes [#9529](https://github.com/lobehub/lobe-chat/issues/9529) ([9b62685](https://github.com/lobehub/lobe-chat/commit/9b62685))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.134.1](https://github.com/lobehub/lobe-chat/compare/v1.134.0...v1.134.1)
+
+<sup>Released on **2025-10-05**</sup>
+
+#### 💄 Styles
+
+- **misc**: Update i18n.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Update i18n, closes [#9546](https://github.com/lobehub/lobe-chat/issues/9546) ([ed8174f](https://github.com/lobehub/lobe-chat/commit/ed8174f))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 1.134.0](https://github.com/lobehub/lobe-chat/compare/v1.133.6...v1.134.0)
+
+<sup>Released on **2025-10-04**</sup>
+
+#### ✨ Features
+
+- **misc**: Support double-click to open multi agent window on the desktop.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Support double-click to open multi agent window on the desktop, closes [#9331](https://github.com/lobehub/lobe-chat/issues/9331) ([a060901](https://github.com/lobehub/lobe-chat/commit/a060901))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.133.6](https://github.com/lobehub/lobe-chat/compare/v1.133.5...v1.133.6)
+
+<sup>Released on **2025-10-04**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: `type` not preserved when model is disabled or sorted.
+
+#### 💄 Styles
+
+- **misc**: Nano banana support `aspect_ratio`.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: `type` not preserved when model is disabled or sorted, closes [#9530](https://github.com/lobehub/lobe-chat/issues/9530) ([476b897](https://github.com/lobehub/lobe-chat/commit/476b897))
+
+#### Styles
+
+- **misc**: Nano banana support `aspect_ratio`, closes [#9528](https://github.com/lobehub/lobe-chat/issues/9528) ([ae3ed6e](https://github.com/lobehub/lobe-chat/commit/ae3ed6e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.133.5](https://github.com/lobehub/lobe-chat/compare/v1.133.4...v1.133.5)
+
+<sup>Released on **2025-10-04**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Custom provider fails when client requests are enabled.
+
+#### 💄 Styles
+
+- **misc**: Optimized `extendParams` UI, update i18n.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Custom provider fails when client requests are enabled, closes [#9534](https://github.com/lobehub/lobe-chat/issues/9534) ([8b12fdf](https://github.com/lobehub/lobe-chat/commit/8b12fdf))
+
+#### Styles
+
+- **misc**: Optimized `extendParams` UI, closes [#9457](https://github.com/lobehub/lobe-chat/issues/9457) ([582f6d1](https://github.com/lobehub/lobe-chat/commit/582f6d1))
+- **misc**: Update i18n, closes [#9514](https://github.com/lobehub/lobe-chat/issues/9514) ([6430f57](https://github.com/lobehub/lobe-chat/commit/6430f57))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.133.4](https://github.com/lobehub/lobe-chat/compare/v1.133.3...v1.133.4)
+
+<sup>Released on **2025-10-01**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: OllamaCloud error.
+
+#### 💄 Styles
+
+- **misc**: Fix chat minimap overflow.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: OllamaCloud error, closes [#9481](https://github.com/lobehub/lobe-chat/issues/9481) ([55c45a5](https://github.com/lobehub/lobe-chat/commit/55c45a5))
+
+#### Styles
+
+- **misc**: Fix chat minimap overflow, closes [#9507](https://github.com/lobehub/lobe-chat/issues/9507) ([d835c33](https://github.com/lobehub/lobe-chat/commit/d835c33))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.133.3](https://github.com/lobehub/lobe-chat/compare/v1.133.2...v1.133.3)
+
+<sup>Released on **2025-10-01**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor a `ssrf-safe-fetch` module.
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix frontend random API key config not work.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor a `ssrf-safe-fetch` module, closes [#9474](https://github.com/lobehub/lobe-chat/issues/9474) ([92da716](https://github.com/lobehub/lobe-chat/commit/92da716))
+
+#### What's fixed
+
+- **misc**: Fix frontend random API key config not work, closes [#9477](https://github.com/lobehub/lobe-chat/issues/9477) [#9255](https://github.com/lobehub/lobe-chat/issues/9255) ([a194d48](https://github.com/lobehub/lobe-chat/commit/a194d48))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.133.2](https://github.com/lobehub/lobe-chat/compare/v1.133.1...v1.133.2)
+
+<sup>Released on **2025-09-30**</sup>
+
+#### 💄 Styles
+
+- **misc**: Add minimap to chat list for quick navigation.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Add minimap to chat list for quick navigation, closes [#9470](https://github.com/lobehub/lobe-chat/issues/9470) ([8db47eb](https://github.com/lobehub/lobe-chat/commit/8db47eb))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.133.1](https://github.com/lobehub/lobe-chat/compare/v1.133.0...v1.133.1)
+
+<sup>Released on **2025-09-30**</sup>
+
+#### 💄 Styles
+
+- **misc**: Update i18n.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Update i18n, closes [#9480](https://github.com/lobehub/lobe-chat/issues/9480) ([dfeb42c](https://github.com/lobehub/lobe-chat/commit/dfeb42c))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 1.133.0](https://github.com/lobehub/lobe-chat/compare/v1.132.19...v1.133.0)
+
+<sup>Released on **2025-09-29**</sup>
+
+#### ✨ Features
+
+- **misc**: Add builtin Python plugin, add Claude Sonnet 4.5 model to AI chat models.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Add builtin Python plugin, closes [#8873](https://github.com/lobehub/lobe-chat/issues/8873) ([fa6ef94](https://github.com/lobehub/lobe-chat/commit/fa6ef94))
+- **misc**: Add Claude Sonnet 4.5 model to AI chat models, closes [#9476](https://github.com/lobehub/lobe-chat/issues/9476) ([a30a65c](https://github.com/lobehub/lobe-chat/commit/a30a65c))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.132.19](https://github.com/lobehub/lobe-chat/compare/v1.132.18...v1.132.19)
+
+<sup>Released on **2025-09-29**</sup>
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.132.18](https://github.com/lobehub/lobe-chat/compare/v1.132.17...v1.132.18)
+
+<sup>Released on **2025-09-28**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Refactor tools-engine and fix search token count.
+
+#### 💄 Styles
+
+- **misc**: Update i18n.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Refactor tools-engine and fix search token count, closes [#9448](https://github.com/lobehub/lobe-chat/issues/9448) ([e82d4b7](https://github.com/lobehub/lobe-chat/commit/e82d4b7))
+
+#### Styles
+
+- **misc**: Update i18n, closes [#9449](https://github.com/lobehub/lobe-chat/issues/9449) ([b04a5d7](https://github.com/lobehub/lobe-chat/commit/b04a5d7))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.132.17](https://github.com/lobehub/lobe-chat/compare/v1.132.16...v1.132.17)
+
+<sup>Released on **2025-09-27**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix input empty group name.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix input empty group name, closes [#9441](https://github.com/lobehub/lobe-chat/issues/9441) ([f653ce1](https://github.com/lobehub/lobe-chat/commit/f653ce1))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.132.16](https://github.com/lobehub/lobe-chat/compare/v1.132.15...v1.132.16)
+
+<sup>Released on **2025-09-26**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Resolve qwen-image-edit imageUrls conversion issue.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Resolve qwen-image-edit imageUrls conversion issue, closes [#9414](https://github.com/lobehub/lobe-chat/issues/9414) ([ec5af1b](https://github.com/lobehub/lobe-chat/commit/ec5af1b))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.132.15](https://github.com/lobehub/lobe-chat/compare/v1.132.14...v1.132.15)
 
 <sup>Released on **2025-09-25**</sup>

CLAUDE.md

@@ -31,28 +31,18 @@ This repository adopts a monorepo structure.
 
 see @.cursor/rules/typescript.mdc
 
-### Modify Code Rules
-
-- **Code Language**:
-  - For files with existing Chinese comments: Continue using Chinese to maintain consistency
-  - For new files or files without Chinese comments: MUST use American English.
-    - eg: new react tsx file and new test file
-- Conservative for existing code, modern approaches for new features
-
 ### Testing
 
-Testing work follows the Rule-Aware Task Execution system above.
-
-- **Required Rule**: `testing-guide/testing-guide.mdc`
+- **Required Rule**: read `@.cursor/rules/testing-guide/testing-guide.mdc` before writing tests
 - **Command**:
   - web: `bunx vitest run --silent='passed-only' '[file-path-pattern]'`
   - packages(eg: database): `cd packages/database && bunx vitest run --silent='passed-only' '[file-path-pattern]'`
 
 **Important**:
 
-- wrapped the file path in single quotes to avoid shell expansion
+- wrap the file path in single quotes to avoid shell expansion
 - Never run `bun run test` etc to run tests, this will run all tests and cost about 10mins
-- If try to fix the same test twice, but still failed, stop and ask for help.
+- If trying to fix the same test twice, but still failed, stop and ask for help.
 
 ### Typecheck
 
@@ -61,40 +51,9 @@ Testing work follows the Rule-Aware Task Execution system above.
 ### i18n
 
 - **Keys**: Add to `src/locales/default/namespace.ts`
-- **Dev**: Translate `locales/zh-CN/namespace.json` locale file only for preview
+- **Dev**: Translate `locales/zh-CN/namespace.json` and `locales/en-US/namespace.json` locales file only for dev preview
 - DON'T run `pnpm i18n`, let CI auto handle it
 
 ## Rules Index
 
-Some useful rules of this project. Read them when needed.
-
-**IMPORTANT**: All rule files referenced in this document are located in the `.cursor/rules/` directory. Throughout this document, rule files are referenced by their filename only for brevity.
-
-### 📋 Complete Rule Files
-
-**Core Development**
-
-- `backend-architecture.mdc` - Three-layer architecture, data flow
-- `react-component.mdc` - antd-style, Lobe UI usage
-- `drizzle-schema-style-guide.mdc` - Schema naming, patterns
-- `define-database-model.mdc` - Model templates, CRUD patterns
-- `i18n.mdc` - Internationalization workflow
-
-**State & UI**
-
-- `zustand-slice-organization.mdc` - Store organization
-- `zustand-action-patterns.mdc` - Action patterns
-- `packages/react-layout-kit.mdc` - flex layout components usage
-
-**Testing & Quality**
-
-- `testing-guide/testing-guide.mdc` - Test strategy, mock patterns
-- `code-review.mdc` - Review process and standards
-
-**Desktop (Electron)**
-
-- `desktop-feature-implementation.mdc` - Main/renderer process patterns
-- `desktop-local-tools-implement.mdc` - Tool integration workflow
-- `desktop-menu-configuration.mdc` - App menu, context menu, tray menu
-- `desktop-window-management.mdc` - Window creation, state management, multi-window
-- `desktop-controller-tests.mdc` - Controller unit testing guide
+Some useful project rules are listed in @.cursor/rules/rules-index.mdc

Dockerfile.database

@@ -302,6 +302,8 @@ ENV \
     BFL_API_KEY="" BFL_MODEL_LIST="" \
     # Vercel AI Gateway
     VERCELAIGATEWAY_API_KEY="" VERCELAIGATEWAY_MODEL_LIST=""
+    # Cerebras
+    CEREBRAS_API_KEY="" CEREBRAS_MODEL_LIST=""
 
 USER nextjs
 

README.md

@@ -382,14 +382,14 @@ In addition, these plugins are not limited to news aggregation, but can also ext
 
 <!-- PLUGIN LIST -->
 
-| Recent Submits                                                                                                                            | Description                                                                                                                |
-| ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| [Web](https://lobechat.com/discover/plugin/web)<br/><sup>By **Proghit** on **2025-01-24**</sup>                                           | Smart web search that reads and analyzes pages to deliver comprehensive answers from Google results.<br/>`web` `search`    |
-| [Bing_websearch](https://lobechat.com/discover/plugin/Bingsearch-identifier)<br/><sup>By **FineHow** on **2024-12-22**</sup>              | Search for information from the internet base BingApi<br/>`bingsearch`                                                     |
-| [Google CSE](https://lobechat.com/discover/plugin/google-cse)<br/><sup>By **vsnthdev** on **2024-12-02**</sup>                            | Searches Google through their official CSE API.<br/>`web` `search`                                                         |
-| [Tongyi wanxiang Image Generator](https://lobechat.com/discover/plugin/alps-tongyi-image)<br/><sup>By **YoungTx** on **2024-08-09**</sup> | This plugin uses Alibaba's Tongyi Wanxiang model to generate images based on text prompts.<br/>`image` `tongyi` `wanxiang` |
+| Recent Submits                                                                                                               | Description                                                                                                             |
+| ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| [PortfolioMeta](https://lobechat.com/discover/plugin/StockData)<br/><sup>By **portfoliometa** on **2025-09-27**</sup>        | Analyze stocks and get comprehensive real-time investment data and analytics.<br/>`stock`                               |
+| [Web](https://lobechat.com/discover/plugin/web)<br/><sup>By **Proghit** on **2025-01-24**</sup>                              | Smart web search that reads and analyzes pages to deliver comprehensive answers from Google results.<br/>`web` `search` |
+| [Bing_websearch](https://lobechat.com/discover/plugin/Bingsearch-identifier)<br/><sup>By **FineHow** on **2024-12-22**</sup> | Search for information from the internet base BingApi<br/>`bingsearch`                                                  |
+| [Google CSE](https://lobechat.com/discover/plugin/google-cse)<br/><sup>By **vsnthdev** on **2024-12-02**</sup>               | Searches Google through their official CSE API.<br/>`web` `search`                                                      |
 
-> 📊 Total plugins: [<kbd>**41**</kbd>](https://lobechat.com/discover/plugins)
+> 📊 Total plugins: [<kbd>**42**</kbd>](https://lobechat.com/discover/plugins)
 
  <!-- PLUGIN LIST -->
 

README.zh-CN.md

@@ -375,14 +375,14 @@ LobeChat 的插件生态系统是其核心功能的重要扩展，它极大地
 
 <!-- PLUGIN LIST -->
 
-| 最近新增                                                                                                                     | 描述                                                                               |
-| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
-| [网页](https://lobechat.com/discover/plugin/web)<br/><sup>By **Proghit** on **2025-01-24**</sup>                             | 智能网页搜索，读取和分析页面，以提供来自 Google 结果的全面答案。<br/>`网页` `搜索` |
-| [必应网页搜索](https://lobechat.com/discover/plugin/Bingsearch-identifier)<br/><sup>By **FineHow** on **2024-12-22**</sup>   | 通过 BingApi 搜索互联网上的信息<br/>`bingsearch`                                   |
-| [谷歌自定义搜索引擎](https://lobechat.com/discover/plugin/google-cse)<br/><sup>By **vsnthdev** on **2024-12-02**</sup>       | 通过他们的官方自定义搜索引擎 API 搜索谷歌。<br/>`网络` `搜索`                      |
-| [通义万象图像生成器](https://lobechat.com/discover/plugin/alps-tongyi-image)<br/><sup>By **YoungTx** on **2024-08-09**</sup> | 此插件使用阿里巴巴的通义万象模型根据文本提示生成图像。<br/>`图像` `通义` `万象`    |
+| 最近新增                                                                                                                   | 描述                                                                               |
+| -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| [PortfolioMeta](https://lobechat.com/discover/plugin/StockData)<br/><sup>By **portfoliometa** on **2025-09-27**</sup>      | 分析股票并获取全面的实时投资数据和分析。<br/>`股票`                                |
+| [网页](https://lobechat.com/discover/plugin/web)<br/><sup>By **Proghit** on **2025-01-24**</sup>                           | 智能网页搜索，读取和分析页面，以提供来自 Google 结果的全面答案。<br/>`网页` `搜索` |
+| [必应网页搜索](https://lobechat.com/discover/plugin/Bingsearch-identifier)<br/><sup>By **FineHow** on **2024-12-22**</sup> | 通过 BingApi 搜索互联网上的信息<br/>`bingsearch`                                   |
+| [谷歌自定义搜索引擎](https://lobechat.com/discover/plugin/google-cse)<br/><sup>By **vsnthdev** on **2024-12-02**</sup>     | 通过他们的官方自定义搜索引擎 API 搜索谷歌。<br/>`网络` `搜索`                      |
 
-> 📊 Total plugins: [<kbd>**41**</kbd>](https://lobechat.com/discover/plugins)
+> 📊 Total plugins: [<kbd>**42**</kbd>](https://lobechat.com/discover/plugins)
 
  <!-- PLUGIN LIST -->
 

apps/desktop/electron-builder.js

@@ -1,5 +1,7 @@
 const dotenv = require('dotenv');
+const fs = require('node:fs/promises');
 const os = require('node:os');
+const path = require('node:path');
 
 dotenv.config();
 
@@ -32,11 +34,50 @@ const getProtocolScheme = () => {
 
 const protocolScheme = getProtocolScheme();
 
+// Determine icon file based on version type
+const getIconFileName = () => {
+  if (isNightly) return 'Icon-nightly';
+  if (isBeta) return 'Icon-beta';
+  return 'Icon';
+};
+
 /**
  * @type {import('electron-builder').Configuration}
  * @see https://www.electron.build/configuration
  */
 const config = {
+  /**
+   * AfterPack hook to copy pre-generated Liquid Glass Assets.car for macOS 26+
+   * @see https://github.com/electron-userland/electron-builder/issues/9254
+   * @see https://github.com/MultiboxLabs/flow-browser/pull/159
+   * @see https://github.com/electron/packager/pull/1806
+   */
+  afterPack: async (context) => {
+    // Only process macOS builds
+    if (context.electronPlatformName !== 'darwin') {
+      return;
+    }
+
+    const iconFileName = getIconFileName();
+    const assetsCarSource = path.join(__dirname, 'build', `${iconFileName}.Assets.car`);
+    const resourcesPath = path.join(
+      context.appOutDir,
+      `${context.packager.appInfo.productFilename}.app`,
+      'Contents',
+      'Resources',
+    );
+    const assetsCarDest = path.join(resourcesPath, 'Assets.car');
+
+    try {
+      await fs.access(assetsCarSource);
+      await fs.copyFile(assetsCarSource, assetsCarDest);
+      console.log(`✅ Copied Liquid Glass icon: ${iconFileName}.Assets.car`);
+    } catch {
+      // Non-critical: Assets.car not found or copy failed
+      // App will use fallback .icns icon on all macOS versions
+      console.log(`⏭️  Skipping Assets.car (not found or copy failed)`);
+    }
+  },
   appId: isNightly
     ? 'com.lobehub.lobehub-desktop-nightly'
     : isBeta
@@ -81,6 +122,7 @@ const config = {
     compression: 'maximum',
     entitlementsInherit: 'build/entitlements.mac.plist',
     extendInfo: {
+      CFBundleIconName: 'AppIcon',
       CFBundleURLTypes: [
         {
           CFBundleURLName: 'LobeHub Protocol',

apps/desktop/src/main/appBrowsers.ts

@@ -46,4 +46,55 @@ export const appBrowsers = {
   },
 } satisfies Record<string, BrowserWindowOpts>;
 
+// Window templates for multi-instance windows
+export interface WindowTemplate {
+  allowMultipleInstances: boolean;
+  // Include common BrowserWindow options
+  autoHideMenuBar?: boolean;
+  baseIdentifier: string;
+  basePath: string;
+  devTools?: boolean;
+  height?: number;
+  keepAlive?: boolean;
+  minWidth?: number;
+  parentIdentifier?: string;
+  showOnInit?: boolean;
+  title?: string;
+  titleBarStyle?: 'hidden' | 'default' | 'hiddenInset' | 'customButtonsOnHover';
+  vibrancy?:
+    | 'appearance-based'
+    | 'content'
+    | 'fullscreen-ui'
+    | 'header'
+    | 'hud'
+    | 'menu'
+    | 'popover'
+    | 'selection'
+    | 'sheet'
+    | 'sidebar'
+    | 'titlebar'
+    | 'tooltip'
+    | 'under-page'
+    | 'under-window'
+    | 'window';
+  width?: number;
+}
+
+export const windowTemplates = {
+  chatSingle: {
+    allowMultipleInstances: true,
+    autoHideMenuBar: true,
+    baseIdentifier: 'chatSingle',
+    basePath: '/chat',
+    height: 600,
+    keepAlive: false, // Multi-instance windows don't need to stay alive
+    minWidth: 400,
+    parentIdentifier: 'chat',
+    titleBarStyle: 'hidden',
+    vibrancy: 'under-window',
+    width: 900,
+  },
+} satisfies Record<string, WindowTemplate>;
+
 export type AppBrowsersIdentifiers = keyof typeof appBrowsers;
+export type WindowTemplateIdentifiers = keyof typeof windowTemplates;

apps/desktop/src/main/controllers/BrowserWindowsCtr.ts

@@ -1,7 +1,7 @@
 import { InterceptRouteParams } from '@lobechat/electron-client-ipc';
 import { extractSubPath, findMatchingRoute } from '~common/routes';
 
-import { AppBrowsersIdentifiers, BrowsersIdentifiers } from '@/appBrowsers';
+import { AppBrowsersIdentifiers, BrowsersIdentifiers, WindowTemplateIdentifiers } from '@/appBrowsers';
 import { IpcClientEventSender } from '@/types/ipcClientEvent';
 
 import { ControllerModule, ipcClientEvent, shortcut } from './index';
@@ -100,6 +100,77 @@ export default class BrowserWindowsCtr extends ControllerModule {
     }
   }
 
+  /**
+   * Create a new multi-instance window
+   */
+  @ipcClientEvent('createMultiInstanceWindow')
+  async createMultiInstanceWindow(params: {
+    templateId: WindowTemplateIdentifiers;
+    path: string;
+    uniqueId?: string;
+  }) {
+    try {
+      console.log('[BrowserWindowsCtr] Creating multi-instance window:', params);
+
+      const result = this.app.browserManager.createMultiInstanceWindow(
+        params.templateId,
+        params.path,
+        params.uniqueId,
+      );
+
+      // Show the window
+      result.browser.show();
+
+      return {
+        success: true,
+        windowId: result.identifier,
+      };
+    } catch (error) {
+      console.error('[BrowserWindowsCtr] Failed to create multi-instance window:', error);
+      return {
+        error: error.message,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Get all windows by template
+   */
+  @ipcClientEvent('getWindowsByTemplate')
+  async getWindowsByTemplate(templateId: string) {
+    try {
+      const windowIds = this.app.browserManager.getWindowsByTemplate(templateId);
+      return {
+        success: true,
+        windowIds,
+      };
+    } catch (error) {
+      console.error('[BrowserWindowsCtr] Failed to get windows by template:', error);
+      return {
+        error: error.message,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Close all windows by template
+   */
+  @ipcClientEvent('closeWindowsByTemplate')
+  async closeWindowsByTemplate(templateId: string) {
+    try {
+      this.app.browserManager.closeWindowsByTemplate(templateId);
+      return { success: true };
+    } catch (error) {
+      console.error('[BrowserWindowsCtr] Failed to close windows by template:', error);
+      return {
+        error: error.message,
+        success: false,
+      };
+    }
+  }
+
   /**
    * Open target window and navigate to specified sub-path
    */

apps/desktop/src/main/core/browser/Browser.ts

@@ -336,7 +336,6 @@ export default class Browser {
       vibrancy: 'sidebar',
       visualEffectState: 'active',
       webPreferences: {
-        backgroundThrottling: false,
         contextIsolation: true,
         preload: join(preloadDir, 'index.js'),
       },

apps/desktop/src/main/core/browser/BrowserManager.ts

@@ -3,7 +3,7 @@ import { WebContents } from 'electron';
 
 import { createLogger } from '@/utils/logger';
 
-import { AppBrowsersIdentifiers, appBrowsers } from '../../appBrowsers';
+import { AppBrowsersIdentifiers, appBrowsers, WindowTemplate, WindowTemplateIdentifiers, windowTemplates } from '../../appBrowsers';
 import type { App } from '../App';
 import type { BrowserWindowOpts } from './Browser';
 import Browser from './Browser';
@@ -14,9 +14,9 @@ const logger = createLogger('core:BrowserManager');
 export class BrowserManager {
   app: App;
 
-  browsers: Map<AppBrowsersIdentifiers, Browser> = new Map();
+  browsers: Map<string, Browser> = new Map();
 
-  private webContentsMap = new Map<WebContents, AppBrowsersIdentifiers>();
+  private webContentsMap = new Map<WebContents, string>();
 
   constructor(app: App) {
     logger.debug('Initializing BrowserManager');
@@ -51,12 +51,12 @@ export class BrowserManager {
   };
 
   broadcastToWindow = <T extends MainBroadcastEventKey>(
-    identifier: AppBrowsersIdentifiers,
+    identifier: string,
     event: T,
     data: MainBroadcastParams<T>,
   ) => {
     logger.debug(`Broadcasting event ${event} to window: ${identifier}`);
-    this.browsers.get(identifier).broadcast(event, data);
+    this.browsers.get(identifier)?.broadcast(event, data);
   };
 
   /**
@@ -87,13 +87,21 @@ export class BrowserManager {
    * @param identifier Window identifier
    * @param subPath Sub-path, such as 'agent', 'about', etc.
    */
-  async redirectToPage(identifier: AppBrowsersIdentifiers, subPath?: string) {
+  async redirectToPage(identifier: string, subPath?: string) {
     try {
       // Ensure window is retrieved or created
       const browser = this.retrieveByIdentifier(identifier);
       browser.hide();
 
-      const baseRoute = appBrowsers[identifier].path;
+      // Handle both static and dynamic windows
+      let baseRoute: string;
+      if (identifier in appBrowsers) {
+        baseRoute = appBrowsers[identifier as AppBrowsersIdentifiers].path;
+      } else {
+        // For dynamic windows, extract base route from the browser options
+        const browserOptions = browser.options;
+        baseRoute = browserOptions.path;
+      }
 
       // Build complete URL path
       const fullPath = subPath ? `${baseRoute}/${subPath}` : baseRoute;
@@ -114,13 +122,75 @@ export class BrowserManager {
   /**
    * get Browser by identifier
    */
-  retrieveByIdentifier(identifier: AppBrowsersIdentifiers) {
+  retrieveByIdentifier(identifier: string) {
     const browser = this.browsers.get(identifier);
 
     if (browser) return browser;
 
-    logger.debug(`Browser ${identifier} not found, initializing new instance`);
-    return this.retrieveOrInitialize(appBrowsers[identifier]);
+    // Check if it's a static browser
+    if (identifier in appBrowsers) {
+      logger.debug(`Browser ${identifier} not found, initializing new instance`);
+      return this.retrieveOrInitialize(appBrowsers[identifier as AppBrowsersIdentifiers]);
+    }
+
+    throw new Error(`Browser ${identifier} not found and is not a static browser`);
+  }
+
+  /**
+   * Create a multi-instance window from template
+   * @param templateId Template identifier
+   * @param path Full path with query parameters
+   * @param uniqueId Optional unique identifier, will be generated if not provided
+   * @returns The window identifier and Browser instance
+   */
+  createMultiInstanceWindow(templateId: WindowTemplateIdentifiers, path: string, uniqueId?: string) {
+    const template = windowTemplates[templateId];
+    if (!template) {
+      throw new Error(`Window template ${templateId} not found`);
+    }
+
+    // Generate unique identifier
+    const windowId = uniqueId || `${template.baseIdentifier}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // Create browser options from template
+    const browserOpts: BrowserWindowOpts = {
+      ...template,
+      identifier: windowId,
+      path: path,
+    };
+
+    logger.debug(`Creating multi-instance window: ${windowId} with path: ${path}`);
+
+    const browser = this.retrieveOrInitialize(browserOpts);
+
+    return {
+      identifier: windowId,
+      browser: browser,
+    };
+  }
+
+  /**
+   * Get all windows based on template
+   * @param templateId Template identifier
+   * @returns Array of window identifiers matching the template
+   */
+  getWindowsByTemplate(templateId: string): string[] {
+    const prefix = `${templateId}_`;
+    return Array.from(this.browsers.keys()).filter(id => id.startsWith(prefix));
+  }
+
+  /**
+   * Close all windows based on template
+   * @param templateId Template identifier
+   */
+  closeWindowsByTemplate(templateId: string): void {
+    const windowIds = this.getWindowsByTemplate(templateId);
+    windowIds.forEach(id => {
+      const browser = this.browsers.get(id);
+      if (browser) {
+        browser.close();
+      }
+    });
   }
 
   /**
@@ -144,7 +214,7 @@ export class BrowserManager {
    * @param options Browser window options
    */
   private retrieveOrInitialize(options: BrowserWindowOpts) {
-    let browser = this.browsers.get(options.identifier as AppBrowsersIdentifiers);
+    let browser = this.browsers.get(options.identifier);
     if (browser) {
       logger.debug(`Retrieved existing browser: ${options.identifier}`);
       return browser;
@@ -153,7 +223,7 @@ export class BrowserManager {
     logger.debug(`Creating new browser: ${options.identifier}`);
     browser = new Browser(options, this.app);
 
-    const identifier = options.identifier as AppBrowsersIdentifiers;
+    const identifier = options.identifier;
     this.browsers.set(identifier, browser);
 
     // 记录 WebContents 和 identifier 的映射
@@ -166,32 +236,32 @@ export class BrowserManager {
 
     browser.browserWindow.on('show', () => {
       if (browser.webContents)
-        this.webContentsMap.set(browser.webContents, browser.identifier as AppBrowsersIdentifiers);
+        this.webContentsMap.set(browser.webContents, browser.identifier);
     });
 
     return browser;
   }
 
   closeWindow(identifier: string) {
-    const browser = this.browsers.get(identifier as AppBrowsersIdentifiers);
+    const browser = this.browsers.get(identifier);
     browser?.close();
   }
 
   minimizeWindow(identifier: string) {
-    const browser = this.browsers.get(identifier as AppBrowsersIdentifiers);
+    const browser = this.browsers.get(identifier);
     browser?.browserWindow.minimize();
   }
 
   maximizeWindow(identifier: string) {
-    const browser = this.browsers.get(identifier as AppBrowsersIdentifiers);
-    if (browser.browserWindow.isMaximized()) {
+    const browser = this.browsers.get(identifier);
+    if (browser?.browserWindow.isMaximized()) {
       browser?.browserWindow.unmaximize();
     } else {
       browser?.browserWindow.maximize();
     }
   }
 
-  getIdentifierByWebContents(webContents: WebContents): AppBrowsersIdentifiers | null {
+  getIdentifierByWebContents(webContents: WebContents): string | null {
     return this.webContentsMap.get(webContents) || null;
   }
 

changelog/v1.json

@@ -1,4 +1,181 @@
 [
+  {
+    "children": {},
+    "date": "2025-10-08",
+    "version": "1.135.6"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-10-08",
+    "version": "1.135.5"
+  },
+  {
+    "children": {
+      "improvements": ["Add GPT-5 pro model."]
+    },
+    "date": "2025-10-07",
+    "version": "1.135.4"
+  },
+  {
+    "children": {
+      "improvements": ["Improve Korean translate."]
+    },
+    "date": "2025-10-07",
+    "version": "1.135.3"
+  },
+  {
+    "children": {},
+    "date": "2025-10-06",
+    "version": "1.135.2"
+  },
+  {
+    "children": {
+      "improvements": ["Improve styles and fix tools calling condition."]
+    },
+    "date": "2025-10-06",
+    "version": "1.135.1"
+  },
+  {
+    "children": {
+      "features": ["Huanyuan text-to-image 3."]
+    },
+    "date": "2025-10-06",
+    "version": "1.135.0"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-10-06",
+    "version": "1.134.7"
+  },
+  {
+    "children": {},
+    "date": "2025-10-05",
+    "version": "1.134.6"
+  },
+  {
+    "children": {},
+    "date": "2025-10-05",
+    "version": "1.134.5"
+  },
+  {
+    "children": {
+      "improvements": ["Add promptfoo to improve prompts quality."]
+    },
+    "date": "2025-10-05",
+    "version": "1.134.4"
+  },
+  {
+    "children": {
+      "fixes": ["Type not preserved when model is sorted."]
+    },
+    "date": "2025-10-05",
+    "version": "1.134.3"
+  },
+  {
+    "children": {
+      "improvements": ["Allow switching model type."]
+    },
+    "date": "2025-10-05",
+    "version": "1.134.2"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-10-05",
+    "version": "1.134.1"
+  },
+  {
+    "children": {
+      "features": ["Support double-click to open multi agent window on the desktop."]
+    },
+    "date": "2025-10-04",
+    "version": "1.134.0"
+  },
+  {
+    "children": {
+      "fixes": ["type not preserved when model is disabled or sorted."],
+      "improvements": ["Nano banana support aspect_ratio."]
+    },
+    "date": "2025-10-04",
+    "version": "1.133.6"
+  },
+  {
+    "children": {
+      "fixes": ["Custom provider fails when client requests are enabled."],
+      "improvements": ["Optimized extendParams UI, update i18n."]
+    },
+    "date": "2025-10-04",
+    "version": "1.133.5"
+  },
+  {
+    "children": {
+      "fixes": ["OllamaCloud error."],
+      "improvements": ["Fix chat minimap overflow."]
+    },
+    "date": "2025-10-01",
+    "version": "1.133.4"
+  },
+  {
+    "children": {
+      "improvements": ["Refactor a ssrf-safe-fetch module."],
+      "fixes": ["Fix frontend random API key config not work."]
+    },
+    "date": "2025-10-01",
+    "version": "1.133.3"
+  },
+  {
+    "children": {
+      "improvements": ["Add minimap to chat list for quick navigation."]
+    },
+    "date": "2025-09-30",
+    "version": "1.133.2"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-09-30",
+    "version": "1.133.1"
+  },
+  {
+    "children": {
+      "features": ["Add builtin Python plugin, add Claude Sonnet 4.5 model to AI chat models."]
+    },
+    "date": "2025-09-29",
+    "version": "1.133.0"
+  },
+  {
+    "children": {},
+    "date": "2025-09-29",
+    "version": "1.132.19"
+  },
+  {
+    "children": {
+      "fixes": ["Refactor tools-engine and fix search token count."],
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-09-28",
+    "version": "1.132.18"
+  },
+  {
+    "children": {
+      "fixes": ["Fix input empty group name."]
+    },
+    "date": "2025-09-27",
+    "version": "1.132.17"
+  },
+  {
+    "children": {
+      "fixes": ["Resolve qwen-image-edit imageUrls conversion issue."]
+    },
+    "date": "2025-09-26",
+    "version": "1.132.16"
+  },
   {
     "children": {
       "fixes": ["Add proxyUrl configuration for NEW API provider."]

docs/development/basic/feature-development-frontend.mdx

@@ -5,7 +5,9 @@ LobeChat is built on the Next.js framework and uses TypeScript as the primary de
 1. Routing: Define routes (`src/app`).
 2. Data Structure: Define data structures (`src/types`).
 3. Business Logic Implementation: Zustand store (`src/store`).
-4. Page Display: Write static components/pages (`src/app/<new-page>/features/<new-feature>.tsx`).
+4. Page Display: Write static components/pages. Create features in:
+   - `src/features/<feature-name>/` for **shared global features** (used across multiple pages)
+   - `src/app/<new-page>/features/<feature-name>/` for **page-specific features** (only used in this page)
 5. Function Binding: Bind the store with page triggers (`const [state, function] = useNewStore(s => [s.state, s.function])`).
 
 Taking the "Chat Messages" feature as an example, here are the brief steps to implement this feature:
@@ -60,7 +62,8 @@ export const useChatStore = create<ChatState>((set) => ({
 In `src/app/<new-page>/features/<new-feature>.tsx`, we need to create a new page or component to display "Chat Messages". In this file, we can use the Zustand Store created earlier and Ant Design components to build the UI:
 
 ```jsx
-// src/features/chat/index.tsx
+// src/app/chat/features/ChatPage/index.tsx
+// Note: Use src/app/<page>/features/ for page-specific components
 import { List, Typography } from 'antd';
 import { useChatStore } from 'src/store/chatStore';
 
@@ -82,6 +85,12 @@ const ChatPage = () => {
 export default ChatPage;
 ```
 
+> **Note on Feature Organization**: LobeChat uses two patterns for organizing features:
+> - **Global features** (`src/features/`): Shared components like `ChatInput`, `Conversation` used across the app
+> - **Page-specific features** (`src/app/<page>/features/`): Components used only within a specific page route
+>
+> Choose based on reusability. If unsure, start with page-specific and refactor to global if needed elsewhere.
+
 ## 5. Function Binding
 
 In a page or component, we need to bind the Zustand Store's state and methods to the UI. In the example above, we have already bound the `messages` state to the `dataSource` property of the list. Now, we also need a method to add new messages. We can define this method in the Zustand Store and then use it in the page or component:

docs/development/basic/feature-development-frontend.zh-CN.mdx

@@ -5,7 +5,9 @@ LobeChat 基于 Next.js 框架构建，使用 TypeScript 作为主要开发语
 1. 路由：定义路由 (`src/app`)
 2. 数据结构： 定义数据结构 ( `src/types` )
 3. 业务功能实现： zustand store (`src/store`)
-4. 页面展示：书写静态组件 / 页面 (`src/app/<new-page>/features/<new-feature>.tsx`)
+4. 页面展示：书写静态组件 / 页面。根据以下方式创建功能组件：
+   - `src/features/<feature-name>/` 用于 **全局共享功能**（跨多个页面使用）
+   - `src/app/<new-page>/features/<feature-name>/` 用于 **页面专属功能**（仅在当前页面使用）
 5. 功能绑定：绑定 store 与页面的触发 (`const  [state,function]= useNewStore(s=>[s.state,s.function])`)
 
 我们以 "会话消息" 功能为例，以下是实现这个功能的简要步骤：
@@ -42,7 +44,7 @@ export type ChatMessage = {
 
 ```ts
 // src/store/chatStore.ts
-import create from 'zustand';
+import { create } from 'zustand';
 
 type ChatState = {
   messages: ChatMessage[];
@@ -60,7 +62,8 @@ export const useChatStore = create<ChatState>((set) => ({
 在 `src/app/<new-page>/features/<new-feature>.tsx` 中，我们需要创建一个新的页面或组件来显示 "会话消息"。在这个文件中，我们可以使用上面创建的 Zustand Store，以及 Ant Design 的组件来构建 UI：
 
 ```jsx
-// src/features/chat/index.tsx
+// src/app/chat/features/ChatPage/index.tsx
+// 注意：使用 src/app/<page>/features/ 放置页面专属组件
 import { List, Typography } from 'antd';
 import { useChatStore } from 'src/store/chatStore';
 
@@ -82,6 +85,12 @@ const ChatPage = () => {
 export default ChatPage;
 ```
 
+> **关于功能组件组织方式的说明**：LobeChat 使用两种模式来组织功能组件：
+> - **全局功能**（`src/features/`）：跨应用共享的组件，如 `ChatInput`、`Conversation` 等
+> - **页面专属功能**（`src/app/<page>/features/`）：仅在特定页面路由中使用的组件
+>
+> 根据可复用性选择合适的方式。如果不确定，可以先放在页面专属位置，需要时再重构为全局共享。
+
 ## 5. 功能绑定
 
 在页面或组件中，我们需要将 Zustand Store 的状态和方法绑定到 UI 上。在上面的示例中，我们已经将 `messages` 状态绑定到了列表的 `dataSource` 属性上。现在，我们还需要一个方法来添加新的消息。我们可以在 Zustand Store 中定义这个方法，然后在页面或组件中使用它：

docs/development/basic/folder-structure.mdx

@@ -4,37 +4,88 @@ The directory structure of LobeChat is as follows:
 
 ```bash
 src
-├── app        # Main logic and state management related code for the application
+├── app        # Next.js App Router implementation with route groups and API routes
 ├── components # Reusable UI components
 ├── config     # Application configuration files, including client-side and server-side environment variables
-├── const      # Used to define constants, such as action types, route names, etc.
 ├── features   # Function modules related to business functions, such as agent settings, plugin development pop-ups, etc.
 ├── hooks      # Custom utility hooks reused throughout the application
 ├── layout     # Application layout components, such as navigation bars, sidebars, etc.
+├── libs       # Third-party integrations (analytics, OIDC, etc.)
 ├── locales    # Internationalization language files
+├── server     # Server-side modules and services
 ├── services   # Encapsulated backend service interfaces, such as HTTP requests
 ├── store      # Zustand store for state management
+├── styles     # Global styles and CSS-in-JS configurations
 ├── types      # TypeScript type definition files
 └── utils      # Common utility functions
 ```
 
 ## app
 
-In the `app` folder, we organize each route page according to the app router's [Route Groups](https://nextjs.org/docs/app/building-your-application/routing/route-groups) to separately handle the implementation of desktop and mobile code. Taking the file structure of the `welcome` page as an example:
+The `app` directory follows Next.js 13+ App Router conventions with a sophisticated architecture using [Route Groups](https://nextjs.org/docs/app/building-your-application/routing/route-groups) to organize backend services, platform variants, and application routes:
 
 ```bash
-welcome
-├── (desktop)               # Desktop implementation
-│   ├── features            # Desktop-specific features
-│   ├── index.tsx           # Main entry file for desktop
-│   └── layout.desktop.tsx  # Desktop layout component
-├── (mobile)                # Mobile implementation
-│   ├── features            # Mobile-specific features
-│   ├── index.tsx           # Main entry file for mobile
-│   └── layout.mobile.tsx   # Mobile layout component
-├── features                # This folder contains features code shared by both desktop and mobile, such as the Banner component
-│   └── Banner
-└── page.tsx                # This is the main entry file for the page, used to load desktop or mobile code based on the device type
+app
+├── (backend)/                    # Backend API routes and services
+│   ├── api/                      # REST API endpoints
+│   │   ├── auth/                 # Authentication routes
+│   │   └── webhooks/             # Webhook handlers
+│   ├── middleware/               # Request middleware
+│   ├── oidc/                     # OpenID Connect routes
+│   ├── trpc/                     # tRPC API endpoints
+│   │   ├── async/                # Async tRPC routes
+│   │   ├── desktop/              # Desktop-specific tRPC routes
+│   │   ├── edge/                 # Edge runtime tRPC routes
+│   │   ├── lambda/               # Lambda tRPC routes
+│   │   └── tools/                # Tools tRPC routes
+│   └── webapi/                   # Web API endpoints
+│       ├── chat/                 # Chat-related APIs
+│       ├── models/               # Model management APIs
+│       ├── tts/                  # Text-to-speech APIs
+│       └── ...
+├── [variants]/                   # Platform and device variants
+│   ├── (auth)/                   # Authentication pages
+│   │   ├── login/
+│   │   ├── signup/
+│   │   └── next-auth/
+│   ├── (main)/                   # Main application routes
+│   │   ├── (mobile)/             # Mobile-specific routes
+│   │   │   └── me/               # Mobile profile pages
+│   │   ├── _layout/              # Layout components
+│   │   ├── chat/                 # Chat interface
+│   │   ├── discover/             # Discovery pages
+│   │   ├── files/                # File management
+│   │   ├── image/                # Image generation
+│   │   ├── profile/              # User profile
+│   │   ├── repos/                # Repository management
+│   │   └── settings/             # Application settings
+│   └── @modal/                   # Parallel modal routes
+│       ├── (.)changelog/
+│       └── _layout/
+├── desktop/                      # Desktop-specific routes
+│   └── devtools/
+├── manifest.ts                   # PWA manifest
+├── robots.tsx                    # Robots.txt generation
+├── sitemap.tsx                   # Sitemap generation
+└── sw.ts                         # Service worker
 ```
 
-In this way, we can clearly distinguish and manage desktop and mobile code, while also easily reusing code required on both devices, thereby improving development efficiency and maintaining code cleanliness and maintainability.
+### Architecture Explanation
+
+**Route Groups:**
+- `(backend)` - Contains all server-side API routes, middleware, and backend services
+- `[variants]` - Dynamic route group handling different platform variants and main application pages
+- `@modal` - Parallel routes for modal dialogs using Next.js parallel routing
+
+**Platform Organization:**
+- The architecture supports multiple platforms (web, desktop, mobile) through route organization
+- Desktop-specific routes are in the `desktop/` directory
+- Mobile-specific routes are organized under `(main)/(mobile)/`
+- Shared layouts and components are in `_layout/` directories
+
+**API Architecture:**
+- REST APIs in `(backend)/api/` and `(backend)/webapi/`
+- tRPC endpoints organized by runtime environment (edge, lambda, async, desktop)
+- Authentication and OIDC handling in dedicated route groups
+
+This architecture provides clear separation of concerns while maintaining flexibility for different deployment targets and runtime environments.

docs/development/basic/folder-structure.zh-CN.mdx

@@ -4,37 +4,88 @@ LobeChat 的文件夹目录架构如下：
 
 ```bash
 src
-├── app        # 应用主要逻辑和状态管理相关的代码
+├── app        # Next.js App Router 实现，包含路由组和 API 路由
 ├── components # 可复用的 UI 组件
 ├── config     # 应用的配置文件，包含客户端环境变量与服务端环境变量
-├── const      # 用于定义常量，如 action 类型、路由名等
 ├── features   # 与业务功能相关的功能模块，如 Agent 设置、插件开发弹窗等
 ├── hooks      # 全应用复用自定义的工具 Hooks
 ├── layout     # 应用的布局组件，如导航栏、侧边栏等
+├── libs       # 第三方集成（分析、OIDC 等）
 ├── locales    # 国际化的语言文件
+├── server     # 服务端模块和服务
 ├── services   # 封装的后端服务接口，如 HTTP 请求
 ├── store      # 用于状态管理的 zustand store
+├── styles     # 全局样式和 CSS-in-JS 配置
 ├── types      # TypeScript 的类型定义文件
 └── utils      # 通用的工具函数
 ```
 
 ## app
 
-在 `app` 文件夹中，我们将每个路由页面按照 app router 的 [Route Groups](https://nextjs.org/docs/app/building-your-application/routing/route-groups) 进行组织，以此来分别处理桌面端和移动端的代码实现。以 `welcome` 页面的文件结构为例：
+`app` 目录遵循 Next.js 13+ App Router 约定，采用复杂的架构，使用 [路由组](https://nextjs.org/docs/app/building-your-application/routing/route-groups) 来组织后端服务、平台变体和应用路由：
 
 ```bash
-welcome
-├── (desktop)               # 桌面端实现
-│   ├── features            # 桌面端特有的功能
-│   ├── index.tsx           # 桌面端的主入口文件
-│   └── layout.desktop.tsx  # 桌面端的布局组件
-├── (mobile)                # 移动端实现
-│   ├── features            # 移动端特有的功能
-│   ├── index.tsx           # 移动端的主入口文件
-│   └── layout.mobile.tsx   # 移动端的布局组件
-├── features                # 此文件夹包含双端共享的特性代码，如 Banner 组件
-│   └── Banner
-└── page.tsx                # 此为页面的主入口文件，用于根据设备类型选择加载桌面端或移动端的代码
+app
+├── (backend)/                    # 后端 API 路由和服务
+│   ├── api/                      # REST API 端点
+│   │   ├── auth/                 # 身份验证路由
+│   │   └── webhooks/             # Webhook 处理器
+│   ├── middleware/               # 请求中间件
+│   ├── oidc/                     # OpenID Connect 路由
+│   ├── trpc/                     # tRPC API 端点
+│   │   ├── async/                # 异步 tRPC 路由
+│   │   ├── desktop/              # 桌面端专用 tRPC 路由
+│   │   ├── edge/                 # Edge 运行时 tRPC 路由
+│   │   ├── lambda/               # Lambda tRPC 路由
+│   │   └── tools/                # 工具 tRPC 路由
+│   └── webapi/                   # Web API 端点
+│       ├── chat/                 # 聊天相关 API
+│       ├── models/               # 模型管理 API
+│       ├── tts/                  # 文本转语音 API
+│       └── ...
+├── [variants]/                   # 平台和设备变体
+│   ├── (auth)/                   # 身份验证页面
+│   │   ├── login/
+│   │   ├── signup/
+│   │   └── next-auth/
+│   ├── (main)/                   # 主应用路由
+│   │   ├── (mobile)/             # 移动端专用路由
+│   │   │   └── me/               # 移动端个人资料页面
+│   │   ├── _layout/              # 布局组件
+│   │   ├── chat/                 # 聊天界面
+│   │   ├── discover/             # 发现页面
+│   │   ├── files/                # 文件管理
+│   │   ├── image/                # 图像生成
+│   │   ├── profile/              # 用户资料
+│   │   ├── repos/                # 仓库管理
+│   │   └── settings/             # 应用设置
+│   └── @modal/                   # 并行模态框路由
+│       ├── (.)changelog/
+│       └── _layout/
+├── desktop/                      # 桌面端专用路由
+│   └── devtools/
+├── manifest.ts                   # PWA 清单
+├── robots.tsx                    # Robots.txt 生成
+├── sitemap.tsx                   # 站点地图生成
+└── sw.ts                         # Service Worker
 ```
 
-通过这种方式，我们可以清晰地区分和管理桌面端和移动端的代码，同时也能方便地复用在两种设备上都需要的代码，从而提高开发效率并保持代码的整洁和可维护性。
+### 架构说明
+
+**路由组：**
+- `(backend)` - 包含所有服务端 API 路由、中间件和后端服务
+- `[variants]` - 处理不同平台变体和主应用页面的动态路由组
+- `@modal` - 使用 Next.js 并行路由的模态框对话框并行路由
+
+**平台组织：**
+- 架构通过路由组织支持多个平台（Web、桌面端、移动端）
+- 桌面端专用路由位于 `desktop/` 目录中
+- 移动端专用路由组织在 `(main)/(mobile)/` 下
+- 共享布局和组件位于 `_layout/` 目录中
+
+**API 架构：**
+- `(backend)/api/` 和 `(backend)/webapi/` 中的 REST API
+- 按运行时环境组织的 tRPC 端点（edge、lambda、async、desktop）
+- 专用路由组中的身份验证和 OIDC 处理
+
+这种架构在保持不同部署目标和运行时环境灵活性的同时，提供了清晰的关注点分离。

docs/development/database-schema.dbml

@@ -16,6 +16,7 @@ table agents {
   provider text
   system_role text
   tts jsonb
+  virtual boolean [default: false]
   opening_message text
   opening_questions text[] [default: `[]`]
   accessed_at "timestamp with time zone" [not null, default: `now()`]
@@ -317,6 +318,24 @@ table message_chunks {
   }
 }
 
+table message_groups {
+  id varchar(255) [pk, not null]
+  topic_id text
+  user_id text [not null]
+  parent_group_id varchar(255)
+  parent_message_id text
+  title varchar(255)
+  description text
+  client_id varchar(255)
+  accessed_at "timestamp with time zone" [not null, default: `now()`]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+  updated_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    (client_id, user_id) [name: 'message_groups_client_id_user_id_unique', unique]
+  }
+}
+
 table message_plugins {
   id text [pk, not null]
   tool_call_id text
@@ -410,6 +429,7 @@ table messages {
   agent_id text
   group_id text
   target_id text
+  message_group_id varchar(255)
   accessed_at "timestamp with time zone" [not null, default: `now()`]
   created_at "timestamp with time zone" [not null, default: `now()`]
   updated_at "timestamp with time zone" [not null, default: `now()`]
@@ -995,6 +1015,12 @@ ref: generations.generation_batch_id > generation_batches.id
 
 ref: generations.async_task_id - async_tasks.id
 
+ref: message_groups.user_id - users.id
+
+ref: message_groups.topic_id - topics.id
+
+ref: message_groups.parent_group_id > message_groups.id
+
 ref: messages_files.file_id > files.id
 
 ref: messages_files.message_id > messages.id
@@ -1007,6 +1033,8 @@ ref: messages.topic_id - topics.id
 
 ref: threads.source_message_id - messages.id
 
+ref: messages.message_group_id > message_groups.id
+
 ref: sessions.group_id - session_groups.id
 
 ref: topic_documents.document_id > documents.id

docs/self-hosting/environment-variables/model-provider.mdx

@@ -717,4 +717,20 @@ NewAPI is a multi-provider model aggregation service that supports automatic mod
 - Default: `-`
 - Example: `-all,+vercel-model-1,+vercel-model-2=vercel-special`
 
+## Cerebras
+
+### `CEREBRAS_API_KEY`
+
+- Type: Required
+- Description: This is the API key you applied for in the Cerebras service.
+- Default: -
+- Example: `csk-xxxxxx...xxxxxx`
+
+### `CEREBRAS_MODEL_LIST`
+
+- Type: Optional
+- Description: Used to control the Cerebras model list. Use `+` to add a model, `-` to hide a model, and `model_name=display_name` to customize the display name of a model. Separate multiple entries with commas. The definition syntax follows the same rules as other providers' model lists.
+- Default: `-`
+- Example: `-all,+cerebras-model-1,+cerebras-model-2=cerebras-special`
+
 [model-list]: /docs/self-hosting/advanced/model-list

docs/self-hosting/environment-variables/model-provider.zh-CN.mdx

@@ -720,4 +720,20 @@ LobeChat 在部署时提供了丰富的模型服务商相关的环境变量，
 - 默认值：`-`
 - 示例：`-all,+vercel-model-1,+vercel-model-2=vercel-special`
 
+## Cerebras
+
+### `CEREBRAS_API_KEY`
+
+- 类型：必选
+- 描述：这是你在 Cerebras 服务中申请的 API 密钥
+- 默认值：-
+- 示例：`csk-xxxxxx...xxxxxx`
+
+### `CEREBRAS_MODEL_LIST`
+
+- 类型：可选
+- 描述：用来控制 Cerebras 模型列表，使用 `+` 增加一个模型，使用 `-` 来隐藏一个模型，使用 `模型名=展示名` 来自定义模型的展示名，用英文逗号隔开。模型定义语法规则与其他 provider 保持一致。
+- 默认值：`-`
+- 示例：`-all,+cerebras-model-1,+cerebras-model-2=cerebras-special`
+
 [model-list]: /zh/docs/self-hosting/advanced/model-list

docs/usage/features/auth.mdx

@@ -29,11 +29,6 @@ LobeChat integrates `next-auth`, a flexible and powerful identity verification l
 - **Social Login**: Support quick login via various social platforms.
 - **Data Security**: Ensure the security and privacy of user data.
 
-<Callout type={'warning'}>
-  Due to workload constraints, integration of next-auth with a server-side database has not been
-  implemented yet. If you need to use a server-side database, please use Clerk.
-</Callout>
-
 <Callout type={'info'}>
   For information on using Next-Auth, you can refer to [Authentication Services - Next
   Auth](/docs/self-hosting/advanced/authentication#next-auth).

docs/usage/features/auth.zh-CN.mdx

@@ -25,11 +25,6 @@ LobeChat 集成了 `next-auth`，一个灵活且强大的身份验证库，支
 - **社交登录**：支持多种社交平台的快捷登录。
 - **数据安全**：保障用户数据的安全性和隐私性。
 
-<Callout type={'warning'}>
-  由于工作量原因，目前还没有实现 next-auth 与服务端数据库的集成，如果需要使用服务端数据库，请使用
-  Clerk 。
-</Callout>
-
 <Callout type={'info'}>
   关于 Next-Auth 的使用，可以查阅 [身份验证服务 - Next
   Auth](/zh/docs/self-hosting/advanced/authentication#next-auth)。

locales/ar/chat.json

@@ -3,8 +3,8 @@
     "title": "النموذج"
   },
   "agentDefaultMessage": "مرحبًا، أنا **{{name}}**، يمكنك بدء المحادثة معي على الفور، أو يمكنك الذهاب إلى [إعدادات المساعد]({{url}}) لإكمال معلوماتي.",
-  "agentDefaultMessageWithSystemRole": "مرحبًا، أنا **{{name}}**، {{systemRole}}، دعنا نبدأ الدردشة!",
-  "agentDefaultMessageWithoutEdit": "مرحبًا، أنا **{{name}}**، دعنا نبدأ المحادثة!",
+  "agentDefaultMessageWithSystemRole": "مرحبًا، أنا **{{name}}**، كيف يمكنني مساعدتك؟",
+  "agentDefaultMessageWithoutEdit": "مرحبًا، أنا **{{name}}**، كيف يمكنني مساعدتك؟",
   "agents": "مساعد",
   "artifact": {
     "generating": "جاري الإنشاء",
@@ -150,6 +150,11 @@
       "total": "الإجمالي المستهلك"
     }
   },
+  "minimap": {
+    "jumpToMessage": "الانتقال إلى الرسالة رقم {{index}}",
+    "nextMessage": "الرسالة التالية",
+    "previousMessage": "الرسالة السابقة"
+  },
   "newAgent": "مساعد جديد",
   "pin": "تثبيت",
   "pinOff": "إلغاء التثبيت",

locales/ar/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "وصف المحتوى الذي ترغب في إنشائه"
     },
+    "quality": {
+      "label": "جودة الصورة",
+      "options": {
+        "hd": "عالي الدقة",
+        "standard": "عادي"
+      }
+    },
     "seed": {
       "label": "البذرة",
       "random": "بذرة عشوائية"

locales/ar/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "أقصى نافذة سياق",
           "unlimited": "غير محدود"
         },
+        "type": {
+          "extra": "أنواع النماذج المختلفة تمتلك سيناريوهات استخدام وقدرات مميزة",
+          "options": {
+            "chat": "محادثة",
+            "embedding": "تضمين",
+            "image": "توليد الصور",
+            "realtime": "محادثة فورية",
+            "stt": "تحويل الصوت إلى نص",
+            "text2music": "تحويل النص إلى موسيقى",
+            "text2video": "تحويل النص إلى فيديو",
+            "tts": "تحويل النص إلى كلام"
+          },
+          "placeholder": "يرجى اختيار نوع النموذج",
+          "title": "نوع النموذج"
+        },
         "vision": {
           "extra": "سيؤدي هذا التكوين إلى فتح إعدادات تحميل الصور في التطبيق، ما إذا كان يدعم التعرف يعتمد بالكامل على النموذج نفسه، يرجى اختبار قابلية استخدام التعرف البصري لهذا النموذج بنفسك",
           "title": "دعم التعرف البصري"

locales/ar/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 - وضع التفكير؛ DeepSeek-V3.1 هو نموذج استدلال هجين جديد من DeepSeek يدعم وضعين للاستدلال: التفكير وعدم التفكير، مع كفاءة تفكير أعلى مقارنة بـ DeepSeek-R1-0528. بعد تحسين ما بعد التدريب، تحسنت بشكل كبير أداء استخدام أدوات الوكيل ومهام الوكيل الذكي."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 هو أحدث نموذج عام أصدرته DeepSeek، يدعم بنية استدلال هجينة، ويتميز بقدرات وكيل أقوى."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "وضع التفكير في DeepSeek V3.2. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من الأفكار لتحسين دقة الإجابة النهائية."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite يتميز بسرعة استجابة فائقة وقيمة أفضل مقابل المال، ويوفر خيارات أكثر مرونة للعملاء في سيناريوهات مختلفة. يدعم الاستدلال والتخصيص مع نافذة سياق 128k."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 هو نموذج لغة كبير بنمط هجين أصدرته DeepSeek AI، وقد شهد ترقيات مهمة متعددة مقارنة بالإصدارات السابقة. من الابتكارات الرئيسية في هذا النموذج دمج \"وضع التفكير\" و\"وضع عدم التفكير\" في نموذج واحد، حيث يمكن للمستخدمين التبديل بينهما بسهولة عبر تعديل قالب المحادثة لتلبية متطلبات المهام المختلفة. من خلال تحسينات ما بعد التدريب المخصصة، تم تعزيز أداء V3.1 في استدعاء الأدوات ومهام الوكيل بشكل ملحوظ، مما يمكنه من دعم أدوات البحث الخارجية وتنفيذ مهام معقدة متعددة الخطوات بشكل أفضل. يعتمد النموذج على DeepSeek-V3.1-Base مع تدريب إضافي، حيث تم توسيع حجم بيانات التدريب بشكل كبير عبر طريقة التوسيع النصي الطويل على مرحلتين، مما يحسن أدائه في معالجة المستندات الطويلة والرموز البرمجية الطويلة. كنموذج مفتوح المصدر، يظهر DeepSeek-V3.1 قدرة تنافسية مع أفضل النماذج المغلقة في مجالات الترميز والرياضيات والاستدلال، وبفضل هيكله المختلط للخبراء (MoE)، يحافظ على سعة نموذج ضخمة مع تقليل تكلفة الاستدلال بفعالية."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus هو نسخة محدثة من نموذج V3.1 الذي أصدرته DeepSeek، ويصنف كنموذج لغة كبير لوكيل هجين. يركز هذا التحديث على إصلاح المشكلات التي أبلغ عنها المستخدمون وتحسين الاستقرار مع الحفاظ على القدرات الأصلية للنموذج. لقد حسّن بشكل ملحوظ اتساق اللغة، وقلل من الاستخدام المختلط للغة الصينية والإنجليزية والرموز غير الطبيعية. يدمج النموذج \"وضع التفكير\" و\"الوضع غير التفكيري\"، حيث يمكن للمستخدمين التبديل بينهما بسهولة عبر قوالب الدردشة لتناسب مهام مختلفة. كتحسين مهم، عزز V3.1-Terminus أداء وكيل الكود ووكيل البحث، مما يجعله أكثر موثوقية في استدعاء الأدوات وتنفيذ المهام المعقدة متعددة الخطوات."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 هو أحدث وأقوى إصدار من Kimi K2. إنه نموذج لغوي من نوع الخبراء المختلطين (MoE) من الطراز الأول، يحتوي على تريليون معلمة إجمالية و32 مليار معلمة مفعلة. تشمل الميزات الرئيسية للنموذج: تعزيز ذكاء التكويد للوكيل، مع تحسينات ملحوظة في الأداء في اختبارات المعيار المفتوحة ومهام التكويد الواقعية للوكيل؛ تحسين تجربة التكويد في الواجهة الأمامية، مع تقدم في الجمالية والعملية في برمجة الواجهة الأمامية."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 يحسن بشكل كبير على قدرات Sonnet 3.7 الرائدة في الصناعة، ويظهر أداءً ممتازًا في الترميز، محققًا 72.7% في SWE-bench. يوازن النموذج بين الأداء والكفاءة، مناسب للحالات الداخلية والخارجية، ويحقق تحكمًا أكبر في التنفيذ من خلال قابلية تحكم محسنة."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "كلود سونيت 4.5 هو أذكى نموذج قدمته شركة أنثروبيك حتى الآن."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B هو نموذج لغة ضخم نادر التنشيط يحتوي على 72 مليار معلمة و16 مليار معلمة نشطة، يعتمد على بنية الخبراء المختلطين المجمعة (MoGE). في مرحلة اختيار الخبراء، يتم تجميع الخبراء وتقيد تنشيط عدد متساوٍ من الخبراء داخل كل مجموعة لكل رمز، مما يحقق توازنًا في تحميل الخبراء ويعزز بشكل كبير كفاءة نشر النموذج على منصة Ascend."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "كلود سونيت 4 نموذج تفكيري يمكنه إنتاج استجابات شبه فورية أو تفكير تدريجي مطول، حيث يمكن للمستخدم رؤية هذه العمليات بوضوح."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "كلود سونيت 4.5 هو أذكى نموذج قدمته شركة أنثروبيك حتى الآن."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 هو مساعد برمجي قوي، يدعم مجموعة متنوعة من لغات البرمجة في الإجابة الذكية وإكمال الشيفرة، مما يعزز من كفاءة التطوير."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 هو نموذج لغة كبير بنمط هجين أصدرته DeepSeek AI، وقد شهد ترقيات مهمة متعددة مقارنة بالإصدارات السابقة. من الابتكارات الرئيسية في هذا النموذج دمج \"وضع التفكير\" و\"وضع عدم التفكير\" في نموذج واحد، حيث يمكن للمستخدمين التبديل بينهما بسهولة عبر تعديل قالب المحادثة لتلبية متطلبات المهام المختلفة. من خلال تحسينات ما بعد التدريب المخصصة، تم تعزيز أداء V3.1 في استدعاء الأدوات ومهام الوكيل بشكل ملحوظ، مما يمكنه من دعم أدوات البحث الخارجية وتنفيذ مهام معقدة متعددة الخطوات بشكل أفضل. يعتمد النموذج على DeepSeek-V3.1-Base مع تدريب إضافي، حيث تم توسيع حجم بيانات التدريب بشكل كبير عبر طريقة التوسيع النصي الطويل على مرحلتين، مما يحسن أدائه في معالجة المستندات الطويلة والرموز البرمجية الطويلة. كنموذج مفتوح المصدر، يظهر DeepSeek-V3.1 قدرة تنافسية مع أفضل النماذج المغلقة في مجالات الترميز والرياضيات والاستدلال، وبفضل هيكله المختلط للخبراء (MoE)، يحافظ على سعة نموذج ضخمة مع تقليل تكلفة الاستدلال بفعالية."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus هو نسخة محدثة من نموذج V3.1 الذي أصدرته DeepSeek، ويصنف كنموذج لغة كبير لوكيل هجين. يركز هذا التحديث على إصلاح المشكلات التي أبلغ عنها المستخدمون وتحسين الاستقرار مع الحفاظ على القدرات الأصلية للنموذج. لقد حسّن بشكل ملحوظ اتساق اللغة، وقلل من الاستخدام المختلط للغة الصينية والإنجليزية والرموز غير الطبيعية. يدمج النموذج \"وضع التفكير\" و\"الوضع غير التفكيري\"، حيث يمكن للمستخدمين التبديل بينهما بسهولة عبر قوالب الدردشة لتناسب مهام مختلفة. كتحسين مهم، عزز V3.1-Terminus أداء وكيل الكود ووكيل البحث، مما يجعله أكثر موثوقية في استدعاء الأدوات وتنفيذ المهام المعقدة متعددة الخطوات."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B هو نموذج متقدم تم تدريبه للحوار المعقد."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: نموذج استدلال من الجيل التالي يعزز القدرات على الاستدلال المعقد والتفكير التسلسلي، مناسب للمهام التي تتطلب تحليلاً عميقًا."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: نموذج الاستدلال من الجيل التالي، يعزز القدرة على الاستنتاج المعقد والتفكير المتسلسل، ومناسب للمهام التي تتطلب تحليلاً عميقاً."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 هو نموذج لغوي بصري مختلط الخبراء (MoE) تم تطويره بناءً على DeepSeekMoE-27B، يستخدم بنية MoE ذات تفعيل نادر، محققًا أداءً ممتازًا مع تفعيل 4.5 مليار معلمة فقط. يقدم هذا النموذج أداءً ممتازًا في مهام مثل الأسئلة البصرية، التعرف الضوئي على الأحرف، فهم الوثائق/الجداول/الرسوم البيانية، وتحديد المواقع البصرية."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 النسخة الكاملة، تحتوي على 671 مليار معلمة، تدعم البحث المتصل في الوقت الحقيقي، وتتمتع بقدرات فهم وتوليد أقوى."
   },
   "deepseek-reasoner": {
-    "description": "وضع التفكير في DeepSeek V3.1. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من التفكير لتحسين دقة الإجابة النهائية."
+    "description": "وضع التفكير في DeepSeek V3.2. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من الأفكار لتحسين دقة الإجابة النهائية."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 هو نموذج لغوي فعال من نوع Mixture-of-Experts، مناسب لاحتياجات المعالجة الاقتصادية."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: نموذج استدلال من الجيل التالي يعزز القدرات على الاستدلال المعقد والتفكير التسلسلي، مناسب للمهام التي تتطلب تحليلاً عميقًا."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp يُدخل آلية الانتباه المتفرق، بهدف تحسين كفاءة التدريب والاستدلال عند معالجة النصوص الطويلة، بسعر أقل من deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 هو نموذج مختلط خبير يحتوي على 685B من المعلمات، وهو أحدث إصدار من سلسلة نماذج الدردشة الرائدة لفريق DeepSeek.\n\nيستفيد من نموذج [DeepSeek V3](/deepseek/deepseek-chat-v3) ويظهر أداءً ممتازًا في مجموعة متنوعة من المهام."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] هو نموذج توليد صور يحتوي على 12 مليار معلمة، يركز على توليد صور عالية الجودة بسرعة."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "نموذج قوي لتوليد الصور متعددة الوسائط الأصلية"
+  },
   "fal-ai/imagen4/preview": {
     "description": "نموذج توليد صور عالي الجودة مقدم من جوجل."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash هو نموذج Google الأكثر فعالية من حيث التكلفة، ويوفر وظائف شاملة."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana هو أحدث وأسرع وأكثر نموذج متعدد الوسائط أصلي كفاءة من Google، يتيح لك إنشاء وتحرير الصور من خلال المحادثة."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana هو أحدث وأسرع وأكثر نموذج متعدد الوسائط أصلي كفاءة من Google، يتيح لك إنشاء وتحرير الصور من خلال المحادثة."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana هو أحدث وأسرع وأكثر نموذج متعدد الوسائط أصلي كفاءة من Google، يتيح لك إنشاء وتحرير الصور من خلال المحادثة."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana هو أحدث وأسرع وأكثر نموذج متعدد الوسائط أصلي كفاءة من Google، يتيح لك إنشاء وتحرير الصور من خلال المحادثة."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite هو أصغر وأفضل نموذج من حيث التكلفة من Google، مصمم للاستخدام على نطاق واسع."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview هو أصغر وأكفأ نموذج من Google، مصمم للاستخدام واسع النطاق."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "إصدار معاينة (25 سبتمبر 2025) من Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "معاينة فلاش جمنّي 2.5 هي النموذج الأكثر كفاءة من جوجل، حيث تقدم مجموعة شاملة من الميزات."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview هو نموذج Google الأكثر فعالية من حيث التكلفة، يقدم وظائف شاملة."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "إصدار معاينة (25 سبتمبر 2025) من Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro هو نموذج التفكير الأكثر تقدمًا من Google، قادر على استدلال المشكلات المعقدة في البرمجة والرياضيات ومجالات STEM، بالإضافة إلى تحليل مجموعات البيانات الكبيرة ومستودعات الأكواد والوثائق باستخدام سياق طويل."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "جيميني 2.5 برو بريڤيو هو أحدث نموذج تفكيري من جوجل، قادر على استنتاج حلول للمشكلات المعقدة في مجالات البرمجة، الرياضيات، والعلوم والتكنولوجيا والهندسة والرياضيات (STEM)، بالإضافة إلى تحليل مجموعات بيانات كبيرة، قواعد بيانات البرمجة، والوثائق باستخدام سياق طويل."
   },
+  "gemini-flash-latest": {
+    "description": "أحدث إصدار من Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "أحدث إصدار من Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "أحدث إصدار من Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B مناسب لمعالجة المهام المتوسطة والصغيرة، ويجمع بين الكفاءة من حيث التكلفة."
   },
@@ -1437,7 +1485,7 @@
     "description": "سلسلة نماذج GLM-4.1V-Thinking هي أقوى نماذج اللغة البصرية المعروفة على مستوى 10 مليارات معلمة، وتدمج مهام اللغة البصرية المتقدمة من نفس المستوى، بما في ذلك فهم الفيديو، الأسئلة والأجوبة على الصور، حل المسائل العلمية، التعرف على النصوص OCR، تفسير الوثائق والرسوم البيانية، وكلاء واجهة المستخدم الرسومية، ترميز صفحات الويب الأمامية، والتثبيت الأرضي، وغيرها. تتفوق قدرات هذه المهام على نموذج Qwen2.5-VL-72B الذي يحتوي على أكثر من 8 أضعاف عدد المعلمات. من خلال تقنيات التعلم المعزز الرائدة، يتقن النموذج تحسين دقة وإثراء الإجابات عبر استدلال سلسلة التفكير، متفوقًا بشكل ملحوظ على النماذج التقليدية غير المعتمدة على التفكير من حيث النتائج النهائية وقابلية التفسير."
   },
   "glm-4.5": {
-    "description": "أحدث نموذج رائد من Zhizhu، يدعم تبديل وضع التفكير، ويحقق مستوى SOTA بين النماذج المفتوحة المصدر في القدرات الشاملة، مع طول سياق يصل إلى 128 ألف رمز."
+    "description": "نموذج الذكاء الاصطناعي الرائد من Zhipu، يدعم تبديل أوضاع التفكير، ويحقق مستوى متقدمًا في القدرات الشاملة مقارنة بالنماذج مفتوحة المصدر، مع طول سياق يصل إلى 128 ألف."
   },
   "glm-4.5-air": {
     "description": "نسخة خفيفة من GLM-4.5، تجمع بين الأداء والقيمة، وتدعم التبديل المرن بين نماذج التفكير المختلطة."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "نموذج استدلال بصري من الجيل الجديد لشركة Zhipu مبني على بنية MOE، بإجمالي 106 مليار معامل و12 مليار معامل نشط، وقد بلغ مستوى الأداء الأعلى (SOTA) بين نماذج التعدد الوسائط مفتوحة المصدر المماثلة على مستوى العالم في عدة اختبارات معيارية، ويغطي مهامًا شائعة مثل فهم الصور والفيديو والمستندات وواجهات المستخدم الرسومية (GUI)."
   },
+  "glm-4.6": {
+    "description": "أحدث نموذج رائد من Zhipu GLM-4.6 (355B) يتفوق بشكل شامل على الأجيال السابقة في الترميز المتقدم، معالجة النصوص الطويلة، الاستدلال، وقدرات الوكيل الذكي، وخاصة في قدرات البرمجة التي تتوافق مع Claude Sonnet 4، ليصبح نموذج الترميز الرائد محليًا."
+  },
   "glm-4v": {
     "description": "GLM-4V يوفر قدرات قوية في فهم الصور والاستدلال، ويدعم مجموعة متنوعة من المهام البصرية."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "أسرع وأكفأ نسخة من GPT-5 من حيث التكلفة. مثالية للتطبيقات التي تتطلب استجابة سريعة وحساسة للتكلفة."
   },
+  "gpt-5-pro": {
+    "description": "يستخدم GPT-5 pro قدرة حسابية أكبر للتفكير بشكل أعمق، ويواصل تقديم إجابات أفضل باستمرار."
+  },
   "gpt-audio": {
     "description": "GPT Audio هو نموذج دردشة عام موجه لإدخال وإخراج الصوت، ويدعم استخدام الصوت في واجهة برمجة تطبيقات Chat Completions."
   },
   "gpt-image-1": {
     "description": "نموذج توليد الصور متعدد الوسائط الأصلي من ChatGPT"
   },
+  "gpt-image-1-mini": {
+    "description": "نسخة منخفضة التكلفة من GPT Image 1، تدعم إدخال النصوص والصور بشكل أصلي وتوليد مخرجات على شكل صور."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4: هيكل Transformer محسّن بالكمية، يحافظ على أداء قوي حتى في ظل محدودية الموارد."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "تحسين كبير لقدرات نموذج التفكير البطيء الرئيسي في الرياضيات الصعبة، الاستدلال المعقد، الشيفرة الصعبة، الالتزام بالتعليمات، وجودة إنشاء النصوص."
   },
-  "hunyuan-t1-vision": {
-    "description": "نموذج تفكير عميق متعدد الوسائط من Hunyuan، يدعم سلاسل التفكير الأصلية متعددة الوسائط، بارع في معالجة مختلف سيناريوهات الاستدلال على الصور، ويحقق تحسينًا شاملاً مقارنة بنموذج التفكير السريع في مسائل العلوم."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "أحدث نموذج تفكير عميق متعدد الوسائط t1-vision من Hunyuan، يدعم سلسلة التفكير الأصلية متعددة الوسائط، مع تحسين شامل مقارنة بالإصدار الافتراضي السابق."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "نموذج تفكير عميق متعدد الوسائط من Hunyuan، يدعم سلاسل تفكير طويلة أصلية متعددة الوسائط، بارع في معالجة مختلف سيناريوهات الاستدلال بالصور، مع تحسين شامل مقارنة بنموذج التفكير السريع في مسائل العلوم."
+  },
   "hunyuan-turbo": {
     "description": "نسخة المعاينة من الجيل الجديد من نموذج اللغة الكبير، يستخدم هيكل نموذج الخبراء المختلط (MoE) الجديد، مما يوفر كفاءة استدلال أسرع وأداء أقوى مقارنة بـ hunyuan-pro."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "ترقية قاعدة التدريب المسبق، مع تحسينات في مهارات الكتابة وفهم القراءة، وزيادة كبيرة في القدرات البرمجية والعلمية، وتحسين مستمر في اتباع التعليمات المعقدة."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "ترقية جودة بيانات قاعدة التدريب المسبق. تحسين استراتيجية التدريب في مرحلة ما بعد التدريب، مع استمرار تحسين قدرات الوكيل، واللغات الإنجليزية واللغات الصغيرة، والامتثال للتعليمات، والبرمجة، والعلوم."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS هو أحدث إصدار من نموذج هونيان الرائد، يتمتع بقدرات تفكير أقوى وتجربة أفضل."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 هو نموذج أساسي بمعمارية MoE يتمتع بقدرات قوية للغاية في البرمجة وقدرات الوكيل (Agent)، بإجمالي معلمات يبلغ 1 تريليون والمعلمات المُفعَّلة 32 مليار. في اختبارات الأداء المعيارية للفئات الرئيسية مثل الاستدلال المعرفي العام والبرمجة والرياضيات والوكلاء (Agent)، تفوق أداء نموذج K2 على النماذج المفتوحة المصدر السائدة الأخرى."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 هو نموذج لغوي خبير هجين واسع النطاق (MoE) تم تطويره بواسطة AI جانب القمر المظلم، يحتوي على تريليون معلمة إجمالية و 32 مليار معلمة تنشيط في كل تمريرة أمامية. تم تحسينه لقدرات الوكيل، بما في ذلك استخدام الأدوات المتقدمة، الاستدلال، وتركيب الشيفرة."
+  },
   "kimi-latest": {
     "description": "يستخدم منتج كيمي المساعد الذكي أحدث نموذج كبير من كيمي، وقد يحتوي على ميزات لم تستقر بعد. يدعم فهم الصور، وسيختار تلقائيًا نموذج 8k/32k/128k كنموذج للتسعير بناءً على طول سياق الطلب."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V هو نموذج لغوي بصري (VLM) من الجيل الأحدث صدر عن Zhipu AI (智谱 AI). بُني النموذج على نموذج النص الرائد GLM-4.5-Air الذي يحتوي على 106B من المعاملات الإجمالية و12B من معاملات التنشيط، ويعتمد على بنية الخبراء المختلطين (MoE) بهدف تحقيق أداء متميز بتكلفة استدلال أقل. من الناحية التقنية، يواصل GLM-4.5V نهج GLM-4.1V-Thinking ويقدّم ابتكارات مثل ترميز المواقع الدوراني ثلاثي الأبعاد (3D-RoPE)، مما عزّز بشكل ملحوظ قدرته على إدراك واستنتاج العلاقات المكانية ثلاثية الأبعاد. وبفضل تحسينات في مراحل ما قبل التدريب، والتعديل بالإشراف، والتعلّم المعزّز، أصبح النموذج قادراً على معالجة محتوى بصري متنوّع مثل الصور والفيديوهات والمستندات الطويلة، وقد حقق مستوى متقدماً ضمن أفضل نماذج المصدر المفتوح في 41 معياراً متعدد الوسائط منشوراً. بالإضافة إلى ذلك، أضاف النموذج مفتاح \"وضع التفكير\" الذي يتيح للمستخدمين التبديل بين الاستجابة السريعة والاستدلال العميق بحرية لتوازن أفضل بين الكفاءة والفعالية."
   },
+  "zai-org/GLM-4.6": {
+    "description": "مقارنةً بـ GLM-4.5، قدم GLM-4.6 عدة تحسينات رئيسية. تم توسيع نافذة السياق من 128 ألف إلى 200 ألف رمز، مما يمكن النموذج من التعامل مع مهام وكيل أكثر تعقيدًا. حقق النموذج درجات أعلى في اختبارات معيارية للبرمجة، وأظهر أداءً أقوى في تطبيقات مثل Claude Code وCline وRoo Code وKilo Code، بما في ذلك تحسينات في إنشاء صفحات أمامية ذات تأثيرات بصرية متقنة. أظهر GLM-4.6 تحسنًا واضحًا في أداء الاستدلال ويدعم استخدام الأدوات أثناء الاستدلال، مما يعزز قدراته الشاملة. كما أنه أقوى في استخدام الأدوات والوكيل المعتمد على البحث، وأكثر فعالية في التكامل ضمن أطر الوكلاء. من حيث الكتابة، يتوافق النموذج بشكل أفضل مع تفضيلات البشر من حيث الأسلوب وقابلية القراءة، ويظهر سلوكًا أكثر طبيعية في سيناريوهات تمثيل الأدوار."
+  },
   "zai/glm-4.5": {
     "description": "سلسلة نماذج GLM-4.5 هي نماذج أساسية مصممة خصيصًا للوكلاء. النموذج الرائد GLM-4.5 يدمج 355 مليار معلمة إجمالية (32 مليار نشطة)، موحدًا الاستدلال، الترميز، وقدرات الوكيل لتلبية متطلبات التطبيقات المعقدة. كنظام استدلال مختلط، يوفر وضعين تشغيليين."
   },

locales/ar/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "تغطي نماذج Ollama مجموعة واسعة من مجالات توليد الشيفرة، والعمليات الرياضية، ومعالجة اللغات المتعددة، والتفاعل الحواري، وتدعم احتياجات النشر على مستوى المؤسسات والتخصيص المحلي."
   },
+  "ollamacloud": {
+    "description": "توفر Ollama Cloud خدمة استدلال مُدارة رسميًا، تتيح الوصول الفوري إلى مكتبة نماذج Ollama، وتدعم واجهة متوافقة مع OpenAI."
+  },
   "openai": {
     "description": "OpenAI هي مؤسسة رائدة عالميًا في أبحاث الذكاء الاصطناعي، حيث دفعت النماذج التي طورتها مثل سلسلة GPT حدود معالجة اللغة الطبيعية. تلتزم OpenAI بتغيير العديد من الصناعات من خلال حلول الذكاء الاصطناعي المبتكرة والفعالة. تتمتع منتجاتهم بأداء ملحوظ وفعالية من حيث التكلفة، وتستخدم على نطاق واسع في البحث والتجارة والتطبيقات الابتكارية."
   },

locales/ar/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "خطأ في التنفيذ",
+    "executing": "جارٍ التنفيذ...",
+    "files": "الملفات:",
+    "output": "الإخراج:",
+    "returnValue": "قيمة الإرجاع:"
+  },
   "dalle": {
     "autoGenerate": "توليد تلقائي",
     "downloading": "صلاحية روابط الصور المُولَّدة بواسطة DallE3 تدوم ساعة واحدة فقط، يتم تحميل الصور إلى الجهاز المحلي...",

locales/bg-BG/chat.json

@@ -3,8 +3,8 @@
     "title": "Модел"
   },
   "agentDefaultMessage": "Здравейте, аз съм **{{name}}**, можете да започнете разговор с мен веднага или да отидете на [Настройки на асистента]({{url}}), за да попълните информацията ми.",
-  "agentDefaultMessageWithSystemRole": "Здравей, аз съм **{{name}}**, {{systemRole}}. Нека започнем да чатим!",
-  "agentDefaultMessageWithoutEdit": "Здравей, аз съм **{{name}}** и нека започнем разговора!",
+  "agentDefaultMessageWithSystemRole": "Здравейте, аз съм **{{name}}**. Как мога да ви помогна?",
+  "agentDefaultMessageWithoutEdit": "Здравейте, аз съм **{{name}}**. Как мога да ви помогна?",
   "agents": "Асистент",
   "artifact": {
     "generating": "Генериране",
@@ -150,6 +150,11 @@
       "total": "Общо разходи"
     }
   },
+  "minimap": {
+    "jumpToMessage": "Отиди до съобщение № {{index}}",
+    "nextMessage": "Следващо съобщение",
+    "previousMessage": "Предишно съобщение"
+  },
   "newAgent": "Нов агент",
   "pin": "Закачи",
   "pinOff": "Откачи",

locales/bg-BG/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "Опишете съдържанието, което искате да генерирате"
     },
+    "quality": {
+      "label": "Качество на изображението",
+      "options": {
+        "hd": "Висока резолюция",
+        "standard": "Стандартно"
+      }
+    },
     "seed": {
       "label": "Семена",
       "random": "Случаен семенен код"

locales/bg-BG/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "Максимален контекстуален прозорец",
           "unlimited": "Без ограничения"
         },
+        "type": {
+          "extra": "Различните типове модели имат различни сценарии на използване и възможности",
+          "options": {
+            "chat": "Чат",
+            "embedding": "Векторизация",
+            "image": "Генериране на изображения",
+            "realtime": "Реално време чат",
+            "stt": "Гласов текст",
+            "text2music": "Текст към музика",
+            "text2video": "Текст към видео",
+            "tts": "Гласово синтезиране"
+          },
+          "placeholder": "Моля, изберете тип модел",
+          "title": "Тип модел"
+        },
         "vision": {
           "extra": "Тази конфигурация ще активира само конфигурацията за качване на изображения в приложението, дали поддържа разпознаване зависи изцяло от самия модел, моля, тествайте наличността на визуалната разпознаваемост на този модел.",
           "title": "Поддръжка на визуално разпознаване"

locales/bg-BG/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 - режим с мислене; DeepSeek-V3.1 е нов хибриден модел за разсъждения, пуснат от DeepSeek, който поддържа два режима на разсъждения - с и без мислене, с по-висока ефективност на мислене в сравнение с DeepSeek-R1-0528. След оптимизация след обучение, използването на инструменти от агенти и изпълнението на задачи с агенти са значително подобрени."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 е най-новият универсален голям модел на DeepSeek, който поддържа хибридна архитектура за извод и притежава по-силни възможности на агент."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "Режим на мислене на DeepSeek V3.2. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да подобри точността на крайния отговор."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite предлага изключително бърза реакция и по-добро съотношение цена-качество, осигурявайки по-гъвкави опции за различни сценарии на клиентите. Поддържа разсъждения и финна настройка с контекстен прозорец от 128k."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 е хибриден голям езиков модел, пуснат от DeepSeek AI, който включва множество важни подобрения спрямо предишните версии. Основната иновация на модела е интеграцията на „режим на мислене“ (Thinking Mode) и „режим без мислене“ (Non-thinking Mode), които потребителите могат гъвкаво да превключват чрез настройка на чат шаблони, за да отговарят на различни задачи. След специална пост-тренировка, V3.1 значително подобрява производителността при използване на инструменти и задачи на агенти, като по-добре поддържа външни търсачки и изпълнение на сложни многостъпкови задачи. Моделът е дообучен върху DeepSeek-V3.1-Base чрез двуфазен метод за разширяване на дълги текстове, което значително увеличава обема на тренировъчните данни и подобрява работата с дълги документи и кодове. Като отворен модел, DeepSeek-V3.1 демонстрира способности, сравними с водещи затворени модели в области като кодиране, математика и разсъждение, като същевременно с хибридната си експертна (MoE) архитектура поддържа голям капацитет на модела и ефективно намалява разходите за изчисления."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus е обновена версия на модела V3.1, пусната от DeepSeek, позиционирана като хибриден интелигентен голям езиков модел. Тази актуализация запазва оригиналните възможности на модела, като се фокусира върху отстраняване на проблеми, посочени от потребителите, и подобряване на стабилността. Значително е подобрена езиковата последователност, намалено е смесването на китайски и английски и появата на аномални символи. Моделът интегрира „режим на мислене“ и „режим без мислене“, като потребителите могат гъвкаво да превключват между тях чрез чат шаблони за различни задачи. Като важна оптимизация, V3.1-Terminus подобрява производителността на кодовия агент и търсещия агент, което ги прави по-надеждни при извикване на инструменти и изпълнение на многократни сложни задачи."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 е най-новата и най-мощна версия на Kimi K2. Това е водещ езиков модел с хибридна експертна архитектура (MoE), с общо 1 трилион параметри и 32 милиарда активни параметри. Основните характеристики на модела включват: подобрена интелигентност при кодиране на агенти, с изразително подобрение в производителността при публични бенчмаркове и реални задачи за кодиране на агенти; усъвършенстван опит при фронтенд кодиране, с напредък както в естетиката, така и в практичността на фронтенд програмирането."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 значително подобрява водещите в индустрията възможности на Sonnet 3.7, с отлични резултати в кодиране и постига водещи 72.7% в SWE-bench. Моделът балансира производителност и ефективност, подходящ е за вътрешни и външни случаи и предлага по-голям контрол чрез подобрена управляемост."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic досега."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B е голям езиков модел с 72 милиарда параметри и 16 милиарда активирани параметри, базиран на архитектурата с групирани смесени експерти (MoGE). Той групира експертите по време на избора им и ограничава активацията на токените да активират равен брой експерти във всяка група, което осигурява балансирано натоварване на експертите и значително подобрява ефективността на разгръщане на модела на платформата Ascend."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "Claude Sonnet 4 мисловен модел може да генерира почти мигновени отговори или удължено стъпково мислене, като потребителите могат ясно да проследят тези процеси."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic досега."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 е мощен AI помощник за програмиране, който поддържа интелигентни въпроси и отговори и автоматично допълване на код за различни програмни езици, повишавайки ефективността на разработката."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 е хибриден голям езиков модел, пуснат от DeepSeek AI, който включва множество важни подобрения спрямо предишните версии. Основната иновация на модела е интеграцията на „режим на мислене“ (Thinking Mode) и „режим без мислене“ (Non-thinking Mode), които потребителите могат гъвкаво да превключват чрез настройка на чат шаблони, за да отговарят на различни задачи. След специална пост-тренировка, V3.1 значително подобрява производителността при използване на инструменти и задачи на агенти, като по-добре поддържа външни търсачки и изпълнение на сложни многостъпкови задачи. Моделът е дообучен върху DeepSeek-V3.1-Base чрез двуфазен метод за разширяване на дълги текстове, което значително увеличава обема на тренировъчните данни и подобрява работата с дълги документи и кодове. Като отворен модел, DeepSeek-V3.1 демонстрира способности, сравними с водещи затворени модели в области като кодиране, математика и разсъждение, като същевременно с хибридната си експертна (MoE) архитектура поддържа голям капацитет на модела и ефективно намалява разходите за изчисления."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus е обновена версия на модела V3.1, пусната от DeepSeek, позиционирана като хибриден интелигентен голям езиков модел. Тази актуализация запазва оригиналните възможности на модела, като се фокусира върху отстраняване на проблеми, посочени от потребителите, и подобряване на стабилността. Значително е подобрена езиковата последователност, намалено е смесването на китайски и английски и появата на аномални символи. Моделът интегрира „режим на мислене“ и „режим без мислене“, като потребителите могат гъвкаво да превключват между тях чрез чат шаблони за различни задачи. Като важна оптимизация, V3.1-Terminus подобрява производителността на кодовия агент и търсещия агент, което ги прави по-надеждни при извикване на инструменти и изпълнение на многократни сложни задачи."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B е напреднал модел, обучен за диалози с висока сложност."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: следващо поколение модел за разсъждение, подобряващ способностите за сложни разсъждения и свързано мислене, подходящ за задачи, изискващи задълбочен анализ."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: следващо поколение модел за разсъждение, с подобрени способности за сложни логически връзки и аналитично мислене, подходящ за задачи, изискващи задълбочен анализ."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 е визуален езиков модел, разработен на базата на DeepSeekMoE-27B, който използва архитектура на смесени експерти (MoE) с рядка активация, постигайки изключителна производителност с активирани само 4.5B параметри. Моделът показва отлични резултати в множество задачи, включително визуални въпроси и отговори, оптично разпознаване на символи, разбиране на документи/таблици/графики и визуална локализация."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 пълна версия, с 671B параметри, поддържаща търсене в реално време, с по-силни способности за разбиране и генериране."
   },
   "deepseek-reasoner": {
-    "description": "DeepSeek V3.1 режим на мислене. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да повиши точността на крайния отговор."
+    "description": "Режим на мислене на DeepSeek V3.2. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да подобри точността на крайния отговор."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 е ефективен модел на Mixture-of-Experts, подходящ за икономически ефективни нужди от обработка."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: следващо поколение модел за разсъждение, подобряващ способностите за сложни разсъждения и свързано мислене, подходящ за задачи, изискващи задълбочен анализ."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp въвежда механизъм за разредено внимание, с цел подобряване на ефективността при обучение и извод при обработка на дълги текстове, като цената е по-ниска от тази на deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 е експертен смесен модел с 685B параметри, последната итерация на флагманската серия чат модели на екипа DeepSeek.\n\nТой наследява модела [DeepSeek V3](/deepseek/deepseek-chat-v3) и показва отлични резултати в различни задачи."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] е модел за генериране на изображения с 12 милиарда параметри, фокусиран върху бързото създаване на висококачествени изображения."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "Мощен оригинален мултимодален модел за генериране на изображения"
+  },
   "fal-ai/imagen4/preview": {
     "description": "Висококачествен модел за генериране на изображения, предоставен от Google."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash е най-ефективният модел на Google, предлагащ пълна функционалност."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana е най-новият, най-бързият и най-ефективният роден мултимодален модел на Google, който ви позволява да генерирате и редактирате изображения чрез диалог."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana е най-новият, най-бързият и най-ефективният роден мултимодален модел на Google, който ви позволява да генерирате и редактирате изображения чрез диалог."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana е най-новият, най-бързият и най-ефективният роден мултимодален модел на Google, който ви позволява да генерирате и редактирате изображения чрез диалог."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana е най-новият, най-бързият и най-ефективният роден мултимодален модел на Google, който ви позволява да генерирате и редактирате изображения чрез диалог."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite е най-малкият и най-ефективен модел на Google, създаден специално за масово използване."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview е най-малкият и най-ефективен модел на Google, проектиран за мащабна употреба."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "Прегледна версия (25 септември 2025 г.) на Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview е моделът с най-добро съотношение цена-качество на Google, предлагащ пълна функционалност."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview е най-ефективният модел на Google, предлагащ пълна функционалност."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "Прегледна версия (25 септември 2025 г.) на Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro е най-напредналият мисловен модел на Google, способен да разсъждава върху сложни проблеми в областта на кода, математиката и STEM, както и да анализира големи набори от данни, кодови бази и документи с дълъг контекст."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview е най-напредналият мисловен модел на Google, способен да разсъждава върху сложни проблеми в областта на кодирането, математиката и STEM, както и да анализира големи набори от данни, кодови бази и документи с дълъг контекст."
   },
+  "gemini-flash-latest": {
+    "description": "Последно издание на Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "Последно издание на Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "Последно издание на Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B е подходяща за обработка на средни и малки задачи, съчетаваща икономичност."
   },
@@ -1437,7 +1485,7 @@
     "description": "Серията модели GLM-4.1V-Thinking е най-мощният визуален модел сред известните VLM модели с размер около 10 милиарда параметри, обединяващ водещи в класа си задачи за визуално-езиково разбиране, включително видео разбиране, въпроси и отговори върху изображения, решаване на предметни задачи, OCR разпознаване на текст, интерпретация на документи и графики, GUI агент, кодиране на уеб страници, Grounding и други. Някои от задачите дори превъзхождат модели с 8 пъти повече параметри като Qwen2.5-VL-72B. Чрез водещи техники за подсилено обучение моделът овладява разсъждения чрез вериги на мисълта, което значително подобрява точността и богатството на отговорите, превъзхождайки традиционните модели без мисловен процес по отношение на крайния резултат и обяснимостта."
   },
   "glm-4.5": {
-    "description": "Най-новият флагмански модел на Zhizhu, поддържащ режим на мислене, с общи способности на ниво SOTA сред отворените модели и контекстова дължина до 128K."
+    "description": "Флагманският модел на Zhipu, поддържа превключване на режим на мислене, с общи възможности, достигащи нивото на SOTA за отворени модели, с контекстова дължина до 128K."
   },
   "glm-4.5-air": {
     "description": "Леката версия на GLM-4.5, балансираща между производителност и цена, с възможност за гъвкаво превключване на смесен мисловен режим."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "Новото поколение визуален модел за разсъждение на Zhipu, базиран на MOE архитектура, с общо 106B параметри и 12B активни параметри, постига SOTA сред отворените мултимодални модели в своя клас в различни бенчмаркове, обхващайки често срещани задачи като обработка на изображения, видео, разбиране на документи и GUI задачи."
   },
+  "glm-4.6": {
+    "description": "Най-новият флагмански модел на Zhipu GLM-4.6 (355B) превъзхожда предишното поколение във високо ниво на кодиране, обработка на дълги текстове, извод и интелигентни агенти, особено в програмирането, където е съпоставим с Claude Sonnet 4, ставайки водещият модел за кодиране в страната."
+  },
   "glm-4v": {
     "description": "GLM-4V предлага мощни способности за разбиране и разсъждение на изображения, поддържаща множество визуални задачи."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "Най-бързата и най-икономична версия на GPT-5. Отлично подходяща за приложения, изискващи бърз отговор и чувствителни към разходите."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 pro използва повече изчислителна мощност за по-задълбочено мислене и постоянно предоставя по-добри отговори."
+  },
   "gpt-audio": {
     "description": "GPT Audio е универсален чат модел, ориентиран към аудио вход и изход, поддържащ използване на аудио I/O в Chat Completions API."
   },
   "gpt-image-1": {
     "description": "Роден мултимодален модел за генериране на изображения ChatGPT."
   },
+  "gpt-image-1-mini": {
+    "description": "По-икономична версия на GPT Image 1, с вградена поддръжка за вход от текст и изображение и генериране на изходно изображение."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4 квантизиран трансформър модел, който запазва силна производителност при ограничени ресурси."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "Значително подобрява способностите на основния модел за бавно мислене при сложна математика, комплексни разсъждения, труден код, спазване на инструкции и качество на текстовото творчество."
   },
-  "hunyuan-t1-vision": {
-    "description": "Модел за дълбоко мултимодално разбиране Hunyuan, поддържащ естествени мултимодални вериги на мислене, експертен в различни сценарии за разсъждение върху изображения, с цялостно подобрение спрямо бързите мисловни модели при научни задачи."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "Най-новият мултимодален дълбок мислещ модел t1-vision на Hunyuan, който поддържа оригинални мултимодални вериги на мисълта и предлага цялостно подобрение спрямо предишната версия по подразбиране."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "Модел за дълбоко мислене с мултимодално разбиране Hunyuan, поддържащ родна мултимодална дълга мисловна верига, експертен в обработката на различни визуални задачи за разсъждение, с цялостно подобрение спрямо бързия мисловен модел при научни проблеми."
+  },
   "hunyuan-turbo": {
     "description": "Предварителна версия на новото поколение голям езиков модел на HunYuan, използваща нова структура на смесен експертен модел (MoE), с по-бърза скорост на извеждане и по-силни резултати в сравнение с hunyuan-pro."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "Актуализирана предварително обучена основа, подобрени умения за писане и разбиране на текст, значително подобрени способности в кодирането и точните науки, както и непрекъснато усъвършенстване в следването на сложни инструкции."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "Актуализация на качеството на данните за предварително обучение. Оптимизирана стратегия за обучение в посттренировъчния етап, с непрекъснато подобряване на възможностите на агента, английския и малките езици, спазването на инструкции, кода и научните способности."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS е последната версия на флагманския модел Hunyuan, с по-силни способности за разсъждение и по-добро потребителско изживяване."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "Kimi-k2 е базов модел с MoE архитектура, който притежава изключителни възможности за работа с код и агентни функции. Общият брой параметри е 1T, а активните параметри са 32B. В бенчмарковете за основни категории като общо знание и разсъждение, програмиране, математика и агентни задачи, моделът K2 превъзхожда другите водещи отворени модели."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 е голям мащабен смесен експертен (MoE) езиков модел, разработен от AI на тъмната страна на Луната, с общо 1 трилион параметри и 32 милиарда активирани параметри при всяко предно преминаване. Той е оптимизиран за агентски способности, включително усъвършенствано използване на инструменти, разсъждения и синтез на код."
+  },
   "kimi-latest": {
     "description": "Kimi интелигентен асистент използва най-новия Kimi голям модел, който може да съдържа нестабилни функции. Поддържа разбиране на изображения и автоматично избира 8k/32k/128k модел за таксуване в зависимост от дължината на контекста на заявката."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V е най-новото поколение визуално-езиков модел (VLM), публикуван от Zhipu AI (智谱 AI). Моделът е изграден върху водещия текстов модел GLM-4.5-Air, който разполага с общо 106 милиарда параметри и 12 милиарда активационни параметри, и използва архитектура с разбъркани експерти (Mixture of Experts, MoE), целяща постигане на висока производителност при по-ниски разходи за инференция. Технически GLM-4.5V продължава линията на GLM-4.1V-Thinking и въвежда иновации като триизмерно ротационно позиционно кодиране (3D-RoPE), което значително засилва възприемането и разсъжденията относно триизмерните пространствени взаимовръзки. Чрез оптимизации в етапите на предварително обучение, супервизирано фино настройване и подсилено обучение, моделът може да обработва различни визуални формати — изображения, видео и дълги документи — и в 41 публични мултимодални бенчмарка достига водещи резултати сред отворените модели от същия клас. Освен това моделът добавя превключвател за 'режим на мислене', който позволява на потребителите гъвкаво да избират между бърз отговор и дълбоко разсъждение, за да балансират ефективността и качеството."
   },
+  "zai-org/GLM-4.6": {
+    "description": "В сравнение с GLM-4.5, GLM-4.6 предлага множество ключови подобрения. Контекстният прозорец е разширен от 128K до 200K токена, което позволява на модела да обработва по-сложни задачи на агенти. Моделът постига по-високи резултати в кодовите бенчмаркове и демонстрира по-силна реална производителност в приложения като Claude Code, Cline, Roo Code и Kilo Code, включително подобрения в генерирането на визуално изискани фронтенд страници. GLM-4.6 показва значително подобрение в производителността на извод и поддържа използването на инструменти по време на извод, което води до по-силни интегрирани възможности. Той е по-добър в използването на инструменти и базирани на търсене агенти и може по-ефективно да се интегрира в агентски рамки. В писането моделът е по-съобразен със стиловите и четивни предпочитания на хората и се представя по-естествено в ролеви игри."
+  },
   "zai/glm-4.5": {
     "description": "Серията модели GLM-4.5 е специално проектирана за агенти. Флагманът GLM-4.5 интегрира 355 милиарда общи параметри (32 милиарда активни), обединявайки разсъждения, кодиране и агентски способности за решаване на сложни приложения. Като хибридна разсъдъчна система, той предлага двойни режими на работа."
   },

locales/bg-BG/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "Моделите, предоставени от Ollama, обхващат широк спектър от области, включително генериране на код, математически операции, многоезично обработване и диалогова интеракция, отговарящи на разнообразните нужди на предприятията и локализирани внедрявания."
   },
+  "ollamacloud": {
+    "description": "Ollama Cloud предлага официално хоствана услуга за изчисления, която осигурява достъп до библиотеката с модели на Ollama веднага след изваждане от кутията и поддържа интерфейс, съвместим с OpenAI."
+  },
   "openai": {
     "description": "OpenAI е водеща световна изследователска институция в областта на изкуствения интелект, чийто модели, като серията GPT, напредват в границите на обработката на естествен език. OpenAI се стреми да трансформира множество индустрии чрез иновации и ефективни AI решения. Продуктите им предлагат значителна производителност и икономичност, широко използвани в изследвания, бизнес и иновационни приложения."
   },

locales/bg-BG/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "Грешка при изпълнение",
+    "executing": "Изпълнение...",
+    "files": "Файлове:",
+    "output": "Изход:",
+    "returnValue": "Върната стойност:"
+  },
   "dalle": {
     "autoGenerate": "Автоматично генериране",
     "downloading": "Връзките към изображенията, генерирани от DALL·E3, са валидни само за 1 час, кеширане на изображенията локално...",

locales/de-DE/chat.json

@@ -3,8 +3,8 @@
     "title": "Modell"
   },
   "agentDefaultMessage": "Hallo, ich bin **{{name}}**. Du kannst sofort mit mir sprechen oder zu den [Assistenteneinstellungen]({{url}}) gehen, um meine Informationen zu vervollständigen.",
-  "agentDefaultMessageWithSystemRole": "Hallo, ich bin **{{name}}**, {{systemRole}}. Lass uns chatten!",
-  "agentDefaultMessageWithoutEdit": "Hallo, ich bin **{{name}}**. Lassen Sie uns ins Gespräch kommen!",
+  "agentDefaultMessageWithSystemRole": "Hallo, ich bin **{{name}}**. Wie kann ich Ihnen behilflich sein?",
+  "agentDefaultMessageWithoutEdit": "Hallo, ich bin **{{name}}**. Wie kann ich Ihnen behilflich sein?",
   "agents": "Assistent",
   "artifact": {
     "generating": "Wird generiert",
@@ -150,6 +150,11 @@
       "total": "Gesamter Verbrauch"
     }
   },
+  "minimap": {
+    "jumpToMessage": "Zur Nachricht Nr. {{index}} springen",
+    "nextMessage": "Nächste Nachricht",
+    "previousMessage": "Vorherige Nachricht"
+  },
   "newAgent": "Neuer Assistent",
   "pin": "Anheften",
   "pinOff": "Anheften aufheben",

locales/de-DE/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "Beschreiben Sie den Inhalt, den Sie generieren möchten"
     },
+    "quality": {
+      "label": "Bildqualität",
+      "options": {
+        "hd": "Hohe Auflösung",
+        "standard": "Standard"
+      }
+    },
     "seed": {
       "label": "Seed",
       "random": "Zufälliger Seed"

locales/de-DE/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "Maximales Kontextfenster",
           "unlimited": "Unbegrenzt"
         },
+        "type": {
+          "extra": "Verschiedene Modelltypen haben unterschiedliche Anwendungsbereiche und Fähigkeiten",
+          "options": {
+            "chat": "Chat",
+            "embedding": "Vektorisierung",
+            "image": "Bildgenerierung",
+            "realtime": "Echtzeit-Chat",
+            "stt": "Spracherkennung",
+            "text2music": "Text zu Musik",
+            "text2video": "Text zu Video",
+            "tts": "Sprachsynthese"
+          },
+          "placeholder": "Bitte Modelltyp auswählen",
+          "title": "Modelltyp"
+        },
         "vision": {
           "extra": "Diese Konfiguration aktiviert nur die Bild-Upload-Funktionalität in der Anwendung. Ob die Erkennung unterstützt wird, hängt vollständig vom Modell selbst ab. Bitte testen Sie die Verwendbarkeit der visuellen Erkennungsfähigkeit des Modells selbst.",
           "title": "Visuelle Erkennung unterstützen"

locales/de-DE/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 - Denkmodus; DeepSeek-V3.1 ist ein neu eingeführtes hybrides Inferenzmodell von DeepSeek, das zwei Inferenzmodi unterstützt: Denk- und Nicht-Denkmodus, mit höherer Denkeffizienz im Vergleich zu DeepSeek-R1-0528. Durch Post-Training-Optimierung wurde die Leistung bei Agenten-Werkzeugnutzung und Agentenaufgaben deutlich verbessert."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 ist das neueste universelle Großmodell von DeepSeek, das eine hybride Inferenzarchitektur unterstützt und über stärkere Agentenfähigkeiten verfügt."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "DeepSeek V3.2 Denkmodus. Bevor die endgültige Antwort ausgegeben wird, gibt das Modell zunächst eine Gedankenkette aus, um die Genauigkeit der finalen Antwort zu verbessern."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite bietet extrem schnelle Reaktionszeiten und ein hervorragendes Preis-Leistungs-Verhältnis, um Kunden in verschiedenen Szenarien flexiblere Optionen zu bieten. Unterstützt Inferenz und Feintuning mit einem Kontextfenster von 128k."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 ist ein hybrides großes Sprachmodell, das von DeepSeek AI veröffentlicht wurde und auf dem Vorgängermodell in vielerlei Hinsicht bedeutende Verbesserungen aufweist. Eine wesentliche Innovation dieses Modells ist die Integration des „Denkmodus“ und des „Nicht-Denkmodus“ in einem System, wobei Nutzer durch Anpassung der Chat-Vorlagen flexibel zwischen den Modi wechseln können, um unterschiedlichen Aufgabenanforderungen gerecht zu werden. Durch spezielles Post-Training wurde die Leistung von V3.1 bei Tool-Aufrufen und Agentenaufgaben deutlich gesteigert, was eine bessere Unterstützung externer Suchwerkzeuge und die Ausführung komplexer mehrstufiger Aufgaben ermöglicht. Das Modell basiert auf DeepSeek-V3.1-Base und wurde durch eine zweistufige Langtext-Erweiterungsmethode nachtrainiert, wodurch das Trainingsdatenvolumen erheblich erhöht wurde und es sich besonders bei der Verarbeitung langer Dokumente und umfangreicher Codes bewährt. Als Open-Source-Modell zeigt DeepSeek-V3.1 in Benchmarks zu Codierung, Mathematik und logischem Denken Fähigkeiten, die mit führenden Closed-Source-Modellen vergleichbar sind. Gleichzeitig senkt seine hybride Expertenarchitektur (MoE) die Inferenzkosten bei gleichzeitiger Beibehaltung einer enormen Modellkapazität."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus ist eine aktualisierte Version des V3.1-Modells von DeepSeek, positioniert als hybrides Agenten-Großsprachmodell. Dieses Update konzentriert sich darauf, auf Nutzerfeedback basierende Probleme zu beheben und die Stabilität zu verbessern, während die ursprünglichen Modellfähigkeiten erhalten bleiben. Es verbessert deutlich die Sprachkonsistenz und reduziert das Vermischen von Chinesisch und Englisch sowie das Auftreten ungewöhnlicher Zeichen. Das Modell integriert den „Denkmodus“ (Thinking Mode) und den „Nicht-Denkmodus“ (Non-thinking Mode), zwischen denen Nutzer flexibel über Chatvorlagen wechseln können, um unterschiedlichen Aufgaben gerecht zu werden. Als wichtige Optimierung verbessert V3.1-Terminus die Leistung des Code-Agenten und des Such-Agenten, wodurch diese bei Werkzeugaufrufen und der Ausführung mehrstufiger komplexer Aufgaben zuverlässiger sind."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 ist die neueste und leistungsstärkste Version von Kimi K2. Es handelt sich um ein erstklassiges Mixture-of-Experts (MoE) Sprachmodell mit insgesamt 1 Billion Parametern und 32 Milliarden aktivierten Parametern. Die Hauptmerkmale dieses Modells umfassen: verbesserte Agenten-Codierungsintelligenz, die in öffentlichen Benchmark-Tests und realen Agenten-Codierungsaufgaben eine signifikante Leistungssteigerung zeigt; verbesserte Frontend-Codierungserfahrung mit Fortschritten in Ästhetik und Praktikabilität der Frontend-Programmierung."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 baut auf den branchenführenden Fähigkeiten von Sonnet 3.7 auf und zeigt herausragende Codierungsleistung mit einem Spitzenwert von 72,7 % bei SWE-bench. Das Modell bietet eine ausgewogene Kombination aus Leistung und Effizienz, geeignet für interne und externe Anwendungsfälle, und ermöglicht durch verbesserte Steuerbarkeit eine größere Kontrolle über die Ergebnisse."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "Claude Sonnet 4.5 ist das bisher intelligenteste Modell von Anthropic."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B ist ein spärlich besetztes großes Sprachmodell mit 72 Milliarden Parametern und 16 Milliarden aktivierten Parametern. Es basiert auf der gruppierten Mixture-of-Experts-Architektur (MoGE), bei der Experten in Gruppen eingeteilt werden und Tokens innerhalb jeder Gruppe eine gleiche Anzahl von Experten aktivieren, um eine ausgewogene Expertenauslastung zu gewährleisten. Dies verbessert die Effizienz der Modellausführung auf der Ascend-Plattform erheblich."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "Claude Sonnet 4 Denkmodell kann nahezu sofortige Antworten oder verlängerte schrittweise Überlegungen erzeugen, die für den Nutzer klar nachvollziehbar sind."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "Claude Sonnet 4.5 ist das bisher intelligenteste Modell von Anthropic."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 ist ein leistungsstarker AI-Programmierassistent, der intelligente Fragen und Codevervollständigung in verschiedenen Programmiersprachen unterstützt und die Entwicklungseffizienz steigert."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 ist ein hybrides großes Sprachmodell, das von DeepSeek AI veröffentlicht wurde und auf dem Vorgängermodell in vielerlei Hinsicht bedeutende Verbesserungen aufweist. Eine wesentliche Innovation dieses Modells ist die Integration des „Denkmodus“ und des „Nicht-Denkmodus“ in einem System, wobei Nutzer durch Anpassung der Chat-Vorlagen flexibel zwischen den Modi wechseln können, um unterschiedlichen Aufgabenanforderungen gerecht zu werden. Durch spezielles Post-Training wurde die Leistung von V3.1 bei Tool-Aufrufen und Agentenaufgaben deutlich gesteigert, was eine bessere Unterstützung externer Suchwerkzeuge und die Ausführung komplexer mehrstufiger Aufgaben ermöglicht. Das Modell basiert auf DeepSeek-V3.1-Base und wurde durch eine zweistufige Langtext-Erweiterungsmethode nachtrainiert, wodurch das Trainingsdatenvolumen erheblich erhöht wurde und es sich besonders bei der Verarbeitung langer Dokumente und umfangreicher Codes bewährt. Als Open-Source-Modell zeigt DeepSeek-V3.1 in Benchmarks zu Codierung, Mathematik und logischem Denken Fähigkeiten, die mit führenden Closed-Source-Modellen vergleichbar sind. Gleichzeitig senkt seine hybride Expertenarchitektur (MoE) die Inferenzkosten bei gleichzeitiger Beibehaltung einer enormen Modellkapazität."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus ist eine aktualisierte Version des V3.1-Modells von DeepSeek, positioniert als hybrides Agenten-Großsprachmodell. Dieses Update konzentriert sich darauf, auf Nutzerfeedback basierende Probleme zu beheben und die Stabilität zu verbessern, während die ursprünglichen Modellfähigkeiten erhalten bleiben. Es verbessert deutlich die Sprachkonsistenz und reduziert das Vermischen von Chinesisch und Englisch sowie das Auftreten ungewöhnlicher Zeichen. Das Modell integriert den „Denkmodus“ (Thinking Mode) und den „Nicht-Denkmodus“ (Non-thinking Mode), zwischen denen Nutzer flexibel über Chatvorlagen wechseln können, um unterschiedlichen Aufgaben gerecht zu werden. Als wichtige Optimierung verbessert V3.1-Terminus die Leistung des Code-Agenten und des Such-Agenten, wodurch diese bei Werkzeugaufrufen und der Ausführung mehrstufiger komplexer Aufgaben zuverlässiger sind."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B ist ein fortschrittliches Modell, das für komplexe Dialoge trainiert wurde."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: Ein Inferenzmodell der nächsten Generation, das komplexe Schlussfolgerungen und verknüpfte Denkfähigkeiten verbessert und sich für Aufgaben eignet, die tiefgehende Analysen erfordern."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: Das nächste Generation von Inferenzmodellen mit verbesserter Fähigkeit zum komplexen Schlussfolgern und vernetztem Denken – ideal für Aufgaben, die tiefgehende Analysen erfordern."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 ist ein hybrides Expertenmodell (MoE) für visuelle Sprache, das auf DeepSeekMoE-27B basiert und eine spärliche Aktivierung der MoE-Architektur verwendet, um außergewöhnliche Leistungen bei der Aktivierung von nur 4,5 Milliarden Parametern zu erzielen. Dieses Modell zeigt hervorragende Leistungen in mehreren Aufgaben, darunter visuelle Fragenbeantwortung, optische Zeichenerkennung, Dokument-/Tabellen-/Diagrammverständnis und visuelle Lokalisierung."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 Vollversion mit 671B Parametern, die Echtzeit-Online-Suche unterstützt und über verbesserte Verständnis- und Generierungsfähigkeiten verfügt."
   },
   "deepseek-reasoner": {
-    "description": "DeepSeek V3.1 Denkmodus. Bevor die endgültige Antwort ausgegeben wird, generiert das Modell eine Kette von Überlegungen, um die Genauigkeit der finalen Antwort zu verbessern."
+    "description": "DeepSeek V3.2 Denkmodus. Bevor die endgültige Antwort ausgegeben wird, gibt das Modell zunächst eine Gedankenkette aus, um die Genauigkeit der finalen Antwort zu verbessern."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 ist ein effizientes Mixture-of-Experts-Sprachmodell, das für wirtschaftliche Verarbeitungsanforderungen geeignet ist."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: Ein Inferenzmodell der nächsten Generation, das komplexe Schlussfolgerungen und verknüpfte Denkfähigkeiten verbessert und sich für Aufgaben eignet, die tiefgehende Analysen erfordern."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp führt einen sparsamen Aufmerksamkeitsmechanismus ein, um die Effizienz beim Training und der Inferenz bei der Verarbeitung langer Texte zu verbessern. Der Preis liegt unter dem von deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 ist ein Experten-Mischmodell mit 685B Parametern und die neueste Iteration der Flaggschiff-Chatmodellreihe des DeepSeek-Teams.\n\nEs erbt das [DeepSeek V3](/deepseek/deepseek-chat-v3) Modell und zeigt hervorragende Leistungen in verschiedenen Aufgaben."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] ist ein bildgenerierendes Modell mit 12 Milliarden Parametern, das sich auf die schnelle Erzeugung hochwertiger Bilder konzentriert."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "Ein leistungsstarkes natives multimodales Bildgenerierungsmodell"
+  },
   "fal-ai/imagen4/preview": {
     "description": "Hochwertiges Bildgenerierungsmodell von Google."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash ist Googles kosteneffizientestes Modell und bietet umfassende Funktionen."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana ist Googles neuestes, schnellstes und effizientestes natives multimodales Modell, das es Ihnen ermöglicht, Bilder durch Dialog zu generieren und zu bearbeiten."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana ist Googles neuestes, schnellstes und effizientestes natives multimodales Modell, das es Ihnen ermöglicht, Bilder durch Dialog zu generieren und zu bearbeiten."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana ist Googles neuestes, schnellstes und effizientestes natives multimodales Modell, das es Ihnen ermöglicht, Bilder durch Dialog zu generieren und zu bearbeiten."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana ist Googles neuestes, schnellstes und effizientestes natives multimodales Modell, das es Ihnen ermöglicht, Bilder durch Dialog zu generieren und zu bearbeiten."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite ist Googles kleinstes und kosteneffizientestes Modell, das speziell für den großflächigen Einsatz entwickelt wurde."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview ist Googles kleinstes und kosteneffizientestes Modell, speziell für den großflächigen Einsatz konzipiert."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "Vorschauversion (25. September 2025) von Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview ist das kosteneffizienteste Modell von Google und bietet umfassende Funktionen."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview ist Googles kosteneffizientestes Modell mit umfassenden Funktionen."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "Vorschauversion (25. September 2025) von Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro ist Googles fortschrittlichstes Denkmodell, das komplexe Probleme in den Bereichen Code, Mathematik und MINT-Fächer lösen kann und große Datensätze, Codebasen und Dokumente mit langem Kontext analysiert."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview ist Googles fortschrittlichstes Denkmodell, das komplexe Probleme in den Bereichen Code, Mathematik und MINT-Fächer lösen kann und große Datensätze, Codebasen und Dokumente mit langem Kontext analysiert."
   },
+  "gemini-flash-latest": {
+    "description": "Neueste Version von Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "Neueste Version von Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "Neueste Version von Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B eignet sich für die Verarbeitung von mittelgroßen Aufgaben und bietet ein gutes Kosten-Nutzen-Verhältnis."
   },
@@ -1437,7 +1485,7 @@
     "description": "Die GLM-4.1V-Thinking-Serie ist das leistungsstärkste visuelle Modell unter den bekannten 10-Milliarden-Parameter-VLMs und integriert SOTA-Leistungen auf diesem Niveau in verschiedenen visuellen Sprachaufgaben, darunter Videoverstehen, Bildfragen, Fachaufgaben, OCR-Texterkennung, Dokumenten- und Diagramminterpretation, GUI-Agenten, Frontend-Web-Coding und Grounding. In vielen Aufgaben übertrifft es sogar das Qwen2.5-VL-72B mit achtmal so vielen Parametern. Durch fortschrittliche Verstärkungslernverfahren beherrscht das Modell die Chain-of-Thought-Schlussfolgerung, was die Genauigkeit und Detailtiefe der Antworten deutlich verbessert und in Bezug auf Endergebnis und Erklärbarkeit traditionelle Nicht-Thinking-Modelle übertrifft."
   },
   "glm-4.5": {
-    "description": "Das neueste Flaggschiff-Modell von Zhipu, unterstützt den Denkmoduswechsel und erreicht eine umfassende Leistungsfähigkeit auf SOTA-Niveau für Open-Source-Modelle mit einer Kontextlänge von bis zu 128K."
+    "description": "Das Flaggschiff-Modell von Zhipu unterstützt den Wechsel zwischen Denkmodi und erreicht eine umfassende Leistungsfähigkeit auf dem Niveau der besten Open-Source-Modelle. Die Kontextlänge beträgt bis zu 128K."
   },
   "glm-4.5-air": {
     "description": "Die leichtgewichtige Version von GLM-4.5, die Leistung und Kosten-Nutzen-Verhältnis ausbalanciert und flexibel zwischen hybriden Denkmodellen wechseln kann."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "Das neue visuelle Inferenzmodell der nächsten Generation von Zhipu, basierend auf der MOE-Architektur, verfügt über 106B Gesamtparameter und 12B aktivierte Parameter und erzielt in verschiedenen Benchmarks State-of-the-Art‑Ergebnisse (SOTA) unter weltweit vergleichbaren Open‑Source‑multimodalen Modellen. Es deckt gängige Aufgaben wie Bild-, Video- und Dokumentenverständnis sowie GUI‑Aufgaben ab."
   },
+  "glm-4.6": {
+    "description": "Das neueste Flaggschiff-Modell von Zhipu, GLM-4.6 (355B), übertrifft die Vorgängergeneration in fortgeschrittener Codierung, Langtextverarbeitung, Inferenz und Agentenfähigkeiten umfassend. Besonders in der Programmierfähigkeit ist es mit Claude Sonnet 4 vergleichbar und gilt als eines der besten Coding-Modelle im Inland."
+  },
   "glm-4v": {
     "description": "GLM-4V bietet starke Fähigkeiten zur Bildverständnis und -schlussfolgerung und unterstützt eine Vielzahl visueller Aufgaben."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "Die schnellste und kostengünstigste Version von GPT-5. Besonders geeignet für Anwendungen, die schnelle Reaktionen und Kostenbewusstsein erfordern."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 Pro nutzt mehr Rechenleistung für tiefgreifendere Überlegungen und liefert kontinuierlich bessere Antworten."
+  },
   "gpt-audio": {
     "description": "GPT Audio ist ein universelles Chatmodell für Audioeingabe und -ausgabe, das Audio-I/O in der Chat Completions API unterstützt."
   },
   "gpt-image-1": {
     "description": "ChatGPT natives multimodales Bildgenerierungsmodell"
   },
+  "gpt-image-1-mini": {
+    "description": "Kostengünstigere Version von GPT Image 1 mit nativer Unterstützung für Text- und Bildeingaben sowie Bildausgaben."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4 quantisierte Transformer-Struktur, die auch bei begrenzten Ressourcen starke Leistung beibehält."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "Erhebliche Verbesserung der Fähigkeiten des Hauptmodells im langsamen Denkmodus bei anspruchsvoller Mathematik, komplexen Schlussfolgerungen, anspruchsvollem Code, Befolgung von Anweisungen und Textkreation."
   },
-  "hunyuan-t1-vision": {
-    "description": "Hunyuan ist ein multimodales Verständnis- und Tiefdenkmodell, das native multimodale lange Denkprozesse unterstützt. Es ist spezialisiert auf verschiedene Bildinferenzszenarien und zeigt im Vergleich zu Schnelldenkmodellen umfassende Verbesserungen bei naturwissenschaftlichen Problemen."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "Die neueste Version des hunyuan t1-vision multimodalen tiefen Denkmodells unterstützt native multimodale Chain-of-Thought-Mechanismen und bietet im Vergleich zur vorherigen Standardversion umfassende Verbesserungen."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "Hunyuan multimodales Verständnis- und Tiefdenkmodell, unterstützt native multimodale lange Gedankenketten, ist spezialisiert auf verschiedene Bildinferenzszenarien und verbessert sich im Vergleich zum Schnelldenkmodell umfassend bei naturwissenschaftlichen Problemen."
+  },
   "hunyuan-turbo": {
     "description": "Die Vorschauversion des neuen großen Sprachmodells von Hunyuan verwendet eine neuartige hybride Expertenmodellstruktur (MoE) und bietet im Vergleich zu Hunyuan-Pro eine schnellere Inferenz und bessere Leistung."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "Upgrade der vortrainierten Basis, verbessert Schreib- und Leseverständnisfähigkeiten, steigert deutlich die Programmier- und naturwissenschaftlichen Kompetenzen und verbessert kontinuierlich die Befolgung komplexer Anweisungen."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "Qualitätsverbesserung der Pretraining-Basisdaten. Optimierung der Trainingsstrategie in der Posttrain-Phase, kontinuierliche Verbesserung der Agenten-, Englisch- und kleinen Sprachfähigkeiten, Befolgung von Anweisungen, Code- und naturwissenschaftlichen Fähigkeiten."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS ist die neueste Version des Hunyuan-Flaggschiffmodells, das über verbesserte Denkfähigkeiten und ein besseres Nutzungserlebnis verfügt."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 ist ein Basis-Modell mit MoE-Architektur und besonders starken Fähigkeiten im Bereich Code und Agenten. Es verfügt über insgesamt 1T Parameter und 32B aktivierte Parameter. In Benchmark-Tests der wichtigsten Kategorien – allgemeines Wissens-Reasoning, Programmierung, Mathematik und Agenten – übertrifft das K2-Modell die Leistung anderer gängiger Open‑Source‑Modelle."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 ist ein von Moon's Dark Side AI entwickeltes großes gemischtes Expertenmodell (MoE) mit insgesamt 1 Billion Parametern und 32 Milliarden aktivierten Parametern pro Vorwärtsdurchlauf. Es ist auf Agentenfähigkeiten optimiert, einschließlich fortgeschrittener Werkzeugnutzung, Schlussfolgerungen und Code-Synthese."
+  },
   "kimi-latest": {
     "description": "Das Kimi intelligente Assistenzprodukt verwendet das neueste Kimi Großmodell, das möglicherweise noch instabile Funktionen enthält. Es unterstützt die Bildverarbeitung und wählt automatisch das Abrechnungsmodell 8k/32k/128k basierend auf der Länge des angeforderten Kontexts aus."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V ist das neueste visuell-sprachliche Modell (VLM), das von Zhipu AI veröffentlicht wurde. Das Modell basiert auf dem Flaggschiff-Textmodell GLM-4.5-Air mit insgesamt 106 Milliarden Parametern und 12 Milliarden Aktivierungsparametern und verwendet eine Mixture-of-Experts-(MoE)-Architektur. Es zielt darauf ab, bei geringeren Inferenzkosten herausragende Leistung zu erzielen. Technisch setzt es die Entwicklungslinie von GLM-4.1V-Thinking fort und führt Innovationen wie die dreidimensionale Rotations-Positionskodierung (3D-RoPE) ein, wodurch die Wahrnehmung und das Schließen über dreidimensionale Raumbeziehungen deutlich verbessert werden. Durch Optimierungen in den Phasen des Pre-Trainings, der überwachten Feinabstimmung und des Reinforcement Learnings ist das Modell in der Lage, verschiedene visuelle Inhalte wie Bilder, Videos und lange Dokumente zu verarbeiten; in 41 öffentlichen multimodalen Benchmarks erreichte es Spitzenwerte unter frei verfügbaren Modellen derselben Klasse. Zudem wurde ein \"Denkmodus\"-Schalter hinzugefügt, der es Nutzern erlaubt, flexibel zwischen schneller Reaktion und tiefgehendem Schlussfolgern zu wählen, um Effizienz und Ergebnisqualität auszubalancieren."
   },
+  "zai-org/GLM-4.6": {
+    "description": "Im Vergleich zu GLM-4.5 bringt GLM-4.6 mehrere wichtige Verbesserungen. Das Kontextfenster wurde von 128K auf 200K Tokens erweitert, wodurch das Modell komplexere Agentenaufgaben bewältigen kann. Das Modell erzielte höhere Werte in Code-Benchmark-Tests und zeigte in Anwendungen wie Claude Code, Cline, Roo Code und Kilo Code eine stärkere Leistung in realen Szenarien, einschließlich verbesserter Generierung visuell ansprechender Frontend-Seiten. GLM-4.6 zeigt eine deutliche Steigerung der Inferenzleistung und unterstützt die Nutzung von Werkzeugen während der Inferenz, was zu einer stärkeren Gesamtkapazität führt. Es zeigt bessere Leistungen bei der Werkzeugnutzung und suchbasierten Agenten und lässt sich effektiver in Agentenframeworks integrieren. Im Bereich des Schreibens entspricht das Modell stilistisch und in der Lesbarkeit stärker menschlichen Präferenzen und verhält sich in Rollenspielszenarien natürlicher."
+  },
   "zai/glm-4.5": {
     "description": "Die GLM-4.5 Modellreihe sind speziell für Agenten entwickelte Basismodelle. Das Flaggschiff GLM-4.5 integriert 355 Milliarden Gesamtparameter (32 Milliarden aktiv) und vereint Inferenz-, Codierungs- und Agentenfähigkeiten zur Lösung komplexer Anwendungsanforderungen. Als hybrides Inferenzsystem bietet es zwei Betriebsmodi."
   },

locales/de-DE/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "Die von Ollama angebotenen Modelle decken ein breites Spektrum ab, darunter Code-Generierung, mathematische Berechnungen, mehrsprachige Verarbeitung und dialogbasierte Interaktionen, und unterstützen die vielfältigen Anforderungen an unternehmensgerechte und lokal angepasste Bereitstellungen."
   },
+  "ollamacloud": {
+    "description": "Ollama Cloud bietet offiziell gehostete Inferenzdienste, mit sofortigem Zugriff auf die Ollama-Modellbibliothek und Unterstützung für OpenAI-kompatible Schnittstellen."
+  },
   "openai": {
     "description": "OpenAI ist eine weltweit führende Forschungsinstitution im Bereich der künstlichen Intelligenz, deren entwickelte Modelle wie die GPT-Serie die Grenzen der Verarbeitung natürlicher Sprache vorantreiben. OpenAI setzt sich dafür ein, durch innovative und effiziente KI-Lösungen verschiedene Branchen zu transformieren. Ihre Produkte zeichnen sich durch herausragende Leistung und Wirtschaftlichkeit aus und finden breite Anwendung in Forschung, Wirtschaft und innovativen Anwendungen."
   },

locales/de-DE/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "Ausführungsfehler",
+    "executing": "Wird ausgeführt...",
+    "files": "Dateien:",
+    "output": "Ausgabe:",
+    "returnValue": "Rückgabewert:"
+  },
   "dalle": {
     "autoGenerate": "Automatisch generieren",
     "downloading": "Die von DallE3 generierten Bildlinks sind nur 1 Stunde lang gültig. Das Bild wird lokal zwischengespeichert...",

locales/en-US/chat.json

@@ -3,8 +3,8 @@
     "title": "Model"
   },
   "agentDefaultMessage": "Hello, I am **{{name}}**. You can start a conversation with me right away, or you can go to [Assistant Settings]({{url}}) to complete my information.",
-  "agentDefaultMessageWithSystemRole": "Hello, I'm **{{name}}**, {{systemRole}}. Let's start chatting!",
-  "agentDefaultMessageWithoutEdit": "Hello, I'm **{{name}}**, let's start chatting!",
+  "agentDefaultMessageWithSystemRole": "Hello, I am **{{name}}**. How can I assist you today?",
+  "agentDefaultMessageWithoutEdit": "Hello, I am **{{name}}**. How can I assist you today?",
   "agents": "Assistants",
   "artifact": {
     "generating": "Generating",
@@ -150,6 +150,11 @@
       "total": "Total Consumption"
     }
   },
+  "minimap": {
+    "jumpToMessage": "Jump to message {{index}}",
+    "nextMessage": "Next message",
+    "previousMessage": "Previous message"
+  },
   "newAgent": "New Assistant",
   "pin": "Pin",
   "pinOff": "Unpin",

locales/en-US/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "Describe what you want to generate"
     },
+    "quality": {
+      "label": "Image Quality",
+      "options": {
+        "hd": "High Definition",
+        "standard": "Standard"
+      }
+    },
     "seed": {
       "label": "Seed",
       "random": "Random Seed"

locales/en-US/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "Maximum Context Window",
           "unlimited": "Unlimited"
         },
+        "type": {
+          "extra": "Different model types have distinct use cases and capabilities",
+          "options": {
+            "chat": "Chat",
+            "embedding": "Embedding",
+            "image": "Image Generation",
+            "realtime": "Real-time Chat",
+            "stt": "Speech-to-Text",
+            "text2music": "Text-to-Music",
+            "text2video": "Text-to-Video",
+            "tts": "Text-to-Speech"
+          },
+          "placeholder": "Please select a model type",
+          "title": "Model Type"
+        },
         "vision": {
           "extra": "This configuration will only enable image upload capabilities in the application. Whether recognition is supported depends entirely on the model itself. Please test the visual recognition capabilities of the model yourself.",
           "title": "Support Vision"

locales/en-US/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 - Thinking Mode; DeepSeek-V3.1 is a newly launched hybrid reasoning model by DeepSeek, supporting both thinking and non-thinking reasoning modes, with higher thinking efficiency compared to DeepSeek-R1-0528. Post-training optimization significantly enhances agent tool usage and agent task performance."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 is the latest general-purpose large model released by DeepSeek, supporting a hybrid inference architecture and featuring enhanced Agent capabilities."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "DeepSeek V3.2 Thinking Mode. Before outputting the final answer, the model first generates a chain of thought to improve the accuracy of the final response."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite offers ultra-fast response times and better cost-effectiveness, providing customers with more flexible options for different scenarios. Supports inference and fine-tuning with a 128k context window."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 is a hybrid large language model released by DeepSeek AI, featuring multiple significant upgrades over its predecessor. A key innovation of this model is the integration of both \"Thinking Mode\" and \"Non-thinking Mode,\" allowing users to flexibly switch between modes by adjusting chat templates to suit different task requirements. Through dedicated post-training optimization, V3.1 significantly enhances performance in tool invocation and Agent tasks, better supporting external search tools and executing complex multi-step tasks. Based on DeepSeek-V3.1-Base, it employs a two-stage long-text extension method to greatly increase training data volume, improving its handling of long documents and extensive code. As an open-source model, DeepSeek-V3.1 demonstrates capabilities comparable to top closed-source models across benchmarks in coding, mathematics, and reasoning. Its Mixture of Experts (MoE) architecture maintains a massive model capacity while effectively reducing inference costs."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus is an updated version of the V3.1 model released by DeepSeek, positioned as a hybrid agent large language model. This update focuses on fixing user-reported issues and improving stability while maintaining the model's original capabilities. It significantly enhances language consistency, reducing the mixing of Chinese and English and the occurrence of abnormal characters. The model integrates both \"Thinking Mode\" and \"Non-thinking Mode,\" allowing users to switch flexibly between chat templates to suit different tasks. As a key optimization, V3.1-Terminus improves the performance of the Code Agent and Search Agent, making tool invocation and multi-step complex task execution more reliable."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 is the latest and most powerful version of Kimi K2. It is a top-tier Mixture of Experts (MoE) language model with a total of 1 trillion parameters and 32 billion activated parameters. Key features of this model include enhanced agent coding intelligence, demonstrating significant performance improvements in public benchmark tests and real-world agent coding tasks; and an improved frontend coding experience, with advancements in both aesthetics and practicality for frontend programming."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 significantly improves upon the industry-leading capabilities of Sonnet 3.7, excelling in coding with state-of-the-art 72.7% on SWE-bench. The model balances performance and efficiency, suitable for both internal and external use cases, and offers enhanced controllability for greater command over outcomes."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "Claude Sonnet 4.5 is Anthropic's most intelligent model to date."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B is a sparse large language model with 72 billion parameters and 16 billion activated parameters. It is based on the Group Mixture of Experts (MoGE) architecture, which groups experts during the expert selection phase and constrains tokens to activate an equal number of experts within each group, achieving expert load balancing and significantly improving deployment efficiency on the Ascend platform."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "Claude Sonnet 4 Thinking model can produce near-instant responses or extended step-by-step reasoning, enabling users to clearly see these processes."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "Claude Sonnet 4.5 is Anthropic's most intelligent model to date."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 is a powerful AI programming assistant that supports intelligent Q&A and code completion in various programming languages, enhancing development efficiency."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 is a hybrid large language model released by DeepSeek AI, featuring multiple significant upgrades over its predecessor. A key innovation of this model is the integration of both \"Thinking Mode\" and \"Non-thinking Mode,\" allowing users to flexibly switch between modes by adjusting chat templates to suit different task requirements. Through dedicated post-training optimization, V3.1 significantly enhances performance in tool invocation and Agent tasks, better supporting external search tools and executing complex multi-step tasks. Based on DeepSeek-V3.1-Base, it employs a two-stage long-text extension method to greatly increase training data volume, improving its handling of long documents and extensive code. As an open-source model, DeepSeek-V3.1 demonstrates capabilities comparable to top closed-source models across benchmarks in coding, mathematics, and reasoning. Its Mixture of Experts (MoE) architecture maintains a massive model capacity while effectively reducing inference costs."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus is an updated version of the V3.1 model released by DeepSeek, positioned as a hybrid agent large language model. This update focuses on fixing user-reported issues and improving stability while maintaining the model's original capabilities. It significantly enhances language consistency, reducing the mixing of Chinese and English and the occurrence of abnormal characters. The model integrates both \"Thinking Mode\" and \"Non-thinking Mode,\" allowing users to switch flexibly between chat templates to suit different tasks. As a key optimization, V3.1-Terminus improves the performance of the Code Agent and Search Agent, making tool invocation and multi-step complex task execution more reliable."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B is an advanced model trained for highly complex conversations."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: The next-generation reasoning model that enhances complex reasoning and chain-of-thought capabilities, suitable for tasks requiring in-depth analysis."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: A next-generation reasoning model designed to enhance complex reasoning and chain-of-thought capabilities, ideal for tasks requiring in-depth analysis."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 is a mixture of experts (MoE) visual language model developed based on DeepSeekMoE-27B, employing a sparsely activated MoE architecture that achieves outstanding performance while activating only 4.5 billion parameters. This model excels in various tasks, including visual question answering, optical character recognition, document/table/chart understanding, and visual localization."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 full version, with 671B parameters, supporting real-time online search, offering enhanced understanding and generation capabilities."
   },
   "deepseek-reasoner": {
-    "description": "DeepSeek V3.1 Thinking Mode. Before outputting the final answer, the model first generates a chain of thought to improve the accuracy of the final response."
+    "description": "DeepSeek V3.2 Thinking Mode. Before outputting the final answer, the model first generates a chain of thought to improve the accuracy of the final response."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 is an efficient Mixture-of-Experts language model, suitable for cost-effective processing needs."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: The next-generation reasoning model that enhances complex reasoning and chain-of-thought capabilities, suitable for tasks requiring in-depth analysis."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp introduces a sparse attention mechanism designed to enhance training and inference efficiency when processing long texts, priced lower than deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 is a 685B parameter expert mixture model, the latest iteration in the DeepSeek team's flagship chat model series.\n\nIt inherits from the [DeepSeek V3](/deepseek/deepseek-chat-v3) model and performs excellently across various tasks."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] is a 12-billion-parameter image generation model focused on fast generation of high-quality images."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "A powerful native multimodal image generation model"
+  },
   "fal-ai/imagen4/preview": {
     "description": "High-quality image generation model provided by Google."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash is Google's most cost-effective model, offering comprehensive capabilities."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana is Google's latest, fastest, and most efficient native multimodal model, allowing you to generate and edit images through conversation."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana is Google's latest, fastest, and most efficient native multimodal model, enabling you to generate and edit images through conversation."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana is Google's latest, fastest, and most efficient native multimodal model, enabling you to generate and edit images through conversation."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana is Google's latest, fastest, and most efficient native multimodal model, allowing you to generate and edit images through conversation."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite is Google's smallest and most cost-effective model, designed for large-scale use."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview is Google's smallest and most cost-efficient model, designed for large-scale usage."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "Preview release (September 25th, 2025) of Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview is Google's most cost-effective model, offering a comprehensive set of features."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview is Google's most cost-effective model, offering comprehensive capabilities."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "Preview release (September 25th, 2025) of Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro is Google's most advanced reasoning model, capable of tackling complex problems in coding, mathematics, and STEM fields, as well as analyzing large datasets, codebases, and documents using long-context processing."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview is Google's most advanced cognitive model, capable of reasoning through complex problems in code, mathematics, and STEM fields, as well as analyzing large datasets, codebases, and documents using long-context understanding."
   },
+  "gemini-flash-latest": {
+    "description": "Latest release of Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "Latest release of Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "Latest release of Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B is suitable for medium to small-scale task processing, offering cost-effectiveness."
   },
@@ -1437,7 +1485,7 @@
     "description": "The GLM-4.1V-Thinking series represents the most powerful vision-language models known at the 10B parameter scale, integrating state-of-the-art capabilities across various vision-language tasks such as video understanding, image question answering, academic problem solving, OCR text recognition, document and chart interpretation, GUI agents, front-end web coding, and grounding. Its performance in many tasks even surpasses that of Qwen2.5-VL-72B, which has over eight times the parameters. Leveraging advanced reinforcement learning techniques, the model masters Chain-of-Thought reasoning to improve answer accuracy and richness, significantly outperforming traditional non-thinking models in final results and interpretability."
   },
   "glm-4.5": {
-    "description": "Zhipu's latest flagship model supports thinking mode switching, achieving state-of-the-art comprehensive capabilities among open-source models, with a context length of up to 128K."
+    "description": "Zhipu's flagship model supports thinking mode switching, with comprehensive capabilities reaching the state-of-the-art level among open-source models, and a context length of up to 128K."
   },
   "glm-4.5-air": {
     "description": "A lightweight version of GLM-4.5 balancing performance and cost-effectiveness, capable of flexibly switching hybrid thinking models."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "Zhipu's next-generation visual reasoning model is built on a Mixture-of-Experts (MoE) architecture. With 106B total parameters and 12B activated parameters, it achieves state-of-the-art performance among open-source multimodal models of similar scale across various benchmarks, supporting common tasks such as image, video, document understanding, and GUI-related tasks."
   },
+  "glm-4.6": {
+    "description": "Zhipu's latest flagship model GLM-4.6 (355B) surpasses its predecessor comprehensively in advanced encoding, long text processing, reasoning, and agent capabilities, especially aligning with Claude Sonnet 4 in programming skills, making it a top-tier coding model in China."
+  },
   "glm-4v": {
     "description": "GLM-4V provides strong image understanding and reasoning capabilities, supporting various visual tasks."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "The fastest and most cost-efficient version of GPT-5. Perfectly suited for applications requiring rapid responses and cost sensitivity."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 Pro leverages greater computational power for deeper reasoning and consistently delivers improved answers."
+  },
   "gpt-audio": {
     "description": "GPT Audio is a general-purpose chat model designed for audio input and output, supporting audio I/O in the Chat Completions API."
   },
   "gpt-image-1": {
     "description": "ChatGPT native multimodal image generation model."
   },
+  "gpt-image-1-mini": {
+    "description": "A more cost-effective version of GPT Image 1, natively supporting both text and image inputs with image generation output."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4 quantized Transformer architecture, delivering strong performance even under resource constraints."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "Significantly enhances the main model's slow-thinking capabilities in advanced mathematics, complex reasoning, difficult coding, instruction adherence, and text creation quality."
   },
-  "hunyuan-t1-vision": {
-    "description": "Hunyuan is a multimodal deep thinking model supporting native multimodal chain-of-thought reasoning, excelling in various image reasoning scenarios and significantly outperforming fast-thinking models on science problems."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "The latest Hunyuan t1-vision multimodal deep thinking model supports native long Chain-of-Thought reasoning across modalities, comprehensively improving over the previous default version."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "Hunyuan multimodal deep reasoning model supporting native long chains of thought across modalities, excelling in various image reasoning scenarios and significantly improving performance on science problems compared to fast thinking models."
+  },
   "hunyuan-turbo": {
     "description": "The preview version of the next-generation Hunyuan large language model, featuring a brand-new mixed expert model (MoE) structure, which offers faster inference efficiency and stronger performance compared to Hunyuan Pro."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "Upgraded pretraining foundation with improved writing and reading comprehension skills, significantly enhanced coding and STEM abilities, and continuous improvements in following complex instructions."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "Pre-training base data quality upgrade. Optimized post-training phase strategies to continuously enhance Agent capabilities, English and minor language proficiency, instruction compliance, coding, and scientific reasoning."
+  },
   "hunyuan-turbos-latest": {
     "description": "The latest version of hunyuan-TurboS, the flagship model of Hunyuan, features enhanced reasoning capabilities and improved user experience."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "Kimi-K2 is a Mixture-of-Experts (MoE) foundation model with exceptional coding and agent capabilities, featuring 1T total parameters and 32B activated parameters. In benchmark evaluations across core categories — general knowledge reasoning, programming, mathematics, and agent tasks — the K2 model outperforms other leading open-source models."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 is a large-scale Mixture of Experts (MoE) language model developed by Moon's Dark Side AI, featuring a total of 1 trillion parameters and 32 billion activated parameters per forward pass. It is optimized for agent capabilities, including advanced tool usage, reasoning, and code synthesis."
+  },
   "kimi-latest": {
     "description": "The Kimi Smart Assistant product uses the latest Kimi large model, which may include features that are not yet stable. It supports image understanding and will automatically select the 8k/32k/128k model as the billing model based on the length of the request context."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V is the latest-generation vision-language model (VLM) released by Zhipu AI. It is built on the flagship text model GLM-4.5-Air, which has 106B total parameters and 12B active parameters, and adopts a Mixture-of-Experts (MoE) architecture to deliver outstanding performance at reduced inference cost. Technically, GLM-4.5V continues the trajectory of GLM-4.1V-Thinking and introduces innovations such as three-dimensional rotary position encoding (3D-RoPE), significantly improving perception and reasoning of three-dimensional spatial relationships. Through optimizations across pretraining, supervised fine-tuning, and reinforcement learning stages, the model can handle a wide range of visual content including images, video, and long documents, and has achieved top-tier performance among comparable open-source models across 41 public multimodal benchmarks. The model also adds a \"Thinking Mode\" toggle that lets users flexibly choose between fast responses and deep reasoning to balance efficiency and effectiveness."
   },
+  "zai-org/GLM-4.6": {
+    "description": "Compared to GLM-4.5, GLM-4.6 introduces several key improvements. Its context window expands from 128K to 200K tokens, enabling the model to handle more complex agent tasks. The model achieves higher scores on code benchmarks and demonstrates stronger real-world performance in applications such as Claude Code, Cline, Roo Code, and Kilo Code, including improvements in generating visually refined front-end pages. GLM-4.6 shows significant enhancements in inference performance and supports tool usage during inference, resulting in stronger overall capabilities. It excels in tool utilization and search-based agents and integrates more effectively into agent frameworks. In writing, the model better aligns with human preferences in style and readability and performs more naturally in role-playing scenarios."
+  },
   "zai/glm-4.5": {
     "description": "The GLM-4.5 series models are foundational models specifically designed for agents. The flagship GLM-4.5 integrates 355 billion total parameters (32 billion active), unifying reasoning, coding, and agent capabilities to address complex application needs. As a hybrid reasoning system, it offers dual operating modes."
   },

locales/en-US/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "Ollama provides models that cover a wide range of fields, including code generation, mathematical operations, multilingual processing, and conversational interaction, catering to diverse enterprise-level and localized deployment needs."
   },
+  "ollamacloud": {
+    "description": "Ollama Cloud offers officially hosted inference services, providing out-of-the-box access to the Ollama model library and supporting OpenAI-compatible interfaces."
+  },
   "openai": {
     "description": "OpenAI is a global leader in artificial intelligence research, with models like the GPT series pushing the frontiers of natural language processing. OpenAI is committed to transforming multiple industries through innovative and efficient AI solutions. Their products demonstrate significant performance and cost-effectiveness, widely used in research, business, and innovative applications."
   },

locales/en-US/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "Execution Error",
+    "executing": "Executing...",
+    "files": "Files:",
+    "output": "Output:",
+    "returnValue": "Return Value:"
+  },
   "dalle": {
     "autoGenerate": "Auto Generate",
     "downloading": "The image links generated by DALL·E3 are only valid for 1 hour, caching the images locally...",

locales/es-ES/chat.json

@@ -3,8 +3,8 @@
     "title": "Cambiar modelo"
   },
   "agentDefaultMessage": "Hola, soy **{{name}}**. Puedes comenzar a hablar conmigo de inmediato o ir a [Configuración del asistente]({{url}}) para completar mi información.",
-  "agentDefaultMessageWithSystemRole": "Hola, soy **{{name}}**, {{systemRole}}, ¡comencemos a chatear!",
-  "agentDefaultMessageWithoutEdit": "¡Hola, soy **{{name}}**! Comencemos nuestra conversación.",
+  "agentDefaultMessageWithSystemRole": "Hola, soy **{{name}}**, ¿en qué puedo ayudarte?",
+  "agentDefaultMessageWithoutEdit": "Hola, soy **{{name}}**, ¿en qué puedo ayudarte?",
   "agents": "Asistente",
   "artifact": {
     "generating": "Generando",
@@ -150,6 +150,11 @@
       "total": "Total consumido"
     }
   },
+  "minimap": {
+    "jumpToMessage": "Ir al mensaje número {{index}}",
+    "nextMessage": "Mensaje siguiente",
+    "previousMessage": "Mensaje anterior"
+  },
   "newAgent": "Nuevo asistente",
   "pin": "Fijar",
   "pinOff": "Desfijar",

locales/es-ES/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "Describe el contenido que deseas generar"
     },
+    "quality": {
+      "label": "Calidad de imagen",
+      "options": {
+        "hd": "Alta definición",
+        "standard": "Estándar"
+      }
+    },
     "seed": {
       "label": "Semilla",
       "random": "Semilla aleatoria"

locales/es-ES/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "Máximo de ventana de contexto",
           "unlimited": "Sin límite"
         },
+        "type": {
+          "extra": "Diferentes tipos de modelos tienen escenarios de uso y capacidades diferenciadas",
+          "options": {
+            "chat": "Chat",
+            "embedding": "Vectorización",
+            "image": "Generación de imágenes",
+            "realtime": "Chat en tiempo real",
+            "stt": "Reconocimiento de voz a texto",
+            "text2music": "Texto a música",
+            "text2video": "Texto a video",
+            "tts": "Síntesis de voz"
+          },
+          "placeholder": "Por favor, seleccione el tipo de modelo",
+          "title": "Tipo de modelo"
+        },
         "vision": {
           "extra": "Esta configuración solo habilitará la configuración de carga de imágenes en la aplicación, si se admite el reconocimiento depende completamente del modelo en sí, prueba la disponibilidad de la capacidad de reconocimiento visual de este modelo.",
           "title": "Soporte para reconocimiento visual"

locales/es-ES/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 en modo reflexivo; DeepSeek-V3.1 es un nuevo modelo híbrido de razonamiento lanzado por DeepSeek, que soporta dos modos de razonamiento: reflexivo y no reflexivo, con una eficiencia de pensamiento superior a DeepSeek-R1-0528. Tras una optimización post-entrenamiento, el uso de herramientas por agentes y el desempeño en tareas de agentes inteligentes han mejorado significativamente."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 es el último modelo general lanzado por DeepSeek, que soporta una arquitectura de inferencia híbrida y cuenta con capacidades de agente más potentes."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "Modo de pensamiento de DeepSeek V3.2. Antes de proporcionar la respuesta final, el modelo genera una cadena de razonamiento para mejorar la precisión de la respuesta."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite ofrece una velocidad de respuesta excepcional y una mejor relación calidad-precio, proporcionando opciones más flexibles para diferentes escenarios de los clientes. Soporta inferencia y ajuste fino con una ventana de contexto de 128k."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 es un modelo de lenguaje grande híbrido lanzado por DeepSeek AI, que incorpora múltiples mejoras importantes sobre su predecesor. Una innovación clave es la integración de los modos \"Pensamiento\" y \"No pensamiento\" en un solo modelo, permitiendo a los usuarios alternar flexiblemente mediante la configuración de plantillas de chat para adaptarse a diferentes tareas. Gracias a una optimización post-entrenamiento especializada, V3.1 mejora significativamente el rendimiento en llamadas a herramientas y tareas Agent, soportando mejor herramientas de búsqueda externas y la ejecución de tareas complejas en múltiples pasos. Basado en DeepSeek-V3.1-Base, se amplió considerablemente la cantidad de datos de entrenamiento mediante un método de extensión de texto largo en dos fases, mejorando su desempeño en documentos extensos y código largo. Como modelo de código abierto, DeepSeek-V3.1 demuestra capacidades comparables a los mejores modelos cerrados en benchmarks de codificación, matemáticas y razonamiento, y gracias a su arquitectura de expertos mixtos (MoE), mantiene una gran capacidad de modelo mientras reduce eficazmente los costos de inferencia."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus es una versión actualizada del modelo V3.1 lanzado por DeepSeek, posicionada como un modelo de lenguaje grande con agentes híbridos. Esta actualización mantiene las capacidades originales del modelo, enfocándose en corregir problemas reportados por los usuarios y mejorar la estabilidad. Mejora significativamente la coherencia del lenguaje, reduciendo la mezcla de chino e inglés y la aparición de caracteres anómalos. El modelo integra el “Modo de pensamiento” y el “Modo sin pensamiento”, permitiendo a los usuarios cambiar flexiblemente mediante plantillas de chat para adaptarse a diferentes tareas. Como optimización importante, V3.1-Terminus mejora el rendimiento del agente de código y del agente de búsqueda, haciéndolos más confiables en la invocación de herramientas y en la ejecución de tareas complejas de múltiples pasos."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 es la versión más reciente y potente de Kimi K2. Es un modelo de lenguaje de expertos mixtos (MoE) de primer nivel, con un total de un billón de parámetros y 32 mil millones de parámetros activados. Las principales características de este modelo incluyen: inteligencia mejorada para agentes de codificación, mostrando un rendimiento notable en pruebas de referencia públicas y en tareas reales de agentes de codificación; y una experiencia mejorada en la codificación frontend, con avances tanto en la estética como en la funcionalidad de la programación frontend."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 mejora significativamente las capacidades líderes de Sonnet 3.7, destacándose en codificación con un rendimiento de vanguardia del 72.7% en SWE-bench. El modelo equilibra rendimiento y eficiencia, adecuado para casos de uso internos y externos, y ofrece mayor control mediante una mejor capacidad de control."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "Claude Sonnet 4.5 es el modelo más inteligente de Anthropic hasta la fecha."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B es un modelo de lenguaje grande disperso con 72 mil millones de parámetros y 16 mil millones de parámetros activados. Está basado en la arquitectura de expertos mixtos agrupados (MoGE), que agrupa expertos durante la selección y restringe la activación de un número igual de expertos por grupo para cada token, logrando un balance de carga entre expertos y mejorando significativamente la eficiencia de despliegue en la plataforma Ascend."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "Modelo de pensamiento Claude Sonnet 4 que puede generar respuestas casi instantáneas o un pensamiento prolongado paso a paso, permitiendo a los usuarios ver claramente estos procesos."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "Claude Sonnet 4.5 es el modelo más inteligente de Anthropic hasta la fecha."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 es un potente asistente de programación AI, que admite preguntas y respuestas inteligentes y autocompletado de código en varios lenguajes de programación, mejorando la eficiencia del desarrollo."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 es un modelo de lenguaje grande híbrido lanzado por DeepSeek AI, que incorpora múltiples mejoras importantes sobre su predecesor. Una innovación clave es la integración de los modos \"Pensamiento\" y \"No pensamiento\" en un solo modelo, permitiendo a los usuarios alternar flexiblemente mediante la configuración de plantillas de chat para adaptarse a diferentes tareas. Gracias a una optimización post-entrenamiento especializada, V3.1 mejora significativamente el rendimiento en llamadas a herramientas y tareas Agent, soportando mejor herramientas de búsqueda externas y la ejecución de tareas complejas en múltiples pasos. Basado en DeepSeek-V3.1-Base, se amplió considerablemente la cantidad de datos de entrenamiento mediante un método de extensión de texto largo en dos fases, mejorando su desempeño en documentos extensos y código largo. Como modelo de código abierto, DeepSeek-V3.1 demuestra capacidades comparables a los mejores modelos cerrados en benchmarks de codificación, matemáticas y razonamiento, y gracias a su arquitectura de expertos mixtos (MoE), mantiene una gran capacidad de modelo mientras reduce eficazmente los costos de inferencia."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus es una versión actualizada del modelo V3.1 lanzado por DeepSeek, posicionada como un modelo de lenguaje grande con agentes híbridos. Esta actualización mantiene las capacidades originales del modelo, enfocándose en corregir problemas reportados por los usuarios y mejorar la estabilidad. Mejora significativamente la coherencia del lenguaje, reduciendo la mezcla de chino e inglés y la aparición de caracteres anómalos. El modelo integra el “Modo de pensamiento” y el “Modo sin pensamiento”, permitiendo a los usuarios cambiar flexiblemente mediante plantillas de chat para adaptarse a diferentes tareas. Como optimización importante, V3.1-Terminus mejora el rendimiento del agente de código y del agente de búsqueda, haciéndolos más confiables en la invocación de herramientas y en la ejecución de tareas complejas de múltiples pasos."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B es un modelo avanzado entrenado para diálogos de alta complejidad."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: modelo de inferencia de próxima generación que mejora las capacidades de razonamiento complejo y pensamiento en cadena, ideal para tareas que requieren análisis profundo."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: un modelo de inferencia de nueva generación que mejora la capacidad de razonamiento complejo y pensamiento en cadena, ideal para tareas que requieren un análisis profundo."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 es un modelo de lenguaje visual de expertos mixtos (MoE) desarrollado sobre DeepSeekMoE-27B, que utiliza una arquitectura MoE de activación dispersa, logrando un rendimiento excepcional al activar solo 4.5B de parámetros. Este modelo destaca en múltiples tareas como preguntas visuales, reconocimiento óptico de caracteres, comprensión de documentos/tablas/gráficos y localización visual."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 versión completa, con 671B de parámetros, que soporta búsqueda en línea en tiempo real, con una capacidad de comprensión y generación más potente."
   },
   "deepseek-reasoner": {
-    "description": "Modo de pensamiento DeepSeek V3.1. Antes de emitir la respuesta final, el modelo genera una cadena de razonamiento para mejorar la precisión de la respuesta."
+    "description": "Modo de pensamiento de DeepSeek V3.2. Antes de proporcionar la respuesta final, el modelo genera una cadena de razonamiento para mejorar la precisión de la respuesta."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 es un modelo de lenguaje Mixture-of-Experts eficiente, adecuado para necesidades de procesamiento económico."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: modelo de inferencia de próxima generación que mejora las capacidades de razonamiento complejo y pensamiento en cadena, ideal para tareas que requieren análisis profundo."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp introduce el mecanismo de atención dispersa, con el objetivo de mejorar la eficiencia en el entrenamiento y la inferencia al procesar textos largos, con un precio inferior al de deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 es un modelo experto de mezcla de 685B parámetros, la última iteración de la serie de modelos de chat insignia del equipo de DeepSeek.\n\nHereda el modelo [DeepSeek V3](/deepseek/deepseek-chat-v3) y se desempeña excepcionalmente en diversas tareas."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] es un modelo generador de imágenes con 12 mil millones de parámetros, enfocado en la generación rápida de imágenes de alta calidad."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "Un potente modelo nativo de generación de imágenes multimodales"
+  },
   "fal-ai/imagen4/preview": {
     "description": "Modelo de generación de imágenes de alta calidad proporcionado por Google."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash es el modelo de mejor relación calidad-precio de Google, que ofrece funcionalidades completas."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana es el modelo multimodal nativo más reciente, rápido y eficiente de Google, que permite generar y editar imágenes mediante diálogo."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana es el modelo multimodal nativo más reciente, rápido y eficiente de Google, que permite generar y editar imágenes mediante diálogo."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana es el modelo multimodal nativo más reciente, rápido y eficiente de Google, que permite generar y editar imágenes mediante diálogo."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana es el modelo multimodal nativo más reciente, rápido y eficiente de Google, que permite generar y editar imágenes mediante diálogo."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite es el modelo más pequeño y rentable de Google, diseñado para un uso a gran escala."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview es el modelo más pequeño y con mejor relación calidad-precio de Google, diseñado para un uso a gran escala."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "Versión preliminar (25 de septiembre de 2025) de Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview es el modelo más rentable de Google, que ofrece una funcionalidad completa."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview es el modelo de mejor relación calidad-precio de Google, que ofrece funcionalidades completas."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "Versión preliminar (25 de septiembre de 2025) de Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro es el modelo de pensamiento más avanzado de Google, capaz de razonar sobre problemas complejos en código, matemáticas y áreas STEM, así como de analizar grandes conjuntos de datos, bases de código y documentos utilizando contextos largos."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview es el modelo de pensamiento más avanzado de Google, capaz de razonar sobre problemas complejos en código, matemáticas y áreas STEM, así como analizar grandes conjuntos de datos, bases de código y documentos utilizando contextos extensos."
   },
+  "gemini-flash-latest": {
+    "description": "Última versión de Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "Última versión de Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "Última versión de Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B es adecuado para el procesamiento de tareas de pequeña y mediana escala, combinando rentabilidad."
   },
@@ -1437,7 +1485,7 @@
     "description": "La serie GLM-4.1V-Thinking es el modelo visual más potente conocido en la categoría de VLMs de 10 mil millones de parámetros, integrando tareas de lenguaje visual de última generación (SOTA) en su nivel, incluyendo comprensión de video, preguntas sobre imágenes, resolución de problemas académicos, reconocimiento OCR, interpretación de documentos y gráficos, agentes GUI, codificación web frontend, grounding, entre otros. En muchas tareas, supera incluso a modelos con 8 veces más parámetros como Qwen2.5-VL-72B. Gracias a técnicas avanzadas de aprendizaje reforzado, el modelo domina el razonamiento mediante cadenas de pensamiento para mejorar la precisión y riqueza de las respuestas, superando significativamente a los modelos tradicionales sin pensamiento en términos de resultados y explicabilidad."
   },
   "glm-4.5": {
-    "description": "El último modelo insignia de Zhipu, soporta modo de pensamiento, con capacidades integrales que alcanzan el nivel SOTA de modelos de código abierto y una longitud de contexto de hasta 128K."
+    "description": "Modelo insignia de Zhipu, que soporta el cambio de modo de pensamiento, con una capacidad integral que alcanza el nivel SOTA de los modelos de código abierto, y una longitud de contexto de hasta 128K."
   },
   "glm-4.5-air": {
     "description": "Versión ligera de GLM-4.5 que equilibra rendimiento y costo, con capacidad flexible para cambiar entre modelos de pensamiento híbrido."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "La nueva generación del modelo de razonamiento visual de Zhipu, basada en la arquitectura MOE, cuenta con 106B de parámetros totales y 12B de parámetros de activación; alcanza el estado del arte (SOTA) entre los modelos multimodales de código abierto de la misma categoría a nivel mundial en diversas pruebas de referencia, y cubre tareas comunes como comprensión de imágenes, vídeo, documentos y tareas de interfaz gráfica de usuario (GUI)."
   },
+  "glm-4.6": {
+    "description": "El último modelo insignia de Zhipu, GLM-4.6 (355B), supera ampliamente a la generación anterior en codificación avanzada, procesamiento de textos largos, inferencia y capacidades de agentes inteligentes, especialmente en habilidades de programación alineadas con Claude Sonnet 4, convirtiéndose en el modelo de codificación líder en China."
+  },
   "glm-4v": {
     "description": "GLM-4V proporciona una poderosa capacidad de comprensión e inferencia de imágenes, soportando diversas tareas visuales."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "Versión más rápida y económica de GPT-5. Perfecta para escenarios que requieren respuestas rápidas y son sensibles al costo."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 pro utiliza más capacidad de cómputo para pensar de forma más profunda y ofrecer respuestas de mayor calidad de manera constante."
+  },
   "gpt-audio": {
     "description": "GPT Audio es un modelo de chat general para entrada y salida de audio, compatible con el uso de audio I/O en la API de Chat Completions."
   },
   "gpt-image-1": {
     "description": "Modelo nativo multimodal de generación de imágenes de ChatGPT."
   },
+  "gpt-image-1-mini": {
+    "description": "Una versión más económica de GPT Image 1, con soporte nativo para entrada de texto e imagen y generación de salida en formato de imagen."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4: estructura Transformer cuantificada que mantiene un rendimiento sólido incluso con recursos limitados."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "Mejora significativamente las capacidades del modelo principal de pensamiento lento en matemáticas avanzadas, razonamiento complejo, código difícil, cumplimiento de instrucciones y calidad en la creación de textos."
   },
-  "hunyuan-t1-vision": {
-    "description": "Modelo de pensamiento profundo multimodal Hunyuan, que soporta cadenas de pensamiento nativas multimodales, sobresale en diversos escenarios de razonamiento con imágenes y mejora significativamente en problemas científicos en comparación con modelos de pensamiento rápido."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "La última versión del modelo de pensamiento profundo multimodal t1-vision de Hunyuan, que soporta cadenas de pensamiento nativas multimodales, con mejoras integrales respecto a la versión predeterminada anterior."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "Modelo de pensamiento profundo multimodal Hunyuan, que soporta cadenas de pensamiento nativas multimodales prolongadas, especializado en diversos escenarios de razonamiento con imágenes, y que mejora integralmente el rendimiento en problemas científicos en comparación con el modelo de pensamiento rápido."
+  },
   "hunyuan-turbo": {
     "description": "Versión preliminar de la nueva generación del modelo de lenguaje de Hunyuan, que utiliza una nueva estructura de modelo de expertos mixtos (MoE), con una eficiencia de inferencia más rápida y un rendimiento más fuerte en comparación con Hunyuan-Pro."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "Actualización de la base de preentrenamiento, mejora en la escritura y comprensión lectora, aumento significativo en habilidades de programación y ciencias, y progreso continuo en el seguimiento de instrucciones complejas."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "Mejora en la calidad de los datos base de preentrenamiento. Optimización de la estrategia de entrenamiento en la fase postentrenamiento, con mejoras continuas en capacidades de agente, idiomas menores en inglés, cumplimiento de instrucciones, código y ciencias."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS es la última versión del modelo insignia Hunyuan, con una mayor capacidad de pensamiento y una mejor experiencia."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 es un modelo base con arquitectura MoE que ofrece potentes capacidades para código y agentes, con 1T parámetros totales y 32B parámetros activados. En las pruebas de referencia en categorías principales como razonamiento de conocimiento general, programación, matemáticas y agentes, el rendimiento del modelo K2 supera al de otros modelos de código abierto más extendidos."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 es un modelo de lenguaje de expertos mixtos a gran escala (MoE) desarrollado por la IA del lado oscuro de la luna, con un total de un billón de parámetros y 32 mil millones de parámetros activados por cada pasada hacia adelante. Está optimizado para capacidades de agente, incluyendo el uso avanzado de herramientas, razonamiento y síntesis de código."
+  },
   "kimi-latest": {
     "description": "El producto asistente inteligente Kimi utiliza el último modelo grande de Kimi, que puede incluir características que aún no están estables. Soporta la comprensión de imágenes y seleccionará automáticamente el modelo de facturación de 8k/32k/128k según la longitud del contexto de la solicitud."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V es la última generación de modelo de lenguaje visual (VLM) publicada por Zhipu AI. Este modelo se basa en el modelo de texto insignia GLM-4.5-Air, que cuenta con 106.000 millones de parámetros totales y 12.000 millones de parámetros de activación, y emplea una arquitectura de expertos mixtos (MoE) para lograr un rendimiento excelente con un coste de inferencia reducido. Técnicamente, GLM-4.5V continúa la línea de GLM-4.1V-Thinking e introduce innovaciones como el codificado rotacional de posiciones en 3D (3D-RoPE), que mejora de forma notable la percepción y el razonamiento sobre las relaciones en el espacio tridimensional. Gracias a optimizaciones en preentrenamiento, ajuste supervisado y aprendizaje por refuerzo, este modelo es capaz de procesar diversos tipos de contenido visual, como imágenes, vídeo y documentos largos, y ha alcanzado niveles punteros entre los modelos open source de su categoría en 41 benchmarks multimodales públicos. Además, el modelo incorpora un interruptor de 'modo de pensamiento' que permite a los usuarios alternar entre respuestas rápidas y razonamiento profundo para equilibrar eficiencia y rendimiento."
   },
+  "zai-org/GLM-4.6": {
+    "description": "En comparación con GLM-4.5, GLM-4.6 presenta varias mejoras clave. Su ventana de contexto se amplió de 128K a 200K tokens, permitiendo al modelo manejar tareas de agente más complejas. El modelo obtuvo puntuaciones más altas en pruebas de referencia de código y mostró un rendimiento superior en aplicaciones como Claude Code, Cline, Roo Code y Kilo Code, incluyendo mejoras en la generación de interfaces front-end visualmente refinadas. GLM-4.6 exhibe un rendimiento de inferencia notablemente mejorado y soporta el uso de herramientas durante la inferencia, lo que aporta una capacidad integral más fuerte. Destaca en el uso de herramientas y agentes basados en búsqueda, y se integra de manera más efectiva en marcos de agentes. En escritura, el modelo se ajusta mejor a las preferencias humanas en estilo y legibilidad, y se comporta de forma más natural en escenarios de juego de roles."
+  },
   "zai/glm-4.5": {
     "description": "La serie de modelos GLM-4.5 está diseñada específicamente como modelos base para agentes inteligentes. El modelo insignia GLM-4.5 integra 355 mil millones de parámetros totales (32 mil millones activos), unificando razonamiento, codificación y capacidades de agente para abordar demandas complejas de aplicaciones. Como sistema de razonamiento híbrido, ofrece modos de operación dual."
   },

locales/es-ES/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "Los modelos ofrecidos por Ollama abarcan ampliamente áreas como la generación de código, cálculos matemáticos, procesamiento multilingüe e interacciones conversacionales, apoyando diversas necesidades de implementación empresarial y local."
   },
+  "ollamacloud": {
+    "description": "Ollama Cloud ofrece un servicio de inferencia alojado oficialmente, acceso inmediato a la biblioteca de modelos de Ollama y soporte para interfaces compatibles con OpenAI."
+  },
   "openai": {
     "description": "OpenAI es una de las principales instituciones de investigación en inteligencia artificial a nivel mundial, cuyos modelos, como la serie GPT, están a la vanguardia del procesamiento del lenguaje natural. OpenAI se dedica a transformar múltiples industrias a través de soluciones de IA innovadoras y eficientes. Sus productos ofrecen un rendimiento y una rentabilidad significativos, siendo ampliamente utilizados en investigación, negocios y aplicaciones innovadoras."
   },

locales/es-ES/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "Error de ejecución",
+    "executing": "Ejecutando...",
+    "files": "Archivos:",
+    "output": "Salida:",
+    "returnValue": "Valor devuelto:"
+  },
   "dalle": {
     "autoGenerate": "Auto-generar",
     "downloading": "El enlace de la imagen generada por DALL·E 3 solo es válido durante 1 hora, descargando la imagen al dispositivo local...",

locales/fa-IR/chat.json

@@ -3,8 +3,8 @@
     "title": "مدل"
   },
   "agentDefaultMessage": "سلام، من **{{name}}** هستم. می‌توانید همین حالا با من گفتگو را شروع کنید یا به [تنظیمات دستیار]({{url}}) بروید و اطلاعات من را تکمیل کنید.",
-  "agentDefaultMessageWithSystemRole": "سلام، من **{{name}}** هستم، {{systemRole}}، بیایید گفتگو را شروع کنیم!",
-  "agentDefaultMessageWithoutEdit": "سلام، من **{{name}}** هستم، بیایید گفتگو را شروع کنیم!",
+  "agentDefaultMessageWithSystemRole": "سلام، من **{{name}}** هستم، چگونه می‌توانم به شما کمک کنم؟",
+  "agentDefaultMessageWithoutEdit": "سلام، من **{{name}}** هستم، چگونه می‌توانم به شما کمک کنم؟",
   "agents": "دستیار",
   "artifact": {
     "generating": "در حال تولید",
@@ -150,6 +150,11 @@
       "total": "مجموع مصرف"
     }
   },
+  "minimap": {
+    "jumpToMessage": "رفتن به پیام شماره {{index}}",
+    "nextMessage": "پیام بعدی",
+    "previousMessage": "پیام قبلی"
+  },
   "newAgent": "دستیار جدید",
   "pin": "سنجاق کردن",
   "pinOff": "لغو سنجاق",

locales/fa-IR/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "توصیف محتوایی که می‌خواهید تولید شود"
     },
+    "quality": {
+      "label": "کیفیت تصویر",
+      "options": {
+        "hd": "وضوح بالا",
+        "standard": "استاندارد"
+      }
+    },
     "seed": {
       "label": "بذر",
       "random": "بذر تصادفی"

locales/fa-IR/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "حداکثر پنجره زمینه",
           "unlimited": "بدون محدودیت"
         },
+        "type": {
+          "extra": "انواع مختلف مدل‌ها دارای سناریوها و قابلیت‌های متفاوتی هستند",
+          "options": {
+            "chat": "گفتگو",
+            "embedding": "بردار‌سازی",
+            "image": "تولید تصویر",
+            "realtime": "گفتگوی زنده",
+            "stt": "تبدیل گفتار به متن",
+            "text2music": "تبدیل متن به موسیقی",
+            "text2video": "تبدیل متن به ویدئو",
+            "tts": "تبدیل متن به گفتار"
+          },
+          "placeholder": "لطفاً نوع مدل را انتخاب کنید",
+          "title": "نوع مدل"
+        },
         "vision": {
           "extra": "این پیکربندی تنها قابلیت بارگذاری تصویر در برنامه را فعال می‌کند، اینکه آیا شناسایی پشتیبانی می‌شود به خود مدل بستگی دارد، لطفاً قابلیت استفاده از شناسایی بصری این مدل را آزمایش کنید",
           "title": "پشتیبانی از شناسایی بصری"

locales/fa-IR/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 حالت تفکری؛ DeepSeek-V3.1 مدل استدلال ترکیبی جدیدی از DeepSeek است که از دو حالت استدلال تفکری و غیرتفکری پشتیبانی می‌کند و نسبت به DeepSeek-R1-0528 در حالت تفکری کارایی بالاتری دارد. پس از آموزش تکمیلی، استفاده از ابزارهای عامل و عملکرد در وظایف عامل به‌طور قابل توجهی بهبود یافته است."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 جدیدترین مدل عمومی منتشر شده توسط DeepSeek است که از معماری استنتاج ترکیبی پشتیبانی می‌کند و دارای قابلیت‌های پیشرفته‌تر عامل (Agent) می‌باشد."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "حالت تفکر DeepSeek V3.2. قبل از ارائه پاسخ نهایی، مدل ابتدا یک زنجیره فکری را تولید می‌کند تا دقت پاسخ نهایی را افزایش دهد."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite دارای سرعت پاسخگویی بی‌نظیر و نسبت قیمت به کارایی بهتر است و گزینه‌های انعطاف‌پذیرتری را برای سناریوهای مختلف مشتریان ارائه می‌دهد. از پنجره متنی 128k برای استدلال و تنظیم دقیق پشتیبانی می‌کند."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 یک مدل زبان بزرگ با حالت ترکیبی است که توسط DeepSeek AI منتشر شده و در مقایسه با نسخه‌های قبلی خود به‌روزرسانی‌های مهمی را تجربه کرده است. نوآوری اصلی این مدل ادغام «حالت تفکر» و «حالت غیرتفکر» در یک مدل است که کاربران می‌توانند با تنظیم قالب گفتگو به صورت انعطاف‌پذیر بین آن‌ها جابجا شوند تا نیازهای مختلف وظایف را برآورده کنند. با بهینه‌سازی پس از آموزش تخصصی، عملکرد V3.1 در فراخوانی ابزارها و وظایف Agent به طور قابل توجهی افزایش یافته و پشتیبانی بهتری از ابزارهای جستجوی خارجی و اجرای وظایف پیچیده چندمرحله‌ای ارائه می‌دهد. این مدل بر پایه DeepSeek-V3.1-Base آموزش داده شده و با روش توسعه متن بلند دو مرحله‌ای، حجم داده‌های آموزشی را به طور چشمگیری افزایش داده است که باعث بهبود عملکرد در پردازش اسناد طولانی و کدهای بلند می‌شود. به عنوان یک مدل متن‌باز، DeepSeek-V3.1 در آزمون‌های معیار مختلفی مانند کدنویسی، ریاضیات و استدلال توانایی‌هایی در حد مدل‌های بسته پیشرفته نشان می‌دهد و با معماری متخصص ترکیبی (MoE) خود، ضمن حفظ ظرفیت عظیم مدل، هزینه‌های استدلال را به طور موثری کاهش می‌دهد."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus نسخه به‌روزرسانی شده مدل V3.1 منتشر شده توسط DeepSeek است که به عنوان یک مدل زبان بزرگ با عامل ترکیبی شناخته می‌شود. این به‌روزرسانی ضمن حفظ قابلیت‌های اصلی مدل، بر رفع مشکلات گزارش شده توسط کاربران و افزایش پایداری تمرکز دارد. این نسخه به طور قابل توجهی انسجام زبانی را بهبود بخشیده و از بروز ترکیب زبان چینی و انگلیسی و کاراکترهای نامتعارف کاسته است. مدل شامل حالت «تفکر» (Thinking Mode) و «غیرتفکر» (Non-thinking Mode) است که کاربران می‌توانند از طریق قالب‌های گفتگو به صورت انعطاف‌پذیر بین آن‌ها جابجا شوند تا با وظایف مختلف سازگار شوند. به عنوان یک بهینه‌سازی مهم، V3.1-Terminus عملکرد عامل کد (Code Agent) و عامل جستجو (Search Agent) را تقویت کرده است تا در فراخوانی ابزارها و اجرای وظایف پیچیده چندمرحله‌ای قابل اعتمادتر باشد."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 جدیدترین و قدرتمندترین نسخه Kimi K2 است. این مدل یک مدل زبان برتر با معماری متخصص ترکیبی (MoE) است که دارای ۱ تریلیون پارامتر کل و ۳۲ میلیارد پارامتر فعال می‌باشد. ویژگی‌های اصلی این مدل شامل: هوش کدگذاری عامل بهبود یافته که در آزمون‌های معیار عمومی و وظایف واقعی کدگذاری عامل عملکرد قابل توجهی نشان می‌دهد؛ تجربه کدگذاری فرانت‌اند بهبود یافته که از نظر زیبایی و کاربردی بودن برنامه‌نویسی فرانت‌اند پیشرفت داشته است."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 بهبود قابل توجهی بر توانایی‌های پیشرو در صنعت Sonnet 3.7 دارد و در کدنویسی عملکرد برجسته‌ای با 72.7% در SWE-bench ارائه می‌دهد. این مدل تعادل بین عملکرد و کارایی را حفظ کرده و برای موارد استفاده داخلی و خارجی مناسب است و با کنترل‌پذیری بهبود یافته، کنترل بیشتری بر نتایج فراهم می‌کند."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "کلود سونت ۴.۵ هوشمندترین مدل تا به امروز شرکت Anthropic است."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B یک مدل زبان بزرگ پراکنده با 72 میلیارد پارامتر و 16 میلیارد پارامتر فعال است که بر اساس معماری متخصصان ترکیبی گروه‌بندی شده (MoGE) ساخته شده است. در مرحله انتخاب متخصص، متخصصان به گروه‌هایی تقسیم می‌شوند و توکن‌ها در هر گروه به تعداد مساوی متخصصان فعال می‌شوند تا تعادل بار متخصصان حفظ شود، که به طور قابل توجهی کارایی استقرار مدل را در پلتفرم Ascend افزایش می‌دهد."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "مدل تفکر Claude Sonnet 4 می‌تواند پاسخ‌های تقریباً فوری یا تفکر گام به گام طولانی‌مدت تولید کند که کاربران می‌توانند این فرآیندها را به وضوح مشاهده کنند."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "کلود سونت ۴.۵ هوشمندترین مدل تا به امروز شرکت Anthropic است."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 یک دستیار برنامه‌نویسی قدرتمند مبتنی بر هوش مصنوعی است که از پرسش و پاسخ هوشمند و تکمیل کد در زبان‌های برنامه‌نویسی مختلف پشتیبانی می‌کند و بهره‌وری توسعه را افزایش می‌دهد."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 یک مدل زبان بزرگ با حالت ترکیبی است که توسط DeepSeek AI منتشر شده و در مقایسه با نسخه‌های قبلی خود به‌روزرسانی‌های مهمی را تجربه کرده است. نوآوری اصلی این مدل ادغام «حالت تفکر» و «حالت غیرتفکر» در یک مدل است که کاربران می‌توانند با تنظیم قالب گفتگو به صورت انعطاف‌پذیر بین آن‌ها جابجا شوند تا نیازهای مختلف وظایف را برآورده کنند. با بهینه‌سازی پس از آموزش تخصصی، عملکرد V3.1 در فراخوانی ابزارها و وظایف Agent به طور قابل توجهی افزایش یافته و پشتیبانی بهتری از ابزارهای جستجوی خارجی و اجرای وظایف پیچیده چندمرحله‌ای ارائه می‌دهد. این مدل بر پایه DeepSeek-V3.1-Base آموزش داده شده و با روش توسعه متن بلند دو مرحله‌ای، حجم داده‌های آموزشی را به طور چشمگیری افزایش داده است که باعث بهبود عملکرد در پردازش اسناد طولانی و کدهای بلند می‌شود. به عنوان یک مدل متن‌باز، DeepSeek-V3.1 در آزمون‌های معیار مختلفی مانند کدنویسی، ریاضیات و استدلال توانایی‌هایی در حد مدل‌های بسته پیشرفته نشان می‌دهد و با معماری متخصص ترکیبی (MoE) خود، ضمن حفظ ظرفیت عظیم مدل، هزینه‌های استدلال را به طور موثری کاهش می‌دهد."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus نسخه به‌روزرسانی شده مدل V3.1 منتشر شده توسط DeepSeek است که به عنوان یک مدل زبان بزرگ با عامل ترکیبی شناخته می‌شود. این به‌روزرسانی ضمن حفظ قابلیت‌های اصلی مدل، بر رفع مشکلات گزارش شده توسط کاربران و افزایش پایداری تمرکز دارد. این نسخه به طور قابل توجهی انسجام زبانی را بهبود بخشیده و از بروز ترکیب زبان چینی و انگلیسی و کاراکترهای نامتعارف کاسته است. مدل شامل حالت «تفکر» (Thinking Mode) و «غیرتفکر» (Non-thinking Mode) است که کاربران می‌توانند از طریق قالب‌های گفتگو به صورت انعطاف‌پذیر بین آن‌ها جابجا شوند تا با وظایف مختلف سازگار شوند. به عنوان یک بهینه‌سازی مهم، V3.1-Terminus عملکرد عامل کد (Code Agent) و عامل جستجو (Search Agent) را تقویت کرده است تا در فراخوانی ابزارها و اجرای وظایف پیچیده چندمرحله‌ای قابل اعتمادتر باشد."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek LLM Chat (67B) یک مدل نوآورانه هوش مصنوعی است که توانایی درک عمیق زبان و تعامل را فراهم می‌کند."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: مدل استنتاج نسل بعدی که توانایی‌های استنتاج پیچیده و تفکر زنجیره‌ای را بهبود بخشیده و برای وظایفی که نیاز به تحلیل عمیق دارند مناسب است."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: نسل جدیدی از مدل‌های استنتاج که توانایی استدلال پیچیده و تفکر زنجیره‌ای را بهبود می‌بخشد، مناسب برای وظایفی که نیاز به تحلیل عمیق دارند."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 یک مدل زبانی بصری مبتنی بر DeepSeekMoE-27B است که از معماری MoE با فعال‌سازی پراکنده استفاده می‌کند و در حالی که تنها 4.5 میلیارد پارامتر فعال است، عملکرد فوق‌العاده‌ای را ارائه می‌دهد. این مدل در چندین وظیفه از جمله پرسش و پاسخ بصری، شناسایی کاراکتر نوری، درک اسناد/جدول‌ها/نمودارها و مکان‌یابی بصری عملکرد عالی دارد."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 نسخه کامل است که دارای 671B پارامتر است و از جستجوی آنلاین زنده پشتیبانی می‌کند و دارای توانایی‌های درک و تولید قوی‌تری است."
   },
   "deepseek-reasoner": {
-    "description": "حالت تفکر DeepSeek V3.1. قبل از ارائه پاسخ نهایی، مدل یک زنجیره فکری را تولید می‌کند تا دقت پاسخ نهایی را افزایش دهد."
+    "description": "حالت تفکر DeepSeek V3.2. قبل از ارائه پاسخ نهایی، مدل ابتدا یک زنجیره فکری را تولید می‌کند تا دقت پاسخ نهایی را افزایش دهد."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 یک مدل زبانی Mixture-of-Experts کارآمد است که برای پردازش نیازهای اقتصادی و کارآمد مناسب می‌باشد."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: مدل استنتاج نسل بعدی که توانایی‌های استنتاج پیچیده و تفکر زنجیره‌ای را بهبود بخشیده و برای وظایفی که نیاز به تحلیل عمیق دارند مناسب است."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp مکانیزم توجه پراکنده را معرفی می‌کند که هدف آن افزایش کارایی آموزش و استنتاج در پردازش متون بلند است و قیمت آن کمتر از deepseek-v3.1 می‌باشد."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 یک مدل ترکیبی متخصص با 685B پارامتر است و جدیدترین نسخه از سری مدل‌های چت پرچمدار تیم DeepSeek می‌باشد.\n\nاین مدل از [DeepSeek V3](/deepseek/deepseek-chat-v3) به ارث برده و در انواع وظایف عملکرد عالی از خود نشان می‌دهد."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] یک مدل تولید تصویر با 12 میلیارد پارامتر است که بر تولید سریع تصاویر با کیفیت بالا تمرکز دارد."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "یک مدل قدرتمند بومی تولید تصویر چندوجهی"
+  },
   "fal-ai/imagen4/preview": {
     "description": "مدل تولید تصویر با کیفیت بالا ارائه شده توسط گوگل"
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash مدل با بهترین نسبت قیمت به کارایی گوگل است که امکانات جامع را ارائه می‌دهد."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana جدیدترین، سریع‌ترین و کارآمدترین مدل چندرسانه‌ای بومی گوگل است که به شما امکان می‌دهد از طریق گفتگو تصاویر را تولید و ویرایش کنید."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana جدیدترین، سریع‌ترین و کارآمدترین مدل چندرسانه‌ای بومی گوگل است که به شما امکان می‌دهد از طریق گفتگو تصاویر را تولید و ویرایش کنید."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana جدیدترین، سریع‌ترین و کارآمدترین مدل چندرسانه‌ای بومی گوگل است که به شما امکان می‌دهد از طریق گفتگو تصاویر را تولید و ویرایش کنید."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana جدیدترین، سریع‌ترین و کارآمدترین مدل چندرسانه‌ای بومی گوگل است که به شما امکان می‌دهد از طریق گفتگو تصاویر را تولید و ویرایش کنید."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite کوچک‌ترین و مقرون‌به‌صرفه‌ترین مدل گوگل است که برای استفاده در مقیاس وسیع طراحی شده است."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview کوچک‌ترین و مقرون‌به‌صرفه‌ترین مدل گوگل است که برای استفاده در مقیاس بزرگ طراحی شده است."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "نسخه پیش‌نمایش (25 سپتامبر 2025) از Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "پیش‌نمایش فلش Gemini 2.5 مدل با بهترین قیمت و کیفیت گوگل است که امکانات جامع و کاملی را ارائه می‌دهد."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview مقرون‌به‌صرفه‌ترین مدل گوگل است که امکانات جامع ارائه می‌دهد."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "نسخه پیش‌نمایش (25 سپتامبر 2025) از Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro پیشرفته‌ترین مدل تفکر گوگل است که قادر به استنتاج مسائل پیچیده در حوزه کد، ریاضیات و STEM بوده و با استفاده از زمینه طولانی، تحلیل مجموعه داده‌ها، کدها و مستندات بزرگ را انجام می‌دهد."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview پیشرفته‌ترین مدل تفکر گوگل است که قادر به استدلال درباره مسائل پیچیده در حوزه کد، ریاضیات و STEM است و می‌تواند با استفاده از زمینه طولانی، داده‌های بزرگ، مخازن کد و مستندات را تحلیل کند."
   },
+  "gemini-flash-latest": {
+    "description": "جدیدترین نسخه Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "جدیدترین نسخه Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "جدیدترین نسخه Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B برای پردازش وظایف کوچک و متوسط مناسب است و از نظر هزینه مؤثر است."
   },
@@ -1437,7 +1485,7 @@
     "description": "سری مدل‌های GLM-4.1V-Thinking قوی‌ترین مدل‌های زبان تصویری (VLM) در سطح 10 میلیارد پارامتر شناخته شده تا کنون هستند که وظایف زبان تصویری پیشرفته هم‌رده SOTA را شامل می‌شوند، از جمله درک ویدئو، پرسش و پاسخ تصویری، حل مسائل علمی، شناسایی متن OCR، تفسیر اسناد و نمودارها، عامل‌های رابط کاربری گرافیکی، کدنویسی صفحات وب فرانت‌اند، و گراندینگ. توانایی‌های این مدل‌ها حتی از مدل Qwen2.5-VL-72B با 8 برابر پارامتر بیشتر نیز فراتر رفته است. با استفاده از فناوری پیشرفته یادگیری تقویتی، مدل توانسته است با استدلال زنجیره تفکر دقت و غنای پاسخ‌ها را افزایش دهد و از نظر نتایج نهایی و قابلیت تبیین به طور قابل توجهی از مدل‌های غیرتفکری سنتی پیشی بگیرد."
   },
   "glm-4.5": {
-    "description": "جدیدترین مدل پرچمدار Zhizhu که از حالت تفکر پشتیبانی می‌کند و توانایی‌های جامع آن به سطح SOTA مدل‌های متن‌باز رسیده است و طول زمینه تا 128 هزار توکن را پشتیبانی می‌کند."
+    "description": "مدل پرچمدار Zhipu که از حالت‌های تفکر متنوع پشتیبانی می‌کند، توانایی‌های جامع آن به سطح SOTA مدل‌های متن‌باز رسیده و طول متن زمینه‌ای تا ۱۲۸ هزار کاراکتر را پشتیبانی می‌کند."
   },
   "glm-4.5-air": {
     "description": "نسخه سبک GLM-4.5 که تعادل بین عملکرد و هزینه را حفظ می‌کند و امکان تغییر انعطاف‌پذیر بین مدل‌های تفکر ترکیبی را فراهم می‌آورد."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "نسل جدید مدل استنتاج بصری Zhipu مبتنی بر معماری MOE، با مجموع 106B پارامتر و 12B پارامتر فعال، در انواع بنچ‌مارک‌ها به SOTA در میان مدل‌های چندمودال متن‌باز هم‌رده در سطح جهانی دست یافته است و وظایف متداولی مانند درک تصویر، ویدئو، اسناد و تعامل با رابط‌های گرافیکی (GUI) را پوشش می‌دهد."
   },
+  "glm-4.6": {
+    "description": "جدیدترین مدل پرچمدار Zhipu، GLM-4.6 (۳۵۵ میلیارد پارامتر)، در کدگذاری پیشرفته، پردازش متون بلند، استنتاج و توانایی‌های عامل هوشمند به طور کامل از نسل قبلی پیشی گرفته است، به ویژه در توانایی برنامه‌نویسی که با Claude Sonnet 4 هم‌تراز است و به یکی از برترین مدل‌های کدینگ داخلی تبدیل شده است."
+  },
   "glm-4v": {
     "description": "GLM-4V قابلیت‌های قدرتمندی در درک و استدلال تصویری ارائه می‌دهد و از وظایف مختلف بصری پشتیبانی می‌کند."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "سریع‌ترین و اقتصادی‌ترین نسخه GPT-5. بسیار مناسب برای کاربردهایی که نیاز به پاسخ سریع و حساسیت به هزینه دارند."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 pro با استفاده از محاسبات بیشتر، عمیق‌تر می‌اندیشد و به طور مداوم پاسخ‌های بهتری ارائه می‌دهد."
+  },
   "gpt-audio": {
     "description": "GPT Audio مدلی عمومی برای چت با ورودی و خروجی صوتی است که از استفاده از ورودی/خروجی صوتی در API تکمیل چت پشتیبانی می‌کند."
   },
   "gpt-image-1": {
     "description": "مدل تولید تصویر چندرسانه‌ای بومی ChatGPT"
   },
+  "gpt-image-1-mini": {
+    "description": "نسخه‌ای مقرون‌به‌صرفه‌تر از GPT Image 1 که به‌صورت بومی از ورودی‌های متنی و تصویری پشتیبانی می‌کند و خروجی تصویری تولید می‌نماید."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4: ساختار ترنسفورمر کوانتیزه شده که حتی در منابع محدود عملکرد قوی خود را حفظ می‌کند."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "توانایی‌های مدل اصلی تفکر کند به‌طور قابل توجهی در زمینه‌های ریاضیات پیشرفته، استدلال پیچیده، کدهای دشوار، پیروی از دستورالعمل‌ها و کیفیت تولید متن بهبود یافته است."
   },
-  "hunyuan-t1-vision": {
-    "description": "مدل تفکر عمیق چندرسانه‌ای Hunyuan که از زنجیره تفکر بلند بومی چندرسانه‌ای پشتیبانی می‌کند، در پردازش انواع سناریوهای استدلال تصویری مهارت دارد و در مسائل علمی نسبت به مدل تفکر سریع بهبود قابل توجهی دارد."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "جدیدترین مدل تفکر عمیق چندرسانه‌ای t1-vision از Hunyuan که از زنجیره تفکر بلند چندرسانه‌ای بومی پشتیبانی می‌کند و نسبت به نسخه پیش‌فرض نسل قبلی به طور کامل بهبود یافته است."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "مدل تفکر عمیق چندرسانه‌ای Hunyuan که از زنجیره‌های فکری بومی چندرسانه‌ای پشتیبانی می‌کند و در پردازش انواع سناریوهای استنتاج تصویری مهارت دارد، در حل مسائل علمی نسبت به مدل تفکر سریع بهبود قابل توجهی یافته است."
+  },
   "hunyuan-turbo": {
     "description": "نسخه پیش‌نمایش مدل زبان بزرگ نسل جدید HunYuan که از ساختار مدل متخصص ترکیبی (MoE) جدید استفاده می‌کند. در مقایسه با hunyuan-pro، کارایی استنتاج سریع‌تر و عملکرد بهتری دارد."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "ارتقاء پایه پیش‌آموزش، بهبود توانایی‌های نوشتن و درک مطلب، افزایش قابل توجه توانایی‌های کدنویسی و علوم پایه، و بهبود مستمر در پیروی از دستورات پیچیده."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "ارتقاء کیفیت داده‌های پایه پیش‌آموزش. بهینه‌سازی استراتژی آموزش در مرحله پس‌آموزش، با هدف بهبود مستمر قابلیت‌های عامل، زبان‌های کوچک انگلیسی، پیروی از دستورات، کدنویسی و علوم پایه."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS آخرین نسخه مدل بزرگ پرچمدار مختلط است که دارای توانایی تفکر قوی‌تر و تجربه بهتری است."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 یک مدل پایه با معماری MoE است که دارای توانمندی‌های بسیار قوی در حوزهٔ برنامه‌نویسی و عامل‌ها (Agent) می‌باشد. مجموع پارامترها 1T و پارامترهای فعال‌شده 32B است. در آزمون‌های بنچمارک در دسته‌های اصلی مانند استدلال دانش عمومی، برنامه‌نویسی، ریاضیات و Agent، عملکرد مدل K2 از سایر مدل‌های متن‌باز مرسوم پیشی گرفته است."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 یک مدل زبان متخصص ترکیبی بزرگ‌مقیاس (MoE) است که توسط هوش مصنوعی ماه تاریک توسعه یافته است، با مجموع ۱ تریلیون پارامتر و ۳۲ میلیارد پارامتر فعال در هر عبور رو به جلو. این مدل برای توانمندی‌های نمایندگی بهینه شده است، از جمله استفاده پیشرفته از ابزارها، استدلال و ترکیب کد."
+  },
   "kimi-latest": {
     "description": "محصول دستیار هوشمند کیمی از جدیدترین مدل بزرگ کیمی استفاده می‌کند و ممکن است شامل ویژگی‌های ناپایدار باشد. از درک تصویر پشتیبانی می‌کند و به‌طور خودکار بر اساس طول متن درخواست، مدل‌های 8k/32k/128k را به‌عنوان مدل محاسبه انتخاب می‌کند."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V نسل جدیدی از مدل‌های زبان-بینایی (VLM) است که توسط Zhipu AI (智谱 AI) منتشر شده. این مدل بر پایهٔ مدل متنی پرچم‌دار GLM-4.5-Air ساخته شده که دارای 106 میلیارد پارامتر کل و 12 میلیارد پارامتر فعال‌سازی است؛ از معماری متخصصان ترکیبی (MoE) بهره می‌برد و هدفش ارائهٔ عملکرد برجسته با هزینهٔ استدلال کمتر است. از منظر فناوری، GLM-4.5V راهبرد GLM-4.1V-Thinking را ادامه می‌دهد و نوآوری‌هایی مانند کدگذاری موقعیت چرخشی سه‌بعدی (3D-RoPE) را معرفی کرده که به‌طور چشمگیری درک و استدلال نسبت‌های فضایی سه‌بعدی را تقویت می‌کند. با بهینه‌سازی در مراحل پیش‌آموزش، ریزتنظیم نظارتی و یادگیری تقویتی، این مدل قادر به پردازش انواع محتواهای بصری از جمله تصویر، ویدیو و اسناد بلند شده و در 41 معیار چندوجهی عمومی به سطح برتر مدل‌های متن‌باز هم‌رده دست یافته است. علاوه بر این، یک سوئیچ «حالت تفکر» به مدل افزوده شده که به کاربران اجازه می‌دهد بین پاسخ‌دهی سریع و استدلال عمیق به‌صورت انعطاف‌پذیر انتخاب کنند تا تعادل بین کارایی و کیفیت برقرار شود."
   },
+  "zai-org/GLM-4.6": {
+    "description": "در مقایسه با GLM-4.5، GLM-4.6 چندین بهبود کلیدی را به همراه دارد. پنجره متنی آن از 128K به 200K توکن افزایش یافته است که امکان پردازش وظایف پیچیده‌تر عامل را فراهم می‌کند. مدل در آزمون‌های معیار کد امتیاز بالاتری کسب کرده و در برنامه‌هایی مانند Claude Code، Cline، Roo Code و Kilo Code عملکرد واقعی بهتری نشان داده است، از جمله بهبود در تولید صفحات فرانت‌اند با جلوه‌های بصری دقیق. GLM-4.6 در عملکرد استنتاج پیشرفت قابل توجهی داشته و از استفاده از ابزارها در حین استنتاج پشتیبانی می‌کند که منجر به توانمندی جامع‌تر شده است. این مدل در استفاده از ابزارها و عامل‌های مبتنی بر جستجو قوی‌تر است و می‌تواند به طور مؤثرتری در چارچوب‌های عامل ادغام شود. در زمینه نگارش، این مدل سبک و خوانایی بهتری دارد که با ترجیحات انسانی همخوانی دارد و در سناریوهای نقش‌آفرینی طبیعی‌تر عمل می‌کند."
+  },
   "zai/glm-4.5": {
     "description": "مجموعه مدل‌های GLM-4.5 مدل‌های پایه طراحی شده برای نمایندگان هوشمند هستند. مدل پرچمدار GLM-4.5 با 355 میلیارد پارامتر کل (32 میلیارد فعال) یکپارچه‌سازی استدلال، کدنویسی و توانایی‌های نمایندگی را برای حل نیازهای پیچیده برنامه‌ها ارائه می‌دهد. به عنوان یک سیستم استدلال ترکیبی، دو حالت عملیاتی دارد."
   },

locales/fa-IR/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "مدل‌های ارائه‌شده توسط Ollama طیف گسترده‌ای از تولید کد، محاسبات ریاضی، پردازش چندزبانه و تعاملات گفتگویی را پوشش می‌دهند و از نیازهای متنوع استقرار در سطح سازمانی و محلی پشتیبانی می‌کنند."
   },
+  "ollamacloud": {
+    "description": "Ollama Cloud خدمات استنتاج میزبانی شده رسمی را ارائه می‌دهد که به‌صورت آماده استفاده به کتابخانه مدل‌های Ollama دسترسی می‌دهد و از رابط‌های سازگار با OpenAI پشتیبانی می‌کند."
+  },
   "openai": {
     "description": "OpenAI یک موسسه پیشرو در تحقیقات هوش مصنوعی در سطح جهان است که مدل‌هایی مانند سری GPT را توسعه داده و مرزهای پردازش زبان طبیعی را پیش برده است. OpenAI متعهد به تغییر صنایع مختلف از طریق راه‌حل‌های نوآورانه و کارآمد هوش مصنوعی است. محصولات آن‌ها دارای عملکرد برجسته و اقتصادی بوده و به طور گسترده در تحقیقات، تجارت و کاربردهای نوآورانه استفاده می‌شوند."
   },

locales/fa-IR/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "خطا در اجرا",
+    "executing": "در حال اجرا...",
+    "files": "فایل‌ها:",
+    "output": "خروجی:",
+    "returnValue": "مقدار بازگشتی:"
+  },
   "dalle": {
     "autoGenerate": "تولید خودکار",
     "downloading": "لینک‌های تصاویر تولید شده توسط DallE3 فقط به مدت ۱ ساعت معتبر هستند، در حال ذخیره‌سازی تصاویر به صورت محلی...",

locales/fr-FR/chat.json

@@ -3,8 +3,8 @@
     "title": "Modèle"
   },
   "agentDefaultMessage": "Bonjour, je suis **{{name}}**, vous pouvez commencer à discuter avec moi immédiatement ou vous rendre dans [Paramètres de l'assistant]({{url}}) pour compléter mes informations.",
-  "agentDefaultMessageWithSystemRole": "Bonjour, je suis **{{name}}**, {{systemRole}}. Commençons la conversation !",
-  "agentDefaultMessageWithoutEdit": "Bonjour, je suis **{{name}}**. Commençons notre conversation !",
+  "agentDefaultMessageWithSystemRole": "Bonjour, je suis **{{name}}**, comment puis-je vous aider ?",
+  "agentDefaultMessageWithoutEdit": "Bonjour, je suis **{{name}}**, comment puis-je vous aider ?",
   "agents": "Assistant",
   "artifact": {
     "generating": "Génération en cours",
@@ -150,6 +150,11 @@
       "total": "Total consommé"
     }
   },
+  "minimap": {
+    "jumpToMessage": "Aller au message n° {{index}}",
+    "nextMessage": "Message suivant",
+    "previousMessage": "Message précédent"
+  },
   "newAgent": "Nouvel agent",
   "pin": "Épingler",
   "pinOff": "Désépingler",

locales/fr-FR/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "Décrivez ce que vous souhaitez générer"
     },
+    "quality": {
+      "label": "Qualité de l'image",
+      "options": {
+        "hd": "Haute définition",
+        "standard": "Standard"
+      }
+    },
     "seed": {
       "label": "Graine",
       "random": "Graine aléatoire"

locales/fr-FR/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "Fenêtre de contexte maximale",
           "unlimited": "Illimité"
         },
+        "type": {
+          "extra": "Différents types de modèles possèdent des scénarios d'utilisation et des capacités distincts",
+          "options": {
+            "chat": "Conversation",
+            "embedding": "Vectorisation",
+            "image": "Génération d'images",
+            "realtime": "Dialogue en temps réel",
+            "stt": "Reconnaissance vocale",
+            "text2music": "Texte en musique",
+            "text2video": "Texte en vidéo",
+            "tts": "Synthèse vocale"
+          },
+          "placeholder": "Veuillez sélectionner un type de modèle",
+          "title": "Type de modèle"
+        },
         "vision": {
           "extra": "Cette configuration n'activera que la configuration de téléchargement d'images dans l'application, la prise en charge de la reconnaissance dépend entièrement du modèle lui-même, veuillez tester la disponibilité des capacités de reconnaissance visuelle de ce modèle.",
           "title": "Reconnaissance visuelle prise en charge"

locales/fr-FR/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 - mode réflexion ; DeepSeek-V3.1 est un nouveau modèle de raisonnement hybride lancé par DeepSeek, supportant deux modes de raisonnement : avec et sans réflexion, avec une efficacité de réflexion supérieure à celle de DeepSeek-R1-0528. Optimisé par post-entraînement, l'utilisation des outils Agent et les performances dans les tâches d'agents ont été grandement améliorées."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 est le dernier modèle universel publié par DeepSeek, prenant en charge une architecture d'inférence hybride et offrant des capacités d'agent renforcées."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "Mode de réflexion DeepSeek V3.2. Avant de fournir la réponse finale, le modèle génère une chaîne de pensée pour améliorer la précision de la réponse."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite offre une vitesse de réponse exceptionnelle et un excellent rapport qualité-prix, offrant aux clients une flexibilité accrue pour différents scénarios. Prend en charge l'inférence et le fine-tuning avec une fenêtre contextuelle de 128k."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 est un grand modèle de langage hybride publié par DeepSeek AI, intégrant de nombreuses améliorations majeures par rapport à la génération précédente. Une innovation clé de ce modèle est l'intégration des modes « réflexion » (Thinking Mode) et « non-réflexion » (Non-thinking Mode), permettant aux utilisateurs de basculer facilement entre eux via des modèles de conversation adaptés aux différents besoins. Grâce à une optimisation post-entraînement spécifique, la version V3.1 améliore significativement les performances dans l'appel d'outils et les tâches d'agent, supportant mieux les outils de recherche externes et l'exécution de tâches complexes en plusieurs étapes. Basé sur DeepSeek-V3.1-Base, il bénéficie d'un entraînement supplémentaire avec une méthode d'extension de texte long en deux phases, augmentant considérablement la quantité de données d'entraînement pour une meilleure gestion des documents longs et des codes étendus. En tant que modèle open source, DeepSeek-V3.1 démontre des capacités comparables aux meilleurs modèles propriétaires dans plusieurs benchmarks en codage, mathématiques et raisonnement, tout en réduisant efficacement les coûts d'inférence grâce à son architecture à experts mixtes (MoE) qui maintient une grande capacité de modèle."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus est une version mise à jour du modèle V3.1 publiée par DeepSeek, positionnée comme un grand modèle de langage hybride pour agents intelligents. Cette mise à jour conserve les capacités originales du modèle tout en se concentrant sur la correction des problèmes signalés par les utilisateurs et l'amélioration de la stabilité. Elle améliore significativement la cohérence linguistique, réduisant le mélange de chinois et d'anglais ainsi que l'apparition de caractères anormaux. Le modèle intègre un « mode réflexion » (Thinking Mode) et un « mode non-réflexion » (Non-thinking Mode), permettant aux utilisateurs de basculer facilement entre ces modes via des modèles de conversation adaptés à différentes tâches. En tant qu'optimisation majeure, V3.1-Terminus renforce les performances des agents de code (Code Agent) et de recherche (Search Agent), rendant leur appel d'outils et l'exécution de tâches complexes en plusieurs étapes plus fiables."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 est la version la plus récente et la plus puissante de Kimi K2. Il s'agit d'un modèle linguistique de pointe à experts mixtes (MoE), avec un total de 1 000 milliards de paramètres et 32 milliards de paramètres activés. Les principales caractéristiques de ce modèle incluent : une intelligence de codage d'agents améliorée, démontrant des performances significatives dans les tests de référence publics et les tâches réelles d'agents de codage ; une expérience de codage frontale améliorée, avec des progrès tant en esthétique qu'en praticité pour la programmation frontale."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 améliore significativement les capacités de Sonnet 3.7, excelle en codage avec un score de pointe de 72,7 % sur SWE-bench. Ce modèle équilibre performance et efficacité, adapté aux cas d'usage internes et externes, avec un contrôle accru grâce à une meilleure contrôlabilité."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "Claude Sonnet 4.5 est le modèle le plus intelligent d'Anthropic à ce jour."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B est un grand modèle de langage sparse à 72 milliards de paramètres, avec 16 milliards de paramètres activés. Il repose sur une architecture Mixture of Experts groupée (MoGE), qui regroupe les experts lors de la sélection et contraint chaque token à activer un nombre égal d'experts dans chaque groupe, assurant ainsi un équilibre de charge entre les experts et améliorant considérablement l'efficacité de déploiement sur la plateforme Ascend."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "Le modèle de réflexion Claude Sonnet 4 produit des réponses quasi instantanées ou des raisonnements prolongés étape par étape, clairement visibles par l'utilisateur."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "Claude Sonnet 4.5 est le modèle le plus intelligent d'Anthropic à ce jour."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 est un puissant assistant de programmation AI, prenant en charge des questions intelligentes et l'achèvement de code dans divers langages de programmation, améliorant l'efficacité du développement."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 est un grand modèle de langage hybride publié par DeepSeek AI, intégrant de nombreuses améliorations majeures par rapport à la génération précédente. Une innovation clé de ce modèle est l'intégration des modes « réflexion » (Thinking Mode) et « non-réflexion » (Non-thinking Mode), permettant aux utilisateurs de basculer facilement entre eux via des modèles de conversation adaptés aux différents besoins. Grâce à une optimisation post-entraînement spécifique, la version V3.1 améliore significativement les performances dans l'appel d'outils et les tâches d'agent, supportant mieux les outils de recherche externes et l'exécution de tâches complexes en plusieurs étapes. Basé sur DeepSeek-V3.1-Base, il bénéficie d'un entraînement supplémentaire avec une méthode d'extension de texte long en deux phases, augmentant considérablement la quantité de données d'entraînement pour une meilleure gestion des documents longs et des codes étendus. En tant que modèle open source, DeepSeek-V3.1 démontre des capacités comparables aux meilleurs modèles propriétaires dans plusieurs benchmarks en codage, mathématiques et raisonnement, tout en réduisant efficacement les coûts d'inférence grâce à son architecture à experts mixtes (MoE) qui maintient une grande capacité de modèle."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus est une version mise à jour du modèle V3.1 publiée par DeepSeek, positionnée comme un grand modèle de langage hybride pour agents intelligents. Cette mise à jour conserve les capacités originales du modèle tout en se concentrant sur la correction des problèmes signalés par les utilisateurs et l'amélioration de la stabilité. Elle améliore significativement la cohérence linguistique, réduisant le mélange de chinois et d'anglais ainsi que l'apparition de caractères anormaux. Le modèle intègre un « mode réflexion » (Thinking Mode) et un « mode non-réflexion » (Non-thinking Mode), permettant aux utilisateurs de basculer facilement entre ces modes via des modèles de conversation adaptés à différentes tâches. En tant qu'optimisation majeure, V3.1-Terminus renforce les performances des agents de code (Code Agent) et de recherche (Search Agent), rendant leur appel d'outils et l'exécution de tâches complexes en plusieurs étapes plus fiables."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B est un modèle avancé formé pour des dialogues de haute complexité."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1 : modèle de raisonnement de nouvelle génération, améliorant les capacités de raisonnement complexe et de réflexion en chaîne, adapté aux tâches nécessitant une analyse approfondie."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1 : un modèle de raisonnement de nouvelle génération, améliorant les capacités de raisonnement complexe et de pensée en chaîne, idéal pour les tâches nécessitant une analyse approfondie."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 est un modèle de langage visuel à experts mixtes (MoE) développé sur la base de DeepSeekMoE-27B, utilisant une architecture MoE à activation sparse, réalisant des performances exceptionnelles tout en n'activant que 4,5 milliards de paramètres. Ce modèle excelle dans plusieurs tâches telles que la question-réponse visuelle, la reconnaissance optique de caractères, la compréhension de documents/tableaux/graphes et le positionnement visuel."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 version complète, avec 671B de paramètres, prenant en charge la recherche en ligne en temps réel, offrant des capacités de compréhension et de génération plus puissantes."
   },
   "deepseek-reasoner": {
-    "description": "DeepSeek V3.1 en mode réflexion. Avant de fournir la réponse finale, le modèle génère une chaîne de pensée pour améliorer la précision de la réponse finale."
+    "description": "Mode de réflexion DeepSeek V3.2. Avant de fournir la réponse finale, le modèle génère une chaîne de pensée pour améliorer la précision de la réponse."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 est un modèle de langage Mixture-of-Experts efficace, adapté aux besoins de traitement économique."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1 : modèle de raisonnement de nouvelle génération, améliorant les capacités de raisonnement complexe et de réflexion en chaîne, adapté aux tâches nécessitant une analyse approfondie."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp introduit un mécanisme d'attention parcimonieuse, visant à améliorer l'efficacité de l'entraînement et de l'inférence lors du traitement de longs textes, à un prix inférieur à celui de deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 est un modèle hybride d'experts avec 685B de paramètres, représentant la dernière itération de la série de modèles de chat phare de l'équipe DeepSeek.\n\nIl hérite du modèle [DeepSeek V3](/deepseek/deepseek-chat-v3) et excelle dans diverses tâches."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] est un modèle de génération d'images de 12 milliards de paramètres, spécialisé dans la génération rapide d'images de haute qualité."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "Un puissant modèle natif de génération d'images multimodales"
+  },
   "fal-ai/imagen4/preview": {
     "description": "Modèle de génération d'images de haute qualité fourni par Google."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash est le modèle le plus rentable de Google, offrant des fonctionnalités complètes."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana est le dernier modèle multimodal natif de Google, le plus rapide et le plus efficace, permettant de générer et d’éditer des images par conversation."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana est le tout dernier modèle multimodal natif de Google, le plus rapide et le plus efficace, qui vous permet de générer et d'éditer des images par conversation."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana est le tout dernier modèle multimodal natif de Google, le plus rapide et le plus efficace, qui vous permet de générer et d'éditer des images par conversation."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana est le dernier modèle multimodal natif de Google, le plus rapide et le plus efficace, permettant de générer et d’éditer des images par conversation."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite est le modèle le plus petit et le plus rentable de Google, conçu pour une utilisation à grande échelle."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview est le modèle le plus compact et rentable de Google, conçu pour une utilisation à grande échelle."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "Version de prévisualisation (25 septembre 2025) de Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview est le modèle le plus rentable de Google, offrant des fonctionnalités complètes."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview est le modèle le plus rentable de Google, offrant des fonctionnalités complètes."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "Version de prévisualisation (25 septembre 2025) de Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro est le modèle de raisonnement le plus avancé de Google, capable de traiter des problèmes complexes en code, mathématiques et domaines STEM, ainsi que d'analyser de grands ensembles de données, des bases de code et des documents avec un contexte étendu."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview est le modèle de pensée le plus avancé de Google, capable de raisonner sur des problèmes complexes en code, mathématiques et domaines STEM, ainsi que d'analyser de grands ensembles de données, bibliothèques de code et documents avec un contexte étendu."
   },
+  "gemini-flash-latest": {
+    "description": "Dernière version de Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "Dernière version de Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "Dernière version de Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B est adapté au traitement de tâches de taille moyenne, alliant coût et efficacité."
   },
@@ -1437,7 +1485,7 @@
     "description": "La série GLM-4.1V-Thinking est actuellement le modèle visuel le plus performant connu dans la catégorie des VLM de 10 milliards de paramètres. Elle intègre les meilleures performances SOTA dans diverses tâches de langage visuel, incluant la compréhension vidéo, les questions-réponses sur images, la résolution de problèmes disciplinaires, la reconnaissance OCR, l'interprétation de documents et graphiques, les agents GUI, le codage web frontal, le grounding, etc. Ses capacités surpassent même celles du Qwen2.5-VL-72B, qui possède plus de huit fois plus de paramètres. Grâce à des techniques avancées d'apprentissage par renforcement, le modèle maîtrise le raisonnement par chaîne de pensée, améliorant la précision et la richesse des réponses, surpassant nettement les modèles traditionnels sans mécanisme de pensée en termes de résultats finaux et d'explicabilité."
   },
   "glm-4.5": {
-    "description": "Le dernier modèle phare de Zhipu, supportant le mode réflexion, avec des capacités globales atteignant le niveau SOTA des modèles open source, et une longueur de contexte allant jusqu'à 128K tokens."
+    "description": "Modèle phare de Zhipu, supportant le changement de mode de réflexion, avec des capacités globales atteignant le niveau SOTA des modèles open source, et une longueur de contexte pouvant atteindre 128K."
   },
   "glm-4.5-air": {
     "description": "Version allégée de GLM-4.5, équilibrant performance et rapport qualité-prix, avec une commutation flexible entre modèles de réflexion hybrides."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "La nouvelle génération de modèle d'inférence visuelle de Zhipu, basée sur l'architecture MOE (Mixture-of-Experts), avec un total de 106 milliards de paramètres et 12 milliards de paramètres d'activation, atteint l'état de l'art (SOTA) parmi les modèles multimodaux open source de même niveau au niveau mondial sur divers benchmarks, couvrant les tâches courantes telles que la compréhension d'images, de vidéos, de documents et d'interfaces graphiques (GUI)."
   },
+  "glm-4.6": {
+    "description": "Le dernier modèle phare de Zhipu, GLM-4.6 (355B), surpasse entièrement la génération précédente en codage avancé, traitement de longs textes, inférence et capacités d'agent intelligent, notamment en alignant ses compétences en programmation avec Claude Sonnet 4, devenant ainsi le modèle de codage de pointe en Chine."
+  },
   "glm-4v": {
     "description": "GLM-4V offre de puissantes capacités de compréhension et de raisonnement d'image, prenant en charge diverses tâches visuelles."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "Version la plus rapide et la plus économique de GPT-5. Parfaitement adaptée aux scénarios nécessitant une réponse rapide et sensibles aux coûts."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 Pro utilise davantage de puissance de calcul pour approfondir sa réflexion et fournir des réponses toujours plus pertinentes."
+  },
   "gpt-audio": {
     "description": "GPT Audio est un modèle de chat universel orienté vers l'entrée et la sortie audio, supportant l'utilisation d'entrées/sorties audio dans l'API Chat Completions."
   },
   "gpt-image-1": {
     "description": "Modèle natif multimodal de génération d'images de ChatGPT."
   },
+  "gpt-image-1-mini": {
+    "description": "Une version plus économique de GPT Image 1, prenant en charge nativement les entrées texte et image, et générant des sorties visuelles."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4 : architecture Transformer quantifiée, offrant des performances solides même en ressources limitées."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "Amélioration significative des capacités du modèle principal de réflexion lente dans les domaines des mathématiques avancées, du raisonnement complexe, du code difficile, du respect des instructions et de la qualité de la création textuelle."
   },
-  "hunyuan-t1-vision": {
-    "description": "Modèle de réflexion profonde multimodal Hunyuan, supportant des chaînes de pensée natives multimodales longues, excellent dans divers scénarios d'inférence d'images, avec une amélioration globale par rapport aux modèles de pensée rapide dans les problèmes scientifiques."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "La dernière version du modèle de réflexion profonde multimodale t1-vision de Hunyuan, supportant une chaîne de pensée native multimodale, avec des améliorations globales par rapport à la version par défaut précédente."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "Modèle de réflexion profonde multimodal Hunyuan, supportant des chaînes de pensée natives multimodales longues, excellent pour divers scénarios de raisonnement d’images, avec une amélioration globale par rapport au modèle Quick Think pour les problèmes scientifiques."
+  },
   "hunyuan-turbo": {
     "description": "Version préliminaire du nouveau modèle de langage de génération Hunyuan, utilisant une nouvelle structure de modèle d'experts mixtes (MoE), offrant une efficacité d'inférence plus rapide et de meilleures performances par rapport à Hunyuan-Pro."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "Mise à niveau de la base pré-entraînée, amélioration des capacités d'écriture et de compréhension de lecture, augmentation significative des compétences en codage et en sciences, avec un suivi continu des instructions complexes."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "Amélioration de la qualité des données de base pour la pré-formation. Optimisation de la stratégie d’entraînement post-formation, avec une amélioration continue des capacités des agents, des langues anglaises et petites langues, de la conformité aux instructions, du code et des sciences."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS est la dernière version du modèle phare Hunyuan, offrant une capacité de réflexion améliorée et une expérience utilisateur optimisée."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 est un modèle de base à architecture MoE doté de capacités remarquables en programmation et en agents autonomes, avec 1T de paramètres au total et 32B de paramètres activés. Dans les principaux tests de référence couvrant le raisonnement général, la programmation, les mathématiques et les agents, le modèle K2 surpasse les autres modèles open source majeurs."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 est un modèle de langage à experts mixtes à grande échelle (MoE) développé par l'IA de la face cachée de la Lune, avec un total de 1 000 milliards de paramètres et 32 milliards de paramètres activés par passage avant. Il est optimisé pour les capacités d'agent, incluant l'utilisation avancée d'outils, le raisonnement et la synthèse de code."
+  },
   "kimi-latest": {
     "description": "Le produit d'assistant intelligent Kimi utilise le dernier modèle Kimi, qui peut inclure des fonctionnalités encore instables. Il prend en charge la compréhension des images et choisit automatiquement le modèle de facturation 8k/32k/128k en fonction de la longueur du contexte de la demande."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V est la dernière génération de modèle langage-visuel (VLM) publiée par Zhipu AI. Ce modèle est construit sur le modèle texte phare GLM-4.5-Air, qui compte 106 milliards de paramètres au total et 12 milliards de paramètres d'activation, et adopte une architecture de mixture d'experts (MoE) afin d'obtenir des performances excellentes à un coût d'inférence réduit. Sur le plan technique, GLM-4.5V prolonge la lignée de GLM-4.1V-Thinking et introduit des innovations telles que l'encodage de position rotatif en 3D (3D-RoPE), renforçant de façon significative la perception et le raisonnement des relations spatiales tridimensionnelles. Grâce aux optimisations apportées lors des phases de pré-entraînement, d'affinage supervisé et d'apprentissage par renforcement, ce modèle est capable de traiter divers contenus visuels, notamment des images, des vidéos et des documents longs, et atteint un niveau de pointe parmi les modèles open source de la même catégorie sur 41 benchmarks multimodaux publics. De plus, le modèle intègre un interrupteur « mode réflexion » permettant aux utilisateurs de choisir de manière flexible entre réponses rapides et raisonnement approfondi, pour équilibrer efficacité et qualité."
   },
+  "zai-org/GLM-4.6": {
+    "description": "Par rapport à GLM-4.5, GLM-4.6 apporte plusieurs améliorations clés. Sa fenêtre contextuelle s’étend de 128K à 200K tokens, permettant au modèle de gérer des tâches d’agents plus complexes. Le modèle obtient de meilleurs scores aux benchmarks de code et montre des performances renforcées dans des applications telles que Claude Code, Cline, Roo Code et Kilo Code, notamment dans la génération de pages frontales visuellement raffinées. GLM-4.6 améliore nettement les performances d’inférence et supporte l’utilisation d’outils durant l’inférence, offrant ainsi une capacité globale renforcée. Il excelle dans l’utilisation d’outils et les agents basés sur la recherche, et s’intègre plus efficacement dans les cadres d’agents. En écriture, ce modèle correspond davantage aux préférences humaines en termes de style et de lisibilité, et se comporte de manière plus naturelle dans les scénarios de jeu de rôle."
+  },
   "zai/glm-4.5": {
     "description": "La série de modèles GLM-4.5 est conçue spécifiquement pour les agents. Le modèle phare GLM-4.5 intègre 355 milliards de paramètres totaux (32 milliards actifs), unifiant raisonnement, codage et capacités d'agent pour répondre à des besoins applicatifs complexes. En tant que système de raisonnement hybride, il offre deux modes d'opération."
   },

locales/fr-FR/providers.json

@@ -110,6 +110,9 @@
   "ollama": {
     "description": "Les modèles proposés par Ollama couvrent largement des domaines tels que la génération de code, les calculs mathématiques, le traitement multilingue et les interactions conversationnelles, répondant à des besoins diversifiés pour le déploiement en entreprise et la localisation."
   },
+  "ollamacloud": {
+    "description": "Ollama Cloud offre un service d'inférence hébergé officiellement, permettant un accès prêt à l'emploi à la bibliothèque de modèles Ollama, avec prise en charge d'une interface compatible OpenAI."
+  },
   "openai": {
     "description": "OpenAI est un institut de recherche en intelligence artificielle de premier plan au monde, dont les modèles, tels que la série GPT, font progresser les frontières du traitement du langage naturel. OpenAI s'engage à transformer plusieurs secteurs grâce à des solutions IA innovantes et efficaces. Leurs produits offrent des performances et une rentabilité remarquables, largement utilisés dans la recherche, le commerce et les applications innovantes."
   },

locales/fr-FR/tool.json

@@ -1,4 +1,11 @@
 {
+  "codeInterpreter": {
+    "error": "Erreur d'exécution",
+    "executing": "Exécution en cours...",
+    "files": "Fichiers :",
+    "output": "Sortie :",
+    "returnValue": "Valeur de retour :"
+  },
   "dalle": {
     "autoGenerate": "Auto-générer",
     "downloading": "Les liens d'image générés par DallE3 ne sont valides que pendant 1 heure. Le téléchargement de l'image est en cours...",

locales/it-IT/chat.json

@@ -3,8 +3,8 @@
     "title": "Modelli"
   },
   "agentDefaultMessage": "Ciao, sono **{{name}}**, puoi iniziare subito a parlare con me oppure andare su [Impostazioni assistente]({{url}}) per completare le mie informazioni.",
-  "agentDefaultMessageWithSystemRole": "Ciao, sono **{{name}}**, {{systemRole}}, iniziamo a chattare!",
-  "agentDefaultMessageWithoutEdit": "Ciao, sono **{{name}}**. Cominciamo a chiacchierare!",
+  "agentDefaultMessageWithSystemRole": "Ciao, sono **{{name}}**, come posso aiutarti?",
+  "agentDefaultMessageWithoutEdit": "Ciao, sono **{{name}}**, come posso aiutarti?",
   "agents": "Assistente",
   "artifact": {
     "generating": "Generazione in corso",
@@ -150,6 +150,11 @@
       "total": "Totale consumato"
     }
   },
+  "minimap": {
+    "jumpToMessage": "Vai al messaggio n. {{index}}",
+    "nextMessage": "Messaggio successivo",
+    "previousMessage": "Messaggio precedente"
+  },
   "newAgent": "Nuovo assistente",
   "pin": "Fissa in alto",
   "pinOff": "Annulla fissaggio in alto",

locales/it-IT/image.json

@@ -30,6 +30,13 @@
     "prompt": {
       "placeholder": "Descrivi ciò che desideri generare"
     },
+    "quality": {
+      "label": "Qualità immagine",
+      "options": {
+        "hd": "Alta definizione",
+        "standard": "Standard"
+      }
+    },
     "seed": {
       "label": "Seed",
       "random": "Seme casuale"

locales/it-IT/modelProvider.json

@@ -294,6 +294,21 @@
           "title": "Finestra di contesto massima",
           "unlimited": "Illimitato"
         },
+        "type": {
+          "extra": "Diversi tipi di modelli hanno scenari d'uso e capacità differenziate",
+          "options": {
+            "chat": "Conversazione",
+            "embedding": "Vettorializzazione",
+            "image": "Generazione di immagini",
+            "realtime": "Conversazione in tempo reale",
+            "stt": "Trascrizione vocale",
+            "text2music": "Testo in musica",
+            "text2video": "Testo in video",
+            "tts": "Sintesi vocale"
+          },
+          "placeholder": "Seleziona il tipo di modello",
+          "title": "Tipo di modello"
+        },
         "vision": {
           "extra": "Questa configurazione abiliterà solo la configurazione di caricamento immagini nell'app, la disponibilità di riconoscimento dipende interamente dal modello stesso, testare autonomamente la disponibilità di riconoscimento visivo di questo modello.",
           "title": "Supporto per riconoscimento visivo"

locales/it-IT/models.json

@@ -92,6 +92,12 @@
   "DeepSeek-V3.1-Think": {
     "description": "DeepSeek-V3.1 - modalità con pensiero; DeepSeek-V3.1 è un nuovo modello di ragionamento ibrido lanciato da DeepSeek, che supporta due modalità di ragionamento: con e senza pensiero, con un'efficienza di pensiero superiore rispetto a DeepSeek-R1-0528. Ottimizzato post-addestramento, l'uso degli strumenti Agent e le prestazioni nei compiti degli agenti sono notevolmente migliorati."
   },
+  "DeepSeek-V3.2-Exp": {
+    "description": "DeepSeek V3.2 è l'ultimo modello generale rilasciato da DeepSeek, supporta un'architettura di inferenza ibrida e possiede capacità agenti potenziate."
+  },
+  "DeepSeek-V3.2-Exp-Think": {
+    "description": "Modalità di pensiero di DeepSeek V3.2. Prima di fornire la risposta finale, il modello genera una catena di pensieri per migliorare l'accuratezza della risposta."
+  },
   "Doubao-lite-128k": {
     "description": "Doubao-lite offre una velocità di risposta eccezionale e un miglior rapporto qualità-prezzo, fornendo ai clienti scelte più flessibili per diversi scenari. Supporta inferenza e fine-tuning con una finestra contestuale di 128k."
   },
@@ -287,6 +293,9 @@
   "Pro/deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 è un modello linguistico di grandi dimensioni a modalità mista rilasciato da DeepSeek AI, che presenta numerosi aggiornamenti significativi rispetto alla generazione precedente. Una delle innovazioni principali è l'integrazione delle modalità “Thinking Mode” e “Non-thinking Mode” in un unico modello, permettendo agli utenti di passare agevolmente da una modalità all'altra modificando il template di chat, per adattarsi a diverse esigenze di compito. Grazie a un'ottimizzazione post-addestramento dedicata, la versione V3.1 ha migliorato significativamente le prestazioni nell'uso degli strumenti e nelle attività degli agenti, supportando meglio strumenti di ricerca esterni e l'esecuzione di compiti complessi a più fasi. Basato su DeepSeek-V3.1-Base, il modello è stato ulteriormente addestrato con un metodo di estensione in due fasi per testi lunghi, aumentando notevolmente la quantità di dati di addestramento e migliorando la gestione di documenti lunghi e codice esteso. Essendo un modello open source, DeepSeek-V3.1 dimostra capacità comparabili ai migliori modelli proprietari in benchmark di codifica, matematica e ragionamento, e grazie alla sua architettura a esperti misti (MoE), mantiene una grande capacità del modello riducendo efficacemente i costi di inferenza."
   },
+  "Pro/deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus è una versione aggiornata del modello V3.1 rilasciata da DeepSeek, concepita come un modello linguistico di grandi dimensioni con agenti ibridi. Questo aggiornamento mantiene le capacità originali del modello, concentrandosi sulla risoluzione dei problemi segnalati dagli utenti e sul miglioramento della stabilità. Migliora significativamente la coerenza linguistica, riducendo l'uso misto di cinese e inglese e la presenza di caratteri anomali. Il modello integra la “Modalità di pensiero” (Thinking Mode) e la “Modalità non di pensiero” (Non-thinking Mode), permettendo agli utenti di passare agevolmente tra le modalità tramite template di chat per adattarsi a diversi compiti. Come ottimizzazione importante, V3.1-Terminus potenzia le prestazioni degli agenti di codice (Code Agent) e di ricerca (Search Agent), rendendoli più affidabili nell'invocazione di strumenti e nell'esecuzione di compiti complessi multi-step."
+  },
   "Pro/moonshotai/Kimi-K2-Instruct-0905": {
     "description": "Kimi K2-Instruct-0905 è l'ultima e più potente versione di Kimi K2. Si tratta di un modello linguistico di esperti misti (MoE) all'avanguardia, con un totale di 1 trilione di parametri e 32 miliardi di parametri attivi. Le caratteristiche principali del modello includono: intelligenza potenziata per la codifica degli agenti, con miglioramenti significativi nelle prestazioni sia nei test di riferimento pubblici sia nelle attività di codifica degli agenti nel mondo reale; esperienza di codifica frontend migliorata, con progressi sia nell'estetica che nella praticità della programmazione frontend."
   },
@@ -680,6 +689,9 @@
   "anthropic/claude-sonnet-4": {
     "description": "Claude Sonnet 4 migliora significativamente le capacità leader del settore di Sonnet 3.7, eccellendo nella codifica con un punteggio all'avanguardia del 72,7% su SWE-bench. Il modello bilancia prestazioni ed efficienza, adatto a casi d'uso interni ed esterni, e offre un controllo maggiore sull'implementazione grazie a una controllabilità migliorata."
   },
+  "anthropic/claude-sonnet-4.5": {
+    "description": "Claude Sonnet 4.5 è il modello più intelligente di Anthropic fino ad oggi."
+  },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B è un modello linguistico di grandi dimensioni a parametri sparsi con 72 miliardi di parametri totali e 16 miliardi di parametri attivati, basato sull'architettura Mixture of Group Experts (MoGE). Durante la fase di selezione degli esperti, gli esperti sono raggruppati e il token attiva un numero uguale di esperti all'interno di ogni gruppo, garantendo un bilanciamento del carico degli esperti e migliorando significativamente l'efficienza di distribuzione del modello sulla piattaforma Ascend."
   },
@@ -773,6 +785,9 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "Modello di pensiero Claude Sonnet 4 che può generare risposte quasi istantanee o un pensiero graduale prolungato, permettendo all'utente di vedere chiaramente questi processi."
   },
+  "claude-sonnet-4-5-20250929": {
+    "description": "Claude Sonnet 4.5 è il modello più intelligente di Anthropic fino ad oggi."
+  },
   "codegeex-4": {
     "description": "CodeGeeX-4 è un potente assistente di programmazione AI, supporta domande intelligenti e completamento del codice in vari linguaggi di programmazione, migliorando l'efficienza dello sviluppo."
   },
@@ -920,6 +935,9 @@
   "deepseek-ai/DeepSeek-V3.1": {
     "description": "DeepSeek-V3.1 è un modello linguistico di grandi dimensioni a modalità mista rilasciato da DeepSeek AI, che presenta numerosi aggiornamenti significativi rispetto alla generazione precedente. Una delle innovazioni principali è l'integrazione delle modalità “Thinking Mode” e “Non-thinking Mode” in un unico modello, permettendo agli utenti di passare agevolmente da una modalità all'altra modificando il template di chat, per adattarsi a diverse esigenze di compito. Grazie a un'ottimizzazione post-addestramento dedicata, la versione V3.1 ha migliorato significativamente le prestazioni nell'uso degli strumenti e nelle attività degli agenti, supportando meglio strumenti di ricerca esterni e l'esecuzione di compiti complessi a più fasi. Basato su DeepSeek-V3.1-Base, il modello è stato ulteriormente addestrato con un metodo di estensione in due fasi per testi lunghi, aumentando notevolmente la quantità di dati di addestramento e migliorando la gestione di documenti lunghi e codice esteso. Essendo un modello open source, DeepSeek-V3.1 dimostra capacità comparabili ai migliori modelli proprietari in benchmark di codifica, matematica e ragionamento, e grazie alla sua architettura a esperti misti (MoE), mantiene una grande capacità del modello riducendo efficacemente i costi di inferenza."
   },
+  "deepseek-ai/DeepSeek-V3.1-Terminus": {
+    "description": "DeepSeek-V3.1-Terminus è una versione aggiornata del modello V3.1 rilasciata da DeepSeek, concepita come un modello linguistico di grandi dimensioni con agenti ibridi. Questo aggiornamento mantiene le capacità originali del modello, concentrandosi sulla risoluzione dei problemi segnalati dagli utenti e sul miglioramento della stabilità. Migliora significativamente la coerenza linguistica, riducendo l'uso misto di cinese e inglese e la presenza di caratteri anomali. Il modello integra la “Modalità di pensiero” (Thinking Mode) e la “Modalità non di pensiero” (Non-thinking Mode), permettendo agli utenti di passare agevolmente tra le modalità tramite template di chat per adattarsi a diversi compiti. Come ottimizzazione importante, V3.1-Terminus potenzia le prestazioni degli agenti di codice (Code Agent) e di ricerca (Search Agent), rendendoli più affidabili nell'invocazione di strumenti e nell'esecuzione di compiti complessi multi-step."
+  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B è un modello avanzato addestrato per dialoghi ad alta complessità."
   },
@@ -929,6 +947,9 @@
   "deepseek-ai/deepseek-v3.1": {
     "description": "DeepSeek V3.1: modello di inferenza di nuova generazione che migliora le capacità di ragionamento complesso e di pensiero a catena, adatto a compiti che richiedono analisi approfondite."
   },
+  "deepseek-ai/deepseek-v3.1-terminus": {
+    "description": "DeepSeek V3.1: un modello di ragionamento di nuova generazione, con capacità avanzate di analisi complessa e pensiero concatenato, ideale per compiti che richiedono un'analisi approfondita."
+  },
   "deepseek-ai/deepseek-vl2": {
     "description": "DeepSeek-VL2 è un modello linguistico visivo a esperti misti (MoE) sviluppato sulla base di DeepSeekMoE-27B, che utilizza un'architettura MoE con attivazione sparsa, raggiungendo prestazioni eccezionali attivando solo 4,5 miliardi di parametri. Questo modello eccelle in vari compiti, tra cui domande visive, riconoscimento ottico dei caratteri, comprensione di documenti/tabelle/grafici e localizzazione visiva."
   },
@@ -993,7 +1014,7 @@
     "description": "DeepSeek R1 versione completa, con 671B parametri, supporta la ricerca online in tempo reale, con capacità di comprensione e generazione più potenti."
   },
   "deepseek-reasoner": {
-    "description": "DeepSeek V3.1 modalità di pensiero. Prima di fornire la risposta finale, il modello genera una catena di pensieri per migliorare la precisione della risposta finale."
+    "description": "Modalità di pensiero di DeepSeek V3.2. Prima di fornire la risposta finale, il modello genera una catena di pensieri per migliorare l'accuratezza della risposta."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 è un modello di linguaggio Mixture-of-Experts efficiente, adatto per esigenze di elaborazione economica."
@@ -1013,6 +1034,9 @@
   "deepseek-v3.1:671b": {
     "description": "DeepSeek V3.1: modello di inferenza di nuova generazione che migliora le capacità di ragionamento complesso e di pensiero a catena, adatto a compiti che richiedono analisi approfondite."
   },
+  "deepseek-v3.2-exp": {
+    "description": "deepseek-v3.2-exp introduce un meccanismo di attenzione sparsa, progettato per migliorare l'efficienza di addestramento e inferenza nel trattamento di testi lunghi, con un costo inferiore rispetto a deepseek-v3.1."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 è un modello misto esperto con 685B di parametri, l'ultima iterazione della serie di modelli di chat di punta del team DeepSeek.\n\nEredita il modello [DeepSeek V3](/deepseek/deepseek-chat-v3) e si comporta eccezionalmente in vari compiti."
   },
@@ -1232,6 +1256,9 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] è un modello di generazione immagini con 12 miliardi di parametri, focalizzato sulla generazione rapida di immagini di alta qualità."
   },
+  "fal-ai/hunyuan-image/v3": {
+    "description": "Un potente modello nativo di generazione di immagini multimodali"
+  },
   "fal-ai/imagen4/preview": {
     "description": "Modello di generazione immagini di alta qualità fornito da Google."
   },
@@ -1343,24 +1370,36 @@
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash è il modello Google con il miglior rapporto qualità-prezzo, offrendo funzionalità complete."
   },
+  "gemini-2.5-flash-image": {
+    "description": "Nano Banana è l'ultimo modello multimodale nativo di Google, il più veloce ed efficiente, che consente di generare e modificare immagini tramite conversazioni."
+  },
   "gemini-2.5-flash-image-preview": {
     "description": "Nano Banana è l'ultimo, più veloce ed efficiente modello multimodale nativo di Google, che consente di generare e modificare immagini tramite conversazione."
   },
   "gemini-2.5-flash-image-preview:image": {
     "description": "Nano Banana è l'ultimo, più veloce ed efficiente modello multimodale nativo di Google, che consente di generare e modificare immagini tramite conversazione."
   },
+  "gemini-2.5-flash-image:image": {
+    "description": "Nano Banana è l'ultimo modello multimodale nativo di Google, il più veloce ed efficiente, che consente di generare e modificare immagini tramite conversazioni."
+  },
   "gemini-2.5-flash-lite": {
     "description": "Gemini 2.5 Flash-Lite è il modello più piccolo e conveniente di Google, progettato per un utilizzo su larga scala."
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "description": "Gemini 2.5 Flash-Lite Preview è il modello Google più piccolo e con il miglior rapporto qualità-prezzo, progettato per un utilizzo su larga scala."
   },
+  "gemini-2.5-flash-lite-preview-09-2025": {
+    "description": "Versione anteprima (25 settembre 2025) di Gemini 2.5 Flash-Lite"
+  },
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview è il modello più conveniente di Google, che offre funzionalità complete."
   },
   "gemini-2.5-flash-preview-05-20": {
     "description": "Gemini 2.5 Flash Preview è il modello Google con il miglior rapporto qualità-prezzo, che offre funzionalità complete."
   },
+  "gemini-2.5-flash-preview-09-2025": {
+    "description": "Versione anteprima (25 settembre 2025) di Gemini 2.5 Flash"
+  },
   "gemini-2.5-pro": {
     "description": "Gemini 2.5 Pro è il modello di pensiero più avanzato di Google, capace di ragionare su codice, matematica e problemi complessi nei campi STEM, oltre a utilizzare contesti lunghi per analizzare grandi dataset, codebase e documenti."
   },
@@ -1373,6 +1412,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview è il modello di pensiero più avanzato di Google, capace di ragionare su problemi complessi in codice, matematica e ambito STEM, oltre a utilizzare contesti estesi per analizzare grandi dataset, librerie di codice e documenti."
   },
+  "gemini-flash-latest": {
+    "description": "Ultima versione di Gemini Flash"
+  },
+  "gemini-flash-lite-latest": {
+    "description": "Ultima versione di Gemini Flash-Lite"
+  },
+  "gemini-pro-latest": {
+    "description": "Ultima versione di Gemini Pro"
+  },
   "gemma-7b-it": {
     "description": "Gemma 7B è adatto per l'elaborazione di compiti di piccole e medie dimensioni, combinando efficienza dei costi."
   },
@@ -1437,7 +1485,7 @@
     "description": "La serie GLM-4.1V-Thinking è attualmente il modello visivo più performante tra i modelli VLM di livello 10 miliardi di parametri noti, integrando le migliori prestazioni SOTA nelle attività di linguaggio visivo di pari livello, tra cui comprensione video, domande sulle immagini, risoluzione di problemi disciplinari, riconoscimento OCR, interpretazione di documenti e grafici, agent GUI, coding front-end web, grounding e altro. Le capacità in molteplici compiti superano persino il modello Qwen2.5-VL-72B con 8 volte più parametri. Grazie a tecniche avanzate di apprendimento rinforzato, il modello padroneggia il ragionamento tramite catena di pensiero per migliorare accuratezza e ricchezza delle risposte, superando significativamente i modelli tradizionali non-thinking in termini di risultati finali e interpretabilità."
   },
   "glm-4.5": {
-    "description": "Ultimo modello di punta di Zhipu, supporta la modalità di pensiero commutabile, con capacità complessive al livello SOTA dei modelli open source e una lunghezza di contesto fino a 128K."
+    "description": "Modello di punta di Zhipu, supporta la modalità di pensiero alternata, con capacità complessive che raggiungono il livello SOTA dei modelli open source, e una lunghezza del contesto fino a 128K."
   },
   "glm-4.5-air": {
     "description": "Versione leggera di GLM-4.5, bilancia prestazioni e rapporto qualità-prezzo, con capacità di commutazione flessibile tra modelli di pensiero ibridi."
@@ -1454,6 +1502,9 @@
   "glm-4.5v": {
     "description": "Una nuova generazione di modello di ragionamento visivo basato sull'architettura MOE, con 106 miliardi di parametri totali e 12 miliardi di parametri di attivazione, che raggiunge lo SOTA tra i modelli multimodali open source della stessa fascia a livello globale in vari benchmark, coprendo attività comuni come la comprensione di immagini, video, documenti e compiti GUI."
   },
+  "glm-4.6": {
+    "description": "Il più recente modello di punta di Zhipu, GLM-4.6 (355B), supera completamente la generazione precedente in codifica avanzata, gestione di testi lunghi, inferenza e capacità agenti, allineandosi in particolare con Claude Sonnet 4 nelle capacità di programmazione, diventando il modello di coding di punta in Cina."
+  },
   "glm-4v": {
     "description": "GLM-4V offre potenti capacità di comprensione e ragionamento visivo, supportando vari compiti visivi."
   },
@@ -1682,12 +1733,18 @@
   "gpt-5-nano": {
     "description": "Versione più veloce ed economica di GPT-5. Perfetta per scenari applicativi che richiedono risposte rapide e sono sensibili ai costi."
   },
+  "gpt-5-pro": {
+    "description": "GPT-5 Pro utilizza maggiori risorse computazionali per un'elaborazione più profonda, offrendo risposte sempre più accurate e pertinenti."
+  },
   "gpt-audio": {
     "description": "GPT Audio è un modello di chat universale per input e output audio, supporta l'uso di I/O audio nell'API Chat Completions."
   },
   "gpt-image-1": {
     "description": "Modello nativo multimodale di generazione immagini di ChatGPT"
   },
+  "gpt-image-1-mini": {
+    "description": "Una versione più economica di GPT Image 1, con supporto nativo per input testuali e visivi e generazione di output in formato immagine."
+  },
   "gpt-oss-120b": {
     "description": "GPT-OSS-120B MXFP4: struttura Transformer quantizzata, mantiene prestazioni elevate anche con risorse limitate."
   },
@@ -1799,12 +1856,12 @@
   "hunyuan-t1-latest": {
     "description": "Migliora significativamente le capacità del modello principale e del modello di pensiero lento in matematica avanzata, ragionamento complesso, codice difficile, rispetto delle istruzioni e qualità della creazione testuale."
   },
-  "hunyuan-t1-vision": {
-    "description": "Modello di comprensione multimodale profonda Hunyuan, supporta catene di pensiero native multimodali, eccelle in vari scenari di ragionamento visivo e migliora significativamente rispetto ai modelli di pensiero rapido nei problemi scientifici."
-  },
   "hunyuan-t1-vision-20250619": {
     "description": "L'ultima versione del modello di pensiero profondo multimodale t1-vision di Hunyuan, supporta catene di pensiero native multimodali e presenta miglioramenti completi rispetto alla versione predefinita della generazione precedente."
   },
+  "hunyuan-t1-vision-20250916": {
+    "description": "Modello di comprensione multimodale Hunyuan con pensiero profondo, supporta catene di pensiero native multimodali estese, eccelle nel gestire vari scenari di ragionamento visivo e migliora significativamente rispetto al modello Quick Think nei problemi scientifici."
+  },
   "hunyuan-turbo": {
     "description": "Anteprima della nuova generazione di modelli di linguaggio di Hunyuan, utilizza una nuova struttura di modello ibrido di esperti (MoE), con una maggiore efficienza di inferenza e prestazioni superiori rispetto a hunyuan-pro."
   },
@@ -1826,6 +1883,9 @@
   "hunyuan-turbos-20250604": {
     "description": "Aggiornamento della base pre-addestrata, con miglioramenti nelle capacità di scrittura e comprensione della lettura, notevoli progressi nelle competenze di programmazione e scientifiche, e continui miglioramenti nell’aderenza a istruzioni complesse."
   },
+  "hunyuan-turbos-20250926": {
+    "description": "Aggiornamento della qualità dei dati della base di pre-addestramento. Ottimizzazione della strategia di addestramento nella fase post-train, migliorando continuamente le capacità di agenti, lingue minori inglesi, conformità alle istruzioni, codice e scienze."
+  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS è l'ultima versione del modello di punta Hunyuan, con capacità di pensiero più forti e un'esperienza utente migliore."
   },
@@ -1916,6 +1976,9 @@
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 è un modello di base con architettura MoE che offre potenti capacità di programmazione e di agent, con 1T di parametri totali e 32B di parametri attivi. Nei benchmark delle principali categorie — ragionamento su conoscenze generali, programmazione, matematica e agent — il modello K2 supera gli altri modelli open source più diffusi."
   },
+  "kimi-k2:1t": {
+    "description": "Kimi K2 è un modello linguistico esperto ibrido su larga scala (MoE) sviluppato da Moon's Dark Side AI, con un totale di 1 trilione di parametri e 32 miliardi di parametri attivati per ogni passaggio in avanti. È ottimizzato per capacità di agente, inclusi l'uso avanzato di strumenti, il ragionamento e la sintesi del codice."
+  },
   "kimi-latest": {
     "description": "Il prodotto Kimi Smart Assistant utilizza il più recente modello Kimi, che potrebbe includere funzionalità non ancora stabili. Supporta la comprensione delle immagini e selezionerà automaticamente il modello di fatturazione 8k/32k/128k in base alla lunghezza del contesto della richiesta."
   },
@@ -3131,6 +3194,9 @@
   "zai-org/GLM-4.5V": {
     "description": "GLM-4.5V è l’ultima generazione di modelli visivo‑linguistici (VLM) rilasciata da Zhipu AI (智谱 AI). Il modello è costruito sul modello testuale di punta GLM-4.5‑Air, che dispone di 106 miliardi di parametri totali e 12 miliardi di parametri di attivazione, e adotta un’architettura mixture-of-experts (MoE) con l’obiettivo di offrire prestazioni eccellenti a un costo di inferenza ridotto. Dal punto di vista tecnico, GLM-4.5V prosegue la linea di GLM-4.1V‑Thinking e introduce innovazioni come il codificatore di posizione rotazionale tridimensionale (3D‑RoPE), migliorando in modo significativo la percezione e il ragionamento sulle relazioni spaziali 3D. Grazie all’ottimizzazione nelle fasi di pre‑addestramento, fine‑tuning supervisionato e apprendimento per rinforzo, il modello è in grado di gestire diversi tipi di contenuti visivi — immagini, video e documenti lunghi — e ha raggiunto livelli di eccellenza tra i modelli open source della stessa categoria in 41 benchmark multimodali pubblici. Inoltre, il modello introduce un interruttore per la “modalità pensiero” che consente all’utente di scegliere con flessibilità tra risposte rapide e ragionamenti approfonditi, bilanciando efficienza ed efficacia."
   },
+  "zai-org/GLM-4.6": {
+    "description": "Rispetto a GLM-4.5, GLM-4.6 introduce numerosi miglioramenti chiave. La finestra contestuale è stata estesa da 128K a 200K token, permettendo al modello di gestire compiti agenti più complessi. Il modello ha ottenuto punteggi più alti nei benchmark di codice e ha mostrato prestazioni migliori nel mondo reale in applicazioni come Claude Code, Cline, Roo Code e Kilo Code, inclusi miglioramenti nella generazione di interfacce front-end visivamente raffinate. GLM-4.6 mostra un netto miglioramento nelle prestazioni di inferenza e supporta l'uso di strumenti durante l'inferenza, offrendo capacità complessive più forti. Eccelle nell'uso di strumenti e agenti basati sulla ricerca, integrandosi più efficacemente nei framework agenti. In ambito di scrittura, il modello rispecchia meglio le preferenze umane in termini di stile e leggibilità, risultando più naturale nei contesti di role-playing."
+  },
   "zai/glm-4.5": {
     "description": "La serie di modelli GLM-4.5 è progettata specificamente come modelli base per agenti intelligenti. Il modello di punta GLM-4.5 integra 355 miliardi di parametri totali (32 miliardi attivi), unificando capacità di ragionamento, codifica e agenti per soddisfare esigenze applicative complesse. Come sistema di ragionamento ibrido, offre modalità operative doppie."
   },