clean deps

.cursor/rules/add-setting-env.mdc

@@ -1,175 +0,0 @@
----
-description: Guide for adding environment variables to configure user settings
-alwaysApply: false
----
-
-# Adding Environment Variable for User Settings
-
-Add server-side environment variables to configure default values for user settings.
-
-**Priority**: User Custom > Server Env Var > Hardcoded Default
-
-## Steps
-
-### 1. Define Environment Variable
-
-Create `src/envs/<domain>.ts`:
-
-```typescript
-import { createEnv } from '@t3-oss/env-nextjs';
-import { z } from 'zod';
-
-export const get<Domain>Config = () => {
-  return createEnv({
-    server: {
-      YOUR_ENV_VAR: z.coerce.number().min(MIN).max(MAX).optional(),
-    },
-    runtimeEnv: {
-      YOUR_ENV_VAR: process.env.YOUR_ENV_VAR,
-    },
-  });
-};
-
-export const <domain>Env = get<Domain>Config();
-```
-
-### 2. Update Type (Optional)
-
-**Skip this step if the domain field already exists in `GlobalServerConfig`.**
-
-Add to `packages/types/src/serverConfig.ts`:
-
-```typescript
-export interface GlobalServerConfig {
-  <domain>?: {
-    <settingName>?: <type>;
-  };
-}
-```
-
-**Prefer reusing existing types** from `packages/types/src/user/settings` with `PartialDeep`:
-
-```typescript
-import { User<Domain>Config } from './user/settings';
-
-export interface GlobalServerConfig {
-  <domain>?: PartialDeep<User<Domain>Config>;
-}
-```
-
-### 3. Assemble Server Config (Optional)
-
-**Skip this step if the domain field already exists in server config.**
-
-In `src/server/globalConfig/index.ts`:
-
-```typescript
-import { <domain>Env } from '@/envs/<domain>';
-import { cleanObject } from '@/utils/object';
-
-export const getServerGlobalConfig = async () => {
-  const config: GlobalServerConfig = {
-    // ...
-    <domain>: cleanObject({
-      <settingName>: <domain>Env.YOUR_ENV_VAR,
-    }),
-  };
-  return config;
-};
-```
-
-If the domain already exists, just add the new field to the existing `cleanObject()`:
-
-```typescript
-<domain>: cleanObject({
-  existingField: <domain>Env.EXISTING_VAR,
-  <settingName>: <domain>Env.YOUR_ENV_VAR, // Add this line
-}),
-```
-
-### 4. Merge to User Store (Optional)
-
-**Skip this step if the domain field already exists in `serverSettings`.**
-
-In `src/store/user/slices/common/action.ts`, add to `serverSettings`:
-
-```typescript
-const serverSettings: PartialDeep<UserSettings> = {
-  defaultAgent: serverConfig.defaultAgent,
-  <domain>: serverConfig.<domain>, // Add this line
-  // ...
-};
-```
-
-### 5. Update .env.example
-
-```bash
-# <Description> (range/options, default: X)
-# YOUR_ENV_VAR=<example>
-```
-
-### 6. Update Documentation
-
-Update both English and Chinese documentation:
-- `docs/self-hosting/environment-variables/basic.mdx`
-- `docs/self-hosting/environment-variables/basic.zh-CN.mdx`
-
-Add new section or subsection with environment variable details (type, description, default, example, range/constraints).
-
-## Type Reuse
-
-**Prefer reusing existing types** from `packages/types/src/user/settings` instead of defining inline types in `serverConfig.ts`.
-
-```typescript
-// ✅ Good - reuse existing type
-import { UserImageConfig } from './user/settings';
-
-export interface GlobalServerConfig {
-  image?: PartialDeep<UserImageConfig>;
-}
-
-// ❌ Bad - inline type definition
-export interface GlobalServerConfig {
-  image?: {
-    defaultImageNum?: number;
-  };
-}
-```
-
-## Example: AI_IMAGE_DEFAULT_IMAGE_NUM
-
-```typescript
-// src/envs/image.ts
-export const getImageConfig = () => {
-  return createEnv({
-    server: {
-      AI_IMAGE_DEFAULT_IMAGE_NUM: z.coerce.number().min(1).max(20).optional(),
-    },
-    runtimeEnv: {
-      AI_IMAGE_DEFAULT_IMAGE_NUM: process.env.AI_IMAGE_DEFAULT_IMAGE_NUM,
-    },
-  });
-};
-
-// packages/types/src/serverConfig.ts
-import { UserImageConfig } from './user/settings';
-
-export interface GlobalServerConfig {
-  image?: PartialDeep<UserImageConfig>;
-}
-
-// src/server/globalConfig/index.ts
-image: cleanObject({
-  defaultImageNum: imageEnv.AI_IMAGE_DEFAULT_IMAGE_NUM,
-}),
-
-// src/store/user/slices/common/action.ts
-const serverSettings: PartialDeep<UserSettings> = {
-  image: serverConfig.image,
-  // ...
-};
-
-// .env.example
-# AI_IMAGE_DEFAULT_IMAGE_NUM=4
-```
-

.cursor/rules/backend-architecture.mdc

@@ -0,0 +1,176 @@
+---
+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

@@ -0,0 +1,58 @@
+---
+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

@@ -0,0 +1,32 @@
+---
+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/db-migrations.mdc

@@ -1,25 +0,0 @@
----
-globs: packages/database/migrations/**/*
-alwaysApply: false
----
-
-# Database Migrations Guide
-
-## Defensive Programming - Use Idempotent Clauses
-
-Always use defensive clauses to make migrations idempotent:
-
-```sql
--- ✅ Good: Idempotent operations
-ALTER TABLE "users" ADD COLUMN IF NOT EXISTS "avatar" text;
-DROP TABLE IF EXISTS "old_table";
-CREATE INDEX IF NOT EXISTS "users_email_idx" ON "users" ("email");
-ALTER TABLE "posts" DROP COLUMN IF EXISTS "deprecated_field";
-
--- ❌ Bad: Non-idempotent operations
-ALTER TABLE "users" ADD COLUMN "avatar" text;
-DROP TABLE "old_table";
-CREATE INDEX "users_email_idx" ON "users" ("email");
-```
-
-**Important**: After modifying migration SQL (e.g., adding `IF NOT EXISTS` clauses), run `bun run db:generate-client` to update the hash in `packages/database/src/core/migrations.json`.

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

@@ -0,0 +1,8 @@
+---
+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,33 +4,41 @@ alwaysApply: true
 
 ## Project Description
 
-You are developing an open-source, modern-design AI chat framework: lobehub(previous lobe-chat).
+You are developing an open-source, modern-design AI chat framework: lobe chat.
 
-Supported platforms:
-
-- web desktop/mobile
-- desktop(electron)
-- mobile app(react native), coming soon
-
-logo emoji: 🤯
+Emoji logo: 🤯
 
 ## Project Technologies Stack
 
-- Next.js 15
-- react 19
-- TypeScript
-- `@lobehub/ui`, antd for component framework
+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
 - antd-style for css-in-js framework
-- lucide-react, `@ant-design/icons` for icons
-- react-layout-kit for flex layout component
+- react-layout-kit for flex layout
 - react-i18next for i18n
-- zustand for state management
-- nuqs for search params management
-- SWR for data fetch
+- 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
 - aHooks for react hooks library
-- dayjs for time library
+- dayjs for date and 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 Neon PostgreSQL for backend DB
+- PGLite for client DB and PostgreSQL for backend DB
 - Drizzle ORM
-- Vitest for testing
+- 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;

.cursor/rules/project-structure.mdc

@@ -5,118 +5,235 @@ alwaysApply: false
 
 # LobeChat Project Structure
 
-## Complete Project Structure
+## Directory Structure
 
-This project uses common monorepo structure. The workspace packages name use `@lobechat/` namespace.
-
-**note**: some not very important files are not shown for simplicity.
+note: some files are not shown for simplicity.
 
 ```plaintext
 lobe-chat/
-├── 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
+├── 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
 ```
 
 ## Architecture Map
 
-- 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.
+- 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
 
 ## Data Flow Architecture
 
-- **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)
+### 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`

.cursor/rules/rules-attach.mdc

@@ -4,12 +4,20 @@ globs:
 alwaysApply: true
 ---
 
-# Available project rules index
+# 📋 Available Rules Index
 
-All following rules are saved under `.cursor/rules/` directory:
+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
 
 ## 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
@@ -34,11 +42,11 @@ All following rules are saved under `.cursor/rules/` directory:
 
 ## Debugging
 
+- `debug.mdc` – General debugging guide
 - `debug-usage.mdc` – Using the debug package and namespace conventions
 
 ## Testing
 
 - `testing-guide/testing-guide.mdc` – Comprehensive testing guide for Vitest
-- `testing-guide/zustand-store-action-test.mdc` – Zustand store action testing best practices
 - `testing-guide/electron-ipc-test.mdc` – Electron IPC interface testing strategy
 - `testing-guide/db-model-test.mdc` – Database Model testing guide

.cursor/rules/system-role.mdc

@@ -0,0 +1,31 @@
+---
+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/testing-guide/zustand-store-action-test.mdc

@@ -1,410 +0,0 @@
----
-globs: src/store/**/__tests__/*.test.ts
-alwaysApply: false
----
-
-# 🏪 Zustand Store Action Testing Guide
-
-Testing guide for Zustand store actions under `src/store`. This guide is based on lessons learned from the `generateAIChat` refactoring practice.
-
-## Core Principles
-
-### 1. Test Layering Principle 🎯
-
-**Each layer should only test direct dependencies, never spy across layers**
-
-```
-❌ Bad Example - Cross-layer spying
-describe('internal_coreProcessMessage', () => {
-  it('test', async () => {
-    // ❌ Skipping internal_fetchAIChatMessage, directly spying on lower-level service
-    const streamSpy = vi.spyOn(chatService, 'createAssistantMessageStream');
-  });
-});
-
-✅ Good Example - Spy on direct dependencies
-describe('internal_coreProcessMessage', () => {
-  it('test', async () => {
-    // ✅ Only spy on directly called methods
-    const fetchSpy = vi.spyOn(result.current, 'internal_fetchAIChatMessage')
-      .mockResolvedValue({ isFunctionCall: false, content: 'response' });
-  });
-});
-```
-
-### 2. Mocking Strategy 🎭
-
-#### Per-Test Mocking (Recommended)
-
-```typescript
-// ✅ Spy on-demand in each test
-describe('myAction', () => {
-  it('should do something', async () => {
-    // Only spy when needed in this specific test
-    const serviceSpy = vi.spyOn(someService, 'method').mockResolvedValue(result);
-
-    // Test logic...
-
-    serviceSpy.mockRestore(); // Optional: cleanup
-  });
-});
-```
-
-#### Avoid Global Mocks
-
-```typescript
-// ❌ Avoid globally spying on everything in beforeEach
-beforeEach(() => {
-  spyOnEverything(); // Creates implicit coupling between tests
-});
-
-// ✅ Only spy on base services that almost all tests need
-beforeEach(() => {
-  spyOnMessageService(); // Most tests need this
-  // Other services should be spied on-demand within tests
-});
-```
-
-## Action Test Templates 📝
-
-### Basic Action Test
-
-```typescript
-import { act, renderHook } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { useStore } from '../store';
-
-// Mock zustand
-vi.mock('zustand/traditional');
-
-// Test constants
-const TEST_IDS = {
-  DATA_ID: 'test-data-id',
-} as const;
-
-// Mock data factory
-const createMockData = (overrides = {}) => ({
-  id: TEST_IDS.DATA_ID,
-  status: 'initial',
-  ...overrides,
-});
-
-beforeEach(() => {
-  vi.clearAllMocks();
-
-  // Setup common mocks that most tests need
-  act(() => {
-    useStore.setState({
-      refreshData: vi.fn(),
-      internalMethod: vi.fn(),
-    });
-  });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe('myAction', () => {
-  describe('validation', () => {
-    it('should return early when conditions not met', async () => {
-      act(() => {
-        useStore.setState({ requiredData: undefined });
-      });
-
-      const { result } = renderHook(() => useStore());
-
-      await act(async () => {
-        await result.current.myAction();
-      });
-
-      expect(result.current.internalMethod).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('main flow', () => {
-    it('should process data correctly', async () => {
-      const { result } = renderHook(() => useStore());
-      const mockData = createMockData();
-
-      await act(async () => {
-        await result.current.myAction(mockData);
-      });
-
-      expect(result.current.internalMethod).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: TEST_IDS.DATA_ID,
-          status: 'processed',
-        }),
-      );
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle errors gracefully', async () => {
-      const { result } = renderHook(() => useStore());
-
-      vi.spyOn(result.current, 'internalMethod').mockRejectedValue(
-        new Error('Test error'),
-      );
-
-      await act(async () => {
-        await result.current.myAction();
-      });
-
-      expect(result.current.errorState).toBeDefined();
-    });
-  });
-});
-```
-
-### Testing Internal Methods
-
-```typescript
-// Save the real implementation for testing
-const realInternalMethod = useStore.getState().internal_method;
-
-describe('internal_method', () => {
-  it('should call correct dependencies', async () => {
-    // Restore the real implementation
-    act(() => {
-      useStore.setState({ internal_method: realInternalMethod });
-    });
-
-    const { result } = renderHook(() => useStore());
-
-    // ✅ Spy on direct dependencies
-    const dependencySpy = vi
-      .spyOn(result.current, 'internal_dependency')
-      .mockResolvedValue(expectedResult);
-
-    await act(async () => {
-      await result.current.internal_method(input);
-    });
-
-    expect(dependencySpy).toHaveBeenCalledWith(
-      expect.objectContaining({ /* expected params */ }),
-    );
-  });
-});
-```
-
-### Testing Streaming/Async Flows
-
-```typescript
-describe('streamingAction', () => {
-  it('should handle streaming chunks', async () => {
-    const { result } = renderHook(() => useStore());
-    const dispatchSpy = vi.spyOn(result.current, 'internal_dispatch');
-
-    // Mock streaming service
-    const streamSpy = vi
-      .spyOn(streamService, 'stream')
-      .mockImplementation(async ({ onChunk, onFinish }) => {
-        await onChunk?.({ type: 'data', content: 'chunk1' });
-        await onChunk?.({ type: 'data', content: 'chunk2' });
-        await onFinish?.('complete');
-      });
-
-    await act(async () => {
-      await result.current.streamingAction();
-    });
-
-    expect(dispatchSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'update',
-        value: expect.objectContaining({ content: 'chunk1' }),
-      }),
-    );
-
-    streamSpy.mockRestore();
-  });
-});
-```
-
-### Testing Toggle/Loading States
-
-```typescript
-describe('internal_toggleLoading', () => {
-  it('should enable loading state with abort controller', () => {
-    const { result } = renderHook(() => useStore());
-
-    act(() => {
-      result.current.internal_toggleLoading(true, TEST_IDS.ITEM_ID, 'action');
-    });
-
-    const state = useStore.getState();
-    expect(state.loadingIds).toEqual([TEST_IDS.ITEM_ID]);
-    expect(state.abortController).toBeInstanceOf(AbortController);
-  });
-
-  it('should disable loading state and clear abort controller', () => {
-    const { result } = renderHook(() => useStore());
-
-    act(() => {
-      result.current.internal_toggleLoading(true, TEST_IDS.ITEM_ID, 'start');
-      result.current.internal_toggleLoading(false, undefined, 'stop');
-    });
-
-    const state = useStore.getState();
-    expect(state.loadingIds).toEqual([]);
-    expect(state.abortController).toBeUndefined();
-  });
-});
-```
-
-## Common Issues and Solutions ⚠️
-
-### Issue 1: React State Update Warning
-
-```typescript
-// ❌ Wrong: setState without wrapping
-useStore.setState({ data: newData });
-
-// ✅ Correct: Wrap all setState with act()
-act(() => {
-  useStore.setState({ data: newData });
-});
-```
-
-### Issue 2: Cross-Layer Spying
-
-```typescript
-// ❌ Wrong: Spy on lower-level services across layers
-describe('highLevelAction', () => {
-  const lowLevelServiceSpy = vi.spyOn(lowLevelService, 'method');
-});
-
-// ✅ Correct: Spy on direct dependencies
-describe('highLevelAction', () => {
-  const directDependencySpy = vi.spyOn(result.current, 'directMethod');
-});
-```
-
-### Issue 3: Mock Type Mismatch
-
-```typescript
-// ❌ Wrong: Return type doesn't match
-vi.spyOn(service, 'method').mockResolvedValue('string');
-// But method returns Response
-
-// ✅ Correct: Return correct type
-vi.spyOn(service, 'method').mockResolvedValue(new Response('string'));
-```
-
-### Issue 4: Global Mock Pollution
-
-```typescript
-// ❌ Wrong: Spy on all services in beforeEach
-beforeEach(() => {
-  spyOnServiceA();
-  spyOnServiceB();
-  spyOnServiceC(); // Creates coupling between tests
-});
-
-// ✅ Correct: Spy on-demand
-beforeEach(() => {
-  spyOnCommonService(); // Only spy on common services
-});
-
-describe('specific test', () => {
-  it('test', () => {
-    const specificSpy = vi.spyOn(specificService, 'method'); // Spy on-demand
-  });
-});
-```
-
-## Test Coverage Goals 📊
-
-### Coverage Requirements
-
-- **Minimum target**: 70%
-- **Recommended target**: 85%+
-- **Excellent target**: 90%+
-
-### Check Coverage
-
-```bash
-# Run coverage for a single test file
-bunx vitest run --coverage 'src/store/[domain]/__tests__/[action].test.ts'
-
-# View coverage for a specific file
-bunx vitest run --coverage --silent='passed-only' 'src/store/[domain]/__tests__/[action].test.ts' | grep "[action].ts"
-```
-
-### Priority Test Scenarios
-
-1. ✅ **Main Flow**: Normal business flow
-2. ✅ **Edge Cases**: Empty data, undefined values, boundary values
-3. ✅ **Error Handling**: Exception scenarios, failure retries
-4. ✅ **State Management**: Loading, Toggle, Abort
-5. ⚠️ **Corner Cases**: Optional, but don't write meaningless tests just for coverage
-
-## Real-World Case: generateAIChat Refactoring 🎓
-
-### Problems Before Refactoring
-
-```typescript
-// ❌ Problem 1: Cross-layer spying
-describe('internal_coreProcessMessage', () => {
-  const streamSpy = vi.spyOn(chatService, 'createAssistantMessageStream');
-  // Skipped the internal_fetchAIChatMessage layer
-});
-
-// ❌ Problem 2: Mocking wrong objects
-describe('internal_fetchAIChatMessage', () => {
-  vi.stubGlobal('fetch', ...); // But doesn't actually call fetch
-});
-
-// ❌ Problem 3: Global spy pollution
-beforeEach(() => {
-  spyOnChatService(); // All tests now have this spy
-});
-```
-
-### Solutions After Refactoring
-
-```typescript
-// ✅ Solution 1: Spy on direct dependencies
-describe('internal_coreProcessMessage', () => {
-  const fetchSpy = vi
-    .spyOn(result.current, 'internal_fetchAIChatMessage')
-    .mockResolvedValue({ isFunctionCall: false, content: 'response' });
-});
-
-// ✅ Solution 2: Mock correct service
-describe('internal_fetchAIChatMessage', () => {
-  const streamSpy = vi
-    .spyOn(chatService, 'createAssistantMessageStream')
-    .mockImplementation(async ({ onMessageHandle, onFinish }) => {
-      await onMessageHandle?.({ type: 'text', text: 'response' });
-      await onFinish?.('response', {});
-    });
-});
-
-// ✅ Solution 3: Spy on-demand
-beforeEach(() => {
-  spyOnMessageService(); // Only spy on common services
-  // Spy on chatService on-demand in tests
-});
-```
-
-### Refactoring Results
-
-- 📈 Coverage improvement: 54.44% → 82.03% (+27.59%)
-- ✅ Test pass rate: 52/52 (100%)
-- 🎯 Type errors: 6 → 0
-- 📝 Clearer tests: Explicit test layering
-
-## Best Practices Checklist ✅
-
-Check before testing:
-
-- [ ] Following test layering principle?
-- [ ] Mock objects match actual calls?
-- [ ] Avoiding global spy pollution?
-- [ ] All setState wrapped with act()?
-- [ ] Tests sufficiently atomic?
-- [ ] Test descriptions clear?
-- [ ] Coverage meets target?

.cursor/rules/typescript.mdc

@@ -10,11 +10,61 @@ 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` and `any`).
+- use the most accurate type possible (e.g., prefer `Record<PropertyKey, unknown>` over `object`).
 - 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` over `as any`
-- Avoid meaningless null/undefined parameters; design strict function contracts.
+- 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
+  }
+  ```
 
 ## Imports and Modules
 
@@ -29,11 +79,16 @@ 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
 
@@ -45,14 +100,15 @@ alwaysApply: false
 ## Performance
 
 - Prefer `for…of` loops to index-based `for` loops when feasible.
-- Reuse existing utils inside `packages/utils` or installed npm packages rather than reinventing the wheel.
+- 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`).
 - 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.
 
-## Logging
+## Some logging rules
 
 - 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.

.env.example

@@ -169,13 +169,6 @@ OPENAI_API_KEY=sk-xxxxxxxxx
 
 # FAL_API_KEY=fal-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
-########################################
-######### AI Image Settings ############
-########################################
-
-# Default image generation count (range: 1-20, default: 4)
-# AI_IMAGE_DEFAULT_IMAGE_NUM=4
-
 ### Nebius ###
 
 # NEBIUS_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.github/ISSUE_TEMPLATE/1_bug_report_cn.yml

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -1,78 +0,0 @@
-// @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

@@ -1,120 +0,0 @@
-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. CRITICAL RULES to prevent hallucination and ensure accuracy:
-
-               - The "Original Content" section MUST contain the EXACT, UNMODIFIED original text byte-for-byte. NEVER add, remove, modify, or hallucinate ANY content in this section.
-               - Code blocks, error logs, JSON structures, and other technical content MUST appear in BOTH the translated section AND the original content section WITHOUT ANY MODIFICATION.
-               - When translating content with code/logs/JSON:
-                 * Copy the code/logs/JSON blocks identically to both sections
-                 * Only translate the natural language text (e.g., Chinese, Japanese) surrounding the code blocks
-                 * Keep all technical content (URLs, variable names, error messages in English) unchanged
-               - ALWAYS verify the "Original Content" section matches the source text exactly before updating
-               - If you detect any discrepancy, retrieve the original content again to ensure accuracy
-               - Pay special attention to the end of comments - do not drop or hallucinate the last sentences
-
-            5. 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

@@ -36,7 +36,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       - name: Install deps
         run: bun i
@@ -95,7 +95,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, macos-15-intel, windows-2025, ubuntu-latest]
+        os: [macos-latest, macos-13, 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 }}
 
@@ -188,7 +188,7 @@ jobs:
             else
               ARCH_SUFFIX="x64"
             fi
-
+            
             mv latest-mac.yml "latest-mac-${ARCH_SUFFIX}.yml"
             echo "✅ Renamed latest-mac.yml to latest-mac-${ARCH_SUFFIX}.yml (detected: $SYSTEM_ARCH)"
             ls -la latest-mac-*.yml
@@ -234,7 +234,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       # 下载所有平台的构建产物
       - name: Download artifacts

.github/workflows/docker-database.yml

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

.github/workflows/docker-pglite.yml

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

.github/workflows/docker.yml

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

.github/workflows/e2e.yml

@@ -1,52 +0,0 @@
-name: E2E CI
-permissions:
-  contents: read
-
-on:
-    pull_request:
-    push:
-
-concurrency:
-    group: e2e-${{ github.ref }}
-    cancel-in-progress: true
-
-jobs:
-    e2e:
-        name: Test Web App
-        runs-on: ubuntu-latest
-        timeout-minutes: 25
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-
-            - name: Setup Bun
-              uses: oven-sh/setup-bun@v2
-              with:
-                  bun-version: latest
-
-            - name: Install dependencies (bun)
-              run: bun install
-
-            - name: Install Playwright browsers (with system deps)
-              run: bunx playwright install --with-deps chromium
-
-            - name: Run E2E tests
-              env:
-                  PORT: 3010
-              run: bun run e2e
-
-            - name: Upload Playwright HTML report (on failure)
-              if: failure()
-              uses: actions/upload-artifact@v4
-              with:
-                  name: playwright-report
-                  path: playwright-report
-                  if-no-files-found: ignore
-
-            - name: Upload Playwright traces (on failure)
-              if: failure()
-              uses: actions/upload-artifact@v4
-              with:
-                  name: test-results
-                  path: test-results
-                  if-no-files-found: ignore

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

@@ -28,7 +28,8 @@ 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.
+            Please make sure you have given us as much context as possible.\
+            非常感谢您提交 issue。我们会尽快调查此事，并尽快回复您。 请确保您已经提供了尽可能多的背景信息。
       - name: Auto Comment on Issues Closed
         uses: wow-actions/auto-comment@v1
         with:
@@ -36,7 +37,8 @@ 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:
@@ -46,7 +48,9 @@ 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
@@ -55,7 +59,8 @@ 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.
+            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 消息。
           emoji: 'hooray'
           pr-emoji: '+1, heart'
       - name: Remove inactive

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

@@ -38,7 +38,8 @@ 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.
+            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，若有任何问题，可评论回复。
       - name: need reproduce
         uses: actions-cool/issues-helper@v3
         with:
@@ -49,7 +50,8 @@ 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.
+            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，若有任何问题，可评论回复。
       - name: need reproduce
         uses: actions-cool/issues-helper@v3
         with:
@@ -60,4 +62,5 @@ 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.
+            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，若有任何问题，可评论回复。

.github/workflows/issues-translate.yml

@@ -0,0 +1,14 @@
+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

@@ -1,26 +0,0 @@
-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@v8
-        with:
-          script: |
-            const lockScript = require('./.github/scripts/lock-closed-issues.js');
-            await lockScript({ github, context });

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

@@ -32,7 +32,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       - name: Install deps
         run: bun i
@@ -82,7 +82,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, macos-15-intel, windows-2025, ubuntu-latest]
+        os: [macos-latest, macos-13, 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 }}
 
@@ -170,7 +170,7 @@ jobs:
             else
               ARCH_SUFFIX="x64"
             fi
-
+            
             mv latest-mac.yml "latest-mac-${ARCH_SUFFIX}.yml"
             echo "✅ Renamed latest-mac.yml to latest-mac-${ARCH_SUFFIX}.yml (detected: $SYSTEM_ARCH)"
             ls -la latest-mac-*.yml
@@ -216,7 +216,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       # 下载所有平台的构建产物
       - name: Download artifacts

.github/workflows/release.yml

@@ -1,10 +1,4 @@
 name: Release CI
-
-permissions:
-  contents: write
-  issues: write
-  pull-requests: write
-
 on:
   push:
     branches:
@@ -41,7 +35,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       - name: Install deps
         run: bun i

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

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

.github/workflows/test.yml

@@ -18,7 +18,6 @@ jobs:
           - web-crawler
           - electron-server-ipc
           - utils
-          - python-interpreter
           - context-engine
           - agent-runtime
 
@@ -45,7 +44,7 @@ jobs:
         run: bun run --filter @lobechat/${{ matrix.package }} test:coverage
 
       - name: Upload ${{ matrix.package }} coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./packages/${{ matrix.package }}/coverage/lcov.info
@@ -71,7 +70,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       - name: Install deps
         run: bun i
@@ -80,7 +79,7 @@ jobs:
         run: bun run --filter ${{ matrix.package }} test:coverage
 
       - name: Upload ${{ matrix.package }} coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./packages/${{ matrix.package }}/coverage/lcov.info
@@ -104,7 +103,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       - name: Install deps
         run: bun i
@@ -113,7 +112,7 @@ jobs:
         run: bun run test-app:coverage
 
       - name: Upload App Coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: ./coverage/app/lcov.info
@@ -148,7 +147,7 @@ jobs:
       - name: Install bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: 1.2.23
+          bun-version: ${{ secrets.BUN_VERSION }}
 
       - name: Install deps
         run: bun i
@@ -174,7 +173,7 @@ jobs:
           APP_URL: https://home.com
 
       - name: Upload Database coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         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: 'chatgpt-4o-latest',
+  modelName: 'gpt-4.1-mini',
   experimental: {
     jsonMode: true,
   },

.vscode/settings.json

@@ -11,7 +11,6 @@
     { "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": [
@@ -82,7 +81,7 @@
 
     "**/src/config/modelProviders/*.ts": "${filename} • provider",
     "**/packages/model-bank/src/aiModels/*.ts": "${filename} • model",
-    "**/packages/model-runtime/src/providers/*/index.ts": "${dirname} • runtime",
+    "**/packages/model-runtime/src/*/index.ts": "${dirname} • runtime",
 
     "**/src/server/services/*/index.ts": "${dirname} • server/service",
     "**/src/server/routers/lambda/*.ts": "${filename} • lambda",

AGENTS.md

@@ -44,7 +44,21 @@ 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
 
@@ -53,57 +67,64 @@ 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]'` (each subpackage contains its own vitest.config.mts)
+- Packages: `cd packages/[package-name] && bunx vitest run --silent='passed-only' '[file-path-pattern]'`
 
 **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
+- 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
 
 ### Type Checking
 
 - Use `bun run type-check` to check for type errors
+- Ensure all TypeScript errors are resolved before committing
 
-### i18n
+### Internationalization
 
-- **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
+- 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)
 
-## Project Rules Index
+## Available Development Rules
 
-All following rules are saved under `.cursor/rules/` directory:
+The project provides comprehensive rules in `.cursor/rules/` directory:
 
-### Backend
+### Core Development
 
-- `drizzle-schema-style-guide.mdc` – Style guide for defining Drizzle ORM schemas
+- `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
 
-### Frontend
+### State Management & UI
 
-- `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
+- `zustand-slice-organization.mdc` - Store organization patterns
+- `zustand-action-patterns.mdc` - Action implementation patterns
+- `packages/react-layout-kit.mdc` - Flex layout component usage
 
-### State Management
+### Testing & Quality
 
-- `zustand-action-patterns.mdc` – Recommended patterns for organizing Zustand actions
-- `zustand-slice-organization.mdc` – Best practices for structuring Zustand slices
+- `testing-guide/testing-guide.mdc` - Comprehensive testing strategy
+- `code-review.mdc` - Code review process and standards
 
 ### Desktop (Electron)
 
-- `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
+- `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
 
-### Debugging
+## Best Practices
 
-- `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
+- **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

CLAUDE.md

@@ -31,18 +31,28 @@ 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
 
-- **Required Rule**: read `@.cursor/rules/testing-guide/testing-guide.mdc` before writing tests
+Testing work follows the Rule-Aware Task Execution system above.
+
+- **Required Rule**: `testing-guide/testing-guide.mdc`
 - **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**:
 
-- wrap the file path in single quotes to avoid shell expansion
+- wrapped 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 trying to fix the same test twice, but still failed, stop and ask for help.
+- If try to fix the same test twice, but still failed, stop and ask for help.
 
 ### Typecheck
 
@@ -51,9 +61,40 @@ see @.cursor/rules/typescript.mdc
 ### i18n
 
 - **Keys**: Add to `src/locales/default/namespace.ts`
-- **Dev**: Translate `locales/zh-CN/namespace.json` and `locales/en-US/namespace.json` locales file only for dev preview
+- **Dev**: Translate `locales/zh-CN/namespace.json` locale file only for preview
 - DON'T run `pnpm i18n`, let CI auto handle it
 
 ## Rules Index
 
-Some useful project rules are listed in @.cursor/rules/rules-index.mdc
+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

Dockerfile

@@ -142,8 +142,7 @@ ENV ACCESS_CODE="" \
     DEFAULT_AGENT_CONFIG="" \
     SYSTEM_AGENT="" \
     FEATURE_FLAGS="" \
-    PROXY_URL="" \
-    ENABLE_AUTH_PROTECTION=""
+    PROXY_URL=""
 
 # Model Variables
 ENV \
@@ -256,7 +255,7 @@ ENV \
     # 302.AI
     AI302_API_KEY="" AI302_MODEL_LIST="" \
     # FAL
-    ENABLED_FAL="" FAL_API_KEY="" FAL_MODEL_LIST="" \
+    FAL_API_KEY="" FAL_MODEL_LIST="" \
     # BFL
     BFL_API_KEY="" BFL_MODEL_LIST="" \
     # Vercel AI Gateway

Dockerfile.database

@@ -39,8 +39,6 @@ ARG USE_CN_MIRROR
 ARG NEXT_PUBLIC_BASE_PATH
 ARG NEXT_PUBLIC_SERVICE_MODE
 ARG NEXT_PUBLIC_ENABLE_NEXT_AUTH
-ARG NEXT_PUBLIC_ENABLE_CLERK_AUTH
-ARG NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY
 ARG NEXT_PUBLIC_SENTRY_DSN
 ARG NEXT_PUBLIC_ANALYTICS_POSTHOG
 ARG NEXT_PUBLIC_POSTHOG_HOST
@@ -55,9 +53,6 @@ ENV NEXT_PUBLIC_BASE_PATH="${NEXT_PUBLIC_BASE_PATH}" \
 
 ENV NEXT_PUBLIC_SERVICE_MODE="${NEXT_PUBLIC_SERVICE_MODE:-server}" \
     NEXT_PUBLIC_ENABLE_NEXT_AUTH="${NEXT_PUBLIC_ENABLE_NEXT_AUTH:-1}" \
-    NEXT_PUBLIC_ENABLE_CLERK_AUTH="${NEXT_PUBLIC_ENABLE_CLERK_AUTH:-0}" \
-    NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY="${NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY}" \
-    CLERK_WEBHOOK_SECRET="whsec_xxx" \
     APP_URL="http://app.com" \
     DATABASE_DRIVER="node" \
     DATABASE_URL="postgres://postgres:password@localhost:5432/postgres" \
@@ -171,8 +166,7 @@ ENV ACCESS_CODE="" \
     DEFAULT_AGENT_CONFIG="" \
     SYSTEM_AGENT="" \
     FEATURE_FLAGS="" \
-    PROXY_URL="" \
-    ENABLE_AUTH_PROTECTION=""
+    PROXY_URL=""
 
 # Database
 ENV KEY_VAULTS_SECRET="" \
@@ -184,19 +178,13 @@ ENV NEXT_AUTH_SECRET="" \
     NEXT_AUTH_SSO_PROVIDERS="" \
     NEXTAUTH_URL=""
 
-# Clerk
-ENV CLERK_SECRET_KEY="" \
-    CLERK_WEBHOOK_SECRET=""
-
 # S3
 ENV NEXT_PUBLIC_S3_DOMAIN="" \
     S3_PUBLIC_DOMAIN="" \
     S3_ACCESS_KEY_ID="" \
     S3_BUCKET="" \
     S3_ENDPOINT="" \
-    S3_SECRET_ACCESS_KEY="" \
-    S3_ENABLE_PATH_STYLE="" \
-    S3_SET_ACL=""
+    S3_SECRET_ACCESS_KEY=""
 
 # Model Variables
 ENV \
@@ -309,13 +297,11 @@ ENV \
     # 302.AI
     AI302_API_KEY="" AI302_MODEL_LIST="" \
     # FAL
-    ENABLED_FAL="" FAL_API_KEY="" FAL_MODEL_LIST="" \
+    FAL_API_KEY="" FAL_MODEL_LIST="" \
     # BFL
     BFL_API_KEY="" BFL_MODEL_LIST="" \
     # Vercel AI Gateway
-    VERCELAIGATEWAY_API_KEY="" VERCELAIGATEWAY_MODEL_LIST="" \
-    # Cerebras
-    CEREBRAS_API_KEY="" CEREBRAS_MODEL_LIST=""
+    VERCELAIGATEWAY_API_KEY="" VERCELAIGATEWAY_MODEL_LIST=""
 
 USER nextjs
 

Dockerfile.pglite

@@ -144,8 +144,7 @@ ENV ACCESS_CODE="" \
     DEFAULT_AGENT_CONFIG="" \
     SYSTEM_AGENT="" \
     FEATURE_FLAGS="" \
-    PROXY_URL="" \
-    ENABLE_AUTH_PROTECTION=""
+    PROXY_URL=""
 
 # Model Variables
 ENV \
@@ -254,7 +253,7 @@ ENV \
     # 302.AI
     AI302_API_KEY="" AI302_MODEL_LIST="" \
     # FAL
-    ENABLED_FAL="" FAL_API_KEY="" FAL_MODEL_LIST="" \
+    FAL_API_KEY="" FAL_MODEL_LIST="" \
     # BFL
     BFL_API_KEY="" BFL_MODEL_LIST="" \
     # Vercel AI Gateway

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                                                                                                             |
-| ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| [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`                                                      |
+| 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` |
 
-> 📊 Total plugins: [<kbd>**42**</kbd>](https://lobechat.com/discover/plugins)
+> 📊 Total plugins: [<kbd>**41**</kbd>](https://lobechat.com/discover/plugins)
 
  <!-- PLUGIN LIST -->
 

README.zh-CN.md

@@ -375,14 +375,14 @@ LobeChat 的插件生态系统是其核心功能的重要扩展，它极大地
 
 <!-- PLUGIN LIST -->
 
-| 最近新增                                                                                                                   | 描述                                                                               |
-| -------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
-| [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/>`网络` `搜索`                      |
+| 最近新增                                                                                                                     | 描述                                                                               |
+| ---------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
+| [网页](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/>`图像` `通义` `万象`    |
 
-> 📊 Total plugins: [<kbd>**42**</kbd>](https://lobechat.com/discover/plugins)
+> 📊 Total plugins: [<kbd>**41**</kbd>](https://lobechat.com/discover/plugins)
 
  <!-- PLUGIN LIST -->
 

apps/desktop/electron-builder.js

@@ -1,7 +1,5 @@
 const dotenv = require('dotenv');
-const fs = require('node:fs/promises');
 const os = require('node:os');
-const path = require('node:path');
 
 dotenv.config();
 
@@ -34,50 +32,11 @@ 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
@@ -122,7 +81,6 @@ const config = {
     compression: 'maximum',
     entitlementsInherit: 'build/entitlements.mac.plist',
     extendInfo: {
-      CFBundleIconName: 'AppIcon',
       CFBundleURLTypes: [
         {
           CFBundleURLName: 'LobeHub Protocol',

apps/desktop/src/main/appBrowsers.ts

@@ -46,55 +46,4 @@ 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, WindowTemplateIdentifiers } from '@/appBrowsers';
+import { AppBrowsersIdentifiers, BrowsersIdentifiers } from '@/appBrowsers';
 import { IpcClientEventSender } from '@/types/ipcClientEvent';
 
 import { ControllerModule, ipcClientEvent, shortcut } from './index';
@@ -100,77 +100,6 @@ 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,6 +336,7 @@ 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, WindowTemplate, WindowTemplateIdentifiers, windowTemplates } from '../../appBrowsers';
+import { AppBrowsersIdentifiers, appBrowsers } 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<string, Browser> = new Map();
+  browsers: Map<AppBrowsersIdentifiers, Browser> = new Map();
 
-  private webContentsMap = new Map<WebContents, string>();
+  private webContentsMap = new Map<WebContents, AppBrowsersIdentifiers>();
 
   constructor(app: App) {
     logger.debug('Initializing BrowserManager');
@@ -51,12 +51,12 @@ export class BrowserManager {
   };
 
   broadcastToWindow = <T extends MainBroadcastEventKey>(
-    identifier: string,
+    identifier: AppBrowsersIdentifiers,
     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,21 +87,13 @@ export class BrowserManager {
    * @param identifier Window identifier
    * @param subPath Sub-path, such as 'agent', 'about', etc.
    */
-  async redirectToPage(identifier: string, subPath?: string) {
+  async redirectToPage(identifier: AppBrowsersIdentifiers, subPath?: string) {
     try {
       // Ensure window is retrieved or created
       const browser = this.retrieveByIdentifier(identifier);
       browser.hide();
 
-      // 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;
-      }
+      const baseRoute = appBrowsers[identifier].path;
 
       // Build complete URL path
       const fullPath = subPath ? `${baseRoute}/${subPath}` : baseRoute;
@@ -122,75 +114,13 @@ export class BrowserManager {
   /**
    * get Browser by identifier
    */
-  retrieveByIdentifier(identifier: string) {
+  retrieveByIdentifier(identifier: AppBrowsersIdentifiers) {
     const browser = this.browsers.get(identifier);
 
     if (browser) return browser;
 
-    // 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();
-      }
-    });
+    logger.debug(`Browser ${identifier} not found, initializing new instance`);
+    return this.retrieveOrInitialize(appBrowsers[identifier]);
   }
 
   /**
@@ -214,7 +144,7 @@ export class BrowserManager {
    * @param options Browser window options
    */
   private retrieveOrInitialize(options: BrowserWindowOpts) {
-    let browser = this.browsers.get(options.identifier);
+    let browser = this.browsers.get(options.identifier as AppBrowsersIdentifiers);
     if (browser) {
       logger.debug(`Retrieved existing browser: ${options.identifier}`);
       return browser;
@@ -223,7 +153,7 @@ export class BrowserManager {
     logger.debug(`Creating new browser: ${options.identifier}`);
     browser = new Browser(options, this.app);
 
-    const identifier = options.identifier;
+    const identifier = options.identifier as AppBrowsersIdentifiers;
     this.browsers.set(identifier, browser);
 
     // 记录 WebContents 和 identifier 的映射
@@ -236,32 +166,32 @@ export class BrowserManager {
 
     browser.browserWindow.on('show', () => {
       if (browser.webContents)
-        this.webContentsMap.set(browser.webContents, browser.identifier);
+        this.webContentsMap.set(browser.webContents, browser.identifier as AppBrowsersIdentifiers);
     });
 
     return browser;
   }
 
   closeWindow(identifier: string) {
-    const browser = this.browsers.get(identifier);
+    const browser = this.browsers.get(identifier as AppBrowsersIdentifiers);
     browser?.close();
   }
 
   minimizeWindow(identifier: string) {
-    const browser = this.browsers.get(identifier);
+    const browser = this.browsers.get(identifier as AppBrowsersIdentifiers);
     browser?.browserWindow.minimize();
   }
 
   maximizeWindow(identifier: string) {
-    const browser = this.browsers.get(identifier);
-    if (browser?.browserWindow.isMaximized()) {
+    const browser = this.browsers.get(identifier as AppBrowsersIdentifiers);
+    if (browser.browserWindow.isMaximized()) {
       browser?.browserWindow.unmaximize();
     } else {
       browser?.browserWindow.maximize();
     }
   }
 
-  getIdentifierByWebContents(webContents: WebContents): string | null {
+  getIdentifierByWebContents(webContents: WebContents): AppBrowsersIdentifiers | null {
     return this.webContentsMap.get(webContents) || null;
   }
 

changelog/v1.json

@@ -1,319 +1,4 @@
 [
-  {
-    "children": {
-      "improvements": ["Add imagen model to vertex ai."]
-    },
-    "date": "2025-10-14",
-    "version": "1.137.5"
-  },
-  {
-    "children": {
-      "fixes": ["Prevent Vertex AI JSON credentials from being split by comma."]
-    },
-    "date": "2025-10-14",
-    "version": "1.137.4"
-  },
-  {
-    "children": {
-      "fixes": [
-        "Fix mcp server connect issue and refactor web search implement, fix tools calling long name length >64 issue."
-      ]
-    },
-    "date": "2025-10-14",
-    "version": "1.137.3"
-  },
-  {
-    "children": {
-      "fixes": ["Fix the Worker URL cross-origin issue."]
-    },
-    "date": "2025-10-14",
-    "version": "1.137.2"
-  },
-  {
-    "children": {
-      "improvements": ["Change the user chatItem maxWidth should use flex 1."]
-    },
-    "date": "2025-10-14",
-    "version": "1.137.1"
-  },
-  {
-    "children": {
-      "features": ["Add new setting for default image num."]
-    },
-    "date": "2025-10-12",
-    "version": "1.137.0"
-  },
-  {
-    "children": {
-      "fixes": ["Fix input cannot send markdown."],
-      "improvements": ["Optimize OpenRouter modelFetch endpoint, update i18n."]
-    },
-    "date": "2025-10-12",
-    "version": "1.136.13"
-  },
-  {
-    "children": {
-      "improvements": ["Add more AWS regions, Update infini-ai models."]
-    },
-    "date": "2025-10-11",
-    "version": "1.136.12"
-  },
-  {
-    "children": {
-      "improvements": [
-        "Add capability inference for web search, image output and video recognition in model parsing and update UI form items to support search, imageOutput and video abilities."
-      ]
-    },
-    "date": "2025-10-11",
-    "version": "1.136.11"
-  },
-  {
-    "children": {
-      "improvements": ["Improve search experience."]
-    },
-    "date": "2025-10-11",
-    "version": "1.136.10"
-  },
-  {
-    "children": {
-      "improvements": ["Add lab to support disable/enable rich text."]
-    },
-    "date": "2025-10-11",
-    "version": "1.136.9"
-  },
-  {
-    "children": {},
-    "date": "2025-10-11",
-    "version": "1.136.8"
-  },
-  {
-    "children": {
-      "fixes": ["Disable rich text in markdown editor."]
-    },
-    "date": "2025-10-11",
-    "version": "1.136.7"
-  },
-  {
-    "children": {},
-    "date": "2025-10-11",
-    "version": "1.136.6"
-  },
-  {
-    "children": {},
-    "date": "2025-10-11",
-    "version": "1.136.5"
-  },
-  {
-    "children": {
-      "fixes": ["Add 'gemini-2.5-flash-image' to disabled models Thinking."]
-    },
-    "date": "2025-10-10",
-    "version": "1.136.4"
-  },
-  {
-    "children": {
-      "improvements": ["Add delete & regenerate hotkeys."]
-    },
-    "date": "2025-10-10",
-    "version": "1.136.3"
-  },
-  {
-    "children": {
-      "improvements": ["Update i18n."]
-    },
-    "date": "2025-10-10",
-    "version": "1.136.2"
-  },
-  {
-    "children": {},
-    "date": "2025-10-09",
-    "version": "1.136.1"
-  },
-  {
-    "children": {
-      "features": ["Add new provider Cerebras."],
-      "fixes": ["Fix standalone plugin rerender issue."]
-    },
-    "date": "2025-10-09",
-    "version": "1.136.0"
-  },
-  {
-    "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,9 +5,7 @@ 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. 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)
+4. Page Display: Write static components/pages (`src/app/<new-page>/features/<new-feature>.tsx`).
 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:
@@ -62,8 +60,7 @@ 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/app/chat/features/ChatPage/index.tsx
-// Note: Use src/app/<page>/features/ for page-specific components
+// src/features/chat/index.tsx
 import { List, Typography } from 'antd';
 import { useChatStore } from 'src/store/chatStore';
 
@@ -85,12 +82,6 @@ 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,9 +5,7 @@ LobeChat 基于 Next.js 框架构建，使用 TypeScript 作为主要开发语
 1. 路由：定义路由 (`src/app`)
 2. 数据结构： 定义数据结构 ( `src/types` )
 3. 业务功能实现： zustand store (`src/store`)
-4. 页面展示：书写静态组件 / 页面。根据以下方式创建功能组件：
-   - `src/features/<feature-name>/` 用于 **全局共享功能**（跨多个页面使用）
-   - `src/app/<new-page>/features/<feature-name>/` 用于 **页面专属功能**（仅在当前页面使用）
+4. 页面展示：书写静态组件 / 页面 (`src/app/<new-page>/features/<new-feature>.tsx`)
 5. 功能绑定：绑定 store 与页面的触发 (`const  [state,function]= useNewStore(s=>[s.state,s.function])`)
 
 我们以 "会话消息" 功能为例，以下是实现这个功能的简要步骤：
@@ -44,7 +42,7 @@ export type ChatMessage = {
 
 ```ts
 // src/store/chatStore.ts
-import { create } from 'zustand';
+import create from 'zustand';
 
 type ChatState = {
   messages: ChatMessage[];
@@ -62,8 +60,7 @@ export const useChatStore = create<ChatState>((set) => ({
 在 `src/app/<new-page>/features/<new-feature>.tsx` 中，我们需要创建一个新的页面或组件来显示 "会话消息"。在这个文件中，我们可以使用上面创建的 Zustand Store，以及 Ant Design 的组件来构建 UI：
 
 ```jsx
-// src/app/chat/features/ChatPage/index.tsx
-// 注意：使用 src/app/<page>/features/ 放置页面专属组件
+// src/features/chat/index.tsx
 import { List, Typography } from 'antd';
 import { useChatStore } from 'src/store/chatStore';
 
@@ -85,12 +82,6 @@ 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,88 +4,37 @@ The directory structure of LobeChat is as follows:
 
 ```bash
 src
-├── app        # Next.js App Router implementation with route groups and API routes
+├── app        # Main logic and state management related code for the application
 ├── 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
 
-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:
+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:
 
 ```bash
-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
+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
 ```
 
-### 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.
+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.

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

@@ -4,88 +4,37 @@ LobeChat 的文件夹目录架构如下：
 
 ```bash
 src
-├── app        # Next.js App Router 实现，包含路由组和 API 路由
+├── app        # 应用主要逻辑和状态管理相关的代码
 ├── 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` 目录遵循 Next.js 13+ App Router 约定，采用复杂的架构，使用 [路由组](https://nextjs.org/docs/app/building-your-application/routing/route-groups) 来组织后端服务、平台变体和应用路由：
+在 `app` 文件夹中，我们将每个路由页面按照 app router 的 [Route Groups](https://nextjs.org/docs/app/building-your-application/routing/route-groups) 进行组织，以此来分别处理桌面端和移动端的代码实现。以 `welcome` 页面的文件结构为例：
 
 ```bash
-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
+welcome
+├── (desktop)               # 桌面端实现
+│   ├── features            # 桌面端特有的功能
+│   ├── index.tsx           # 桌面端的主入口文件
+│   └── layout.desktop.tsx  # 桌面端的布局组件
+├── (mobile)                # 移动端实现
+│   ├── features            # 移动端特有的功能
+│   ├── index.tsx           # 移动端的主入口文件
+│   └── layout.mobile.tsx   # 移动端的布局组件
+├── features                # 此文件夹包含双端共享的特性代码，如 Banner 组件
+│   └── Banner
+└── page.tsx                # 此为页面的主入口文件，用于根据设备类型选择加载桌面端或移动端的代码
 ```
 
-### 架构说明
-
-**路由组：**
-- `(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,7 +16,6 @@ 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()`]
@@ -318,24 +317,6 @@ 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
@@ -429,7 +410,6 @@ 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()`]
@@ -945,7 +925,6 @@ table user_settings {
   system_agent jsonb
   default_agent jsonb
   tool jsonb
-  image jsonb
 }
 
 table users {
@@ -966,127 +945,6 @@ table users {
   updated_at "timestamp with time zone" [not null, default: `now()`]
 }
 
-table user_memories {
-  id varchar(255) [pk, not null]
-  user_id text
-  memory_category varchar(255)
-  memory_layer varchar(255)
-  memory_type varchar(255)
-  title varchar(255)
-  summary text
-  summary_vector_1024 vector(1024)
-  details text
-  details_vector_1024 vector(1024)
-  status varchar(255)
-  accessed_count bigint [default: 0]
-  last_accessed_at "timestamp with time zone" [not null]
-  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 {
-    summary_vector_1024 [name: 'user_memories_summary_vector_1024_index']
-    details_vector_1024 [name: 'user_memories_details_vector_1024_index']
-  }
-}
-
-table user_memories_contexts {
-  id varchar(255) [pk, not null]
-  user_memory_ids jsonb
-  labels jsonb
-  extracted_labels jsonb
-  associated_objects jsonb
-  associated_subjects jsonb
-  title text
-  title_vector vector(1024)
-  description text
-  description_vector vector(1024)
-  type varchar(255)
-  current_status text
-  score_impact numeric [default: 0]
-  score_urgency numeric [default: 0]
-  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 {
-    title_vector [name: 'user_memories_contexts_title_vector_index']
-    description_vector [name: 'user_memories_contexts_description_vector_index']
-    type [name: 'user_memories_contexts_type_index']
-  }
-}
-
-table user_memories_experiences {
-  id varchar(255) [pk, not null]
-  user_memory_id text
-  labels jsonb
-  extracted_labels jsonb
-  type varchar(255)
-  situation text
-  situation_vector vector(1024)
-  reasoning text
-  possible_outcome text
-  action text
-  action_vector vector(1024)
-  key_learning text
-  key_learning_vector vector(1024)
-  metadata jsonb
-  score_confidence real [default: 0]
-  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 {
-    situation_vector [name: 'user_memories_experiences_situation_vector_index']
-    action_vector [name: 'user_memories_experiences_action_vector_index']
-    key_learning_vector [name: 'user_memories_experiences_key_learning_vector_index']
-    type [name: 'user_memories_experiences_type_index']
-  }
-}
-
-table user_memories_identities {
-  current_focuses text
-  description text
-  description_vector vector(1024)
-  experience text
-  extracted_labels jsonb
-  id varchar(255) [pk, not null]
-  labels jsonb
-  relationship text
-  role text
-  type varchar(255)
-  user_memory_id text
-  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 {
-    description_vector [name: 'user_memories_identities_description_vector_index']
-    type [name: 'user_memories_identities_type_index']
-  }
-}
-
-table user_memories_preferences {
-  id varchar(255) [pk, not null]
-  context_id varchar(255)
-  user_memory_id varchar(255)
-  labels jsonb
-  extracted_labels jsonb
-  extracted_scopes jsonb
-  conclusion_directives text
-  conclusion_directives_vector vector(1024)
-  type varchar(255)
-  suggestions text
-  score_priority numeric [default: 0]
-  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 {
-    conclusion_directives_vector [name: 'user_memories_preferences_conclusion_directives_vector_index']
-  }
-}
-
 ref: agents_files.file_id > files.id
 
 ref: agents_files.agent_id > agents.id
@@ -1137,12 +995,6 @@ 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
@@ -1155,8 +1007,6 @@ 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/advanced/feature-flags.mdx

@@ -31,30 +31,20 @@ You can achieve various feature combinations using the above configuration synta
   their default values).
 </Callout>
 
-| Configuration Item        | Description                                                                                              | Default Value |
-| ------------------------- | -------------------------------------------------------------------------------------------------------- | ------------- |
-| `check_updates`           | Allows checking for updates.                                                                             | Enabled       |
-| `pin_list`                | Controls pinned agent list display in sidebar.                                                           | Disabled      |
-| `language_model_settings` | Enables language model settings.                                                                         | Enabled       |
-| `provider_settings`       | Controls model provider settings display.                                                                | Enabled       |
-| `openai_api_key`          | Allows users to customize the OpenAI API Key.                                                            | Enabled       |
-| `openai_proxy_url`        | Allows users to customize the OpenAI proxy URL.                                                          | Enabled       |
-| `api_key_manage`          | Controls access to API key management page (/profile/apikey).                                            | Disabled      |
-| `create_session`          | Allows users to create sessions.                                                                         | Enabled       |
-| `edit_agent`              | Allows users to edit assistants.                                                                         | Enabled       |
-| `plugins`                 | Controls plugin functionality in chat and agent settings.                                                | Enabled       |
-| `dalle`                   | Enables the DALL-E functionality.                                                                        | Enabled       |
-| `ai_image`                | Controls AI image generation feature and page (/image).                                                  | Enabled       |
-| `speech_to_text`          | Enables speech-to-text functionality.                                                                    | Enabled       |
-| `token_counter`           | Reserved for token counter display.                                                                      | Enabled       |
-| `welcome_suggest`         | Displays welcome suggestions.                                                                            | Enabled       |
-| `changelog`               | Controls changelog modal/page display.                                                                   | Enabled       |
-| `clerk_sign_up`           | Enables the Clerk SignUp functionality.                                                                  | Enabled       |
-| `market`                  | Enables the assistant market functionality.                                                              | Enabled       |
-| `knowledge_base`          | Enables the knowledge base functionality.                                                                | Enabled       |
-| `rag_eval`                | Controls RAG evaluation feature (/repos/\[id]/evals).                                                    | Disabled      |
-| `cloud_promotion`         | Controls cloud service promotion link display in user menu.                                              | Disabled      |
-| `commercial_hide_github`  | Hides GitHub-related links in settings footer (requires commercial license).                             | Disabled      |
-| `commercial_hide_docs`    | Hides documentation and help menu including changelog, docs, and feedback (requires commercial license). | Disabled      |
+| Configuration Item        | Description                                     | Default Value |
+| ------------------------- | ----------------------------------------------- | ------------- |
+| `webrtc_sync`             | Enables WebRTC sync functionality.              | Disabled      |
+| `language_model_settings` | Enables language model settings.                | Enabled       |
+| `openai_api_key`          | Allows users to customize the OpenAI API Key.   | Enabled       |
+| `openai_proxy_url`        | Allows users to customize the OpenAI proxy URL. | Enabled       |
+| `create_session`          | Allows users to create sessions.                | Enabled       |
+| `edit_agent`              | Allows users to edit assistants.                | Enabled       |
+| `dalle`                   | Enables the DALL-E functionality.               | Enabled       |
+| `check_updates`           | Allows checking for updates.                    | Enabled       |
+| `welcome_suggest`         | Displays welcome suggestions.                   | Enabled       |
+| `market`                  | Enables the assistant market functionality.     | Enabled       |
+| `speech_to_text`          | Enables speech-to-text functionality.           | Enabled       |
+| `knowledge_base`          | Enables the knowledge base functionality.       | Enabled       |
+| `clerk_sign_up`           | Enables the Clerk SignUp functionality.         | Enabled       |
 
 You can always check the [featureFlags](https://github.com/lobehub/lobe-chat/blob/main/src/config/featureFlags/schema.ts) to get the latest list of feature flags.

docs/self-hosting/advanced/feature-flags.zh-CN.mdx

@@ -28,30 +28,20 @@ tags:
   关键字，你需要手动控制所有的功能标志（否则它们会采用对应的默认值）。
 </Callout>
 
-| 配置项                       | 解释                                   | 默认值 |
-| ------------------------- | ------------------------------------ | --- |
-| `check_updates`           | 允许检查更新。                              | 开启  |
-| `pin_list`                | 控制侧边栏中置顶助手列表的显示。                     | 关闭  |
-| `language_model_settings` | 启用语言模型设置。                            | 开启  |
-| `provider_settings`       | 控制模型供应商设置的显示。                        | 开启  |
-| `openai_api_key`          | 允许用户自定义 OpenAI API Key。              | 开启  |
-| `openai_proxy_url`        | 允许用户自定义 OpenAI 代理 URL。               | 开启  |
-| `api_key_manage`          | 控制 API 密钥管理页面 (/profile/apikey) 的访问。 | 关闭  |
-| `create_session`          | 允许用户创建会话。                            | 开启  |
-| `edit_agent`              | 允许用户编辑助手。                            | 开启  |
-| `plugins`                 | 控制聊天和助手设置中的插件功能。                     | 开启  |
-| `dalle`                   | 启用 DALL-E 功能。                        | 开启  |
-| `ai_image`                | 控制 AI 图像生成功能和页面 (/image)。            | 开启  |
-| `speech_to_text`          | 启用语音转文本功能。                           | 开启  |
-| `token_counter`           | 保留用于令牌计数器显示。                         | 开启  |
-| `welcome_suggest`         | 显示欢迎建议。                              | 开启  |
-| `changelog`               | 控制更新日志弹窗 / 页面的显示。                    | 开启  |
-| `clerk_sign_up`           | 启用 Clerk 注册功能。                       | 开启  |
-| `market`                  | 启用助手市场功能。                            | 开启  |
-| `knowledge_base`          | 启用知识库功能。                             | 开启  |
-| `rag_eval`                | 控制 RAG 评估功能 (/repos/\[id]/evals)。    | 关闭  |
-| `cloud_promotion`         | 控制用户菜单中云服务推广链接的显示。                   | 关闭  |
-| `commercial_hide_github`  | 隐藏设置页面底部的 GitHub 相关链接（需要商业授权）。       | 关闭  |
-| `commercial_hide_docs`    | 隐藏文档和帮助菜单，包括更新日志、文档和反馈（需要商业授权）。      | 关闭  |
+| 配置项                       | 解释                      | 默认值 |
+| ------------------------- | ----------------------- | --- |
+| `webrtc_sync`             | 启用 WebRTC 同步功能。         | 关闭  |
+| `language_model_settings` | 启用语言模型设置。               | 开启  |
+| `openai_api_key`          | 允许用户自定义 OpenAI API Key。 | 开启  |
+| `openai_proxy_url`        | 允许用户自定义 OpenAI 代理 URL。  | 开启  |
+| `create_session`          | 允许用户创建会话。               | 开启  |
+| `edit_agent`              | 允许用户编辑助手。               | 开启  |
+| `dalle`                   | 启用 DALL-E 功能。           | 开启  |
+| `check_updates`           | 允许检查更新。                 | 开启  |
+| `welcome_suggest`         | 显示欢迎建议。                 | 开启  |
+| `market`                  | 启用助手市场功能。               | 开启  |
+| `speech_to_text`          | 启用语音转文本功能。              | 开启  |
+| `knowledge_base`          | 启用知识库功能。                | 开启  |
+| `clerk_sign_up`           | 启用 Clerk 注册功能。          | 开启  |
 
 你可以随时检查 [featureFlags](https://github.com/lobehub/lobe-chat/blob/main/src/config/featureFlags/schema.ts) 以获取最新的特性标志列表。

docs/self-hosting/environment-variables/basic.mdx

@@ -152,18 +152,6 @@ For specific content, please refer to the [Feature Flags](/docs/self-hosting/adv
 - Default: -
 - Example: `https://cdn.example.com`
 
-## AI Image
-
-### `AI_IMAGE_DEFAULT_IMAGE_NUM`
-
-- Type: Optional
-- Description: Sets the default number of images to generate for AI image generation. Users can still override this value in their settings.
-- Default: `4`
-- Example: `6`
-- Range: `1-20`
-
-This environment variable allows administrators to customize the default image generation count for their deployment. The value must be between 1 and 20. If not set, it defaults to 4. Users can still adjust this value in their personal settings.
-
 ## Plugin Service
 
 ### `PLUGINS_INDEX_URL`

docs/self-hosting/environment-variables/basic.zh-CN.mdx

@@ -148,18 +148,6 @@ LobeChat 在部署时提供了一些额外的配置项，你可以使用环境
 - 默认值：-
 - 示例：`https://cdn.example.com`
 
-## AI 图像
-
-### `AI_IMAGE_DEFAULT_IMAGE_NUM`
-
-- 类型：可选
-- 描述：设置 AI 图像生成的默认图片数量。用户仍可在个人设置中覆盖此值。
-- 默认值：`4`
-- 示例：`6`
-- 范围：`1-20`
-
-此环境变量允许管理员为其部署自定义默认图片生成数量。值必须在 1 到 20 之间。如果未设置，默认为 4。用户仍可在个人设置中调整此值。
-
 ## 插件服务
 
 ### `PLUGINS_INDEX_URL`

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

@@ -717,20 +717,4 @@ 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,20 +720,4 @@ 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,6 +29,11 @@ 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,6 +25,11 @@ 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)。

e2e/routes.spec.ts

@@ -1,73 +0,0 @@
-import { expect, test } from '@playwright/test';
-
-// 覆盖核心可访问路径（含重定向来源）
-const baseRoutes: string[] = [
-  '/',
-  '/chat',
-  '/discover',
-  '/image',
-  '/files',
-  '/repos', // next.config.ts -> /files
-  '/changelog',
-];
-
-// settings 路由改为通过 query 参数控制 active tab
-// 参考 SettingsTabs: about, agent, common, hotkey, llm, provider, proxy, storage, system-agent, tts
-const settingsTabs = [
-  'common',
-  'llm',
-  'provider',
-  'about',
-  'hotkey',
-  'proxy',
-  'storage',
-  'tts',
-  'system-agent',
-  'agent',
-];
-
-const routes: string[] = [...baseRoutes, ...settingsTabs.map((key) => `/settings?active=${key}`)];
-
-// CI 环境下跳过容易不稳定或受特性开关影响的路由
-const ciSkipPaths = new Set<string>([
-  '/image',
-  '/changelog',
-  '/settings?active=common',
-  '/settings?active=llm',
-]);
-
-// @ts-ignore
-async function assertNoPageErrors(page: Parameters<typeof test>[0]['page']) {
-  const pageErrors: Error[] = [];
-  const consoleErrors: string[] = [];
-
-  page.on('pageerror', (err: Error) => pageErrors.push(err));
-  page.on('console', (msg: any) => {
-    if (msg.type() === 'error') consoleErrors.push(msg.text());
-  });
-
-  // 仅校验页面级错误，忽略控制台 error 以提升稳定性
-  expect
-    .soft(pageErrors, `page errors: ${pageErrors.map((e) => e.message).join('\n')}`)
-    .toHaveLength(0);
-}
-
-test.describe('Smoke: core routes', () => {
-  for (const path of routes) {
-    test(`should open ${path} without error`, async ({ page }) => {
-      if (process.env.CI && ciSkipPaths.has(path)) test.skip(true, 'skip flaky route on CI');
-      const response = await page.goto(path, { waitUntil: 'commit' });
-      // 2xx 或 3xx 视为可接受（允许中间件/重定向）
-      const status = response?.status() ?? 0;
-      expect(status, `unexpected status for ${path}: ${status}`).toBeLessThan(400);
-
-      // 一般错误标题防御
-      await expect(page).not.toHaveTitle(/not found|error/i);
-
-      // body 可见
-      await expect(page.locator('body')).toBeVisible();
-
-      await assertNoPageErrors(page);
-    });
-  }
-});

locales/ar/chat.json

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

locales/ar/common.json

@@ -236,7 +236,6 @@
   },
   "information": "المجتمع والمعلومات",
   "installPWA": "تثبيت تطبيق المتصفح",
-  "labs": "المختبرات",
   "lang": {
     "ar": "العربية",
     "bg-BG": "البلغارية",

locales/ar/hotkey.json

@@ -7,14 +7,6 @@
     "desc": "مسح الرسائل والملفات المرفوعة في المحادثة الحالية",
     "title": "مسح رسائل المحادثة"
   },
-  "deleteAndRegenerateMessage": {
-    "desc": "حذف الرسالة الأخيرة وإعادة إنشائها",
-    "title": "حذف وإعادة إنشاء"
-  },
-  "deleteLastMessage": {
-    "desc": "حذف الرسالة الأخيرة",
-    "title": "حذف الرسالة الأخيرة"
-  },
   "desktop": {
     "openSettings": {
       "desc": "افتح صفحة إعدادات التطبيق",

locales/ar/image.json

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

locales/ar/labs.json

@@ -1,14 +0,0 @@
-{
-  "desc": "سنقوم بتحديث الميزات الجديدة التي نستكشفها من وقت لآخر، ندعوك لتجربتها!",
-  "features": {
-    "groupChat": {
-      "desc": "تفعيل إمكانية تنسيق المحادثات الجماعية متعددة الوكلاء.",
-      "title": "دردشة جماعية (متعددة الوكلاء)"
-    },
-    "inputMarkdown": {
-      "desc": "عرض Markdown في منطقة الإدخال بشكل فوري (مثل النص العريض، كتل الشيفرة، الجداول، وغيرها).",
-      "title": "عرض Markdown في حقل الإدخال"
-    }
-  },
-  "title": "المختبر"
-}

locales/ar/modelProvider.json

@@ -284,43 +284,16 @@
           "placeholder": "يرجى إدخال معرف النموذج، مثل gpt-4o أو claude-3.5-sonnet",
           "title": "معرف النموذج"
         },
-        "imageOutput": {
-          "extra": "سيؤدي هذا الإعداد فقط إلى تفعيل قدرة النموذج على توليد الصور، وتعتمد النتيجة بالكامل على قدرات النموذج نفسه. يُرجى اختبار ما إذا كان النموذج يدعم توليد الصور بشكل فعّال.",
-          "title": "يدعم توليد الصور"
-        },
         "modalTitle": "تكوين النموذج المخصص",
         "reasoning": {
           "extra": "هذا الإعداد سيفتح فقط قدرة النموذج على التفكير العميق، التأثير الفعلي يعتمد بالكامل على النموذج نفسه، يرجى اختبار ما إذا كان هذا النموذج يمتلك القدرة على التفكير العميق القابل للاستخدام",
           "title": "يدعم التفكير العميق"
         },
-        "search": {
-          "extra": "سيؤدي هذا الإعداد فقط إلى تفعيل قدرة محرك البحث المدمج في النموذج على الاتصال بالإنترنت. تعتمد إمكانية استخدام محرك البحث المدمج على قدرات النموذج نفسه. يُرجى اختبار ما إذا كان محرك البحث المدمج في النموذج يعمل بشكل فعّال.",
-          "title": "يدعم البحث عبر الإنترنت"
-        },
         "tokens": {
           "extra": "تعيين الحد الأقصى لعدد الرموز المدعومة من قبل النموذج",
           "title": "أقصى نافذة سياق",
           "unlimited": "غير محدود"
         },
-        "type": {
-          "extra": "أنواع النماذج المختلفة تمتلك سيناريوهات استخدام وقدرات مميزة",
-          "options": {
-            "chat": "محادثة",
-            "embedding": "تضمين",
-            "image": "توليد الصور",
-            "realtime": "محادثة فورية",
-            "stt": "تحويل الصوت إلى نص",
-            "text2music": "تحويل النص إلى موسيقى",
-            "text2video": "تحويل النص إلى فيديو",
-            "tts": "تحويل النص إلى كلام"
-          },
-          "placeholder": "يرجى اختيار نوع النموذج",
-          "title": "نوع النموذج"
-        },
-        "video": {
-          "extra": "سيؤدي هذا الإعداد فقط إلى تفعيل إعدادات التعرف على الفيديو داخل التطبيق. وتعتمد إمكانية التعرف على الفيديو بالكامل على قدرات النموذج نفسه. يُرجى اختبار ما إذا كان النموذج يدعم التعرف على الفيديو بشكل فعّال.",
-          "title": "يدعم التعرف على الفيديو"
-        },
         "vision": {
           "extra": "سيؤدي هذا التكوين إلى فتح إعدادات تحميل الصور في التطبيق، ما إذا كان يدعم التعرف يعتمد بالكامل على النموذج نفسه، يرجى اختبار قابلية استخدام التعرف البصري لهذا النموذج بنفسك",
           "title": "دعم التعرف البصري"

locales/ar/models.json

@@ -92,12 +92,6 @@
   "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."
   },
@@ -293,9 +287,6 @@
   "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 مليار معلمة مفعلة. تشمل الميزات الرئيسية للنموذج: تعزيز ذكاء التكويد للوكيل، مع تحسينات ملحوظة في الأداء في اختبارات المعيار المفتوحة ومهام التكويد الواقعية للوكيل؛ تحسين تجربة التكويد في الواجهة الأمامية، مع تقدم في الجمالية والعملية في برمجة الواجهة الأمامية."
   },
@@ -689,9 +680,6 @@
   "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."
   },
@@ -704,9 +692,6 @@
   "azure-DeepSeek-R1-0528": {
     "description": "مقدم من مايكروسوفت؛ تم ترقية نموذج DeepSeek R1 بإصدار فرعي، الإصدار الحالي هو DeepSeek-R1-0528. في التحديث الأخير، حسّن DeepSeek R1 بشكل كبير عمق الاستدلال وقدرات التنبؤ من خلال زيادة موارد الحوسبة وإدخال آليات تحسين الخوارزميات في مرحلة ما بعد التدريب. النموذج يحقق أداءً ممتازًا في اختبارات معيارية متعددة مثل الرياضيات والبرمجة والمنطق العام، وأداؤه الكلي يقترب من النماذج الرائدة مثل O3 و Gemini 2.5 Pro."
   },
-  "baichuan-m2-32b": {
-    "description": "Baichuan M2 32B هو نموذج خبراء هجين أطلقته شركة Baichuan Intelligence، يتمتع بقدرات استدلال قوية."
-  },
   "baichuan/baichuan2-13b-chat": {
     "description": "Baichuan-13B هو نموذج لغوي كبير مفتوح المصدر قابل للاستخدام التجاري تم تطويره بواسطة Baichuan Intelligence، ويحتوي على 13 مليار معلمة، وقد حقق أفضل النتائج في المعايير الصينية والإنجليزية."
   },
@@ -731,6 +716,12 @@
   "charglm-4": {
     "description": "CharGLM-4 مصمم خصيصًا للأدوار والشعور بالرفقة، يدعم الذاكرة متعددة الجولات الطويلة والحوار المخصص، ويستخدم على نطاق واسع."
   },
+  "chatglm3": {
+    "description": "ChatGLM3 هو نموذج مغلق المصدر تم إصداره بواسطة مختبر KEG في جامعة تسينغهوا وشركة Zhizhu AI، وقد تم تدريبه مسبقًا على كميات هائلة من المعرفة المعرفية باللغتين الصينية والإنجليزية، وتم تحسينه وفقًا للاختيارات البشرية. مقارنة بالنموذج الأول، حقق تحسينات بنسبة 16٪ و 36٪ و 280٪ في MMLU و C-Eval و GSM8K على التوالي، وتصدر قائمة المهام الصينية C-Eval. يناسب هذا النموذج السيناريوهات التي تتطلب كميات كبيرة من المعرفة وقدرات الاستدلال والإبداع، مثل كتابة النصوص الإعلانية وكتابة الروايات وكتابة المحتوى المعرفي وتكوين الكود."
+  },
+  "chatglm3-6b-base": {
+    "description": "ChatGLM3-6b-base هو النموذج الأساسي المفتوح المصدر الأحدث من سلسلة ChatGLM التي طورتها شركة Zhìpǔ، ويحتوي على 6 مليارات معلمة."
+  },
   "chatgpt-4o-latest": {
     "description": "ChatGPT-4o هو نموذج ديناميكي يتم تحديثه في الوقت الحقيقي للحفاظ على أحدث إصدار. يجمع بين فهم اللغة القوي وقدرات التوليد، مما يجعله مناسبًا لمجموعة واسعة من التطبيقات، بما في ذلك خدمة العملاء والتعليم والدعم الفني."
   },
@@ -782,9 +773,6 @@
   "claude-sonnet-4-20250514-thinking": {
     "description": "كلود سونيت 4 نموذج تفكيري يمكنه إنتاج استجابات شبه فورية أو تفكير تدريجي مطول، حيث يمكن للمستخدم رؤية هذه العمليات بوضوح."
   },
-  "claude-sonnet-4-5-20250929": {
-    "description": "كلود سونيت 4.5 هو أذكى نموذج قدمته شركة أنثروبيك حتى الآن."
-  },
   "codegeex-4": {
     "description": "CodeGeeX-4 هو مساعد برمجي قوي، يدعم مجموعة متنوعة من لغات البرمجة في الإجابة الذكية وإكمال الشيفرة، مما يعزز من كفاءة التطوير."
   },
@@ -932,12 +920,6 @@
   "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-V3.2-Exp": {
-    "description": "نموذج DeepSeek V3.2 Exp هو نموذج بهيكلية استدلال هجينة، يدعم وضعي التفكير وغير التفكير."
-  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B هو نموذج متقدم تم تدريبه للحوار المعقد."
   },
@@ -947,9 +929,6 @@
   "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 مليار معلمة فقط. يقدم هذا النموذج أداءً ممتازًا في مهام مثل الأسئلة البصرية، التعرف الضوئي على الأحرف، فهم الوثائق/الجداول/الرسوم البيانية، وتحديد المواقع البصرية."
   },
@@ -1014,7 +993,7 @@
     "description": "DeepSeek R1 النسخة الكاملة، تحتوي على 671 مليار معلمة، تدعم البحث المتصل في الوقت الحقيقي، وتتمتع بقدرات فهم وتوليد أقوى."
   },
   "deepseek-reasoner": {
-    "description": "وضع التفكير في DeepSeek V3.2. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من الأفكار لتحسين دقة الإجابة النهائية."
+    "description": "وضع التفكير في DeepSeek V3.1. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من التفكير لتحسين دقة الإجابة النهائية."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 هو نموذج لغوي فعال من نوع Mixture-of-Experts، مناسب لاحتياجات المعالجة الاقتصادية."
@@ -1031,15 +1010,9 @@
   "deepseek-v3.1": {
     "description": "DeepSeek-V3.1 هو نموذج استدلال هجين جديد أطلقته DeepSeek، يدعم وضعين للاستدلال: التفكير وعدم التفكير، مع كفاءة تفكير أعلى مقارنة بـ DeepSeek-R1-0528. بعد تحسين ما بعد التدريب، تم تعزيز استخدام أدوات الوكيل وأداء مهام الوكيل بشكل كبير. يدعم نافذة سياق تصل إلى 128 ألف، وطول إخراج يصل إلى 64 ألف رمز."
   },
-  "deepseek-v3.1-terminus": {
-    "description": "DeepSeek-V3.1-Terminus هو إصدار محسن من نموذج اللغة الكبير أطلقته DeepSeek، ومُصمم خصيصًا للأجهزة الطرفية."
-  },
   "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) ويظهر أداءً ممتازًا في مجموعة متنوعة من المهام."
   },
@@ -1196,12 +1169,6 @@
   "ernie-4.0-turbo-8k-preview": {
     "description": "نموذج اللغة الكبير الرائد الذي طورته بايدو، والذي يظهر أداءً ممتازًا بشكل شامل، ويستخدم على نطاق واسع في مشاهد المهام المعقدة في مختلف المجالات؛ يدعم الاتصال التلقائي بمكونات البحث من بايدو، مما يضمن تحديث معلومات الإجابة. مقارنةً بـ ERNIE 4.0، يظهر أداءً أفضل."
   },
-  "ernie-4.5-21b-a3b": {
-    "description": "ERNIE 4.5 21B A3B هو نموذج خبراء هجين أطلقته Baidu Wenxin، يتمتع بقدرات قوية في الاستدلال ودعم متعدد اللغات."
-  },
-  "ernie-4.5-300b-a47b": {
-    "description": "ERNIE 4.5 300B A47B هو نموذج خبراء هجين فائق الحجم أطلقته Baidu Wenxin، يتميز بقدرات استدلال فائقة."
-  },
   "ernie-4.5-8k-preview": {
     "description": "نموذج ونسين 4.5 هو نموذج أساسي جديد متعدد الوسائط تم تطويره ذاتيًا بواسطة بايدو، من خلال نمذجة متعددة الوسائط لتحقيق تحسين متزامن، ويظهر قدرة ممتازة على الفهم متعدد الوسائط؛ يتمتع بقدرات لغوية متقدمة، مع تحسين شامل في الفهم، والتوليد، والمنطق، والذاكرة، مع تحسين كبير في إزالة الأوهام، والاستدلال المنطقي، وقدرات البرمجة."
   },
@@ -1265,9 +1232,6 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] هو نموذج توليد صور يحتوي على 12 مليار معلمة، يركز على توليد صور عالية الجودة بسرعة."
   },
-  "fal-ai/hunyuan-image/v3": {
-    "description": "نموذج قوي لتوليد الصور متعددة الوسائط الأصلية"
-  },
   "fal-ai/imagen4/preview": {
     "description": "نموذج توليد صور عالي الجودة مقدم من جوجل."
   },
@@ -1379,36 +1343,24 @@
   "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، بالإضافة إلى تحليل مجموعات البيانات الكبيرة ومستودعات الأكواد والوثائق باستخدام سياق طويل."
   },
@@ -1421,15 +1373,6 @@
   "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 مناسب لمعالجة المهام المتوسطة والصغيرة، ويجمع بين الكفاءة من حيث التكلفة."
   },
@@ -1458,7 +1401,7 @@
     "description": "GLM-4-0520 هو أحدث إصدار من النموذج، مصمم للمهام المعقدة والمتنوعة، ويظهر أداءً ممتازًا."
   },
   "glm-4-9b-chat": {
-    "description": "يُظهر GLM-4-9B-Chat أداءً عاليًا في مجالات الدلالة، والرياضيات، والاستدلال، والبرمجة، والمعرفة. كما يدعم تصفح الويب، وتنفيذ الأكواد، واستدعاء الأدوات المخصصة، والاستدلال على النصوص الطويلة. يدعم 26 لغة من بينها اليابانية والكورية والألمانية."
+    "description": "يظهر GLM-4-9B-Chat أداءً عاليًا في مجالات متعددة مثل الدلالات والرياضيات والاستدلال والترميز والمعرفة. كما أنه مزود بقدرات تصفح الويب وتنفيذ الشيفرات واستدعاء الأدوات المخصصة واستدلال النصوص الطويلة. يدعم 26 لغة بما في ذلك اليابانية والكورية والألمانية."
   },
   "glm-4-air": {
     "description": "GLM-4-Air هو إصدار ذو قيمة عالية، يتمتع بأداء قريب من GLM-4، ويقدم سرعة عالية وسعرًا معقولًا."
@@ -1494,7 +1437,7 @@
     "description": "سلسلة نماذج GLM-4.1V-Thinking هي أقوى نماذج اللغة البصرية المعروفة على مستوى 10 مليارات معلمة، وتدمج مهام اللغة البصرية المتقدمة من نفس المستوى، بما في ذلك فهم الفيديو، الأسئلة والأجوبة على الصور، حل المسائل العلمية، التعرف على النصوص OCR، تفسير الوثائق والرسوم البيانية، وكلاء واجهة المستخدم الرسومية، ترميز صفحات الويب الأمامية، والتثبيت الأرضي، وغيرها. تتفوق قدرات هذه المهام على نموذج Qwen2.5-VL-72B الذي يحتوي على أكثر من 8 أضعاف عدد المعلمات. من خلال تقنيات التعلم المعزز الرائدة، يتقن النموذج تحسين دقة وإثراء الإجابات عبر استدلال سلسلة التفكير، متفوقًا بشكل ملحوظ على النماذج التقليدية غير المعتمدة على التفكير من حيث النتائج النهائية وقابلية التفسير."
   },
   "glm-4.5": {
-    "description": "نموذج الذكاء الاصطناعي الرائد من Zhipu، يدعم تبديل أوضاع التفكير، ويحقق مستوى متقدمًا في القدرات الشاملة مقارنة بالنماذج مفتوحة المصدر، مع طول سياق يصل إلى 128 ألف."
+    "description": "أحدث نموذج رائد من Zhizhu، يدعم تبديل وضع التفكير، ويحقق مستوى SOTA بين النماذج المفتوحة المصدر في القدرات الشاملة، مع طول سياق يصل إلى 128 ألف رمز."
   },
   "glm-4.5-air": {
     "description": "نسخة خفيفة من GLM-4.5، تجمع بين الأداء والقيمة، وتدعم التبديل المرن بين نماذج التفكير المختلطة."
@@ -1511,9 +1454,6 @@
   "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 يوفر قدرات قوية في فهم الصور والاستدلال، ويدعم مجموعة متنوعة من المهام البصرية."
   },
@@ -1541,9 +1481,6 @@
   "glm-zero-preview": {
     "description": "يمتلك GLM-Zero-Preview قدرة قوية على الاستدلال المعقد، ويظهر أداءً ممتازًا في مجالات الاستدلال المنطقي، والرياضيات، والبرمجة."
   },
-  "glm4.6:355b": {
-    "description": "نموذج GLM-4.6 (355B) الرائد الأحدث من Zhipu يتفوق بشكل شامل على الجيل السابق في الترميز المتقدم، ومعالجة النصوص الطويلة، والاستدلال، وقدرات الوكلاء الذكيين، لا سيما في مجال البرمجة حيث يتماشى مع Claude Sonnet 4، ليصبح من أفضل نماذج الترميز في الصين."
-  },
   "google/gemini-2.0-flash": {
     "description": "Gemini 2.0 Flash يقدم ميزات الجيل التالي وتحسينات تشمل سرعة فائقة، استخدام أدوات مدمجة، توليد متعدد الوسائط، ونافذة سياق تصل إلى مليون رمز."
   },
@@ -1745,23 +1682,14 @@
   "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 هو نموذج لغة مفتوح المصدر واسع النطاق أطلقته OpenAI، يتمتع بقدرات قوية في توليد النصوص."
-  },
-  "gpt-oss-20b": {
-    "description": "يتطلب هذا النموذج تقديم طلب للتجربة. GPT-OSS-20B هو نموذج لغة مفتوح المصدر متوسط الحجم أطلقته OpenAI، يتميز بكفاءة عالية في توليد النصوص."
+    "description": "GPT-OSS-120B MXFP4: هيكل Transformer محسّن بالكمية، يحافظ على أداء قوي حتى في ظل محدودية الموارد."
   },
   "gpt-oss:120b": {
     "description": "GPT-OSS 120B هو نموذج لغة كبير مفتوح المصدر أصدرته OpenAI، يستخدم تقنية التكميم MXFP4، ويعتبر نموذجًا رائدًا. يتطلب تشغيله بيئة متعددة وحدات معالجة الرسومات أو محطة عمل عالية الأداء، ويتميز بأداء متفوق في الاستدلال المعقد، وتوليد الأكواد، ومعالجة اللغات المتعددة، ويدعم استدعاء الدوال المتقدمة وتكامل الأدوات."
@@ -1772,6 +1700,9 @@
   "gpt-realtime": {
     "description": "نموذج عام في الوقت الحقيقي يدعم الإدخال والإخراج النصي والصوتي، ويدعم أيضًا إدخال الصور."
   },
+  "grok-2-1212": {
+    "description": "لقد تم تحسين هذا النموذج في الدقة، والامتثال للتعليمات، والقدرة على التعامل مع لغات متعددة."
+  },
   "grok-2-image-1212": {
     "description": "نموذج توليد الصور الأحدث لدينا قادر على توليد صور حيوية وواقعية بناءً على الأوامر النصية. يبرع في مجالات التسويق، وسائل التواصل الاجتماعي، والترفيه."
   },
@@ -1781,9 +1712,15 @@
   "grok-3": {
     "description": "نموذج رائد، بارع في استخراج البيانات، البرمجة، وتلخيص النصوص لتطبيقات المؤسسات، يمتلك معرفة عميقة في مجالات المالية، الطب، القانون، والعلوم."
   },
+  "grok-3-fast": {
+    "description": "نموذج رائد، بارع في استخراج البيانات، البرمجة، وتلخيص النصوص لتطبيقات المؤسسات، يمتلك معرفة عميقة في مجالات المالية، الطب، القانون، والعلوم."
+  },
   "grok-3-mini": {
     "description": "نموذج خفيف الوزن، يفكر قبل المحادثة. سريع وذكي، مناسب للمهام المنطقية التي لا تتطلب معرفة متخصصة عميقة، ويستطيع تتبع مسار التفكير الأصلي."
   },
+  "grok-3-mini-fast": {
+    "description": "نموذج خفيف الوزن، يفكر قبل المحادثة. سريع وذكي، مناسب للمهام المنطقية التي لا تتطلب معرفة متخصصة عميقة، ويستطيع تتبع مسار التفكير الأصلي."
+  },
   "grok-4": {
     "description": "نموذجنا الرائد الأحدث والأقوى، يتميز بأداء ممتاز في معالجة اللغة الطبيعية، الحسابات الرياضية، والاستدلال — إنه لاعب شامل مثالي."
   },
@@ -1862,12 +1799,12 @@
   "hunyuan-t1-latest": {
     "description": "تحسين كبير لقدرات نموذج التفكير البطيء الرئيسي في الرياضيات الصعبة، الاستدلال المعقد، الشيفرة الصعبة، الالتزام بالتعليمات، وجودة إنشاء النصوص."
   },
+  "hunyuan-t1-vision": {
+    "description": "نموذج تفكير عميق متعدد الوسائط من Hunyuan، يدعم سلاسل التفكير الأصلية متعددة الوسائط، بارع في معالجة مختلف سيناريوهات الاستدلال على الصور، ويحقق تحسينًا شاملاً مقارنة بنموذج التفكير السريع في مسائل العلوم."
+  },
   "hunyuan-t1-vision-20250619": {
     "description": "أحدث نموذج تفكير عميق متعدد الوسائط t1-vision من Hunyuan، يدعم سلسلة التفكير الأصلية متعددة الوسائط، مع تحسين شامل مقارنة بالإصدار الافتراضي السابق."
   },
-  "hunyuan-t1-vision-20250916": {
-    "description": "أحدث إصدار من نموذج Hunyuan t1-vision للتفكير البصري العميق، يقدم تحسينات شاملة مقارنة بالإصدار السابق في مهام الأسئلة والأجوبة العامة على الصور والنصوص، التحديد البصري، التعرف البصري على الحروف (OCR)، الرسوم البيانية، حل المسائل المصورة، والإبداع البصري، مع تحسين ملحوظ في دعم اللغة الإنجليزية واللغات الأقل استخدامًا."
-  },
   "hunyuan-turbo": {
     "description": "نسخة المعاينة من الجيل الجديد من نموذج اللغة الكبير، يستخدم هيكل نموذج الخبراء المختلط (MoE) الجديد، مما يوفر كفاءة استدلال أسرع وأداء أقوى مقارنة بـ hunyuan-pro."
   },
@@ -1889,9 +1826,6 @@
   "hunyuan-turbos-20250604": {
     "description": "ترقية قاعدة التدريب المسبق، مع تحسينات في مهارات الكتابة وفهم القراءة، وزيادة كبيرة في القدرات البرمجية والعلمية، وتحسين مستمر في اتباع التعليمات المعقدة."
   },
-  "hunyuan-turbos-20250926": {
-    "description": "ترقية جودة بيانات قاعدة التدريب المسبق. تحسين استراتيجية التدريب في مرحلة ما بعد التدريب، مع استمرار تحسين قدرات الوكيل، واللغات الإنجليزية واللغات الصغيرة، والامتثال للتعليمات، والبرمجة، والعلوم."
-  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS هو أحدث إصدار من نموذج هونيان الرائد، يتمتع بقدرات تفكير أقوى وتجربة أفضل."
   },
@@ -1979,15 +1913,9 @@
   "kimi-k2-0905-preview": {
     "description": "نموذج kimi-k2-0905-preview يدعم طول سياق 256k، يتمتع بقدرات ترميز وكيل أقوى، وجمالية وعملية أفضل في الشيفرة الأمامية، وفهم سياق محسن."
   },
-  "kimi-k2-instruct": {
-    "description": "Kimi K2 Instruct هو نموذج لغة كبير أطلقته Moonshot AI، يتمتع بقدرة فائقة على معالجة السياقات الطويلة."
-  },
   "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 كنموذج للتسعير بناءً على طول سياق الطلب."
   },
@@ -2003,6 +1931,9 @@
   "lite": {
     "description": "سبارك لايت هو نموذج لغوي كبير خفيف الوزن، يتميز بتأخير منخفض للغاية وكفاءة عالية في المعالجة، وهو مجاني تمامًا ومفتوح، ويدعم وظيفة البحث عبر الإنترنت في الوقت الحقيقي. تجعل خصائص استجابته السريعة منه مثاليًا لتطبيقات الاستدلال على الأجهزة ذات القدرة الحاسوبية المنخفضة وضبط النماذج، مما يوفر للمستخدمين قيمة ممتازة من حيث التكلفة وتجربة ذكية، خاصة في مجالات الأسئلة والأجوبة المعرفية، وتوليد المحتوى، وسيناريوهات البحث."
   },
+  "llama-2-7b-chat": {
+    "description": "Llama2 هو سلسلة من النماذج اللغوية الكبيرة (LLM) التي طورتها Meta وأطلقتها كمصدر مفتوح، وهي تتكون من نماذج توليد نص مسبقة التدريب ومتخصصة بحجم يتراوح من 7 مليارات إلى 70 مليار معلمة. على مستوى العمارة، Llama2 هو نموذج لغوي تراجعي تلقائي يستخدم معمارية محول محسنة. الإصدارات المعدلة تستخدم التدريب الدقيق تحت الإشراف (SFT) والتعلم التقويمي مع تعزيزات من البشر (RLHF) لتوافق تفضيلات البشر فيما يتعلق بالفائدة والأمان. أظهر Llama2 أداءً أفضل بكثير من سلسلة Llama في العديد من المجموعات الأكاديمية، مما قدم إلهامًا لتصميم وتطوير العديد من النماذج الأخرى."
+  },
   "llama-3.1-70b-versatile": {
     "description": "Llama 3.1 70B يوفر قدرة استدلال ذكائي أقوى، مناسب للتطبيقات المعقدة، يدعم معالجة حسابية ضخمة ويضمن الكفاءة والدقة."
   },
@@ -2027,8 +1958,8 @@
   "llama-3.2-vision-instruct": {
     "description": "تم تحسين نموذج Llama 3.2-Vision المعدل للتعليمات للتعرف البصري، والاستدلال على الصور، ووصف الصور، والإجابة على الأسئلة العامة المتعلقة بالصور."
   },
-  "llama-3.3-70b": {
-    "description": "Llama 3.3 70B: نموذج Llama متوسط إلى كبير الحجم، يوازن بين قدرات الاستدلال والكفاءة الإنتاجية."
+  "llama-3.3-70b-instruct": {
+    "description": "Llama 3.3 هو النموذج الأكثر تقدمًا في سلسلة Llama، وهو نموذج لغوي مفتوح المصدر متعدد اللغات، يوفر تجربة أداء تنافس نموذج 405B بتكلفة منخفضة للغاية. يعتمد على هيكل Transformer، وتم تحسين فائدته وأمانه من خلال التعديل الدقيق تحت الإشراف (SFT) والتعلم المعزز من خلال التغذية الراجعة البشرية (RLHF). تم تحسين نسخة التعديل الخاصة به لتكون مثالية للحوار متعدد اللغات، حيث يتفوق في العديد من المعايير الصناعية على العديد من نماذج الدردشة المفتوحة والمغلقة. تاريخ انتهاء المعرفة هو ديسمبر 2023."
   },
   "llama-3.3-70b-versatile": {
     "description": "ميتّا لاما 3.3 هو نموذج لغة كبير متعدد اللغات (LLM) يضم 70 مليار (إدخال نص/إخراج نص) من النموذج المدرب مسبقًا والمعدل وفقًا للتعليمات. تم تحسين نموذج لاما 3.3 المعدل وفقًا للتعليمات للاستخدامات الحوارية متعددة اللغات ويتفوق على العديد من النماذج المتاحة مفتوحة المصدر والمغلقة في المعايير الصناعية الشائعة."
@@ -2036,12 +1967,6 @@
   "llama-3.3-instruct": {
     "description": "تم تحسين نموذج Llama 3.3 المعدل للتعليمات خصيصًا لسيناريوهات المحادثة، حيث تفوق على العديد من نماذج الدردشة مفتوحة المصدر الحالية في اختبارات المعايير الصناعية الشائعة."
   },
-  "llama-4-maverick-17b-128e-instruct": {
-    "description": "Llama 4 Maverick: نموذج عالي الأداء من سلسلة Llama، مناسب لمهام الاستدلال المتقدم، حل المشكلات المعقدة، وتنفيذ التعليمات."
-  },
-  "llama-4-scout-17b-16e-instruct": {
-    "description": "Llama 4 Scout: نموذج عالي الأداء من سلسلة Llama، مثالي للسيناريوهات التي تتطلب إنتاجية عالية وزمن استجابة منخفض."
-  },
   "llama3-70b-8192": {
     "description": "Meta Llama 3 70B يوفر قدرة معالجة معقدة لا مثيل لها، مصمم خصيصًا للمشاريع ذات المتطلبات العالية."
   },
@@ -2057,9 +1982,6 @@
   "llama3.1": {
     "description": "Llama 3.1 هو النموذج الرائد الذي أطلقته Meta، يدعم ما يصل إلى 405B من المعلمات، ويمكن تطبيقه في مجالات الحوار المعقد، والترجمة متعددة اللغات، وتحليل البيانات."
   },
-  "llama3.1-8b": {
-    "description": "Llama 3.1 8B: إصدار خفيف ومنخفض التأخير من Llama، مناسب للاستدلال التفاعلي الخفيف عبر الإنترنت."
-  },
   "llama3.1:405b": {
     "description": "Llama 3.1 هو النموذج الرائد الذي أطلقته Meta، يدعم ما يصل إلى 405B من المعلمات، ويمكن تطبيقه في مجالات الحوار المعقد، والترجمة متعددة اللغات، وتحليل البيانات."
   },
@@ -2091,7 +2013,7 @@
     "description": "سبارك ماكس 32K مزود بقدرة معالجة سياق كبيرة، مع فهم أقوى للسياق وقدرة على الاستدلال المنطقي، يدعم إدخال نصوص تصل إلى 32K توكن، مما يجعله مناسبًا لقراءة الوثائق الطويلة، والأسئلة والأجوبة المعرفية الخاصة، وغيرها من السيناريوهات."
   },
   "megrez-3b-instruct": {
-    "description": "Megrez 3B Instruct هو نموذج صغير الحجم وعالي الكفاءة أطلقته شركة Wuwen Xinqiong."
+    "description": "Megrez-3B-Instruct هو نموذج لغة كبير تم تدريبه بشكل مستقل من قبل شركة ووون تشينغ. يهدف Megrez-3B-Instruct إلى تقديم حل ذكاء على جهاز نهائي سريع وصغير وسهل الاستخدام من خلال مفهوم التكامل بين البرمجيات والأجهزة."
   },
   "meta-llama-3-70b-instruct": {
     "description": "نموذج قوي بحجم 70 مليار معلمة يتفوق في التفكير، والترميز، وتطبيقات اللغة الواسعة."
@@ -2648,12 +2570,6 @@
   "pro-128k": {
     "description": "سبارك برو 128K مزود بقدرة معالجة سياق كبيرة جدًا، قادر على معالجة ما يصل إلى 128K من معلومات السياق، مما يجعله مناسبًا بشكل خاص للتحليل الشامل ومعالجة الروابط المنطقية طويلة الأمد في المحتوى الطويل، ويمكنه تقديم منطق سلس ومتسق ودعم متنوع للاقتباسات في الاتصالات النصية المعقدة."
   },
-  "pro-deepseek-r1": {
-    "description": "نموذج مخصص لخدمات المؤسسات، يشمل خدمات متزامنة."
-  },
-  "pro-deepseek-v3": {
-    "description": "نموذج مخصص لخدمات المؤسسات، يشمل خدمات متزامنة."
-  },
   "qvq-72b-preview": {
     "description": "نموذج QVQ هو نموذج بحث تجريبي تم تطويره بواسطة فريق Qwen، يركز على تعزيز قدرات الاستدلال البصري، خاصة في مجال الاستدلال الرياضي."
   },
@@ -2663,12 +2579,6 @@
   "qvq-plus": {
     "description": "نموذج استدلال بصري يدعم الإدخال البصري وإخراج سلسلة التفكير. النسخة بلس التي تلت نموذج qvq-max، تتميز بسرعة استدلال أعلى وتوازن أفضل بين الأداء والتكلفة مقارنة بنموذج qvq-max."
   },
-  "qwen-3-32b": {
-    "description": "Qwen 3 32B: نموذج من سلسلة Qwen يتميز بأداء ممتاز في المهام متعددة اللغات والبرمجة، مناسب للاستخدام الإنتاجي متوسط النطاق."
-  },
-  "qwen-3-coder-480b": {
-    "description": "Qwen 3 Coder 480B: نموذج طويل السياق مخصص لتوليد الشيفرات والمهام البرمجية المعقدة."
-  },
   "qwen-coder-plus": {
     "description": "نموذج Tongyi Qianwen للبرمجة."
   },
@@ -2789,6 +2699,12 @@
   "qwen2": {
     "description": "Qwen2 هو نموذج لغوي كبير من الجيل الجديد من Alibaba، يدعم أداءً ممتازًا لتلبية احتياجات التطبيقات المتنوعة."
   },
+  "qwen2-72b-instruct": {
+    "description": "Qwen2 هو سلسلة نماذج لغوية كبيرة جديدة تم إطلاقها من قبل فريق Qwen. تعتمد هذه النماذج على هندسة Transformer وتستخدم دالة التنشيط SwiGLU، وتحيز الانتباه QKV (attention QKV bias)، وانتباه الاستفسار الجماعي (group query attention)، وخلط انتباه النافذة المتزحلقة والانتباه الكامل (mixture of sliding window attention and full attention). بالإضافة إلى ذلك، قام فريق Qwen بتحسين مجزئ يتكيف مع العديد من اللغات الطبيعية والأكواد."
+  },
+  "qwen2-7b-instruct": {
+    "description": "Qwen2 هو سلسلة نماذج لغوية كبيرة جديدة تم طرحها من قبل فريق Qwen. يعتمد هذا النموذج على هندسة Transformer، ويستخدم دالة التنشيط SwiGLU، وتحيز QKV للانتباه (attention QKV bias)، وانتباه الاستفسار الجماعي (group query attention)، وخلط انتباه النافذة المتزحلقة والانتباه الكامل. بالإضافة إلى ذلك، قام فريق Qwen بتحسين المقطّع الذي يتكيف مع العديد من اللغات الطبيعية والأكواد."
+  },
   "qwen2.5": {
     "description": "Qwen2.5 هو الجيل الجديد من نماذج اللغة الكبيرة من Alibaba، يدعم احتياجات التطبيقات المتنوعة بأداء ممتاز."
   },
@@ -2927,12 +2843,6 @@
   "qwen3-next-80b-a3b-thinking": {
     "description": "نموذج مفتوح المصدر من الجيل الجديد لوضع التفكير مبني على Qwen3، يتميز بتحسين في الالتزام بالتعليمات مقارنة بالإصدار السابق (Tongyi Qianwen 3-235B-A22B-Thinking-2507)، مع ردود ملخصة وأكثر إيجازًا من النموذج."
   },
-  "qwen3-vl-235b-a22b-instruct": {
-    "description": "Qwen3 VL 235B A22B Instruct هو نموذج متعدد الوسائط أطلقته Tongyi Qianwen، يدعم الفهم البصري والاستدلال."
-  },
-  "qwen3-vl-235b-a22b-thinking": {
-    "description": "Qwen3 VL 235B A22B Thinking هو نموذج استدلال متعدد الوسائط أطلقته Tongyi Qianwen، يدعم الفهم البصري والاستدلال."
-  },
   "qwen3-vl-plus": {
     "description": "Tongyi Qianwen VL هو نموذج توليد نصوص يمتلك قدرات فهم بصرية (صور)، لا يقتصر على التعرف الضوئي على الحروف (OCR)، بل يمكنه أيضًا التلخيص والاستدلال، مثل استخراج خصائص من صور المنتجات، وحل المسائل بناءً على صور التمارين."
   },
@@ -3050,9 +2960,6 @@
   "step-r1-v-mini": {
     "description": "هذا النموذج هو نموذج استدلال كبير يتمتع بقدرة قوية على فهم الصور، يمكنه معالجة المعلومات النصية والصورية، ويخرج نصوصًا بعد تفكير عميق. يظهر هذا النموذج أداءً بارزًا في مجال الاستدلال البصري، كما يمتلك قدرات رياضية، برمجية، ونصية من الدرجة الأولى. طول السياق هو 100k."
   },
-  "step3": {
-    "description": "Step3 هو نموذج متعدد الوسائط أطلقته Jiexue Xingchen، يتمتع بقدرات قوية في الفهم البصري."
-  },
   "stepfun-ai/step3": {
     "description": "Step3 هو نموذج استدلال متعدد الوسائط متقدم أصدرته شركة 阶跃星辰 (StepFun). بُني على بنية مزيج الخبراء (MoE) التي تضم 321 مليار معلمة إجمالية و38 مليار معلمة تنشيط. صُمم النموذج بنهج من الطرف إلى الطرف ليقلل تكلفة فك الترميز، مع تقديم أداء رائد في الاستدلال البصري-اللغوي. من خلال التصميم التعاوني لآلية انتباه تفكيك متعدد المصفوفات (MFA) وفصل الانتباه عن شبكة التغذية الأمامية (AFD)، يحافظ Step3 على كفاءة ممتازة على كل من المسرعات الرائدة والمسرعات منخفضة التكلفة. في مرحلة ما قبل التدريب عالج Step3 أكثر من 20 تريليون توكن نصي و4 تريليون توكن مختلط نص-صورة، مغطياً أكثر من عشر لغات. حقق النموذج أداءً متقدماً بين نماذج المصدر المفتوح في عدة معايير قياسية تشمل الرياضيات والبرمجة والمهام متعددة الوسائط."
   },
@@ -3176,6 +3083,9 @@
   "xai/grok-4": {
     "description": "أحدث وأعظم نموذج رائد من xAI، يقدم أداءً لا مثيل له في اللغة الطبيعية، الرياضيات، والاستدلال — الخيار المثالي متعدد الاستخدامات."
   },
+  "yi-1.5-34b-chat": {
+    "description": "يي-1.5 هو إصدار مُحدّث من يي. تم تدريبه بشكل مُسبق باستخدام مكتبة بيانات عالية الجودة تحتوي على 500 مليار علامة (Token) على يي، وتم تحسينه أيضًا باستخدام 3 ملايين مثال متنوع للتدريب الدقيق."
+  },
   "yi-large": {
     "description": "نموذج جديد بمليارات المعلمات، يوفر قدرة قوية على الإجابة وتوليد النصوص."
   },
@@ -3221,9 +3131,6 @@
   "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

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

locales/ar/setting.json

@@ -294,13 +294,6 @@
     },
     "title": "الإعدادات العامة"
   },
-  "settingImage": {
-    "defaultCount": {
-      "desc": "اضبط عدد الصور الافتراضي عند إنشاء مهمة جديدة في لوحة توليد الصور.",
-      "label": "عدد الصور الافتراضي",
-      "title": "إعدادات الرسم بالذكاء الاصطناعي"
-    }
-  },
   "settingModel": {
     "enableMaxTokens": {
       "title": "تمكين الحد الأقصى للردود"
@@ -556,7 +549,6 @@
     "common": "إعدادات عامة",
     "experiment": "تجربة",
     "hotkey": "اختصارات لوحة المفاتيح",
-    "image": "الرسم بالذكاء الاصطناعي",
     "llm": "نموذج اللغة",
     "provider": "مزود خدمة الذكاء الاصطناعي",
     "proxy": "وكيل الشبكة",

locales/ar/tool.json

@@ -1,11 +1,4 @@
 {
-  "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}}**. Как мога да ви помогна?",
-  "agentDefaultMessageWithoutEdit": "Здравейте, аз съм **{{name}}**. Как мога да ви помогна?",
+  "agentDefaultMessageWithSystemRole": "Здравей, аз съм **{{name}}**, {{systemRole}}. Нека започнем да чатим!",
+  "agentDefaultMessageWithoutEdit": "Здравей, аз съм **{{name}}** и нека започнем разговора!",
   "agents": "Асистент",
   "artifact": {
     "generating": "Генериране",
@@ -150,11 +150,6 @@
       "total": "Общо разходи"
     }
   },
-  "minimap": {
-    "jumpToMessage": "Отиди до съобщение № {{index}}",
-    "nextMessage": "Следващо съобщение",
-    "previousMessage": "Предишно съобщение"
-  },
   "newAgent": "Нов агент",
   "pin": "Закачи",
   "pinOff": "Откачи",

locales/bg-BG/common.json

@@ -236,7 +236,6 @@
   },
   "information": "Общност и информация",
   "installPWA": "Инсталиране на PWA",
-  "labs": "Лаборатория",
   "lang": {
     "ar": "Арабски",
     "bg-BG": "български",

locales/bg-BG/hotkey.json

@@ -7,14 +7,6 @@
     "desc": "Изтриване на текущите съобщения и качените файлове в сесията",
     "title": "Изтриване на съобщенията в сесията"
   },
-  "deleteAndRegenerateMessage": {
-    "desc": "Изтриване на последното съобщение и повторно генериране",
-    "title": "Изтрий и генерирай отново"
-  },
-  "deleteLastMessage": {
-    "desc": "Изтриване на последното съобщение",
-    "title": "Изтрий последното съобщение"
-  },
   "desktop": {
     "openSettings": {
       "desc": "Отворете страницата с настройки на приложението",

locales/bg-BG/image.json

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

locales/bg-BG/labs.json

@@ -1,14 +0,0 @@
-{
-  "desc": "Тук периодично ще актуализираме новите функции, които изследваме. Добре дошли да ги изпробвате!",
-  "features": {
-    "groupChat": {
-      "desc": "Активиране на възможността за координация в групов чат с множество интелигентни агенти.",
-      "title": "Групов чат (множество агенти)"
-    },
-    "inputMarkdown": {
-      "desc": "Реално време визуализация на Markdown в полето за въвеждане (удебелен текст, кодови блокове, таблици и др.).",
-      "title": "Markdown визуализация в полето за въвеждане"
-    }
-  },
-  "title": "Лаборатория"
-}

locales/bg-BG/modelProvider.json

@@ -284,43 +284,16 @@
           "placeholder": "Моля, въведете идентификатор на модела, например gpt-4o или claude-3.5-sonnet",
           "title": "ID на модела"
         },
-        "imageOutput": {
-          "extra": "Тази конфигурация ще активира само способността на модела да генерира изображения. Конкретният резултат зависи изцяло от самия модел. Моля, тествайте сами дали моделът има способност за генериране на изображения.",
-          "title": "Поддържа генериране на изображения"
-        },
         "modalTitle": "Конфигурация на персонализиран модел",
         "reasoning": {
           "extra": "Тази конфигурация ще активира само способността на модела за дълбоко мислене, конкретният ефект зависи изцяло от самия модел, моля, тествайте сами дали моделът притежава налична способност за дълбоко мислене",
           "title": "Поддръжка на дълбоко мислене"
         },
-        "search": {
-          "extra": "Тази конфигурация ще активира само възможността за онлайн търсене чрез вградения търсач на модела. Дали се поддържа вграден търсач зависи от самия модел. Моля, тествайте сами дали тази функция е налична.",
-          "title": "Поддържа онлайн търсене"
-        },
         "tokens": {
           "extra": "Настройте максималния брой токени, поддържани от модела",
           "title": "Максимален контекстуален прозорец",
           "unlimited": "Без ограничения"
         },
-        "type": {
-          "extra": "Различните типове модели имат различни сценарии на използване и възможности",
-          "options": {
-            "chat": "Чат",
-            "embedding": "Векторизация",
-            "image": "Генериране на изображения",
-            "realtime": "Реално време чат",
-            "stt": "Гласов текст",
-            "text2music": "Текст към музика",
-            "text2video": "Текст към видео",
-            "tts": "Гласово синтезиране"
-          },
-          "placeholder": "Моля, изберете тип модел",
-          "title": "Тип модел"
-        },
-        "video": {
-          "extra": "Тази конфигурация ще активира само настройките за разпознаване на видео в приложението. Дали се поддържа разпознаване зависи изцяло от самия модел. Моля, тествайте сами дали моделът поддържа разпознаване на видео.",
-          "title": "Поддържа разпознаване на видео"
-        },
         "vision": {
           "extra": "Тази конфигурация ще активира само конфигурацията за качване на изображения в приложението, дали поддържа разпознаване зависи изцяло от самия модел, моля, тествайте наличността на визуалната разпознаваемост на този модел.",
           "title": "Поддръжка на визуално разпознаване"

locales/bg-BG/models.json

@@ -92,12 +92,6 @@
   "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."
   },
@@ -293,9 +287,6 @@
   "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 милиарда активни параметри. Основните характеристики на модела включват: подобрена интелигентност при кодиране на агенти, с изразително подобрение в производителността при публични бенчмаркове и реални задачи за кодиране на агенти; усъвършенстван опит при фронтенд кодиране, с напредък както в естетиката, така и в практичността на фронтенд програмирането."
   },
@@ -689,9 +680,6 @@
   "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."
   },
@@ -704,9 +692,6 @@
   "azure-DeepSeek-R1-0528": {
     "description": "Доставен от Microsoft; моделът DeepSeek R1 е получил малка версия ъпгрейд, текущата версия е DeepSeek-R1-0528. В най-новата актуализация DeepSeek R1 значително подобрява дълбочината на разсъждение и способността за извод чрез увеличаване на изчислителните ресурси и въвеждане на алгоритмична оптимизация в следтренировъчния етап. Този модел се представя отлично в множество бенчмаркове като математика, програмиране и обща логика, като общата му производителност вече е близка до водещи модели като O3 и Gemini 2.5 Pro."
   },
-  "baichuan-m2-32b": {
-    "description": "Baichuan M2 32B е хибриден експертен модел, разработен от Baichuan Intelligence, с мощни способности за извеждане на заключения."
-  },
   "baichuan/baichuan2-13b-chat": {
     "description": "Baichuan-13B е отворен, комерсиален голям езиков модел, разработен от Baichuan Intelligence, с 13 милиарда параметри, който постига най-добрите резултати в своя размер на авторитетни бенчмаркове на китайски и английски."
   },
@@ -731,6 +716,12 @@
   "charglm-4": {
     "description": "CharGLM-4 е проектиран за ролеви игри и емоционално придружаване, поддържащ дългосрочна памет и персонализирани диалози, с широко приложение."
   },
+  "chatglm3": {
+    "description": "ChatGLM3 е закритоизточен модел, обявен от интелигентната платформа AI и лабораторията KEG на Университета в Тайхуа. Той е претрениран с голям обем на китайски и английски идентификатори и е подложен на тренировка за съответствие с хуманите предпочитания. Сравнено с първата версия на модела, ChatGLM3 постига подобрения от 16%, 36% и 280% в MMLU, C-Eval и GSM8K съответно, и е класифициран на първо място в китайския рейтинг C-Eval. Този модел е подходящ за сценарии, които изискват високи стандарти за знания, умения за разсъждаване и креативност, като например създаване на рекламни текстове, писане на романи, научно-популярно писане и генериране на код."
+  },
+  "chatglm3-6b-base": {
+    "description": "ChatGLM3-6b-base е последната генерация на редицата ChatGLM, разработена от компанията Zhipu, с 6 милиарда параметри и е открит източник."
+  },
   "chatgpt-4o-latest": {
     "description": "ChatGPT-4o е динамичен модел, който се актуализира в реално време, за да поддържа най-новата версия. Той комбинира мощно разбиране на езика и генериране на текст, подходящ за мащабни приложения, включително обслужване на клиенти, образование и техническа поддръжка."
   },
@@ -782,9 +773,6 @@
   "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 помощник за програмиране, който поддържа интелигентни въпроси и отговори и автоматично допълване на код за различни програмни езици, повишавайки ефективността на разработката."
   },
@@ -932,12 +920,6 @@
   "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-V3.2-Exp": {
-    "description": "Моделът DeepSeek V3.2 Exp е с хибридна архитектура за извеждане на заключения и поддържа както мисловен, така и немисловен режим."
-  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B е напреднал модел, обучен за диалози с висока сложност."
   },
@@ -947,9 +929,6 @@
   "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 параметри. Моделът показва отлични резултати в множество задачи, включително визуални въпроси и отговори, оптично разпознаване на символи, разбиране на документи/таблици/графики и визуална локализация."
   },
@@ -1014,7 +993,7 @@
     "description": "DeepSeek R1 пълна версия, с 671B параметри, поддържаща търсене в реално време, с по-силни способности за разбиране и генериране."
   },
   "deepseek-reasoner": {
-    "description": "Режим на мислене на DeepSeek V3.2. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да подобри точността на крайния отговор."
+    "description": "DeepSeek V3.1 режим на мислене. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да повиши точността на крайния отговор."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 е ефективен модел на Mixture-of-Experts, подходящ за икономически ефективни нужди от обработка."
@@ -1031,15 +1010,9 @@
   "deepseek-v3.1": {
     "description": "DeepSeek-V3.1 е новият хибриден модел за разсъждение на DeepSeek, който поддържа два режима на разсъждение: мислене и немислене, с по-висока ефективност на мислене в сравнение с DeepSeek-R1-0528. След оптимизация чрез пост-тренировка, използването на агентски инструменти и изпълнението на задачи от интелигентни агенти са значително подобрени. Поддържа контекстен прозорец до 128k и максимална дължина на изхода до 64k токена."
   },
-  "deepseek-v3.1-terminus": {
-    "description": "DeepSeek-V3.1-Terminus е оптимизирана версия на голям езиков модел от DeepSeek, създаден специално за крайни устройства."
-  },
   "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) и показва отлични резултати в различни задачи."
   },
@@ -1196,12 +1169,6 @@
   "ernie-4.0-turbo-8k-preview": {
     "description": "Флагманският голям езиков модел, разработен от Baidu, с отлични общи резултати, широко приложим в сложни задачи в различни области; поддържа автоматично свързване с плъгина за търсене на Baidu, осигурявайки актуалност на информацията. В сравнение с ERNIE 4.0, показва по-добри резултати."
   },
-  "ernie-4.5-21b-a3b": {
-    "description": "ERNIE 4.5 21B A3B е хибриден експертен модел, разработен от Baidu Wenxin, с мощни способности за извеждане на заключения и поддръжка на множество езици."
-  },
-  "ernie-4.5-300b-a47b": {
-    "description": "ERNIE 4.5 300B A47B е мащабен хибриден експертен модел от Baidu Wenxin, отличаващ се с изключителни способности за извеждане на заключения."
-  },
   "ernie-4.5-8k-preview": {
     "description": "Моделът Ernie 4.5 е ново поколение оригинален много модален основен модел, разработен от Baidu, който постига съвместна оптимизация чрез многомодално моделиране, с отлични способности за разбиране на много модалности; предлага усъвършенствани езикови способности, с подобрено разбиране, генериране, логика и памет, значително подобрени способности за избягване на халюцинации, логическо разсъждение и код."
   },
@@ -1265,9 +1232,6 @@
   "fal-ai/flux/schnell": {
     "description": "FLUX.1 [schnell] е модел за генериране на изображения с 12 милиарда параметри, фокусиран върху бързото създаване на висококачествени изображения."
   },
-  "fal-ai/hunyuan-image/v3": {
-    "description": "Мощен оригинален мултимодален модел за генериране на изображения"
-  },
   "fal-ai/imagen4/preview": {
     "description": "Висококачествен модел за генериране на изображения, предоставен от Google."
   },
@@ -1379,36 +1343,24 @@
   "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, както и да анализира големи набори от данни, кодови бази и документи с дълъг контекст."
   },
@@ -1421,15 +1373,6 @@
   "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 е подходяща за обработка на средни и малки задачи, съчетаваща икономичност."
   },
@@ -1458,7 +1401,7 @@
     "description": "GLM-4-0520 е най-новата версия на модела, проектирана за високо сложни и разнообразни задачи, с отлични резултати."
   },
   "glm-4-9b-chat": {
-    "description": "GLM-4-9B-Chat показва висока производителност в области като семантика, математика, логическо мислене, програмиране и общи знания. Поддържа също така уеб браузване, изпълнение на код, извикване на персонализирани инструменти и извеждане на заключения от дълги текстове. Поддържа 26 езика, включително японски, корейски и немски."
+    "description": "GLM-4-9B-Chat показва висока производителност в множество области, включително семантика, математика, логическо разсъждение, код и знания. Също така предлага уеб браузинг, изпълнение на код, извикване на персонализирани инструменти и разсъждение върху дълги текстове. Поддържа 26 езика, включително японски, корейски и немски."
   },
   "glm-4-air": {
     "description": "GLM-4-Air е икономичен вариант, с производителност близка до GLM-4, предлагаща бързина и достъпна цена."
@@ -1494,7 +1437,7 @@
     "description": "Серията модели GLM-4.1V-Thinking е най-мощният визуален модел сред известните VLM модели с размер около 10 милиарда параметри, обединяващ водещи в класа си задачи за визуално-езиково разбиране, включително видео разбиране, въпроси и отговори върху изображения, решаване на предметни задачи, OCR разпознаване на текст, интерпретация на документи и графики, GUI агент, кодиране на уеб страници, Grounding и други. Някои от задачите дори превъзхождат модели с 8 пъти повече параметри като Qwen2.5-VL-72B. Чрез водещи техники за подсилено обучение моделът овладява разсъждения чрез вериги на мисълта, което значително подобрява точността и богатството на отговорите, превъзхождайки традиционните модели без мисловен процес по отношение на крайния резултат и обяснимостта."
   },
   "glm-4.5": {
-    "description": "Флагманският модел на Zhipu, поддържа превключване на режим на мислене, с общи възможности, достигащи нивото на SOTA за отворени модели, с контекстова дължина до 128K."
+    "description": "Най-новият флагмански модел на Zhizhu, поддържащ режим на мислене, с общи способности на ниво SOTA сред отворените модели и контекстова дължина до 128K."
   },
   "glm-4.5-air": {
     "description": "Леката версия на GLM-4.5, балансираща между производителност и цена, с възможност за гъвкаво превключване на смесен мисловен режим."
@@ -1511,9 +1454,6 @@
   "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 предлага мощни способности за разбиране и разсъждение на изображения, поддържаща множество визуални задачи."
   },
@@ -1541,9 +1481,6 @@
   "glm-zero-preview": {
     "description": "GLM-Zero-Preview притежава мощни способности за сложни разсъждения, показвайки отлични резултати в логическото разсъждение, математиката и програмирането."
   },
-  "glm4.6:355b": {
-    "description": "Най-новият флагмански модел на Zhipu — GLM-4.6 (355B) — значително надминава предшествениците си в напреднало програмиране, обработка на дълги текстове, логическо разсъждение и способности на интелигентни агенти. Особено в програмирането се изравнява с Claude Sonnet 4, превръщайки се в водещ модел за кодиране в Китай."
-  },
   "google/gemini-2.0-flash": {
     "description": "Gemini 2.0 Flash предлага следващо поколение функции и подобрения, включително изключителна скорост, вградена употреба на инструменти, мултимодално генериране и контекстен прозорец от 1 милион токена."
   },
@@ -1745,23 +1682,14 @@
   "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 е отворен голям езиков модел, разработен от OpenAI, с мощни способности за генериране на текст."
-  },
-  "gpt-oss-20b": {
-    "description": "Този модел изисква заявка за достъп. GPT-OSS-20B е отворен среден езиков модел, разработен от OpenAI, с ефективни способности за генериране на текст."
+    "description": "GPT-OSS-120B MXFP4 квантизиран трансформър модел, който запазва силна производителност при ограничени ресурси."
   },
   "gpt-oss:120b": {
     "description": "GPT-OSS 120B е голям отворен езиков модел, публикуван от OpenAI, използващ технологията за квантуване MXFP4, предназначен за флагмански клас модели. Изисква многократни GPU или високопроизводителна работна станция за работа, с изключителни възможности в сложни разсъждения, генериране на код и многоезична обработка, поддържайки усъвършенствано извикване на функции и интеграция на инструменти."
@@ -1772,6 +1700,9 @@
   "gpt-realtime": {
     "description": "Универсален модел в реално време, поддържащ текстов и аудио вход и изход, както и вход на изображения."
   },
+  "grok-2-1212": {
+    "description": "Този модел е подобрен по отношение на точност, спазване на инструкции и многоезични способности."
+  },
   "grok-2-image-1212": {
     "description": "Нашият най-нов модел за генериране на изображения може да създава живи и реалистични изображения въз основа на текстови подсказки. Той се представя отлично в маркетинг, социални медии и развлекателни области."
   },
@@ -1781,9 +1712,15 @@
   "grok-3": {
     "description": "Флагмански модел, експертен в извличане на данни, програмиране и обобщаване на текст за корпоративни приложения, с дълбоки знания в областите финанси, медицина, право и наука."
   },
+  "grok-3-fast": {
+    "description": "Флагмански модел, експертен в извличане на данни, програмиране и обобщаване на текст за корпоративни приложения, с дълбоки знания в областите финанси, медицина, право и наука."
+  },
   "grok-3-mini": {
     "description": "Лек модел, който мисли преди разговор. Работи бързо и интелигентно, подходящ за логически задачи без нужда от дълбоки специализирани знания и позволява проследяване на оригиналния мисловен процес."
   },
+  "grok-3-mini-fast": {
+    "description": "Лек модел, който мисли преди разговор. Работи бързо и интелигентно, подходящ за логически задачи без нужда от дълбоки специализирани знания и позволява проследяване на оригиналния мисловен процес."
+  },
   "grok-4": {
     "description": "Нашият най-нов и най-мощен флагмански модел, който се отличава с изключителни резултати в обработката на естествен език, математическите изчисления и разсъжденията — перфектен универсален играч."
   },
@@ -1862,12 +1799,12 @@
   "hunyuan-t1-latest": {
     "description": "Значително подобрява способностите на основния модел за бавно мислене при сложна математика, комплексни разсъждения, труден код, спазване на инструкции и качество на текстовото творчество."
   },
+  "hunyuan-t1-vision": {
+    "description": "Модел за дълбоко мултимодално разбиране Hunyuan, поддържащ естествени мултимодални вериги на мислене, експертен в различни сценарии за разсъждение върху изображения, с цялостно подобрение спрямо бързите мисловни модели при научни задачи."
+  },
   "hunyuan-t1-vision-20250619": {
     "description": "Най-новият мултимодален дълбок мислещ модел t1-vision на Hunyuan, който поддържа оригинални мултимодални вериги на мисълта и предлага цялостно подобрение спрямо предишната версия по подразбиране."
   },
-  "hunyuan-t1-vision-20250916": {
-    "description": "Най-новият модел за визуално дълбоко мислене Hunyuan t1-vision предлага цялостни подобрения спрямо предишната версия в задачи като общи въпроси и отговори по изображения, визуално локализиране, OCR, графики, решаване на задачи по снимка и творческо писане по изображение. Значително е подобрена и поддръжката на английски и по-малко разпространени езици."
-  },
   "hunyuan-turbo": {
     "description": "Предварителна версия на новото поколение голям езиков модел на HunYuan, използваща нова структура на смесен експертен модел (MoE), с по-бърза скорост на извеждане и по-силни резултати в сравнение с hunyuan-pro."
   },
@@ -1889,9 +1826,6 @@
   "hunyuan-turbos-20250604": {
     "description": "Актуализирана предварително обучена основа, подобрени умения за писане и разбиране на текст, значително подобрени способности в кодирането и точните науки, както и непрекъснато усъвършенстване в следването на сложни инструкции."
   },
-  "hunyuan-turbos-20250926": {
-    "description": "Актуализация на качеството на данните за предварително обучение. Оптимизирана стратегия за обучение в посттренировъчния етап, с непрекъснато подобряване на възможностите на агента, английския и малките езици, спазването на инструкции, кода и научните способности."
-  },
   "hunyuan-turbos-latest": {
     "description": "hunyuan-TurboS е последната версия на флагманския модел Hunyuan, с по-силни способности за разсъждение и по-добро потребителско изживяване."
   },
@@ -1979,15 +1913,9 @@
   "kimi-k2-0905-preview": {
     "description": "Моделът kimi-k2-0905-preview има контекстна дължина от 256k, с по-силни способности за агентно кодиране, по-изразителна естетика и практичност на фронтенд кода, както и по-добро разбиране на контекста."
   },
-  "kimi-k2-instruct": {
-    "description": "Kimi K2 Instruct е голям езиков модел, разработен от Moonshot AI, с изключителна способност за обработка на дълъг контекст."
-  },
   "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 модел за таксуване в зависимост от дължината на контекста на заявката."
   },
@@ -2003,6 +1931,9 @@
   "lite": {
     "description": "Spark Lite е лек модел на голям език, с изключително ниска латентност и ефективна обработка, напълно безплатен и отворен, поддържащ функции за онлайн търсене в реално време. Неговите бързи отговори го правят отличен за приложения на нискомощни устройства и фина настройка на модели, предоставяйки на потребителите отлична рентабилност и интелигентно изживяване, особено в контекста на въпроси и отговори, генериране на съдържание и търсене."
   },
+  "llama-2-7b-chat": {
+    "description": "Llama2 е серия от големи модели за език (LLM), разработени и с отворен код от Meta. Това е набор от генеративни текстови модели с различен размер, от 7 милиарда до 70 милиарда параметри, които са претренирани и майсторски оптимизирани. Архитектурно, Llama2 е автоматично регресивен езиков модел, използващ оптимизирана трансформаторна архитектура. Подобренията включват супервизирано майсторско трениране (SFT) и подкрепено с учене с награди (RLHF) за подреждане на предпочтенията на хората за полезност и безопасност. Llama2 демонстрира значително подобрени резултати върху множество академични набори от данни, което предоставя възможности за дизайн и развитие на много други модели."
+  },
   "llama-3.1-70b-versatile": {
     "description": "Llama 3.1 70B предлага по-мощни способности за разсъждение на AI, подходящи за сложни приложения, поддържащи множество изчислителни обработки и осигуряващи ефективност и точност."
   },
@@ -2027,8 +1958,8 @@
   "llama-3.2-vision-instruct": {
     "description": "Моделът Llama 3.2-Vision с инструкции е оптимизиран за визуално разпознаване, изводи от изображения, описание на изображения и отговаряне на общи въпроси, свързани с изображения."
   },
-  "llama-3.3-70b": {
-    "description": "Llama 3.3 70B: средно до голямо Llama решение, съчетаващо логическо разсъждение и висока производителност."
+  "llama-3.3-70b-instruct": {
+    "description": "Llama 3.3 е най-напредналият многоезичен отворен езиков модел от серията Llama, който предлага производителност, сравнима с 405B моделите, на изключително ниска цена. Базиран на структурата Transformer и подобрен чрез супервизирано фино настройване (SFT) и обучение с човешка обратна връзка (RLHF) за повишаване на полезността и безопасността. Неговата версия, оптимизирана за инструкции, е специално проектирана за многоезични диалози и показва по-добри резултати от много от отворените и затворените чат модели в множество индустриални бенчмаркове. Краен срок за знания: декември 2023."
   },
   "llama-3.3-70b-versatile": {
     "description": "Meta Llama 3.3 е многоезичен модел за генерация на език (LLM) с 70B (вход/изход на текст), който е предварително обучен и е пригоден за указания. Чистият текстов модел на Llama 3.3 е оптимизиран за многоезични диалогови случаи и надминава много налични отворени и затворени чат модели на стандартни индустриални тестове."
@@ -2036,12 +1967,6 @@
   "llama-3.3-instruct": {
     "description": "Моделата Llama 3.3 с фина настройка за инструкции е оптимизирана за диалогови сценарии и надминава много съществуващи модели с отворен код в общи отраслови бенчмарк тестове."
   },
-  "llama-4-maverick-17b-128e-instruct": {
-    "description": "Llama 4 Maverick: високопроизводителен модел от серията Llama, подходящ за напреднало разсъждение, решаване на сложни задачи и следване на инструкции."
-  },
-  "llama-4-scout-17b-16e-instruct": {
-    "description": "Llama 4 Scout: високопроизводителен модел от серията Llama, оптимизиран за сценарии с висока пропускателна способност и ниска латентност."
-  },
   "llama3-70b-8192": {
     "description": "Meta Llama 3 70B предлага ненадмината способност за обработка на сложност, проектирана за високи изисквания."
   },
@@ -2057,9 +1982,6 @@
   "llama3.1": {
     "description": "Llama 3.1 е водещ модел, представен от Meta, поддържащ до 405B параметри, приложим в области като сложни диалози, многоезичен превод и анализ на данни."
   },
-  "llama3.1-8b": {
-    "description": "Llama 3.1 8B: лек и с ниска латентност вариант на Llama, идеален за онлайн разсъждение и интерактивни приложения."
-  },
   "llama3.1:405b": {
     "description": "Llama 3.1 е водещ модел, представен от Meta, поддържащ до 405B параметри, приложим в области като сложни диалози, многоезичен превод и анализ на данни."
   },
@@ -2091,7 +2013,7 @@
     "description": "Spark Max 32K е конфигуриран с голяма способност за обработка на контекст, с по-силно разбиране на контекста и логическо разсъждение, поддържащ текстови входове до 32K токена, подходящ за четене на дълги документи, частни въпроси и отговори и други сценарии."
   },
   "megrez-3b-instruct": {
-    "description": "Megrez 3B Instruct е ефективен модел с малък брой параметри, разработен от Wuwen Xinqiong."
+    "description": "Megrez-3B-Instruct е голям езиков модел, напълно обучен от безкрайната връху чиповете. Megrez-3B-Instruct се стреми чрез концепцията за съвместно хардуерно-софтуерно взаимодействие да създаде решение за крайните устройства, което е бързо за извършване, компактно и лесно за използване."
   },
   "meta-llama-3-70b-instruct": {
     "description": "Мощен модел с 70 милиарда параметри, отличаващ се в разсъждения, кодиране и широки езикови приложения."
@@ -2648,12 +2570,6 @@
   "pro-128k": {
     "description": "Spark Pro 128K е конфигуриран с изключителна способност за обработка на контекст, способен да обработва до 128K контекстна информация, особено подходящ за дълги текстове, изискващи цялостен анализ и дългосрочна логическа свързаност, предоставяйки гладка и последователна логика и разнообразна поддръжка на цитати в сложни текстови комуникации."
   },
-  "pro-deepseek-r1": {
-    "description": "Специализиран модел за корпоративни услуги, включващ паралелна обработка."
-  },
-  "pro-deepseek-v3": {
-    "description": "Специализиран модел за корпоративни услуги, включващ паралелна обработка."
-  },
   "qvq-72b-preview": {
     "description": "QVQ моделът е експериментален изследователски модел, разработен от екипа на Qwen, фокусиран върху повишаване на визуалните способности за разсъждение, особено в областта на математическото разсъждение."
   },
@@ -2663,12 +2579,6 @@
   "qvq-plus": {
     "description": "Модел за визуално разсъждение. Поддържа визуален вход и изход на мисловни вериги. Версия plus, пусната след модела qvq-max, предлага по-бързо разсъждение и по-добър баланс между ефективност и разходи в сравнение с qvq-max."
   },
-  "qwen-3-32b": {
-    "description": "Qwen 3 32B: модел от серията Qwen с отлична производителност при многоезични и програмни задачи, подходящ за средномащабна продукционна употреба."
-  },
-  "qwen-3-coder-480b": {
-    "description": "Qwen 3 Coder 480B: модел с дълъг контекст, предназначен за генериране на код и сложни програмни задачи."
-  },
   "qwen-coder-plus": {
     "description": "Tongyi Qianwen модел за кодиране."
   },
@@ -2789,6 +2699,12 @@
   "qwen2": {
     "description": "Qwen2 е новото поколение голям езиков модел на Alibaba, предлагащ отлична производителност за разнообразни приложения."
   },
+  "qwen2-72b-instruct": {
+    "description": "Qwen2 е новият серий на големи модели за език, предложен от екипа Qwen. Той се основава на архитектурата Transformer и използва SwiGLU активационна функция, внимание QKV смещение (attention QKV bias), групово запитване на внимание (group query attention), смесени техники за внимание с превъртващи се прозорци (mixture of sliding window attention) и пълно внимание. Освен това, екипът Qwen също е подобрал токенизатора, който поддържа множество езици и код."
+  },
+  "qwen2-7b-instruct": {
+    "description": "Qwen2 е новият серийен модел за големи езици, представен от екипа Qwen. Той се основава на архитектурата Transformer и използва SwiGLU активационна функция, внимание с QKV смещение (attention QKV bias), групово внимание за заявки (group query attention), смесени техники за обръщане на внимание с превъртващи се прозорци (mixture of sliding window attention) и пълно внимание. Освен това, екипът Qwen е подобрил токенизатора, който поддържа множество езици и код."
+  },
   "qwen2.5": {
     "description": "Qwen2.5 е новото поколение мащабен езиков модел на Alibaba, който предлага отлична производителност, за да отговори на разнообразни приложни нужди."
   },
@@ -2927,12 +2843,6 @@
   "qwen3-next-80b-a3b-thinking": {
     "description": "Базирано на Qwen3, ново поколение отворен модел с мисловен режим, който подобрява спазването на инструкции и предоставя по-кратки и точни обобщения в сравнение с предишната версия (Tongyi Qianwen 3-235B-A22B-Thinking-2507)."
   },
-  "qwen3-vl-235b-a22b-instruct": {
-    "description": "Qwen3 VL 235B A22B Instruct е мултимодален модел, разработен от Tongyi Qianwen, който поддържа визуално разбиране и извеждане на заключения."
-  },
-  "qwen3-vl-235b-a22b-thinking": {
-    "description": "Qwen3 VL 235B A22B Thinking е мултимодален модел за извеждане на заключения, разработен от Tongyi Qianwen, с поддръжка на визуално разбиране и логическо мислене."
-  },
   "qwen3-vl-plus": {
     "description": "Tongyi Qianwen VL е текстов генеративен модел с визуални (изображения) разбирания, който не само може да извършва OCR (разпознаване на текст в изображения), но и да обобщава и прави изводи, например извличане на атрибути от снимки на продукти или решаване на задачи по математика от изображения."
   },
@@ -3050,9 +2960,6 @@
   "step-r1-v-mini": {
     "description": "Този модел е мощен модел за разсъждение с отлични способности за разбиране на изображения, способен да обработва информация от изображения и текст, и след дълбочинно разсъждение да генерира текстово съдържание. Моделът показва изключителни резултати в областта на визуалните разсъждения, като същевременно притежава първокласни способности в математиката, кода и текстовите разсъждения. Дължината на контекста е 100k."
   },
-  "step3": {
-    "description": "Step3 е мултимодален модел, разработен от StepStar, с мощни способности за визуално разбиране."
-  },
   "stepfun-ai/step3": {
     "description": "Step3 е авангарден мултимодален модел за разсъждение, публикуван от StepFun (阶跃星辰). Той е изграден върху архитектура на смес от експерти (MoE) с общо 321 милиарда параметъра и 38 милиарда активни параметъра. Моделът е с енд-ту-енд дизайн, целящ минимизиране на разходите за декодиране, като същевременно предоставя водещи резултати във визуално-лингвистичното разсъждение. Чрез кооперативния дизайн на многоматрично факторизирано внимание (MFA) и декуплиране на внимание и FFN (AFD), Step3 поддържа отлична ефективност както на флагмански, така и на по-бюджетни ускорители. По време на предварителното обучение Step3 е обработил над 20 трилиона текстови токена и 4 трилиона смесени текстово-изображенчески токена, обхващайки повече от десет езика. Моделът постига водещи резултати сред отворените модели в множество бенчмаркове, включително математика, код и мултимодални задачи."
   },
@@ -3176,6 +3083,9 @@
   "xai/grok-4": {
     "description": "Най-новият и най-велик флагмански модел на xAI, предоставящ ненадмината производителност в естествен език, математика и разсъждения — перфектният универсален играч."
   },
+  "yi-1.5-34b-chat": {
+    "description": "Yi-1.5 е обновена версия на Yi. Тя използва висококачествен корпус от 500B токена за продължителна предварителна обучение на Yi и е майсторски подобрявана с 3M разнообразни примера за fino-tuning."
+  },
   "yi-large": {
     "description": "Новият модел с хиляда милиарда параметри предлага изключителни способности за отговори и генериране на текст."
   },
@@ -3221,9 +3131,6 @@
   "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

@@ -32,9 +32,6 @@
   "bfl": {
     "description": "Водеща изследователска лаборатория за авангарден изкуствен интелект, която изгражда визуалната инфраструктура на утрешния ден."
   },
-  "cerebras": {
-    "description": "Cerebras е AI платформа за извеждане, базирана на специализираната си система CS-3, създадена да предоставя най-бързите в света услуги за големи езикови модели (LLM) с незабавен отговор и висок капацитет на обработка. Тя е проектирана да елиминира закъсненията и да ускори сложни AI работни процеси, като генериране на код в реално време и изпълнение на агентски задачи."
-  },
   "cloudflare": {
     "description": "Работа с модели на машинно обучение, задвижвани от безсървърни GPU, в глобалната мрежа на Cloudflare."
   },
@@ -113,9 +110,6 @@
   "ollama": {
     "description": "Моделите, предоставени от Ollama, обхващат широк спектър от области, включително генериране на код, математически операции, многоезично обработване и диалогова интеракция, отговарящи на разнообразните нужди на предприятията и локализирани внедрявания."
   },
-  "ollamacloud": {
-    "description": "Ollama Cloud предлага официално хоствана услуга за изчисления, която осигурява достъп до библиотеката с модели на Ollama веднага след изваждане от кутията и поддържа интерфейс, съвместим с OpenAI."
-  },
   "openai": {
     "description": "OpenAI е водеща световна изследователска институция в областта на изкуствения интелект, чийто модели, като серията GPT, напредват в границите на обработката на естествен език. OpenAI се стреми да трансформира множество индустрии чрез иновации и ефективни AI решения. Продуктите им предлагат значителна производителност и икономичност, широко използвани в изследвания, бизнес и иновационни приложения."
   },

locales/bg-BG/setting.json

@@ -294,13 +294,6 @@
     },
     "title": "Общи настройки"
   },
-  "settingImage": {
-    "defaultCount": {
-      "desc": "Задайте броя на изображенията по подразбиране, които да се генерират при създаване на нова задача в панела за генериране на изображения.",
-      "label": "Брой изображения по подразбиране",
-      "title": "Настройки за AI рисуване"
-    }
-  },
   "settingModel": {
     "enableMaxTokens": {
       "title": "Активиране на ограничението за максимален брой токени"
@@ -556,7 +549,6 @@
     "common": "Общи настройки",
     "experiment": "Експеримент",
     "hotkey": "Бързи клавиши",
-    "image": "AI рисуване",
     "llm": "Езиков модел",
     "provider": "AI доставчик",
     "proxy": "Мрежов прокси",

locales/bg-BG/tool.json

@@ -1,11 +1,4 @@
 {
-  "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}}**. Wie kann ich Ihnen behilflich sein?",
-  "agentDefaultMessageWithoutEdit": "Hallo, ich bin **{{name}}**. Wie kann ich Ihnen behilflich sein?",
+  "agentDefaultMessageWithSystemRole": "Hallo, ich bin **{{name}}**, {{systemRole}}. Lass uns chatten!",
+  "agentDefaultMessageWithoutEdit": "Hallo, ich bin **{{name}}**. Lassen Sie uns ins Gespräch kommen!",
   "agents": "Assistent",
   "artifact": {
     "generating": "Wird generiert",
@@ -150,11 +150,6 @@
       "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/common.json

@@ -236,7 +236,6 @@
   },
   "information": "Community und Informationen",
   "installPWA": "Installiere die Browser-App",
-  "labs": "Labore",
   "lang": {
     "ar": "Arabisch",
     "bg-BG": "Bulgarisch",

locales/de-DE/hotkey.json

@@ -7,14 +7,6 @@
     "desc": "Aktuelle Nachrichten und hochgeladene Dateien im Gespräch löschen",
     "title": "Gesprächsnachrichten löschen"
   },
-  "deleteAndRegenerateMessage": {
-    "desc": "Letzte Nachricht löschen und neu generieren",
-    "title": "Löschen und neu generieren"
-  },
-  "deleteLastMessage": {
-    "desc": "Letzte Nachricht löschen",
-    "title": "Letzte Nachricht löschen"
-  },
   "desktop": {
     "openSettings": {
       "desc": "Öffnet die Anwendungseinstellungsseite",

locales/de-DE/image.json

@@ -30,13 +30,6 @@
     "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/labs.json

@@ -1,14 +0,0 @@
-{
-  "desc": "Hier werden wir regelmäßig neue Funktionen vorstellen, die wir gerade erforschen – probieren Sie sie gerne aus!",
-  "features": {
-    "groupChat": {
-      "desc": "Aktivieren Sie die Koordination von Gruppenchats mit mehreren KI-Agenten.",
-      "title": "Gruppenchats (mehrere Agenten)"
-    },
-    "inputMarkdown": {
-      "desc": "Echtzeit-Rendering von Markdown im Eingabefeld (Fettdruck, Codeblöcke, Tabellen usw.).",
-      "title": "Markdown-Rendering im Eingabefeld"
-    }
-  },
-  "title": "Labor"
-}

locales/de-DE/modelProvider.json

@@ -284,43 +284,16 @@
           "placeholder": "Bitte Modell-ID eingeben, z. B. gpt-4o oder claude-3.5-sonnet",
           "title": "Modell-ID"
         },
-        "imageOutput": {
-          "extra": "Diese Einstellung aktiviert lediglich die Fähigkeit des Modells zur Bildgenerierung. Die tatsächliche Leistung hängt vollständig vom Modell selbst ab. Bitte testen Sie selbst, ob das Modell über eine nutzbare Bildgenerierungsfunktion verfügt.",
-          "title": "Bildgenerierung unterstützen"
-        },
         "modalTitle": "Benutzerdefinierte Modellkonfiguration",
         "reasoning": {
           "extra": "Diese Konfiguration aktiviert nur die Fähigkeit des Modells zu tiefem Denken. Die tatsächlichen Ergebnisse hängen vollständig vom Modell selbst ab. Bitte testen Sie selbst, ob das Modell über die Fähigkeit zum tiefen Denken verfügt.",
           "title": "Unterstützung für tiefes Denken"
         },
-        "search": {
-          "extra": "Diese Einstellung aktiviert lediglich die integrierte Internetsuchfunktion des Modells. Ob eine integrierte Suchmaschine unterstützt wird, hängt vom Modell selbst ab. Bitte testen Sie selbst, ob die Suchfunktion des Modells verfügbar ist.",
-          "title": "Internetsuche unterstützen"
-        },
         "tokens": {
           "extra": "Maximale Token-Anzahl für das Modell festlegen",
           "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"
-        },
-        "video": {
-          "extra": "Diese Einstellung aktiviert lediglich die Videorekognition innerhalb der Anwendung. Ob die Erkennung unterstützt wird, hängt vollständig vom Modell selbst ab. Bitte testen Sie selbst, ob das Modell über eine nutzbare Videorekognitionsfunktion verfügt.",
-          "title": "Videoerkennung unterstützen"
-        },
         "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,12 +92,6 @@
   "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."
   },
@@ -293,9 +287,6 @@
   "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."
   },
@@ -689,9 +680,6 @@
   "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."
   },
@@ -704,9 +692,6 @@
   "azure-DeepSeek-R1-0528": {
     "description": "Bereitgestellt von Microsoft; Das DeepSeek R1 Modell wurde in einer kleinen Versionsaktualisierung verbessert, die aktuelle Version ist DeepSeek-R1-0528. Im neuesten Update wurde die Rechentiefe und Inferenzfähigkeit von DeepSeek R1 durch Erhöhung der Rechenressourcen und Einführung eines Algorithmus-Optimierungsmechanismus in der Nachtrainingsphase erheblich gesteigert. Dieses Modell zeigt hervorragende Leistungen in mehreren Benchmark-Tests wie Mathematik, Programmierung und allgemeiner Logik und nähert sich in der Gesamtleistung führenden Modellen wie O3 und Gemini 2.5 Pro an."
   },
-  "baichuan-m2-32b": {
-    "description": "Baichuan M2 32B ist ein hybrides Expertenmodell von Baichuan Intelligence mit leistungsstarken Fähigkeiten im logischen Schlussfolgern."
-  },
   "baichuan/baichuan2-13b-chat": {
     "description": "Baichuan-13B ist ein Open-Source-Sprachmodell mit 13 Milliarden Parametern, das von Baichuan Intelligence entwickelt wurde und in autorisierten chinesischen und englischen Benchmarks die besten Ergebnisse in seiner Größenordnung erzielt hat."
   },
@@ -731,6 +716,12 @@
   "charglm-4": {
     "description": "CharGLM-4 wurde speziell für Rollenspiele und emotionale Begleitung entwickelt, unterstützt extrem lange Mehrfachgedächtnisse und personalisierte Dialoge und findet breite Anwendung."
   },
+  "chatglm3": {
+    "description": "ChatGLM3 ist ein proprietäres Modell, das von der KI-Forschungsgruppe Zhipu AI und dem KEG-Labor der Tsinghua-Universität veröffentlicht wurde. Es wurde durch umfangreiche Vortrainings mit chinesischen und englischen Bezeichnern sowie durch die Anpassung an menschliche Präferenzen entwickelt. Im Vergleich zum ersten Modell erzielte es Verbesserungen von 16 %, 36 % und 280 % in den Benchmarks MMLU, C-Eval und GSM8K und steht an der Spitze der chinesischen Aufgabenliste C-Eval. Es eignet sich für Szenarien, die hohe Anforderungen an das Wissensvolumen, die Inferenzfähigkeit und die Kreativität stellen, wie z. B. die Erstellung von Werbetexten, das Schreiben von Romanen, wissensbasiertes Schreiben und die Generierung von Code."
+  },
+  "chatglm3-6b-base": {
+    "description": "ChatGLM3-6b-base ist das neueste Modell der ChatGLM-Serie mit 6 Milliarden Parametern, entwickelt von Zhipu."
+  },
   "chatgpt-4o-latest": {
     "description": "ChatGPT-4o ist ein dynamisches Modell, das in Echtzeit aktualisiert wird, um die neueste Version zu gewährleisten. Es kombiniert starke Sprachverständnis- und Generierungsfähigkeiten und eignet sich für großangelegte Anwendungsszenarien, einschließlich Kundenservice, Bildung und technische Unterstützung."
   },
@@ -782,9 +773,6 @@
   "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."
   },
@@ -932,12 +920,6 @@
   "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-V3.2-Exp": {
-    "description": "Das DeepSeek V3.2 Exp Modell ist eine hybride Inferenzarchitektur, die sowohl Denk- als auch Nicht-Denk-Modi unterstützt."
-  },
   "deepseek-ai/deepseek-llm-67b-chat": {
     "description": "DeepSeek 67B ist ein fortschrittliches Modell, das für komplexe Dialoge trainiert wurde."
   },
@@ -947,9 +929,6 @@
   "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."
   },
@@ -1014,7 +993,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.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."
+    "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."
   },
   "deepseek-v2": {
     "description": "DeepSeek V2 ist ein effizientes Mixture-of-Experts-Sprachmodell, das für wirtschaftliche Verarbeitungsanforderungen geeignet ist."
@@ -1031,15 +1010,9 @@
   "deepseek-v3.1": {
     "description": "DeepSeek-V3.1 ist ein neu eingeführtes hybrides Inferenzmodell von DeepSeek, das zwei Inferenzmodi unterstützt: Denkmodus und Nicht-Denkmodus. Es ist effizienter im Denkprozess als DeepSeek-R1-0528. Durch Post-Training-Optimierung wurden die Nutzung von Agenten-Tools und die Leistung bei Agentenaufgaben erheblich verbessert. Unterstützt ein Kontextfenster von 128k und eine maximale Ausgabelänge von 64k Tokens."
   },
-  "deepseek-v3.1-terminus": {
-    "description": "DeepSeek-V3.1-Terminus ist eine optimierte Version des großen Sprachmodells von DeepSeek, speziell für Endgeräte entwickelt."
-  },
   "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."
   },
@@ -1196,12 +1169,6 @@
   "ernie-4.0-turbo-8k-preview": {
     "description": "Das von Baidu entwickelte Flaggschiff-Modell für große Sprachmodelle zeigt hervorragende Gesamtergebnisse und ist weit verbreitet in komplexen Aufgabenbereichen anwendbar; es unterstützt die automatische Anbindung an das Baidu-Suchplugin, um die Aktualität der Antwortinformationen zu gewährleisten. Im Vergleich zu ERNIE 4.0 bietet es eine bessere Leistung."
   },
-  "ernie-4.5-21b-a3b": {
-    "description": "ERNIE 4.5 21B A3B ist ein hybrides Expertenmodell von Baidu Wenxin mit herausragenden Fähigkeiten im logischen Denken und in der Mehrsprachigkeit."
-  },
-  "ernie-4.5-300b-a47b": {
-    "description": "ERNIE 4.5 300B A47B ist ein großskaliges hybrides Expertenmodell von Baidu Wenxin mit exzellenten Fähigkeiten im logischen Schlussfolgern."
-  },
   "ernie-4.5-8k-preview": {
     "description": "Das ERNIE 4.5 Modell ist ein neu entwickeltes, natives multimodales Basis-Modell von Baidu, das durch die gemeinsame Modellierung mehrerer Modalitäten eine synergistische Optimierung erreicht und über hervorragende multimodale Verständnisfähigkeiten verfügt; es bietet verbesserte Sprachfähigkeiten, umfassende Verbesserungen in Verständnis, Generierung, Logik und Gedächtnis, sowie signifikante Verbesserungen in der Vermeidung von Halluzinationen, logischen Schlussfolgerungen und Programmierfähigkeiten."
   },
@@ -1265,9 +1232,6 @@
   "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."
   },
@@ -1379,36 +1343,24 @@
   "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."
   },
@@ -1421,15 +1373,6 @@
   "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."
   },
@@ -1458,7 +1401,7 @@
     "description": "GLM-4-0520 ist die neueste Modellversion, die für hochkomplexe und vielfältige Aufgaben konzipiert wurde und hervorragende Leistungen zeigt."
   },
   "glm-4-9b-chat": {
-    "description": "GLM-4-9B-Chat bietet hohe Leistung in Bereichen wie Semantik, Mathematik, logisches Denken, Programmierung und Wissen. Es unterstützt Web-Browsing, Code-Ausführung, benutzerdefinierte Tool-Nutzung und Langtext-Inferenz. Unterstützt 26 Sprachen, darunter Japanisch, Koreanisch und Deutsch."
+    "description": "GLM-4-9B-Chat zeigt in den Bereichen Semantik, Mathematik, Schlussfolgerungen, Code und Wissen eine hohe Leistung. Es verfügt auch über Funktionen wie Web-Browsing, Code-Ausführung, benutzerdefinierte Toolaufrufe und langes Textverständnis. Es unterstützt 26 Sprachen, darunter Japanisch, Koreanisch und Deutsch."
   },
   "glm-4-air": {
     "description": "GLM-4-Air ist eine kosteneffiziente Version, die in der Leistung nahe am GLM-4 liegt und schnelle Geschwindigkeiten zu einem erschwinglichen Preis bietet."
@@ -1494,7 +1437,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 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."
+    "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."
   },
   "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."
@@ -1511,9 +1454,6 @@
   "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."
   },
@@ -1541,9 +1481,6 @@
   "glm-zero-preview": {
     "description": "GLM-Zero-Preview verfügt über starke Fähigkeiten zur komplexen Schlussfolgerung und zeigt hervorragende Leistungen in den Bereichen logisches Denken, Mathematik und Programmierung."
   },
-  "glm4.6:355b": {
-    "description": "Das neueste Flaggschiffmodell GLM-4.6 (355B) von Zhipu übertrifft seinen Vorgänger in den Bereichen fortgeschrittenes Codieren, Verarbeitung langer Texte, logisches Schlussfolgern und Agentenfähigkeiten deutlich. Besonders im Bereich Programmierung erreicht es das Niveau von Claude Sonnet 4 und zählt damit zu den führenden Coding-Modellen in China."
-  },
   "google/gemini-2.0-flash": {
     "description": "Gemini 2.0 Flash bietet Funktionen der nächsten Generation und Verbesserungen, darunter herausragende Geschwindigkeit, integrierte Werkzeugnutzung, multimodale Generierung und ein Kontextfenster von 1 Million Tokens."
   },
@@ -1745,23 +1682,14 @@
   "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": "Dieses Modell erfordert eine Zugangsanfrage. GPT-OSS-120B ist ein quelloffenes, großskaliges Sprachmodell von OpenAI mit leistungsstarken Textgenerierungsfähigkeiten."
-  },
-  "gpt-oss-20b": {
-    "description": "Dieses Modell erfordert eine Zugangsanfrage. GPT-OSS-20B ist ein quelloffenes, mittelgroßes Sprachmodell von OpenAI mit effizienter Textgenerierung."
+    "description": "GPT-OSS-120B MXFP4 quantisierte Transformer-Struktur, die auch bei begrenzten Ressourcen starke Leistung beibehält."
   },
   "gpt-oss:120b": {
     "description": "GPT-OSS 120B ist ein von OpenAI veröffentlichtes großes Open-Source-Sprachmodell, das die MXFP4-Quantisierungstechnologie verwendet und als Flaggschiff-Modell gilt. Es erfordert den Betrieb auf Multi-GPU- oder Hochleistungs-Workstation-Umgebungen und bietet herausragende Leistungen bei komplexen Inferenzaufgaben, Codegenerierung und mehrsprachiger Verarbeitung. Es unterstützt fortgeschrittene Funktionsaufrufe und die Integration von Werkzeugen."
@@ -1772,6 +1700,9 @@
   "gpt-realtime": {
     "description": "Universelles Echtzeitmodell, das Echtzeit-Text- und Audioeingabe/-ausgabe unterstützt und zudem Bildinput ermöglicht."
   },
+  "grok-2-1212": {
+    "description": "Dieses Modell hat Verbesserungen in Bezug auf Genauigkeit, Befolgung von Anweisungen und Mehrsprachigkeit erfahren."
+  },
   "grok-2-image-1212": {
     "description": "Unser neuestes Bildgenerierungsmodell kann lebendige und realistische Bilder basierend auf Text-Prompts erzeugen. Es zeigt hervorragende Leistungen in den Bereichen Marketing, soziale Medien und Unterhaltung."
   },
@@ -1781,9 +1712,15 @@
   "grok-3": {
     "description": "Ein Flaggschiffmodell, spezialisiert auf Datenextraktion, Programmierung und Textzusammenfassung für Unternehmensanwendungen, mit tiefgreifendem Wissen in den Bereichen Finanzen, Medizin, Recht und Wissenschaft."
   },
+  "grok-3-fast": {
+    "description": "Ein Flaggschiffmodell, spezialisiert auf Datenextraktion, Programmierung und Textzusammenfassung für Unternehmensanwendungen, mit tiefgreifendem Wissen in den Bereichen Finanzen, Medizin, Recht und Wissenschaft."
+  },
   "grok-3-mini": {
     "description": "Ein leichtgewichtiges Modell, das vor der Antwort nachdenkt. Es arbeitet schnell und intelligent, eignet sich für logische Aufgaben ohne tiefgehendes Fachwissen und ermöglicht die Nachverfolgung des ursprünglichen Denkprozesses."
   },
+  "grok-3-mini-fast": {
+    "description": "Ein leichtgewichtiges Modell, das vor der Antwort nachdenkt. Es arbeitet schnell und intelligent, eignet sich für logische Aufgaben ohne tiefgehendes Fachwissen und ermöglicht die Nachverfolgung des ursprünglichen Denkprozesses."
+  },
   "grok-4": {
     "description": "Unser neuestes und leistungsstärkstes Flaggschiffmodell, das in der Verarbeitung natürlicher Sprache, mathematischen Berechnungen und logischem Denken herausragende Leistungen erbringt – ein perfekter Allrounder."
   },
@@ -1862,12 +1799,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": "Die neueste Version des Hunyuan t1-vision Modells für visuelles, tiefes Denken bietet im Vergleich zur Vorgängerversion umfassende Verbesserungen bei allgemeinen Bild-Text-Fragen, visueller Lokalisierung, OCR, Diagrammverarbeitung, Aufgabenlösung per Foto und kreativer Bildinterpretation. Die Fähigkeiten in Englisch und kleineren Sprachen wurden deutlich optimiert."
-  },
   "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."
   },
@@ -1889,9 +1826,6 @@
   "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."
   },
@@ -1979,15 +1913,9 @@
   "kimi-k2-0905-preview": {
     "description": "Das Modell kimi-k2-0905-preview hat eine Kontextlänge von 256k, verfügt über stärkere Agentic-Coding-Fähigkeiten, eine herausragendere Ästhetik und Praktikabilität von Frontend-Code sowie ein besseres Kontextverständnis."
   },
-  "kimi-k2-instruct": {
-    "description": "Kimi K2 Instruct ist ein großes Sprachmodell von Moonshot AI mit der Fähigkeit zur Verarbeitung extrem langer Kontexte."
-  },
   "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."
   },
@@ -2003,6 +1931,9 @@
   "lite": {
     "description": "Spark Lite ist ein leichtgewichtiges großes Sprachmodell mit extrem niedriger Latenz und effizienter Verarbeitung, das vollständig kostenlos und offen ist und Echtzeitsuchfunktionen unterstützt. Seine schnelle Reaktionsfähigkeit macht es besonders geeignet für Inferenzanwendungen und Modellanpassungen auf Geräten mit geringer Rechenleistung und bietet den Nutzern ein hervorragendes Kosten-Nutzen-Verhältnis sowie ein intelligentes Erlebnis, insbesondere in den Bereichen Wissensabfragen, Inhaltserstellung und Suchszenarien."
   },
+  "llama-2-7b-chat": {
+    "description": "Llama2 ist eine Serie großer Sprachmodelle (LLM), die von Meta entwickelt und als Open Source veröffentlicht wurden. Diese Serie umfasst generative Textmodelle mit einer Parameteranzahl von 7 Milliarden bis 70 Milliarden, die vortrainiert und feinjustiert wurden. Architekturtechnisch ist Llama2 ein autoregressives Sprachmodell, das eine optimierte Transformer-Architektur verwendet. Die angepassten Versionen nutzen überwachte Feinabstimmung (SFT) und Reinforcement Learning mit menschlichem Feedback (RLHF), um den menschlichen Vorlieben für Nützlichkeit und Sicherheit zu entsprechen. Llama2 übertrifft die Leistung der Llama-Serie in mehreren akademischen Datensätzen und bietet Inspiration für die Entwicklung und Gestaltung vieler anderer Modelle."
+  },
   "llama-3.1-70b-versatile": {
     "description": "Llama 3.1 70B bietet leistungsstarke KI-Schlussfolgerungsfähigkeiten, die für komplexe Anwendungen geeignet sind und eine hohe Rechenverarbeitung bei gleichzeitiger Effizienz und Genauigkeit unterstützen."
   },
@@ -2027,8 +1958,8 @@
   "llama-3.2-vision-instruct": {
     "description": "Das Llama 3.2-Vision-Instruct-Modell ist optimiert für visuelle Erkennung, Bildschlussfolgerungen, Bildbeschreibungen und das Beantworten von allgemeinen Fragen, die mit Bildern zusammenhängen."
   },
-  "llama-3.3-70b": {
-    "description": "Llama 3.3 70B: Ein mittelgroßes Llama-Modell, das eine ausgewogene Kombination aus logischem Denken und hoher Verarbeitungskapazität bietet."
+  "llama-3.3-70b-instruct": {
+    "description": "Llama 3.3 ist das fortschrittlichste mehrsprachige Open-Source-Sprachmodell der Llama-Serie, das eine Leistung bietet, die mit einem 405B-Modell vergleichbar ist, und das zu extrem niedrigen Kosten. Es basiert auf der Transformer-Architektur und verbessert die Nützlichkeit und Sicherheit durch überwachte Feinabstimmung (SFT) und verstärkendes Lernen mit menschlichem Feedback (RLHF). Die auf Anweisungen optimierte Version ist speziell für mehrsprachige Dialoge optimiert und übertrifft in mehreren Branchenbenchmarks viele Open-Source- und geschlossene Chat-Modelle. Das Wissensdatum endet im Dezember 2023."
   },
   "llama-3.3-70b-versatile": {
     "description": "Das Meta Llama 3.3 ist ein mehrsprachiges, großes Sprachmodell (LLM), das aus einem vortrainierten und anweisungsorientierten generativen Modell mit 70B (Text-Eingabe/Text-Ausgabe) besteht. Das anweisungsorientierte Modell von Llama 3.3 ist für mehrsprachige Dialoganwendungen optimiert und übertrifft viele verfügbare Open-Source- und Closed-Source-Chat-Modelle bei gängigen Branchenbenchmarks."
@@ -2036,12 +1967,6 @@
   "llama-3.3-instruct": {
     "description": "Das Llama 3.3 Instruct-Modell ist für Dialogszenarien optimiert und übertrifft in gängigen Branchenbenchmarks viele bestehende Open-Source-Chatmodelle."
   },
-  "llama-4-maverick-17b-128e-instruct": {
-    "description": "Llama 4 Maverick: Ein leistungsstarkes Modell der Llama-Serie, ideal für fortgeschrittenes logisches Denken, komplexe Problemlösungen und Aufgaben mit Anweisungsbefolgung."
-  },
-  "llama-4-scout-17b-16e-instruct": {
-    "description": "Llama 4 Scout: Ein leistungsstarkes Modell der Llama-Serie, optimiert für Szenarien mit hoher Verarbeitungsgeschwindigkeit und niedriger Latenz."
-  },
   "llama3-70b-8192": {
     "description": "Meta Llama 3 70B bietet unvergleichliche Fähigkeiten zur Verarbeitung von Komplexität und ist maßgeschneidert für Projekte mit hohen Anforderungen."
   },
@@ -2057,9 +1982,6 @@
   "llama3.1": {
     "description": "Llama 3.1 ist ein führendes Modell von Meta, das bis zu 405B Parameter unterstützt und in den Bereichen komplexe Dialoge, mehrsprachige Übersetzungen und Datenanalysen eingesetzt werden kann."
   },
-  "llama3.1-8b": {
-    "description": "Llama 3.1 8B: Eine kompakte, latenzarme Variante des Llama-Modells, ideal für leichte Online-Inferenz- und Interaktionsszenarien."
-  },
   "llama3.1:405b": {
     "description": "Llama 3.1 ist ein führendes Modell von Meta, das bis zu 405B Parameter unterstützt und in den Bereichen komplexe Dialoge, mehrsprachige Übersetzungen und Datenanalysen eingesetzt werden kann."
   },
@@ -2091,7 +2013,7 @@
     "description": "Spark Max 32K bietet eine große Kontextverarbeitungsfähigkeit mit verbesserter Kontextverständnis und logischer Schlussfolgerungsfähigkeit und unterstützt Texteingaben von bis zu 32K Tokens, was es ideal für das Lesen langer Dokumente und private Wissensabfragen macht."
   },
   "megrez-3b-instruct": {
-    "description": "Megrez 3B Instruct ist ein effizientes Modell mit geringer Parameteranzahl, entwickelt von Wuwen Xinqiong."
+    "description": "Megrez-3B-Instruct ist ein großes Sprachmodell, das vollständig von Wuxin XinQiong trainiert wurde. Megrez-3B-Instruct zielt darauf ab, durch die Idee der Hardware-Software-Kooperation eine schnelle Inferenz, ein kompaktes Design und eine benutzerfreundliche Endgerätlösung zu schaffen."
   },
   "meta-llama-3-70b-instruct": {
     "description": "Ein leistungsstarkes Modell mit 70 Milliarden Parametern, das in den Bereichen Schlussfolgerungen, Programmierung und breiten Sprachanwendungen herausragt."
@@ -2648,12 +2570,6 @@
   "pro-128k": {
     "description": "Spark Pro 128K verfügt über eine außergewöhnliche Kontextverarbeitungsfähigkeit und kann bis zu 128K Kontextinformationen verarbeiten, was es besonders geeignet für die Analyse langer Texte und die Verarbeitung langfristiger logischer Zusammenhänge macht. Es bietet in komplexen Textkommunikationen flüssige und konsistente Logik sowie vielfältige Unterstützung für Zitate."
   },
-  "pro-deepseek-r1": {
-    "description": "Modell für exklusive Unternehmensdienste, inklusive paralleler Serviceunterstützung."
-  },
-  "pro-deepseek-v3": {
-    "description": "Modell für exklusive Unternehmensdienste, inklusive paralleler Serviceunterstützung."
-  },
   "qvq-72b-preview": {
     "description": "Das QVQ-Modell ist ein experimentelles Forschungsmodell, das vom Qwen-Team entwickelt wurde und sich auf die Verbesserung der visuellen Schlussfolgerungsfähigkeiten konzentriert, insbesondere im Bereich der mathematischen Schlussfolgerungen."
   },
@@ -2663,12 +2579,6 @@
   "qvq-plus": {
     "description": "Visuelles Schlussfolgerungsmodell. Unterstützt visuelle Eingaben und Denkprozess-Ausgaben. Die Plus-Version, die auf dem qvq-max-Modell basiert, bietet schnellere Inferenzgeschwindigkeit sowie ein ausgewogeneres Verhältnis von Leistung und Kosten."
   },
-  "qwen-3-32b": {
-    "description": "Qwen 3 32B: Ein Modell der Qwen-Serie mit starker Leistung bei mehrsprachigen und Programmieraufgaben, geeignet für mittelgroße produktive Einsätze."
-  },
-  "qwen-3-coder-480b": {
-    "description": "Qwen 3 Coder 480B: Ein Modell mit langem Kontext, das für Codegenerierung und komplexe Programmieraufgaben entwickelt wurde."
-  },
   "qwen-coder-plus": {
     "description": "Tongyi Qianwen Codierungsmodell."
   },
@@ -2789,6 +2699,12 @@
   "qwen2": {
     "description": "Qwen2 ist das neue große Sprachmodell von Alibaba, das mit hervorragender Leistung eine Vielzahl von Anwendungsanforderungen unterstützt."
   },
+  "qwen2-72b-instruct": {
+    "description": "Qwen2 ist die neueste Generation von Sprachmodellen, die vom Qwen-Team entwickelt wurde. Es basiert auf der Transformer-Architektur und verwendet Techniken wie die SwiGLU-Aktivierungsfunktion, die Aufmerksamkeits-QKV-Bias (attention QKV bias), die gruppenbasierte Abfrageaufmerksamkeit (group query attention) und eine Mischung aus rutschendem Fenster und voller Aufmerksamkeit (mixture of sliding window attention and full attention). Darüber hinaus hat das Qwen-Team den Tokenizer verbessert, der für die Verarbeitung von natürlicher Sprache und Code optimiert ist."
+  },
+  "qwen2-7b-instruct": {
+    "description": "Qwen2 ist die neueste Serie von großen Sprachmodellen, die vom Qwen-Team entwickelt wurde. Es basiert auf der Transformer-Architektur und verwendet Techniken wie die SwiGLU-Aktivierungsfunktion, die Aufmerksamkeits-QKV-Bias (attention QKV bias), die Gruppenabfrageaufmerksamkeit (group query attention) und eine Mischung aus rutschendem Fenster und voller Aufmerksamkeit (mixture of sliding window attention and full attention). Zudem hat das Qwen-Team den Tokenizer verbessert, um mehrere natürliche Sprachen und Code besser zu verarbeiten."
+  },
   "qwen2.5": {
     "description": "Qwen2.5 ist das neue, groß angelegte Sprachmodell der Alibaba-Gruppe, das hervorragende Leistungen zur Unterstützung vielfältiger Anwendungsbedürfnisse bietet."
   },
@@ -2927,12 +2843,6 @@
   "qwen3-next-80b-a3b-thinking": {
     "description": "Ein neues Open-Source-Modell der nächsten Generation im Denkmodus basierend auf Qwen3. Im Vergleich zur vorherigen Version (Tongyi Qianwen 3-235B-A22B-Thinking-2507) wurde die Befehlsbefolgung verbessert und die Modellantworten sind prägnanter zusammengefasst."
   },
-  "qwen3-vl-235b-a22b-instruct": {
-    "description": "Qwen3 VL 235B A22B Instruct ist ein multimodales Modell von Tongyi Qianwen mit Unterstützung für visuelles Verständnis und logisches Denken."
-  },
-  "qwen3-vl-235b-a22b-thinking": {
-    "description": "Qwen3 VL 235B A22B Thinking ist ein multimodales Inferenzmodell von Tongyi Qianwen mit Unterstützung für visuelles Verständnis und logisches Denken."
-  },
   "qwen3-vl-plus": {
     "description": "Tongyi Qianwen VL ist ein Textgenerierungsmodell mit visuellen (Bild-)Verständnisfähigkeiten. Es kann nicht nur OCR (Texterkennung in Bildern) durchführen, sondern auch weiterführende Zusammenfassungen und Schlussfolgerungen ziehen, z. B. Attribute aus Produktfotos extrahieren oder Aufgaben anhand von Übungsbildern lösen."
   },
@@ -3050,9 +2960,6 @@
   "step-r1-v-mini": {
     "description": "Dieses Modell ist ein leistungsstarkes Schlussfolgerungsmodell mit starker Bildverständnisfähigkeit, das in der Lage ist, Bild- und Textinformationen zu verarbeiten und nach tiefem Denken Textinhalte zu generieren. Es zeigt herausragende Leistungen im Bereich der visuellen Schlussfolgerung und verfügt über erstklassige Fähigkeiten in Mathematik, Programmierung und Textschlussfolgerung. Die Kontextlänge beträgt 100k."
   },
-  "step3": {
-    "description": "Step3 ist ein multimodales Modell von StepStar mit leistungsstarken Fähigkeiten im visuellen Verständnis."
-  },
   "stepfun-ai/step3": {
     "description": "Step3 ist ein wegweisendes multimodales Inferenzmodell, veröffentlicht von StepFun (阶跃星辰). Es basiert auf einer Mixture-of-Experts-(MoE)-Architektur mit insgesamt 321 Milliarden Parametern und 38 Milliarden Aktivierungsparametern. Das Modell ist als End-to-End-System konzipiert, um die Decodierungskosten zu minimieren und gleichzeitig erstklassige Leistung bei visuell-sprachlicher Inferenz zu bieten. Durch die synergistische Kombination von Multi-Matrix-Factorization-Attention (MFA) und Attention-FFN-Dekopplung (AFD) erzielt Step3 sowohl auf High-End- als auch auf ressourcenbeschränkten Beschleunigern hohe Effizienz. In der Vortrainingsphase verarbeitete Step3 mehr als 20 Billionen Text-Tokens und 4 Billionen multimodale (Bild‑Text) Tokens und deckt dabei über zehn Sprachen ab. Das Modell erzielt in zahlreichen Benchmarks — etwa in Mathematik, Programmierung und Multimodalität — führende Ergebnisse unter den Open‑Source‑Modellen."
   },
@@ -3176,6 +3083,9 @@
   "xai/grok-4": {
     "description": "xAIs neuestes und bestes Flaggschiffmodell mit unvergleichlicher Leistung in natürlicher Sprache, Mathematik und Inferenz – der perfekte Allrounder."
   },
+  "yi-1.5-34b-chat": {
+    "description": "Yi-1.5 ist eine verbesserte Version von Yi. Es wurde mit einem hochwertigen Korpus von 500B Tokens auf Yi fortlaufend vortrainiert und auf 3M diversen Feinabstimmungsbeispielen feinjustiert."
+  },
   "yi-large": {
     "description": "Das brandneue Modell mit einer Billion Parametern bietet außergewöhnliche Frage- und Textgenerierungsfähigkeiten."
   },
@@ -3221,9 +3131,6 @@
   "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

@@ -32,9 +32,6 @@
   "bfl": {
     "description": "Ein führendes, an vorderster Front tätiges KI-Forschungslabor, das die visuelle Infrastruktur von morgen gestaltet."
   },
-  "cerebras": {
-    "description": "Cerebras ist eine KI-Inferenzplattform, die auf dem spezialisierten CS-3-System basiert. Sie wurde entwickelt, um weltweit die schnellsten, in Echtzeit reagierenden und hochdurchsatzfähigen LLM-Dienste bereitzustellen. Ziel ist es, Latenzen zu eliminieren und komplexe KI-Workflows wie die Echtzeit-Codegenerierung und Agentenaufgaben zu beschleunigen."
-  },
   "cloudflare": {
     "description": "Führen Sie von serverlosen GPUs betriebene Machine-Learning-Modelle im globalen Netzwerk von Cloudflare aus."
   },
@@ -113,9 +110,6 @@
   "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."
   },