🔖 chore(release): v2.0.0-next.109 [skip ci]

## [Version 2.0.0-next.109](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.108...v2.0.0-next.109)
<sup>Released on **2025-11-24**</sup>

#### 🐛 Bug Fixes

- **misc**: Fixed the knowledge files cant open error.

#### 💄 Styles

- **misc**: Update i18n.

<br/>

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

#### What's fixed

* **misc**: Fixed the knowledge files cant open error, closes [#10386](https://github.com/lobehub/lobe-chat/issues/10386) ([8104c77](https://github.com/lobehub/lobe-chat/commit/8104c77))

#### Styles

* **misc**: Update i18n, closes [#10368](https://github.com/lobehub/lobe-chat/issues/10368) ([ed707af](https://github.com/lobehub/lobe-chat/commit/ed707af))

</details>

<div align="right">

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

</div>

.console-log-whitelist.json

@@ -0,0 +1,14 @@
+{
+  "files": ["drizzle.config.ts"],
+  "patterns": [
+    "scripts/**",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "**/examples/**",
+    "e2e/**",
+    ".github/scripts/**",
+    "apps/desktop/**"
+  ]
+}

.github/workflows/check-console-log.yml

@@ -0,0 +1,117 @@
+name: Check Console Log (Warning)
+
+on:
+  pull_request:
+    branches:
+      - main
+      - next
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  check-console-log:
+    name: Check for console.log statements (non-blocking)
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install bun
+        uses: oven-sh/setup-bun@v2
+
+      - name: Run console.log check
+        id: check
+        run: |
+          OUTPUT=$(bunx tsx scripts/checkConsoleLog.mts 2>&1)
+          echo "$OUTPUT"
+
+          # Save output to file for later use
+          echo "$OUTPUT" > /tmp/console-log-output.txt
+
+          # Check if violations were found
+          if echo "$OUTPUT" | grep -q "Total violations:"; then
+            echo "has_violations=true" >> $GITHUB_OUTPUT
+            TOTAL=$(echo "$OUTPUT" | grep -oP "Total violations: \K\d+")
+            echo "total=$TOTAL" >> $GITHUB_OUTPUT
+          else
+            echo "has_violations=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Comment on PR
+        if: steps.check.outputs.has_violations == 'true'
+        uses: actions/github-script@v7
+        env:
+          VIOLATION_COUNT: ${{ steps.check.outputs.total }}
+        with:
+          script: |
+            const fs = require('fs');
+            const output = fs.readFileSync('/tmp/console-log-output.txt', 'utf8');
+            const total = process.env.VIOLATION_COUNT || '0';
+
+            // Parse violations from output (format: "  file:line" followed by "    content")
+            const lines = output.split('\n');
+            const violations = [];
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i];
+              // Match lines like "  packages/database/src/client/db.ts:258"
+              const fileMatch = line.match(/^\s{2}(\S+:\d+)\s*$/);
+              if (fileMatch) {
+                const file = fileMatch[1];
+                const content = lines[i + 1]?.trim() || '';
+                violations.push({ file, content });
+                i++;
+              }
+            }
+
+            // Build comment body
+            const maxDisplay = 30;
+            let body = `## ⚠️ Console.log Check Warning\n\n`;
+            body += `Found **${total}** \`console.log\` statement(s) in this PR.\n\n`;
+
+            if (violations.length > 0) {
+              body += `<details>\n<summary>📋 Click to see violations (${Math.min(violations.length, maxDisplay)} of ${total} shown)</summary>\n\n`;
+              body += `| File | Code |\n|------|------|\n`;
+              violations.slice(0, maxDisplay).forEach(v => {
+                const escapedContent = v.content
+                  .substring(0, 60)
+                  .replace(/\|/g, '\\|')
+                  .replace(/`/g, "'");
+                body += `| \`${v.file}\` | \`${escapedContent}${v.content.length > 60 ? '...' : ''}\` |\n`;
+              });
+              if (parseInt(total) > maxDisplay) {
+                body += `\n*...and ${parseInt(total) - maxDisplay} more violations*\n`;
+              }
+              body += `\n</details>\n\n`;
+            }
+
+            body += `> 💡 **Tip:** Remove \`console.log\` or add files to \`.console-log-whitelist.json\`\n`;
+            body += `> ✅ This check is **non-blocking** and won't prevent merging.`;
+
+            // Find existing comment to update instead of creating duplicates
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+
+            const botComment = comments.find(c =>
+              c.user.type === 'Bot' && c.body.includes('Console.log Check Warning')
+            );
+
+            if (botComment) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: botComment.id,
+                body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body,
+              });
+            }

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

@@ -1,7 +1,7 @@
 name: Desktop PR Build
 
 on:
-  pull_request_target:
+  pull_request:
     types: [synchronize, labeled, unlabeled] # PR 更新或标签变化时触发
 
 # 确保同一 PR 同一时间只运行一个相同的 workflow，取消正在进行的旧的运行
@@ -32,7 +32,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun
@@ -66,7 +66,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       # 主要逻辑：确定构建版本号
@@ -111,7 +111,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       # node-linker=hoisted 模式将可以确保 asar 压缩可用
@@ -126,6 +126,7 @@ jobs:
         run: npm run workflow:set-desktop-version ${{ needs.version.outputs.version }} nightly
 
       # macOS 构建处理
+      # 注意：fork 的 PR 无法访问 secrets，会构建未签名版本
       - name: Build artifact on macOS
         if: runner.os == 'macOS'
         run: npm run desktop:build
@@ -136,7 +137,7 @@ jobs:
           DATABASE_URL: "postgresql://postgres@localhost:5432/postgres"
           # 默认添加一个加密 SECRET
           KEY_VAULTS_SECRET: "oLXWIiR/AKF+rWaqy9lHkrYgzpATbW3CtJp3UfkVgpE="
-          # macOS 签名和公证配置
+          # macOS 签名和公证配置（fork 的 PR 访问不到 secrets，会跳过签名）
           CSC_LINK: ${{ secrets.APPLE_CERTIFICATE_BASE64 }}
           CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
           NEXT_PUBLIC_DESKTOP_PROJECT_ID: ${{ secrets.UMAMI_NIGHTLY_DESKTOP_PROJECT_ID }}
@@ -148,7 +149,8 @@ jobs:
           APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_APP_SPECIFIC_PASSWORD }}
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
 
-      #  Windows 平台构建处理
+      # Windows 平台构建处理
+      # 注意：fork 的 PR 无法访问 secrets，会构建未签名版本
       - name: Build artifact on Windows
         if: runner.os == 'Windows'
         run: npm run desktop:build
@@ -230,7 +232,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun
@@ -275,6 +277,8 @@ jobs:
   publish-pr:
     needs: [merge-mac-files, version]
     name: Publish PR Build
+    # 只为非 fork 的 PR 发布（fork 的 PR 没有写权限）
+    if: github.event.pull_request.head.repo.full_name == github.repository
     runs-on: ubuntu-latest
     # Grant write permissions for creating release and commenting on PR
     permissions:

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

@@ -20,15 +20,6 @@ jobs:
       pull-requests: write # for actions-cool/issues-helper to update PRs
     runs-on: ubuntu-latest
     steps:
-      - name: Auto Comment on Issues Opened
-        uses: wow-actions/auto-comment@v1
-        with:
-          GITHUB_TOKEN: ${{ secrets.GH_TOKEN}}
-          issuesOpened: |
-            👀 @{{ 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.
       - name: Auto Comment on Issues Closed
         uses: wow-actions/auto-comment@v1
         with:
@@ -37,16 +28,6 @@ jobs:
             ✅ @{{ author }}
 
             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:
-          GITHUB_TOKEN: ${{ secrets.GH_TOKEN}}
-          pullRequestOpened: |
-            👍 @{{ author }}
-
-            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.
       - name: Auto Comment on Pull Request Merged
         uses: actions-cool/pr-welcome@main
         if: github.event.pull_request.merged == true

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

@@ -26,7 +26,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun
@@ -55,7 +55,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       # 主要逻辑：确定构建版本号
@@ -96,7 +96,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       # node-linker=hoisted 模式将可以确保 asar 压缩可用
@@ -210,7 +210,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun

.github/workflows/release.yml

@@ -35,7 +35,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun

.github/workflows/test.yml

@@ -31,7 +31,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun
@@ -66,7 +66,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun
@@ -99,7 +99,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install bun
@@ -131,7 +131,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Setup pnpm
@@ -179,7 +179,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: 24
+          node-version: 24.11.1
           package-manager-cache: false
 
       - name: Install pnpm

.gitignore

@@ -103,8 +103,8 @@ vertex-ai-key.json
 .local/
 .claude/
 .mcp.json
-
 CLAUDE.local.md
+.agent/
 
 # MCP tools
 .serena/**

AGENTS.md

@@ -28,6 +28,7 @@ The project follows a well-organized monorepo structure:
 
 ### Git Workflow
 
+- The current release branch is `next` instead of `main` until v2.0.0 is officially released
 - Use rebase for git pull
 - Git commit messages should prefix with gitmoji
 - Git branch name format: `username/feat/feature-name`

CLAUDE.md

@@ -14,6 +14,7 @@ read @.cursor/rules/project-structure.mdc
 
 ### Git Workflow
 
+- The current release branch is `next` instead of `main` until v2.0.0 is officially released
 - use rebase for git pull
 - git commit message should prefix with gitmoji
 - git branch name format example: tj/feat/feature-name

apps/desktop/package.json

@@ -52,12 +52,13 @@
     "@typescript/native-preview": "7.0.0-dev.20250711.1",
     "consola": "^3.4.2",
     "cookie": "^1.0.2",
+    "diff": "^8.0.2",
     "electron": "^38.7.0",
     "electron-builder": "^26.0.12",
     "electron-is": "^3.0.0",
     "electron-log": "^5.4.3",
     "electron-store": "^8.2.0",
-    "electron-vite": "^3.1.0",
+    "electron-vite": "^4.0.1",
     "execa": "^9.6.0",
     "fast-glob": "^3.3.3",
     "fix-path": "^5.0.0",
@@ -72,7 +73,7 @@
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "undici": "^7.16.0",
-    "vite": "^6.4.1",
+    "vite": "^7.2.4",
     "vitest": "^3.2.4"
   },
   "pnpm": {

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

@@ -18,6 +18,7 @@ import {
   WriteLocalFileParams,
 } from '@lobechat/electron-client-ipc';
 import { SYSTEM_FILES_TO_IGNORE, loadFile } from '@lobechat/file-loaders';
+import { createPatch } from 'diff';
 import { shell } from 'electron';
 import fg from 'fast-glob';
 import { Stats, constants } from 'node:fs';
@@ -94,26 +95,45 @@ export default class LocalFileCtr extends ControllerModule {
   }
 
   @ipcClientEvent('readLocalFile')
-  async readFile({ path: filePath, loc }: LocalReadFileParams): Promise<LocalReadFileResult> {
-    const effectiveLoc = loc ?? [0, 200];
-    logger.debug('Starting to read file:', { filePath, loc: effectiveLoc });
+  async readFile({
+    path: filePath,
+    loc,
+    fullContent,
+  }: LocalReadFileParams): Promise<LocalReadFileResult> {
+    const effectiveLoc = fullContent ? undefined : (loc ?? [0, 200]);
+    logger.debug('Starting to read file:', { filePath, fullContent, loc: effectiveLoc });
 
     try {
       const fileDocument = await loadFile(filePath);
 
-      const [startLine, endLine] = effectiveLoc;
       const lines = fileDocument.content.split('\n');
       const totalLineCount = lines.length;
       const totalCharCount = fileDocument.content.length;
 
-      // Adjust slice indices to be 0-based and inclusive/exclusive
-      const selectedLines = lines.slice(startLine, endLine);
-      const content = selectedLines.join('\n');
-      const charCount = content.length;
-      const lineCount = selectedLines.length;
+      let content: string;
+      let charCount: number;
+      let lineCount: number;
+      let actualLoc: [number, number];
+
+      if (effectiveLoc === undefined) {
+        // Return full content
+        content = fileDocument.content;
+        charCount = totalCharCount;
+        lineCount = totalLineCount;
+        actualLoc = [0, totalLineCount];
+      } else {
+        // Return specified range
+        const [startLine, endLine] = effectiveLoc;
+        const selectedLines = lines.slice(startLine, endLine);
+        content = selectedLines.join('\n');
+        charCount = content.length;
+        lineCount = selectedLines.length;
+        actualLoc = effectiveLoc;
+      }
 
       logger.debug('File read successfully:', {
         filePath,
+        fullContent,
         selectedLineCount: lineCount,
         totalCharCount,
         totalLineCount,
@@ -128,7 +148,7 @@ export default class LocalFileCtr extends ControllerModule {
         fileType: fileDocument.fileType,
         filename: fileDocument.filename,
         lineCount,
-        loc: effectiveLoc,
+        loc: actualLoc,
         // Line count for the selected range
         modifiedTime: fileDocument.modifiedTime,
 
@@ -711,8 +731,32 @@ export default class LocalFileCtr extends ControllerModule {
       // Write back to file
       await writeFile(filePath, newContent, 'utf8');
 
-      logger.info(`${logPrefix} File edited successfully`, { replacements });
+      // Generate diff for UI display
+      const patch = createPatch(filePath, content, newContent, '', '');
+      const diffText = `diff --git a${filePath} b${filePath}\n${patch}`;
+
+      // Calculate lines added and deleted from patch
+      const patchLines = patch.split('\n');
+      let linesAdded = 0;
+      let linesDeleted = 0;
+
+      for (const line of patchLines) {
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+          linesAdded++;
+        } else if (line.startsWith('-') && !line.startsWith('---')) {
+          linesDeleted++;
+        }
+      }
+
+      logger.info(`${logPrefix} File edited successfully`, {
+        linesAdded,
+        linesDeleted,
+        replacements,
+      });
       return {
+        diffText,
+        linesAdded,
+        linesDeleted,
         replacements,
         success: true,
       };

apps/desktop/src/main/controllers/__tests__/LocalFileCtr.test.ts

@@ -183,6 +183,26 @@ describe('LocalFileCtr', () => {
       expect(result.totalLineCount).toBe(5);
     });
 
+    it('should read full file content when fullContent is true', async () => {
+      const mockFileContent = 'line1\nline2\nline3\nline4\nline5';
+      vi.mocked(mockLoadFile).mockResolvedValue({
+        content: mockFileContent,
+        filename: 'test.txt',
+        fileType: 'txt',
+        createdTime: new Date('2024-01-01'),
+        modifiedTime: new Date('2024-01-02'),
+      });
+
+      const result = await localFileCtr.readFile({ path: '/test/file.txt', fullContent: true });
+
+      expect(result.content).toBe(mockFileContent);
+      expect(result.lineCount).toBe(5);
+      expect(result.charCount).toBe(mockFileContent.length);
+      expect(result.totalLineCount).toBe(5);
+      expect(result.totalCharCount).toBe(mockFileContent.length);
+      expect(result.loc).toEqual([0, 5]);
+    });
+
     it('should handle file read error', async () => {
       vi.mocked(mockLoadFile).mockRejectedValue(new Error('File not found'));
 
@@ -392,4 +412,137 @@ describe('LocalFileCtr', () => {
       });
     });
   });
+
+  describe('handleEditFile', () => {
+    it('should replace first occurrence successfully', async () => {
+      const originalContent = 'Hello world\nHello again\nGoodbye world';
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue(originalContent);
+      vi.mocked(mockFsPromises.writeFile).mockResolvedValue(undefined);
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.txt',
+        old_string: 'Hello',
+        new_string: 'Hi',
+        replace_all: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.replacements).toBe(1);
+      expect(result.linesAdded).toBe(1);
+      expect(result.linesDeleted).toBe(1);
+      expect(result.diffText).toContain('diff --git a/test/file.txt b/test/file.txt');
+      expect(mockFsPromises.writeFile).toHaveBeenCalledWith(
+        '/test/file.txt',
+        'Hi world\nHello again\nGoodbye world',
+        'utf8',
+      );
+    });
+
+    it('should replace all occurrences when replace_all is true', async () => {
+      const originalContent = 'Hello world\nHello again\nHello there';
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue(originalContent);
+      vi.mocked(mockFsPromises.writeFile).mockResolvedValue(undefined);
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.txt',
+        old_string: 'Hello',
+        new_string: 'Hi',
+        replace_all: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.replacements).toBe(3);
+      expect(result.linesAdded).toBe(3);
+      expect(result.linesDeleted).toBe(3);
+      expect(mockFsPromises.writeFile).toHaveBeenCalledWith(
+        '/test/file.txt',
+        'Hi world\nHi again\nHi there',
+        'utf8',
+      );
+    });
+
+    it('should handle multiline replacement correctly', async () => {
+      const originalContent = 'function test() {\n  console.log("old");\n}';
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue(originalContent);
+      vi.mocked(mockFsPromises.writeFile).mockResolvedValue(undefined);
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.js',
+        old_string: 'console.log("old");',
+        new_string: 'console.log("new");\n  console.log("added");',
+        replace_all: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.replacements).toBe(1);
+      expect(result.linesAdded).toBe(2);
+      expect(result.linesDeleted).toBe(1);
+    });
+
+    it('should return error when old_string is not found', async () => {
+      const originalContent = 'Hello world';
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue(originalContent);
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.txt',
+        old_string: 'NonExistent',
+        new_string: 'New',
+        replace_all: false,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('The specified old_string was not found in the file');
+      expect(result.replacements).toBe(0);
+      expect(mockFsPromises.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('should handle file read error', async () => {
+      vi.mocked(mockFsPromises.readFile).mockRejectedValue(new Error('Permission denied'));
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.txt',
+        old_string: 'Hello',
+        new_string: 'Hi',
+        replace_all: false,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Permission denied');
+      expect(result.replacements).toBe(0);
+    });
+
+    it('should handle file write error', async () => {
+      const originalContent = 'Hello world';
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue(originalContent);
+      vi.mocked(mockFsPromises.writeFile).mockRejectedValue(new Error('Disk full'));
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.txt',
+        old_string: 'Hello',
+        new_string: 'Hi',
+        replace_all: false,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Disk full');
+    });
+
+    it('should generate correct diff format', async () => {
+      const originalContent = 'line 1\nline 2\nline 3';
+      vi.mocked(mockFsPromises.readFile).mockResolvedValue(originalContent);
+      vi.mocked(mockFsPromises.writeFile).mockResolvedValue(undefined);
+
+      const result = await localFileCtr.handleEditFile({
+        file_path: '/test/file.txt',
+        old_string: 'line 2',
+        new_string: 'modified line 2',
+        replace_all: false,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.diffText).toContain('diff --git a/test/file.txt b/test/file.txt');
+      expect(result.diffText).toContain('-line 2');
+      expect(result.diffText).toContain('+modified line 2');
+    });
+  });
 });

apps/desktop/src/main/modules/networkProxy/dispatcher.ts

@@ -10,14 +10,14 @@ import { ProxyUrlBuilder } from './urlBuilder';
 const logger = createLogger('modules:networkProxy:dispatcher');
 
 /**
- * 代理管理器
+ * Proxy dispatcher manager
  */
 export class ProxyDispatcherManager {
   private static isChanging = false;
   private static changeQueue: Array<() => Promise<void>> = [];
 
   /**
-   * 应用代理设置（带并发控制）
+   * Apply proxy settings (with concurrency control)
    */
   static async applyProxySettings(config: NetworkProxySettings): Promise<void> {
     return new Promise((resolve, reject) => {
@@ -31,17 +31,17 @@ export class ProxyDispatcherManager {
       };
 
       if (this.isChanging) {
-        // 如果正在切换，加入队列
+        // If currently switching, add to queue
         this.changeQueue.push(operation);
       } else {
-        // 立即执行
+        // Execute immediately
         operation();
       }
     });
   }
 
   /**
-   * 执行代理设置应用
+   * Execute proxy settings application
    */
   private static async doApplyProxySettings(config: NetworkProxySettings): Promise<void> {
     this.isChanging = true;
@@ -49,22 +49,22 @@ export class ProxyDispatcherManager {
     try {
       const currentDispatcher = getGlobalDispatcher();
 
-      // 禁用代理，恢复默认连接
+      // Disable proxy, restore default connection
       if (!config.enableProxy) {
         await this.safeDestroyDispatcher(currentDispatcher);
-        // 创建一个新的默认 Agent 来替代代理
+        // Create a new default Agent to replace the proxy
         setGlobalDispatcher(new Agent());
         logger.debug('Proxy disabled, reset to direct connection mode');
         return;
       }
 
-      // 构建代理 URL
+      // Build proxy URL
       const proxyUrl = ProxyUrlBuilder.build(config);
 
-      // 创建代理 agent
+      // Create proxy agent
       const agent = this.createProxyAgent(config.proxyType, proxyUrl);
 
-      // 切换代理前销毁旧 dispatcher
+      // Destroy old dispatcher before switching proxy
       await this.safeDestroyDispatcher(currentDispatcher);
       setGlobalDispatcher(agent);
 
@@ -77,7 +77,7 @@ export class ProxyDispatcherManager {
     } finally {
       this.isChanging = false;
 
-      // 处理队列中的下一个操作
+      // Process next operation in queue
       if (this.changeQueue.length > 0) {
         const nextOperation = this.changeQueue.shift();
         if (nextOperation) {
@@ -88,12 +88,12 @@ export class ProxyDispatcherManager {
   }
 
   /**
-   * 创建代理 agent
+   * Create proxy agent
    */
   static createProxyAgent(proxyType: string, proxyUrl: string) {
     try {
       if (proxyType === 'socks5') {
-        // 解析 SOCKS5 代理 URL
+        // Parse SOCKS5 proxy URL
         const url = new URL(proxyUrl);
         const socksProxies: SocksProxies = [
           {
@@ -109,10 +109,10 @@ export class ProxyDispatcherManager {
           },
         ];
 
-        // 使用 fetch-socks 处理 SOCKS5 代理
+        // Use fetch-socks to handle SOCKS5 proxy
         return socksDispatcher(socksProxies);
       } else {
-        // undici 的 ProxyAgent 支持 http, https
+        // undici's ProxyAgent supports http, https
         return new ProxyAgent({ uri: proxyUrl });
       }
     } catch (error) {
@@ -124,7 +124,7 @@ export class ProxyDispatcherManager {
   }
 
   /**
-   * 安全销毁 dispatcher
+   * Safely destroy dispatcher
    */
   private static async safeDestroyDispatcher(dispatcher: any): Promise<void> {
     try {

apps/desktop/src/main/modules/networkProxy/tester.ts

@@ -11,7 +11,7 @@ import { ProxyConfigValidator } from './validator';
 const logger = createLogger('modules:networkProxy:tester');
 
 /**
- * 代理连接测试结果
+ * Proxy connection test result
  */
 export interface ProxyTestResult {
   message?: string;
@@ -20,14 +20,14 @@ export interface ProxyTestResult {
 }
 
 /**
- * 代理连接测试器
+ * Proxy connection tester
  */
 export class ProxyConnectionTester {
-  private static readonly DEFAULT_TIMEOUT = 10_000; // 10秒超时
+  private static readonly DEFAULT_TIMEOUT = 10_000; // 10 seconds timeout
   private static readonly DEFAULT_TEST_URL = 'https://www.google.com';
 
   /**
-   * 测试代理连接
+   * Test proxy connection
    */
   static async testConnection(
     url: string = this.DEFAULT_TEST_URL,
@@ -77,13 +77,13 @@ export class ProxyConnectionTester {
   }
 
   /**
-   * 测试指定代理配置的连接
+   * Test connection with specified proxy configuration
    */
   static async testProxyConfig(
     config: NetworkProxySettings,
     testUrl: string = this.DEFAULT_TEST_URL,
   ): Promise<ProxyTestResult> {
-    // 验证配置
+    // Validate configuration
     const validation = ProxyConfigValidator.validate(config);
     if (!validation.isValid) {
       return {
@@ -92,12 +92,12 @@ export class ProxyConnectionTester {
       };
     }
 
-    // 如果未启用代理，直接测试
+    // If proxy is not enabled, test directly
     if (!config.enableProxy) {
       return this.testConnection(testUrl);
     }
 
-    // 创建临时代理 agent 进行测试
+    // Create temporary proxy agent for testing
     try {
       const proxyUrl = ProxyUrlBuilder.build(config);
       logger.debug(`Testing proxy with URL: ${proxyUrl}`);
@@ -108,7 +108,7 @@ export class ProxyConnectionTester {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), this.DEFAULT_TIMEOUT);
 
-      // 临时设置代理进行测试
+      // Temporarily set proxy for testing
       const originalDispatcher = getGlobalDispatcher();
       setGlobalDispatcher(agent);
 
@@ -138,9 +138,9 @@ export class ProxyConnectionTester {
         clearTimeout(timeoutId);
         throw fetchError;
       } finally {
-        // 恢复原来的 dispatcher
+        // Restore original dispatcher
         setGlobalDispatcher(originalDispatcher);
-        // 清理临时创建的代理 agent
+        // Clean up temporary proxy agent
         if (agent && typeof agent.destroy === 'function') {
           try {
             await agent.destroy();

apps/desktop/src/main/modules/networkProxy/urlBuilder.ts

@@ -1,11 +1,11 @@
 import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
 
 /**
- * 代理 URL 构建器
+ * Proxy URL builder
  */
 export const ProxyUrlBuilder = {
   /**
-   * 构建代理 URL
+   * Build proxy URL
    */
   build(config: NetworkProxySettings): string {
     const { proxyType, proxyServer, proxyPort, proxyRequireAuth, proxyUsername, proxyPassword } =
@@ -13,7 +13,7 @@ export const ProxyUrlBuilder = {
 
     let proxyUrl = `${proxyType}://${proxyServer}:${proxyPort}`;
 
-    // 添加认证信息
+    // Add authentication information
     if (proxyRequireAuth && proxyUsername && proxyPassword) {
       const encodedUsername = encodeURIComponent(proxyUsername);
       const encodedPassword = encodeURIComponent(proxyPassword);

apps/desktop/src/main/modules/networkProxy/validator.ts

@@ -1,7 +1,7 @@
 import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
 
 /**
- * 代理配置验证结果
+ * Proxy configuration validation result
  */
 export interface ProxyValidationResult {
   errors: string[];
@@ -9,38 +9,38 @@ export interface ProxyValidationResult {
 }
 
 /**
- * 代理配置验证器
+ * Proxy configuration validator
  */
 export class ProxyConfigValidator {
   private static readonly SUPPORTED_TYPES = ['http', 'https', 'socks5'] as const;
   private static readonly DEFAULT_BYPASS = 'localhost,127.0.0.1,::1';
 
   /**
-   * 验证代理配置
+   * Validate proxy configuration
    */
   static validate(config: NetworkProxySettings): ProxyValidationResult {
     const errors: string[] = [];
 
-    // 如果未启用代理，跳过验证
+    // If proxy is not enabled, skip validation
     if (!config.enableProxy) {
       return { errors: [], isValid: true };
     }
 
-    // 验证代理类型
+    // Validate proxy type
     if (!this.SUPPORTED_TYPES.includes(config.proxyType as any)) {
       errors.push(
         `Unsupported proxy type: ${config.proxyType}. Supported types: ${this.SUPPORTED_TYPES.join(', ')}`,
       );
     }
 
-    // 验证代理服务器
+    // Validate proxy server
     if (!config.proxyServer?.trim()) {
       errors.push('Proxy server is required when proxy is enabled');
     } else if (!this.isValidHost(config.proxyServer)) {
       errors.push('Invalid proxy server format');
     }
 
-    // 验证代理端口
+    // Validate proxy port
     if (!config.proxyPort?.trim()) {
       errors.push('Proxy port is required when proxy is enabled');
     } else {
@@ -50,7 +50,7 @@ export class ProxyConfigValidator {
       }
     }
 
-    // 验证认证信息
+    // Validate authentication information
     if (config.proxyRequireAuth) {
       if (!config.proxyUsername?.trim()) {
         errors.push('Proxy username is required when authentication is enabled');
@@ -67,10 +67,10 @@ export class ProxyConfigValidator {
   }
 
   /**
-   * 验证主机名格式
+   * Validate host format
    */
   private static isValidHost(host: string): boolean {
-    // 简单的主机名验证（IP 地址或域名）
+    // Simple host validation (IP address or domain name)
     const ipRegex = /^(\d{1,3}\.){3}\d{1,3}$/;
     const domainRegex =
       /^[\dA-Za-z]([\dA-Za-z-]*[\dA-Za-z])?(\.[\dA-Za-z]([\dA-Za-z-]*[\dA-Za-z])?)*$/;

apps/desktop/src/main/services/__tests__/fileSrv.test.ts

@@ -0,0 +1,603 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+import FileService, { FileNotFoundError } from '../fileSrv';
+
+// Mock electron
+vi.mock('electron', () => ({
+  app: {
+    getAppPath: vi.fn(() => '/mock/app/path'),
+    getPath: vi.fn(() => '/mock/user/data'),
+  },
+}));
+
+// Mock constants that depend on electron
+vi.mock('@/const/dir', () => ({
+  FILE_STORAGE_DIR: 'file-storage',
+  LOCAL_STORAGE_URL_PREFIX: '/lobe-desktop-file',
+}));
+
+// Mock logger
+vi.mock('@/utils/logger', () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }),
+}));
+
+// Mock file-system utilities
+vi.mock('@/utils/file-system', () => ({
+  makeSureDirExist: vi.fn(),
+}));
+
+// Mock node:fs/promises
+vi.mock('node:fs/promises', () => ({
+  writeFile: vi.fn(),
+  readFile: vi.fn(),
+  access: vi.fn(),
+}));
+
+// Mock node:fs
+vi.mock('node:fs', () => ({
+  default: {
+    constants: { F_OK: 0 },
+    promises: { access: vi.fn() },
+    readFile: vi.fn(),
+    unlink: vi.fn(),
+  },
+  constants: { F_OK: 0 },
+  promises: { access: vi.fn() },
+  readFile: vi.fn(),
+  unlink: vi.fn(),
+}));
+
+// Mock node:util promisify
+vi.mock('node:util', () => ({
+  promisify: vi.fn((fn: any) => {
+    return vi.fn(async (...args: any[]) => {
+      return new Promise((resolve, reject) => {
+        fn(...args, (err: any, data: any) => {
+          if (err) reject(err);
+          else resolve(data);
+        });
+      });
+    });
+  }),
+}));
+
+describe('FileService', () => {
+  let fileService: FileService;
+  let mockApp: App;
+  let mockMakeSureDirExist: any;
+  let mockWriteFile: any;
+  let mockReadFile: any;
+  let mockAccess: any;
+  let mockFsReadFile: any;
+  let mockFsUnlink: any;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+
+    // Setup mock app
+    mockApp = {
+      appStoragePath: '/mock/app/storage',
+      staticFileServerManager: {
+        getFileServerDomain: vi.fn().mockReturnValue('http://localhost:3000'),
+      },
+    } as unknown as App;
+
+    // Import mocks
+    mockMakeSureDirExist = (await import('@/utils/file-system')).makeSureDirExist;
+    const fsPromises = await import('node:fs/promises');
+    mockWriteFile = fsPromises.writeFile;
+    mockReadFile = fsPromises.readFile;
+    mockAccess = fsPromises.access;
+
+    const fs = await import('node:fs');
+    mockFsReadFile = fs.readFile;
+    mockFsUnlink = fs.unlink;
+
+    fileService = new FileService(mockApp);
+  });
+
+  describe('uploadFile', () => {
+    it('should upload file with ArrayBuffer content successfully', async () => {
+      const content = new ArrayBuffer(10);
+      const params = {
+        content,
+        filename: 'test.png',
+        hash: 'abc123',
+        path: 'user_uploads/images/test.png',
+        type: 'image/png',
+      };
+
+      mockWriteFile.mockResolvedValue(undefined);
+
+      const result = await fileService.uploadFile(params);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.filename).toBe('test.png');
+      expect(result.metadata.dirname).toBe('user_uploads/images');
+      expect(result.metadata.path).toBe('desktop://user_uploads/images/test.png');
+      expect(mockMakeSureDirExist).toHaveBeenCalled();
+      expect(mockWriteFile).toHaveBeenCalledTimes(2); // file + metadata
+    });
+
+    it('should upload file with Base64 string content successfully', async () => {
+      const base64Content = Buffer.from('test content').toString('base64');
+      const params = {
+        content: base64Content,
+        filename: 'test.txt',
+        hash: 'def456',
+        path: 'documents/test.txt',
+        type: 'text/plain',
+      };
+
+      mockWriteFile.mockResolvedValue(undefined);
+
+      const result = await fileService.uploadFile(params);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.filename).toBe('test.txt');
+      expect(result.metadata.path).toBe('desktop://documents/test.txt');
+    });
+
+    it('should create metadata file with correct structure', async () => {
+      const content = new ArrayBuffer(100);
+      const params = {
+        content,
+        filename: 'image.jpg',
+        hash: 'xyz789',
+        path: 'photos/image.jpg',
+        type: 'image/jpeg',
+      };
+
+      let metadataContent: string = '';
+      mockWriteFile.mockImplementation(async (path: any, data: any) => {
+        if (path.toString().endsWith('.meta')) {
+          metadataContent = data;
+        }
+      });
+
+      await fileService.uploadFile(params);
+
+      expect(metadataContent).toBeTruthy();
+      const metadata = JSON.parse(metadataContent);
+      expect(metadata.filename).toBe('image.jpg');
+      expect(metadata.hash).toBe('xyz789');
+      expect(metadata.type).toBe('image/jpeg');
+      expect(metadata.size).toBe(100);
+      expect(metadata.createdAt).toBeDefined();
+    });
+
+    it('should handle upload failure and throw error', async () => {
+      const params = {
+        content: new ArrayBuffer(10),
+        filename: 'test.png',
+        hash: 'abc123',
+        path: 'uploads/test.png',
+        type: 'image/png',
+      };
+
+      mockWriteFile.mockRejectedValue(new Error('Disk full'));
+
+      await expect(fileService.uploadFile(params)).rejects.toThrow('File upload failed: Disk full');
+    });
+
+    it('should handle file path with no directory', async () => {
+      const params = {
+        content: new ArrayBuffer(10),
+        filename: 'test.txt',
+        hash: 'abc',
+        path: 'test.txt',
+        type: 'text/plain',
+      };
+
+      mockWriteFile.mockResolvedValue(undefined);
+
+      const result = await fileService.uploadFile(params);
+
+      expect(result.success).toBe(true);
+      expect(result.metadata.dirname).toBe('');
+      expect(result.metadata.filename).toBe('test.txt');
+    });
+  });
+
+  describe('getFile', () => {
+    it('should get file from new path format successfully', async () => {
+      const mockContent = Buffer.from('test content');
+
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        callback(null, mockContent);
+      });
+
+      // Mock metadata read failure, will infer from extension
+      mockReadFile.mockRejectedValue(new Error('No metadata'));
+
+      const result = await fileService.getFile('desktop://documents/test.txt');
+
+      // Since metadata fails, it will use default or infer from extension
+      expect(result.mimeType).toBeDefined();
+      expect(result.content).toBeDefined();
+    });
+
+    it('should get file from legacy path format (timestamp directory)', async () => {
+      const mockContent = Buffer.from('legacy content');
+
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        callback(null, mockContent);
+      });
+
+      // Mock metadata read to succeed this time
+      mockReadFile.mockResolvedValue(JSON.stringify({ type: 'image/png' }));
+
+      const result = await fileService.getFile('desktop://1234567890/abc123.png');
+
+      // Check that result is returned
+      expect(result.mimeType).toBeDefined();
+      expect(result.content).toBeDefined();
+    });
+
+    it('should fallback from legacy to new path on failure', async () => {
+      const mockContent = Buffer.from('fallback content');
+
+      let callCount = 0;
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        callCount++;
+        if (callCount === 1) {
+          // First read (legacy) fails
+          const error: any = new Error('ENOENT');
+          error.code = 'ENOENT';
+          callback(error, null);
+        } else {
+          // Second read (fallback) succeeds
+          callback(null, mockContent);
+        }
+      });
+
+      mockReadFile.mockRejectedValue(new Error('No metadata'));
+
+      const result = await fileService.getFile('desktop://1234567890/fallback.jpg');
+
+      // Check that fallback worked and result is returned
+      expect(result.content).toBeDefined();
+      expect(result.mimeType).toBeDefined();
+    });
+
+    it('should infer MIME type from file extension when metadata missing', async () => {
+      const mockContent = Buffer.from('image data');
+
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        callback(null, mockContent);
+      });
+
+      mockReadFile.mockRejectedValue(new Error('Metadata not found'));
+
+      const result = await fileService.getFile('desktop://images/photo.png');
+
+      expect(result.mimeType).toBe('image/png');
+    });
+
+    it('should infer correct MIME types for various image formats', async () => {
+      const mockContent = Buffer.from('image');
+
+      const testCases = [
+        { path: 'desktop://test.jpg', expected: 'image/jpeg' },
+        { path: 'desktop://test.jpeg', expected: 'image/jpeg' },
+        { path: 'desktop://test.gif', expected: 'image/gif' },
+        { path: 'desktop://test.webp', expected: 'image/webp' },
+        { path: 'desktop://test.svg', expected: 'image/svg+xml' },
+        { path: 'desktop://test.pdf', expected: 'application/pdf' },
+      ];
+
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        callback(null, mockContent);
+      });
+
+      for (const testCase of testCases) {
+        mockReadFile.mockRejectedValue(new Error('No metadata'));
+
+        const result = await fileService.getFile(testCase.path);
+        expect(result.mimeType).toBe(testCase.expected);
+      }
+    });
+
+    it('should use default MIME type for unknown extensions', async () => {
+      const mockContent = Buffer.from('unknown');
+
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        callback(null, mockContent);
+      });
+
+      mockReadFile.mockRejectedValue(new Error('No metadata'));
+
+      const result = await fileService.getFile('desktop://file.unknown');
+
+      expect(result.mimeType).toBe('application/octet-stream');
+    });
+
+    it('should throw FileNotFoundError when file does not exist', async () => {
+      mockFsReadFile.mockImplementation((path: any, callback: any) => {
+        const error: any = new Error('ENOENT: no such file');
+        error.code = 'ENOENT';
+        error.message = 'ENOENT: no such file';
+        callback(error, null);
+      });
+
+      await expect(fileService.getFile('desktop://missing/file.txt')).rejects.toThrow(
+        FileNotFoundError,
+      );
+    });
+
+    it('should throw error for invalid path without desktop:// prefix', async () => {
+      await expect(fileService.getFile('/invalid/path.txt')).rejects.toThrow(
+        'Invalid desktop file path',
+      );
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('should delete file from new path format successfully', async () => {
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callback(null);
+      });
+
+      const result = await fileService.deleteFile('desktop://documents/test.txt');
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should delete file from legacy path format', async () => {
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callback(null);
+      });
+
+      const result = await fileService.deleteFile('desktop://1234567890/file.png');
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should fallback from legacy to new path on deletion failure', async () => {
+      let callCount = 0;
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callCount++;
+        if (callCount === 1) {
+          // First attempt (legacy file) fails
+          callback(new Error('ENOENT'));
+        } else {
+          // All subsequent attempts succeed
+          callback(null);
+        }
+      });
+
+      const result = await fileService.deleteFile('desktop://1234567890/fallback.txt');
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle metadata deletion failure gracefully', async () => {
+      let callCount = 0;
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callCount++;
+        if (callCount === 1) {
+          // File deletion succeeds
+          callback(null);
+        } else {
+          // Metadata deletion fails (but doesn't throw)
+          callback(new Error('Metadata not found'));
+        }
+      });
+
+      const result = await fileService.deleteFile('desktop://files/test.txt');
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should throw error when file deletion fails', async () => {
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callback(new Error('Permission denied'));
+      });
+
+      await expect(fileService.deleteFile('desktop://protected/file.txt')).rejects.toThrow(
+        'File deletion failed: Permission denied',
+      );
+    });
+
+    it('should throw error for invalid path without desktop:// prefix', async () => {
+      await expect(fileService.deleteFile('/invalid/path.txt')).rejects.toThrow(
+        'Invalid desktop file path',
+      );
+    });
+  });
+
+  describe('deleteFiles', () => {
+    it('should delete multiple files successfully', async () => {
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callback(null);
+      });
+
+      const paths = [
+        'desktop://files/file1.txt',
+        'desktop://files/file2.txt',
+        'desktop://files/file3.txt',
+      ];
+
+      const result = await fileService.deleteFiles(paths);
+
+      expect(result.success).toBe(true);
+      expect(result.errors).toBeUndefined();
+    });
+
+    it('should handle partial failures in batch deletion', async () => {
+      let callCount = 0;
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        callCount++;
+        // Fail on a specific file
+        if (path.includes('file2.txt') && !path.includes('.meta')) {
+          callback(new Error('Permission denied'));
+        } else {
+          callback(null);
+        }
+      });
+
+      const paths = [
+        'desktop://files/file1.txt',
+        'desktop://files/file2.txt',
+        'desktop://files/file3.txt',
+      ];
+
+      const result = await fileService.deleteFiles(paths);
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors?.length).toBeGreaterThan(0);
+    });
+
+    it('should return errors array with failed file paths', async () => {
+      mockFsUnlink.mockImplementation((path: any, callback: any) => {
+        if (path.includes('file2') && !path.includes('.meta')) {
+          callback(new Error('Access denied'));
+        } else {
+          callback(null);
+        }
+      });
+
+      const paths = ['desktop://files/file1.txt', 'desktop://files/file2.txt'];
+
+      const result = await fileService.deleteFiles(paths);
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors?.[0].path).toBe('desktop://files/file2.txt');
+      expect(result.errors?.[0].message).toContain('Access denied');
+    });
+
+    it('should handle empty paths array', async () => {
+      const result = await fileService.deleteFiles([]);
+
+      expect(result.success).toBe(true);
+      expect(result.errors).toBeUndefined();
+    });
+  });
+
+  describe('getFilePath', () => {
+    it('should return correct path for new format', async () => {
+      mockAccess.mockResolvedValue(undefined);
+
+      const result = await fileService.getFilePath('desktop://documents/test.txt');
+
+      expect(result).toBe('/mock/app/storage/file-storage/documents/test.txt');
+    });
+
+    it('should return legacy path when file exists in uploads directory', async () => {
+      mockAccess.mockResolvedValue(undefined);
+
+      const result = await fileService.getFilePath('desktop://1234567890/legacy.png');
+
+      expect(result).toBe('/mock/app/storage/file-storage/uploads/1234567890/legacy.png');
+    });
+
+    it('should fallback to new path when legacy path does not exist', async () => {
+      mockAccess
+        .mockRejectedValueOnce(new Error('Not found')) // legacy fails
+        .mockResolvedValueOnce(undefined); // fallback succeeds
+
+      const result = await fileService.getFilePath('desktop://1234567890/migrated.png');
+
+      // When legacy path doesn't exist and fallback exists, it returns the fallback path
+      // But since isLegacyPath returns true for timestamps, and the fallback succeeds,
+      // it should update to the fallback path
+      expect(result).toContain('1234567890/migrated.png');
+    });
+
+    it('should return legacy path when both paths do not exist', async () => {
+      mockAccess
+        .mockRejectedValueOnce(new Error('Not found'))
+        .mockRejectedValueOnce(new Error('Not found'));
+
+      const result = await fileService.getFilePath('desktop://1234567890/missing.png');
+
+      expect(result).toBe('/mock/app/storage/file-storage/uploads/1234567890/missing.png');
+    });
+
+    it('should throw error for invalid path', async () => {
+      await expect(fileService.getFilePath('/invalid/path')).rejects.toThrow(
+        'Invalid desktop file path',
+      );
+    });
+  });
+
+  describe('getFileHTTPURL', () => {
+    it('should generate correct HTTP URL for new format', async () => {
+      const result = await fileService.getFileHTTPURL('desktop://documents/photo.jpg');
+
+      expect(result).toBe('http://localhost:3000/lobe-desktop-file/documents/photo.jpg');
+    });
+
+    it('should generate correct HTTP URL for legacy format', async () => {
+      const result = await fileService.getFileHTTPURL('desktop://1234567890/image.png');
+
+      expect(result).toBe('http://localhost:3000/lobe-desktop-file/1234567890/image.png');
+    });
+
+    it('should throw error for invalid path', async () => {
+      await expect(fileService.getFileHTTPURL('/invalid/path')).rejects.toThrow(
+        'Invalid desktop file path',
+      );
+    });
+
+    it('should handle paths with special characters', async () => {
+      const result = await fileService.getFileHTTPURL('desktop://user/my%20file.txt');
+
+      expect(result).toBe('http://localhost:3000/lobe-desktop-file/user/my%20file.txt');
+    });
+  });
+
+  describe('isLegacyPath (via behavior testing)', () => {
+    it('should treat timestamp-based paths as legacy', async () => {
+      mockAccess.mockResolvedValue(undefined);
+
+      const result = await fileService.getFilePath('desktop://1234567890/file.txt');
+
+      // Legacy paths go to uploads directory
+      expect(result).toContain('uploads/1234567890/file.txt');
+    });
+
+    it('should treat custom paths as new format', async () => {
+      mockAccess.mockResolvedValue(undefined);
+
+      const result = await fileService.getFilePath('desktop://custom/path/file.txt');
+
+      expect(result).toContain('file-storage/custom/path/file.txt');
+      expect(result).not.toContain('uploads');
+    });
+
+    it('should handle single-level paths correctly', async () => {
+      mockAccess.mockResolvedValue(undefined);
+
+      const result = await fileService.getFilePath('desktop://file.txt');
+
+      expect(result).toContain('file-storage/file.txt');
+    });
+  });
+
+  describe('UPLOADS_DIR getter', () => {
+    it('should return correct uploads directory path', () => {
+      expect(fileService.UPLOADS_DIR).toBe('/mock/app/storage/file-storage/uploads');
+    });
+  });
+
+  describe('FileNotFoundError', () => {
+    it('should create error with correct properties', () => {
+      const error = new FileNotFoundError('File not found', 'desktop://missing.txt');
+
+      expect(error.name).toBe('FileNotFoundError');
+      expect(error.message).toBe('File not found');
+      expect(error.path).toBe('desktop://missing.txt');
+      expect(error instanceof Error).toBe(true);
+    });
+  });
+});

apps/desktop/src/preload/index.ts

@@ -4,9 +4,9 @@ import { setupRouteInterceptors } from './routeInterceptor';
 const setupPreload = () => {
   setupElectronApi();
 
-  // 设置路由拦截逻辑
+  // Setup route interception logic
   window.addEventListener('DOMContentLoaded', () => {
-    // 设置客户端路由拦截器
+    // Setup client-side route interceptor
     setupRouteInterceptors();
   });
 };

apps/desktop/src/preload/invoke.ts

@@ -2,7 +2,7 @@ import { ClientDispatchEventKey, DispatchInvoke } from '@lobechat/electron-clien
 import { ipcRenderer } from 'electron';
 
 /**
- * client 端请求 electron main 端方法
+ * Client-side method to invoke electron main process
  */
 export const invoke: DispatchInvoke = async <T extends ClientDispatchEventKey>(
   event: T,

apps/desktop/src/preload/routeInterceptor.ts

@@ -9,7 +9,7 @@ const interceptRoute = async (
 ) => {
   console.log(`[preload] Intercepted ${source} and prevented default behavior:`, path);
 
-  // 使用electron-client-ipc的dispatch方法
+  // Use electron-client-ipc's dispatch method
   try {
     await invoke('interceptRoute', { path, source, url });
   } catch (e) {
@@ -17,15 +17,15 @@ const interceptRoute = async (
   }
 };
 /**
- * 路由拦截器 - 负责捕获和拦截客户端路由导航
+ * Route interceptor - Responsible for capturing and intercepting client-side route navigation
  */
 export const setupRouteInterceptors = function () {
   console.log('[preload] Setting up route interceptors');
 
-  // 存储被阻止的路径，避免pushState重复触发
+  // Store prevented paths to avoid pushState duplicate triggers
   const preventedPaths = new Set<string>();
 
-  // 重写 window.open 方法来拦截 JavaScript 调用
+  // Override window.open method to intercept JavaScript calls
   const originalWindowOpen = window.open;
   window.open = function (url?: string | URL, target?: string, features?: string) {
     if (url) {
@@ -33,15 +33,15 @@ export const setupRouteInterceptors = function () {
         const urlString = typeof url === 'string' ? url : url.toString();
         const urlObj = new URL(urlString, window.location.href);
 
-        // 检查是否为外部链接
+        // Check if it's an external link
         if (urlObj.origin !== window.location.origin) {
           console.log(`[preload] Intercepted window.open for external URL:`, urlString);
-          // 调用主进程处理外部链接
+          // Call main process to handle external link
           invoke('openExternalLink', urlString);
-          return null; // 返回 null 表示没有打开新窗口
+          return null; // Return null to indicate no window was opened
         }
       } catch (error) {
-        // 处理无效 URL 或特殊协议
+        // Handle invalid URL or special protocol
         console.error(`[preload] Intercepted window.open for special protocol:`, url);
         console.error(error);
         invoke('openExternalLink', typeof url === 'string' ? url : url.toString());
@@ -49,11 +49,11 @@ export const setupRouteInterceptors = function () {
       }
     }
 
-    // 对于内部链接，调用原始的 window.open
+    // For internal links, call original window.open
     return originalWindowOpen.call(window, url, target, features);
   };
 
-  // 拦截所有a标签的点击事件 - 针对Next.js的Link组件
+  // Intercept all a tag click events - For Next.js Link component
   document.addEventListener(
     'click',
     async (e) => {
@@ -62,30 +62,30 @@ export const setupRouteInterceptors = function () {
         try {
           const url = new URL(link.href);
 
-          // 检查是否为外部链接
+          // Check if it's an external link
           if (url.origin !== window.location.origin) {
             console.log(`[preload] Intercepted external link click:`, url.href);
-            // 阻止默认的链接跳转行为
+            // Prevent default link navigation behavior
             e.preventDefault();
             e.stopPropagation();
-            // 调用主进程处理外部链接
+            // Call main process to handle external link
             await invoke('openExternalLink', url.href);
-            return false; // 明确阻止后续处理
+            return false; // Explicitly prevent subsequent processing
           }
 
-          // 如果不是外部链接，则继续处理内部路由拦截逻辑
-          // 使用共享配置检查是否需要拦截
+          // If not external link, continue with internal route interception logic
+          // Use shared config to check if interception is needed
           const matchedRoute = findMatchingRoute(url.pathname);
 
-          // 如果是需要拦截的路径
+          // If it's a path that needs interception
           if (matchedRoute) {
             const currentPath = window.location.pathname;
             const isAlreadyInTargetPage = currentPath.startsWith(matchedRoute.pathPrefix);
 
-            // 如果已经在目标页面下，则不拦截，让默认导航继续
+            // If already in target page, don't intercept, let default navigation continue
             if (isAlreadyInTargetPage) return;
 
-            // 立即阻止默认行为，避免Next.js接管路由
+            // Immediately prevent default behavior to avoid Next.js taking over routing
             e.preventDefault();
             e.stopPropagation();
 
@@ -94,15 +94,15 @@ export const setupRouteInterceptors = function () {
             return false;
           }
         } catch (err) {
-          // 处理可能的 URL 解析错误或其他问题
-          // 例如 mailto:, tel: 等协议会导致 new URL() 抛出错误
+          // Handle possible URL parsing errors or other issues
+          // For example mailto:, tel: protocols will cause new URL() to throw error
           if (err instanceof TypeError && err.message.includes('Invalid URL')) {
             console.log(
               '[preload] Non-HTTP link clicked, allowing default browser behavior:',
               link.href,
             );
-            // 对于非 HTTP/HTTPS 链接，允许浏览器默认处理
-            // 不需要 e.preventDefault() 或 invoke
+            // For non-HTTP/HTTPS links, allow browser default handling
+            // No need for e.preventDefault() or invoke
           } else {
             console.error('[preload] Link interception error:', err);
           }
@@ -112,28 +112,28 @@ export const setupRouteInterceptors = function () {
     true,
   );
 
-  // 拦截 history API (用于捕获Next.js的useRouter().push/replace等)
+  // Intercept history API (for capturing Next.js useRouter().push/replace etc.)
   const originalPushState = history.pushState;
   const originalReplaceState = history.replaceState;
 
-  // 重写pushState
+  // Override pushState
   history.pushState = function () {
     const url = arguments[2];
     if (typeof url === 'string') {
       try {
-        // 只处理相对路径或当前域的URL
+        // Only handle relative paths or current domain URLs
         const parsedUrl = new URL(url, window.location.origin);
 
-        // 使用共享配置检查是否需要拦截
+        // Use shared config to check if interception is needed
         const matchedRoute = findMatchingRoute(parsedUrl.pathname);
 
-        // 检查是否需要拦截这个导航
+        // Check if this navigation needs interception
         if (matchedRoute) {
-          // 检查当前页面是否已经在目标路径下，如果是则不拦截
+          // Check if current page is already under target path, if so don't intercept
           const currentPath = window.location.pathname;
           const isAlreadyInTargetPage = currentPath.startsWith(matchedRoute.pathPrefix);
 
-          // 如果已经在目标页面下，则不拦截，让默认导航继续
+          // If already in target page, don't intercept, let default navigation continue
           if (isAlreadyInTargetPage) {
             console.log(
               `[preload] Skip pushState interception for ${parsedUrl.pathname} because already in target page ${matchedRoute.pathPrefix}`,
@@ -141,13 +141,13 @@ export const setupRouteInterceptors = function () {
             return Reflect.apply(originalPushState, this, arguments);
           }
 
-          // 将此路径添加到已阻止集合中
+          // Add this path to prevented set
           preventedPaths.add(parsedUrl.pathname);
 
           interceptRoute(parsedUrl.pathname, 'push-state', parsedUrl.href);
 
-          // 不执行原始的pushState操作，阻止导航发生
-          // 但返回undefined以避免错误
+          // Don't execute original pushState operation, prevent navigation
+          // But return undefined to avoid errors
           return;
         }
       } catch (err) {
@@ -157,23 +157,23 @@ export const setupRouteInterceptors = function () {
     return Reflect.apply(originalPushState, this, arguments);
   };
 
-  // 重写replaceState
+  // Override replaceState
   history.replaceState = function () {
     const url = arguments[2];
     if (typeof url === 'string') {
       try {
         const parsedUrl = new URL(url, window.location.origin);
 
-        // 使用共享配置检查是否需要拦截
+        // Use shared config to check if interception is needed
         const matchedRoute = findMatchingRoute(parsedUrl.pathname);
 
-        // 检查是否需要拦截这个导航
+        // Check if this navigation needs interception
         if (matchedRoute) {
-          // 检查当前页面是否已经在目标路径下，如果是则不拦截
+          // Check if current page is already under target path, if so don't intercept
           const currentPath = window.location.pathname;
           const isAlreadyInTargetPage = currentPath.startsWith(matchedRoute.pathPrefix);
 
-          // 如果已经在目标页面下，则不拦截，让默认导航继续
+          // If already in target page, don't intercept, let default navigation continue
           if (isAlreadyInTargetPage) {
             console.log(
               `[preload] Skip replaceState interception for ${parsedUrl.pathname} because already in target page ${matchedRoute.pathPrefix}`,
@@ -181,12 +181,12 @@ export const setupRouteInterceptors = function () {
             return Reflect.apply(originalReplaceState, this, arguments);
           }
 
-          // 添加到已阻止集合
+          // Add to prevented set
           preventedPaths.add(parsedUrl.pathname);
 
           interceptRoute(parsedUrl.pathname, 'replace-state', parsedUrl.href);
 
-          // 阻止导航
+          // Prevent navigation
           return;
         }
       } catch (err) {
@@ -196,7 +196,7 @@ export const setupRouteInterceptors = function () {
     return Reflect.apply(originalReplaceState, this, arguments);
   };
 
-  // 监听并拦截路由错误 - 有时Next.js会在路由错误时尝试恢复导航
+  // Listen and intercept routing errors - Sometimes Next.js tries to recover navigation on routing errors
   window.addEventListener(
     'error',
     function (e) {

changelog/v1.json

@@ -1,4 +1,271 @@
 [
+  {
+    "children": {
+      "fixes": ["Fixed the pinned session not work."]
+    },
+    "date": "2025-11-24",
+    "version": "2.0.0-next.108"
+  },
+  {
+    "children": {
+      "improvements": ["Optimize nana banana pro error message."]
+    },
+    "date": "2025-11-23",
+    "version": "2.0.0-next.107"
+  },
+  {
+    "children": {
+      "features": ["Add nano-banana-pro model support and optimization."]
+    },
+    "date": "2025-11-23",
+    "version": "2.0.0-next.106"
+  },
+  {
+    "children": {},
+    "date": "2025-11-23",
+    "version": "2.0.0-next.105"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-11-22",
+    "version": "2.0.0-next.104"
+  },
+  {
+    "children": {
+      "fixes": ["Hide ai image config item in settings category."]
+    },
+    "date": "2025-11-22",
+    "version": "2.0.0-next.103"
+  },
+  {
+    "children": {
+      "features": ["Add new provider ZenMux & Gemini 3 Pro Image Preview."]
+    },
+    "date": "2025-11-22",
+    "version": "2.0.0-next.102"
+  },
+  {
+    "children": {
+      "features": ["Support bedrok prompt cache and usage compute."]
+    },
+    "date": "2025-11-22",
+    "version": "2.0.0-next.101"
+  },
+  {
+    "children": {
+      "fixes": ["Gemini 3 Pro does not display thought summaries."]
+    },
+    "date": "2025-11-21",
+    "version": "2.0.0-next.100"
+  },
+  {
+    "children": {
+      "features": ["Refactor to use kb search tool."]
+    },
+    "date": "2025-11-21",
+    "version": "2.0.0-next.99"
+  },
+  {
+    "children": {
+      "fixes": ["Fixed changelog pages and open again."],
+      "improvements": ["Fix some translations."]
+    },
+    "date": "2025-11-21",
+    "version": "2.0.0-next.98"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-11-21",
+    "version": "2.0.0-next.97"
+  },
+  {
+    "children": {
+      "features": ["Support Command Menu (CMD + J)."]
+    },
+    "date": "2025-11-20",
+    "version": "2.0.0-next.96"
+  },
+  {
+    "children": {
+      "features": ["Add Security Blacklist for agent runtime."]
+    },
+    "date": "2025-11-20",
+    "version": "2.0.0-next.95"
+  },
+  {
+    "children": {
+      "fixes": ["Provider settings button unable to redirect."]
+    },
+    "date": "2025-11-20",
+    "version": "2.0.0-next.94"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-11-20",
+    "version": "2.0.0-next.93"
+  },
+  {
+    "children": {
+      "improvements": ["Remove debug console logs and add loading state."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.92"
+  },
+  {
+    "children": {
+      "fixes": ["Fixed the hydrated false problem."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.91"
+  },
+  {
+    "children": {
+      "improvements": ["Extract StatusIndicator component and improve tools display."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.90"
+  },
+  {
+    "children": {
+      "features": ["Support gemini 3.0 tools calling."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.89"
+  },
+  {
+    "children": {
+      "improvements": ["Fully support Gemini 3.0 model."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.88"
+  },
+  {
+    "children": {
+      "improvements": ["Refactor chat selectors."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.87"
+  },
+  {
+    "children": {
+      "features": ["Support user abort in the agent runtime."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.86"
+  },
+  {
+    "children": {
+      "fixes": ["Slove discover pagination router."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.85"
+  },
+  {
+    "children": {
+      "improvements": ["Add Gemini 3.0 Pro Preview to Google Provider."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.84"
+  },
+  {
+    "children": {
+      "features": ["New API support switch Responses API mode."],
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-11-19",
+    "version": "2.0.0-next.83"
+  },
+  {
+    "children": {
+      "fixes": ["Fix noisy error notification."]
+    },
+    "date": "2025-11-18",
+    "version": "2.0.0-next.82"
+  },
+  {
+    "children": {
+      "fixes": ["Slove when logout always show loading."]
+    },
+    "date": "2025-11-18",
+    "version": "2.0.0-next.81"
+  },
+  {
+    "children": {},
+    "date": "2025-11-18",
+    "version": "2.0.0-next.80"
+  },
+  {
+    "children": {
+      "fixes": ["Fixed the discover page categray sider link error."]
+    },
+    "date": "2025-11-18",
+    "version": "2.0.0-next.79"
+  },
+  {
+    "children": {},
+    "date": "2025-11-18",
+    "version": "2.0.0-next.78"
+  },
+  {
+    "children": {
+      "improvements": ["Delete /settings/newapi pages in nextjs build."]
+    },
+    "date": "2025-11-18",
+    "version": "2.0.0-next.77"
+  },
+  {
+    "children": {
+      "features": ["Support Interleaved thinking in MiniMax."]
+    },
+    "date": "2025-11-18",
+    "version": "2.0.0-next.76"
+  },
+  {
+    "children": {
+      "improvements": ["Update i18n."]
+    },
+    "date": "2025-11-18",
+    "version": "2.0.0-next.75"
+  },
+  {
+    "children": {
+      "features": ["Edit local file render & intervention."]
+    },
+    "date": "2025-11-17",
+    "version": "2.0.0-next.74"
+  },
+  {
+    "children": {
+      "features": ["Support parallel topic agent runtime."]
+    },
+    "date": "2025-11-17",
+    "version": "2.0.0-next.73"
+  },
+  {
+    "children": {
+      "improvements": ["Add model information for the Qiniu provider."]
+    },
+    "date": "2025-11-17",
+    "version": "2.0.0-next.72"
+  },
+  {
+    "children": {
+      "fixes": ["Fix desktop user panel."]
+    },
+    "date": "2025-11-17",
+    "version": "2.0.0-next.71"
+  },
+  {
+    "children": {},
+    "date": "2025-11-17",
+    "version": "2.0.0-next.70"
+  },
   {
     "children": {
       "improvements": ["Remove language_model_settings and remove isDeprecatedEdition."]

codecov.yml

@@ -32,6 +32,7 @@ coverage:
       app:
         flags:
           - app
+      threshold: 0.5
     patch: off
 
 

docs/development/database-schema.dbml

@@ -170,20 +170,8 @@ table chat_groups_agents {
   }
 }
 
-table document_chunks {
-  document_id varchar(30) [not null]
-  chunk_id uuid [not null]
-  page_index integer
-  user_id text [not null]
-  created_at "timestamp with time zone" [not null, default: `now()`]
-
-  indexes {
-    (document_id, chunk_id) [pk]
-  }
-}
-
 table documents {
-  id varchar(30) [pk, not null]
+  id varchar(255) [pk, not null]
   title text
   content text
   file_type varchar(255) [not null]
@@ -195,6 +183,7 @@ table documents {
   source_type text [not null]
   source text [not null]
   file_id text
+  parent_id varchar(255)
   user_id text [not null]
   client_id text
   editor_data jsonb
@@ -206,6 +195,7 @@ table documents {
     source [name: 'documents_source_idx']
     file_type [name: 'documents_file_type_idx']
     file_id [name: 'documents_file_id_idx']
+    parent_id [name: 'documents_parent_id_idx']
     (client_id, user_id) [name: 'documents_client_id_user_id_unique', unique]
   }
 }
@@ -219,16 +209,19 @@ table files {
   size integer [not null]
   url text [not null]
   source text
+  parent_id varchar(255)
   client_id text
   metadata jsonb
   chunk_task_id uuid
   embedding_task_id uuid
+  slug text [unique]
   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 {
     file_hash [name: 'file_hash_idx']
+    parent_id [name: 'files_parent_id_idx']
     (client_id, user_id) [name: 'files_client_id_user_id_unique', unique]
   }
 }
@@ -660,6 +653,18 @@ table chunks {
   }
 }
 
+table document_chunks {
+  document_id varchar(30) [not null]
+  chunk_id uuid [not null]
+  page_index integer
+  user_id text [not null]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    (document_id, chunk_id) [pk]
+  }
+}
+
 table embeddings {
   id uuid [pk, not null, default: `gen_random_uuid()`]
   chunk_id uuid [unique]

docs/usage/providers/comfyui.mdx

@@ -11,7 +11,7 @@ tags:
 
 # Using ComfyUI in LobeChat
 
-<Image alt={'Using ComfyUI in LobeChat'} cover src={'https://github.com/lobehub/lobe-chat/assets/17870709/c9e5eafc-ca22-496b-a88d-cc0ae53bf720'} />
+<Image alt={'Using ComfyUI in LobeChat'} cover src={'https://hub-apac-1.lobeobjects.space/docs/e9b811f248a1db2bd1be1af888cf9b9d.png'} />
 
 This documentation will guide you on how to use [ComfyUI](https://github.com/comfyanonymous/ComfyUI) in LobeChat for high-quality AI image generation and editing.
 

docs/usage/providers/comfyui.zh-CN.mdx

@@ -11,7 +11,7 @@ tags:
 
 # 在 LobeChat 中使用 ComfyUI
 
-<Image alt={'在 LobeChat 中使用 ComfyUI'} cover src={'https://github.com/lobehub/lobe-chat/assets/17870709/c9e5eafc-ca22-496b-a88d-cc0ae53bf720'} />
+<Image alt={'在 LobeChat 中使用 ComfyUI'} cover src={'https://hub-apac-1.lobeobjects.space/docs/e9b811f248a1db2bd1be1af888cf9b9d.png'} />
 
 本文档将指导你如何在 LobeChat 中使用 [ComfyUI](https://github.com/comfyanonymous/ComfyUI) 进行高质量的 AI 图像生成和编辑。
 

e2e/package.json

@@ -17,7 +17,7 @@
     "playwright": "^1.56.1"
   },
   "devDependencies": {
-    "@types/node": "^22.19.1",
+    "@types/node": "^24.10.1",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3"
   }

locales/ar/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "مفتاح التفكير العميق"
     },
+    "thinkingLevel": {
+      "title": "مستوى التفكير"
+    },
     "title": "وظائف توسيع النموذج",
     "urlContext": {
       "desc": "عند التفعيل، سيتم تحليل روابط الويب تلقائيًا للحصول على محتوى السياق الفعلي للصفحة",
@@ -330,6 +333,11 @@
     "screenshot": "لقطة شاشة",
     "settings": "إعدادات التصدير",
     "text": "نص",
+    "widthMode": {
+      "label": "وضع العرض",
+      "narrow": "وضع الشاشة الضيقة",
+      "wide": "وضع الشاشة الواسعة"
+    },
     "withBackground": "تضمين صورة الخلفية",
     "withFooter": "تضمين تذييل",
     "withPluginInfo": "تضمين معلومات البرنامج المساعد",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "إدخال سبب الرفض سيساعد الوكيل على الفهم وتحسين الإجراءات المستقبلية",
       "rejectTitle": "رفض استدعاء الأداة هذه المرة",
       "rejectedWithReason": "تم رفض استدعاء الأداة هذه المرة بشكل يدوي: {{reason}}",
+      "toolAbort": "تم إلغاء استدعاء الأداة من قبل المستخدم",
       "toolRejected": "تم رفض استدعاء الأداة هذه المرة بشكل يدوي"
     }
   },

locales/ar/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "إغلاق",
+  "cmdk": {
+    "about": "حول",
+    "communitySupport": "دعم المجتمع",
+    "discover": "استكشاف",
+    "knowledgeBase": "قاعدة المعرفة",
+    "navigate": "التنقل",
+    "newAgent": "إنشاء مساعد جديد",
+    "noResults": "لم يتم العثور على نتائج",
+    "openSettings": "فتح الإعدادات",
+    "painting": "الرسم بالذكاء الاصطناعي",
+    "searchPlaceholder": "أدخل أمرًا أو ابحث...",
+    "settings": "الإعدادات",
+    "starOnGitHub": "قيّمنا على GitHub",
+    "submitIssue": "إرسال مشكلة",
+    "theme": "السمة",
+    "themeAuto": "اتباع النظام",
+    "themeDark": "الوضع الداكن",
+    "themeLight": "الوضع الفاتح",
+    "toOpen": "فتح",
+    "toSelect": "تحديد"
+  },
   "confirm": "تأكيد",
   "contact": "اتصل بنا",
   "copy": "نسخ",
@@ -283,6 +304,7 @@
     "business": "شراكات تجارية",
     "support": "الدعم عبر البريد الإلكتروني"
   },
+  "new": "جديد",
   "oauth": "تسجيل الدخول SSO",
   "officialSite": "الموقع الرسمي",
   "ok": "موافق",

locales/ar/error.json

@@ -102,7 +102,7 @@
       "SPII": "قد يحتوي المحتوى على معلومات شخصية حساسة. لحماية الخصوصية، يرجى إزالة المعلومات الحساسة ثم المحاولة مرة أخرى.",
       "default": "تم حظر المحتوى: {{blockReason}}. يرجى تعديل طلبك ثم المحاولة مرة أخرى."
     },
-    "InsufficientQuota": "عذرًا، لقد reached الحد الأقصى للحصة (quota) لهذه المفتاح، يرجى التحقق من رصيد الحساب الخاص بك أو زيادة حصة المفتاح ثم المحاولة مرة أخرى",
+    "InsufficientQuota": "عذرًا، لقد تم الوصول إلى الحد الأقصى لحصة المفتاح (quota). يرجى التحقق من رصيد الحساب أو زيادة حصة المفتاح ثم المحاولة مرة أخرى.",
     "InvalidAccessCode": "كلمة المرور غير صحيحة أو فارغة، يرجى إدخال كلمة مرور الوصول الصحيحة أو إضافة مفتاح API مخصص",
     "InvalidBedrockCredentials": "فشلت مصادقة Bedrock، يرجى التحقق من AccessKeyId/SecretAccessKey وإعادة المحاولة",
     "InvalidClerkUser": "عذرًا، لم تقم بتسجيل الدخول بعد، يرجى تسجيل الدخول أو التسجيل للمتابعة",
@@ -131,7 +131,7 @@
     "PluginServerError": "خطأ في استجابة الخادم لطلب الإضافة، يرجى التحقق من ملف وصف الإضافة وتكوين الإضافة وتنفيذ الخادم وفقًا لمعلومات الخطأ أدناه",
     "PluginSettingsInvalid": "تحتاج هذه الإضافة إلى تكوين صحيح قبل الاستخدام، يرجى التحقق من صحة تكوينك",
     "ProviderBizError": "طلب خدمة {{provider}} خاطئ، يرجى التحقق من المعلومات التالية أو إعادة المحاولة",
-    "QuotaLimitReached": "عذرًا، لقد reached الحد الأقصى من استخدام الرموز أو عدد الطلبات لهذا المفتاح. يرجى زيادة حصة هذا المفتاح أو المحاولة لاحقًا.",
+    "QuotaLimitReached": "عذرًا، لقد تم الوصول إلى الحد الأقصى لاستخدام الرموز (Token) أو عدد الطلبات لهذا المفتاح. يرجى زيادة حصة المفتاح أو المحاولة لاحقًا.",
     "StreamChunkError": "خطأ في تحليل كتلة الرسالة لطلب التدفق، يرجى التحقق مما إذا كانت واجهة برمجة التطبيقات الحالية تتوافق مع المعايير، أو الاتصال بمزود واجهة برمجة التطبيقات الخاصة بك للاستفسار.",
     "SubscriptionKeyMismatch": "نعتذر، بسبب عطل عرضي في النظام، فإن استخدام الاشتراك الحالي غير فعال مؤقتًا. يرجى النقر على الزر أدناه لاستعادة الاشتراك، أو مراسلتنا عبر البريد الإلكتروني للحصول على الدعم.",
     "SubscriptionPlanLimit": "لقد استنفدت نقاط اشتراكك، ولا يمكنك استخدام هذه الميزة. يرجى الترقية إلى خطة أعلى، أو تكوين واجهة برمجة التطبيقات للنموذج المخصص للاستمرار في الاستخدام",

locales/ar/file.json

@@ -55,11 +55,11 @@
   },
   "documentList": {
     "copyContent": "نسخ المحتوى الكامل",
-    "documentCount": "إجمالي {{count}} مستند",
     "duplicate": "إنشاء نسخة",
-    "empty": "لا توجد مستندات حاليًا، انقر على الزر أعلاه لإنشاء أول مستند لك",
+    "empty": "لا توجد مستندات حالياً، انقر على الزر أعلاه لإنشاء أول مستند لك",
     "noResults": "لم يتم العثور على مستندات مطابقة",
-    "selectNote": "اختر مستندًا للبدء في التحرير",
+    "pageCount": "إجمالي {{count}} مستند",
+    "selectNote": "اختر مستندًا لبدء التحرير",
     "untitled": "بدون عنوان"
   },
   "empty": "لا توجد ملفات/مجلدات تم تحميلها بعد",
@@ -70,7 +70,6 @@
       "uploadFile": "رفع ملف",
       "uploadFolder": "رفع مجلد"
     },
-    "newDocumentButton": "مستند جديد",
     "newNoteDialog": {
       "cancel": "إلغاء",
       "editTitle": "تحرير المستند",
@@ -83,14 +82,15 @@
       "title": "مستند جديد",
       "updateSuccess": "تم تحديث المستند بنجاح"
     },
+    "newPageButton": "إنشاء مستند جديد",
     "uploadButton": "رفع"
   },
   "home": {
     "getStarted": "ابدأ الآن",
     "greeting": "ابدأ",
     "quickActions": "إجراءات سريعة",
-    "recentDocuments": "المستندات الأخيرة",
     "recentFiles": "الملفات الأخيرة",
+    "recentPages": "الصفحات الأخيرة",
     "subtitle": "مرحبًا بك في قاعدة المعرفة، ابدأ من هنا لإدارة مستنداتك وملاحظاتك",
     "uploadEntries": {
       "files": {
@@ -102,8 +102,8 @@
       "knowledgeBase": {
         "title": "قاعدة معرفة جديدة"
       },
-      "newDocument": {
-        "title": "مستند جديد"
+      "newPage": {
+        "title": "إنشاء مستند جديد"
       }
     }
   },
@@ -116,8 +116,8 @@
     "title": "المكتبة المعرفية"
   },
   "menu": {
-    "allDocuments": "جميع المستندات",
-    "allFiles": "جميع الملفات"
+    "allFiles": "جميع الملفات",
+    "allPages": "جميع المستندات"
   },
   "networkError": "فشل في الحصول على قاعدة المعرفة، يرجى التحقق من اتصال الشبكة ثم إعادة المحاولة",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "تحميل الملف",
     "unsupportedFileAndContact": "هذا التنسيق من الملفات غير مدعوم للمعاينة عبر الإنترنت، إذا كان لديك طلب للمعاينة، فلا تتردد في <1>إبلاغنا</1>"
   },
-  "searchDocumentPlaceholder": "ابحث في المستندات",
   "searchFilePlaceholder": "بحث عن ملف",
+  "searchPagePlaceholder": "ابحث في المستندات",
   "tab": {
     "all": "الكل",
     "audios": "الصوتيات",
@@ -156,9 +156,7 @@
     "websites": "المواقع"
   },
   "title": "قاعدة المعرفة",
-  "toggleLeftPanel": {
-    "title": "عرض/إخفاء اللوحة الجانبية اليسرى"
-  },
+  "toggleLeftPanel": "إظهار/إخفاء اللوحة الجانبية اليسرى",
   "uploadDock": {
     "body": {
       "collapse": "طي",

locales/ar/hotkey.json

@@ -7,6 +7,10 @@
     "desc": "مسح الرسائل والملفات المرفوعة في المحادثة الحالية",
     "title": "مسح رسائل المحادثة"
   },
+  "commandPalette": {
+    "desc": "افتح لوحة الأوامر العامة للوصول السريع إلى الميزات",
+    "title": "لوحة الأوامر"
+  },
   "deleteAndRegenerateMessage": {
     "desc": "حذف الرسالة الأخيرة وإعادة إنشائها",
     "title": "حذف وإعادة إنشاء"

locales/ar/image.json

@@ -37,6 +37,14 @@
         "standard": "عادي"
       }
     },
+    "resolution": {
+      "label": "الدقة",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "البذرة",
       "random": "بذرة عشوائية"

locales/ar/modelProvider.json

@@ -295,7 +295,7 @@
       },
       "helpDoc": "دليل التكوين",
       "responsesApi": {
-        "desc": "استخدام معيار طلبات الجيل الجديد من OpenAI، لفتح ميزات متقدمة مثل سلسلة التفكير",
+        "desc": "يعتمد تنسيق طلب الجيل الجديد من OpenAI، لتمكين ميزات متقدمة مثل سلسلة التفكير (مدعومة فقط من نماذج OpenAI)",
         "title": "استخدام معيار Responses API"
       },
       "waitingForMore": "المزيد من النماذج قيد <1>التخطيط للإدماج</1>، يرجى الانتظار"

locales/ar/models.json

@@ -236,6 +236,9 @@
   "MiniMaxAI/MiniMax-M1-80k": {
     "description": "MiniMax-M1 هو نموذج استدلال كبير الحجم مفتوح المصدر يعتمد على الانتباه المختلط، يحتوي على 456 مليار معلمة، حيث يمكن لكل رمز تفعيل حوالي 45.9 مليار معلمة. يدعم النموذج أصلاً سياقًا فائق الطول يصل إلى مليون رمز، ومن خلال آلية الانتباه السريع، يوفر 75% من العمليات الحسابية العائمة في مهام التوليد التي تصل إلى 100 ألف رمز مقارنة بـ DeepSeek R1. بالإضافة إلى ذلك، يعتمد MiniMax-M1 على بنية MoE (الخبراء المختلطون)، ويجمع بين خوارزمية CISPO وتصميم الانتباه المختلط لتدريب تعلم معزز فعال، محققًا أداءً رائدًا في الصناعة في استدلال الإدخالات الطويلة وسيناريوهات هندسة البرمجيات الحقيقية."
   },
+  "MiniMaxAI/MiniMax-M2": {
+    "description": "MiniMax-M2 يعيد تعريف الكفاءة للوكيل الذكي. إنه نموذج MoE مدمج وسريع وفعّال من حيث التكلفة، يحتوي على 230 مليار معلمة إجمالية و10 مليارات معلمة نشطة، وقد صُمم لتحقيق أداء رفيع المستوى في مهام الترميز والوكالة، مع الحفاظ على ذكاء عام قوي. بفضل 10 مليارات معلمة نشطة فقط، يقدم MiniMax-M2 أداءً يُضاهي النماذج الضخمة، مما يجعله خيارًا مثاليًا للتطبيقات عالية الكفاءة."
+  },
   "Moonshot-Kimi-K2-Instruct": {
     "description": "يحتوي على 1 تريليون معلمة و32 مليار معلمة مفعلة. من بين النماذج غير المعتمدة على التفكير، يحقق مستويات متقدمة في المعرفة الحديثة، الرياضيات والبرمجة، ويتفوق في مهام الوكيل العامة. تم تحسينه بعناية لمهام الوكيل، لا يجيب فقط على الأسئلة بل يتخذ إجراءات. مثالي للدردشة العفوية، التجارب العامة والوكيل، وهو نموذج سريع الاستجابة لا يتطلب تفكيرًا طويلًا."
   },
@@ -717,25 +720,28 @@
     "description": "Claude 3 Opus هو أذكى نموذج من Anthropic، يقدم أداءً رائدًا في السوق للمهام المعقدة للغاية. يتميز بسلاسة استثنائية وفهم شبيه بالبشر للتعامل مع المطالبات المفتوحة والسيناريوهات غير المسبوقة."
   },
   "anthropic/claude-3.5-haiku": {
-    "description": "Claude 3.5 Haiku هو الجيل التالي من أسرع نماذجنا. يتمتع بسرعة مماثلة لـ Claude 3 Haiku، مع تحسينات في كل مجموعة مهارات، وتفوق في العديد من اختبارات الذكاء على أكبر نموذج لدينا من الجيل السابق Claude 3 Opus."
+    "description": "يتميز Claude 3.5 Haiku بقدرات محسّنة في السرعة ودقة البرمجة واستخدام الأدوات. مناسب للسيناريوهات التي تتطلب سرعة عالية وتفاعلًا فعالًا مع الأدوات."
   },
   "anthropic/claude-3.5-sonnet": {
-    "description": "Claude 3.5 Sonnet يحقق توازنًا مثاليًا بين الذكاء والسرعة، خاصة لأعباء العمل المؤسسية. يقدم أداءً قويًا بتكلفة أقل مقارنة بالمنافسين، ومصمم لتحمل عالي في نشرات الذكاء الاصطناعي على نطاق واسع."
+    "description": "Claude 3.5 Sonnet هو نموذج سريع وفعّال من عائلة Sonnet، يوفر أداءً أفضل في البرمجة والاستدلال، وسيتم استبدال بعض نسخه تدريجيًا بـ Sonnet 3.7 وما بعده."
   },
   "anthropic/claude-3.7-sonnet": {
-    "description": "Claude 3.7 Sonnet هو أول نموذج استدلال مختلط، وأذكى نموذج حتى الآن من Anthropic. يقدم أداءً متقدمًا في الترميز، وتوليد المحتوى، وتحليل البيانات، ومهام التخطيط، مبنيًا على قدرات الهندسة البرمجية واستخدام الحاسوب في سلفه Claude 3.5 Sonnet."
+    "description": "Claude 3.7 Sonnet هو إصدار مطوّر من سلسلة Sonnet، يتمتع بقدرات استدلال وبرمجة أقوى، ومناسب للمهام المعقدة على مستوى المؤسسات."
+  },
+  "anthropic/claude-haiku-4.5": {
+    "description": "Claude Haiku 4.5 هو نموذج عالي الأداء من Anthropic يتميز بزمن استجابة منخفض جدًا مع الحفاظ على دقة عالية."
   },
   "anthropic/claude-opus-4": {
-    "description": "Claude Opus 4 هو أقوى نموذج حتى الآن من Anthropic، وأفضل نموذج ترميز في العالم، متصدرًا في اختبارات SWE-bench (72.5%) وTerminal-bench (43.2%). يوفر أداءً مستمرًا للمهام الطويلة التي تتطلب تركيزًا وجهدًا وآلاف الخطوات، قادرًا على العمل لساعات متواصلة، مما يوسع بشكل كبير قدرات وكلاء الذكاء الاصطناعي."
+    "description": "Opus 4 هو النموذج الرائد من Anthropic، مصمم خصيصًا للمهام المعقدة والتطبيقات المؤسسية."
   },
   "anthropic/claude-opus-4.1": {
-    "description": "Claude Opus 4.1 هو بديل جاهز للاستخدام لـ Opus 4، يقدم أداءً ودقة ممتازة في مهام الترميز والوكالة العملية. يرفع أداء الترميز المتقدم إلى 74.5% في SWE-bench Verified، ويتعامل مع المشكلات المعقدة متعددة الخطوات بدقة واهتمام أكبر بالتفاصيل."
+    "description": "Opus 4.1 هو نموذج متقدم من Anthropic، محسن للبرمجة، الاستدلال المعقد، والمهام المستمرة."
   },
   "anthropic/claude-sonnet-4": {
-    "description": "Claude Sonnet 4 يحسن بشكل كبير على قدرات Sonnet 3.7 الرائدة في الصناعة، ويظهر أداءً ممتازًا في الترميز، محققًا 72.7% في SWE-bench. يوازن النموذج بين الأداء والكفاءة، مناسب للحالات الداخلية والخارجية، ويحقق تحكمًا أكبر في التنفيذ من خلال قابلية تحكم محسنة."
+    "description": "Claude Sonnet 4 هو إصدار الاستدلال الهجين من Anthropic، يجمع بين قدرات التفكير وغير التفكير."
   },
   "anthropic/claude-sonnet-4.5": {
-    "description": "كلود سونيت 4.5 هو أذكى نموذج قدمته شركة أنثروبيك حتى الآن."
+    "description": "Claude Sonnet 4.5 هو أحدث نموذج استدلال هجين من Anthropic، محسن للاستدلال المعقد والبرمجة."
   },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B هو نموذج لغة ضخم نادر التنشيط يحتوي على 72 مليار معلمة و16 مليار معلمة نشطة، يعتمد على بنية الخبراء المختلطين المجمعة (MoGE). في مرحلة اختيار الخبراء، يتم تجميع الخبراء وتقيد تنشيط عدد متساوٍ من الخبراء داخل كل مجموعة لكل رمز، مما يحقق توازنًا في تحميل الخبراء ويعزز بشكل كبير كفاءة نشر النموذج على منصة Ascend."
@@ -758,6 +764,9 @@
   "baidu/ERNIE-4.5-300B-A47B": {
     "description": "ERNIE-4.5-300B-A47B هو نموذج لغة ضخم يعتمد على بنية الخبراء المختلطين (MoE) تم تطويره بواسطة شركة بايدو. يحتوي النموذج على 300 مليار معلمة إجمالاً، لكنه ينشط فقط 47 مليار معلمة لكل رمز أثناء الاستدلال، مما يوازن بين الأداء القوي والكفاءة الحسابية. كأحد النماذج الأساسية في سلسلة ERNIE 4.5، يظهر أداءً متميزًا في مهام فهم النصوص، التوليد، الاستدلال، والبرمجة. يستخدم النموذج طريقة تدريب مسبق مبتكرة متعددة الوسائط ومتغايرة تعتمد على MoE، من خلال التدريب المشترك للنصوص والوسائط البصرية، مما يعزز قدراته الشاملة، خاصة في الالتزام بالتعليمات وتذكر المعرفة العالمية."
   },
+  "baidu/ernie-5.0-thinking-preview": {
+    "description": "ERNIE 5.0 Thinking Preview هو نموذج Wenxin متعدد الوسائط من الجيل الجديد من Baidu، بارع في الفهم متعدد الوسائط، اتباع التعليمات، الإبداع، الأسئلة والأجوبة الواقعية، واستخدام الأدوات."
+  },
   "c4ai-aya-expanse-32b": {
     "description": "Aya Expanse هو نموذج متعدد اللغات عالي الأداء بسعة 32B، يهدف إلى تحدي أداء النماذج أحادية اللغة من خلال تحسين التعليمات، وتداول البيانات، وتدريب التفضيلات، وابتكارات دمج النماذج. يدعم 23 لغة."
   },
@@ -866,6 +875,9 @@
   "codex-mini-latest": {
     "description": "codex-mini-latest هو نسخة محسنة من o4-mini، مخصصة لـ Codex CLI. بالنسبة للاستخدام المباشر عبر API، نوصي بالبدء من gpt-4.1."
   },
+  "cogito-2.1:671b": {
+    "description": "Cogito v2.1 671B هو نموذج لغة مفتوح المصدر من الولايات المتحدة ومتاح للاستخدام التجاري المجاني، يتميز بأداء يقارن بأفضل النماذج، وكفاءة استدلال أعلى، وسياق طويل يصل إلى 128k، وقدرات شاملة قوية."
+  },
   "cogview-4": {
     "description": "CogView-4 هو أول نموذج مفتوح المصدر من Zhipu يدعم توليد الحروف الصينية، مع تحسينات شاملة في فهم المعاني، وجودة توليد الصور، وقدرات توليد النصوص باللغتين الصينية والإنجليزية، ويدعم إدخال ثنائي اللغة بأي طول، وقادر على توليد صور بأي دقة ضمن النطاق المحدد."
   },
@@ -1136,6 +1148,9 @@
   "deepseek-vl2-small": {
     "description": "DeepSeek VL2 Small، نسخة خفيفة متعددة الوسائط، مناسبة للبيئات ذات الموارد المحدودة وسيناريوهات الحمل العالي."
   },
+  "deepseek/deepseek-chat": {
+    "description": "DeepSeek-V3 هو نموذج استدلال هجين عالي الأداء من فريق DeepSeek، مناسب للمهام المعقدة وتكامل الأدوات."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 هو نموذج مختلط خبير يحتوي على 685B من المعلمات، وهو أحدث إصدار من سلسلة نماذج الدردشة الرائدة لفريق DeepSeek.\n\nيستفيد من نموذج [DeepSeek V3](/deepseek/deepseek-chat-v3) ويظهر أداءً ممتازًا في مجموعة متنوعة من المهام."
   },
@@ -1143,19 +1158,19 @@
     "description": "DeepSeek V3 هو نموذج مختلط خبير يحتوي على 685B من المعلمات، وهو أحدث إصدار من سلسلة نماذج الدردشة الرائدة لفريق DeepSeek.\n\nيستفيد من نموذج [DeepSeek V3](/deepseek/deepseek-chat-v3) ويظهر أداءً ممتازًا في مجموعة متنوعة من المهام."
   },
   "deepseek/deepseek-chat-v3.1": {
-    "description": "DeepSeek-V3.1 هو نموذج استدلال هجين كبير يدعم سياق طويل يصل إلى 128K وتبديل أوضاع فعال، ويحقق أداءً وسرعة ممتازة في استدعاء الأدوات، وتوليد الأكواد، والمهام الاستدلالية المعقدة."
+    "description": "DeepSeek-V3.1 هو نموذج استدلال هجين طويل السياق من DeepSeek، يدعم أوضاع التفكير وغير التفكير وتكامل الأدوات."
   },
   "deepseek/deepseek-r1": {
     "description": "تم ترقية نموذج DeepSeek R1 إلى إصدار صغير جديد، الإصدار الحالي هو DeepSeek-R1-0528. في التحديث الأخير، حسّن DeepSeek R1 عمق الاستدلال وقدرته بشكل ملحوظ من خلال استغلال موارد حسابية متزايدة وإدخال آليات تحسين خوارزمية بعد التدريب. النموذج يحقق أداءً ممتازًا في تقييمات معيارية متعددة مثل الرياضيات، والبرمجة، والمنطق العام، وأداؤه العام يقترب الآن من النماذج الرائدة مثل O3 وGemini 2.5 Pro."
   },
   "deepseek/deepseek-r1-0528": {
-    "description": "DeepSeek-R1 يعزز بشكل كبير قدرة الاستدلال للنموذج حتى مع وجود بيانات تعليمية قليلة جدًا. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من التفكير لتحسين دقة الإجابة النهائية."
+    "description": "DeepSeek R1 0528 هو إصدار محدث من DeepSeek، يركز على المصدر المفتوح وعمق الاستدلال."
   },
   "deepseek/deepseek-r1-0528:free": {
     "description": "DeepSeek-R1 يعزز بشكل كبير قدرة الاستدلال للنموذج حتى مع وجود بيانات تعليمية قليلة جدًا. قبل إخراج الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من التفكير لتحسين دقة الإجابة النهائية."
   },
   "deepseek/deepseek-r1-distill-llama-70b": {
-    "description": "DeepSeek-R1-Distill-Llama-70B هو نسخة مكثفة وأكثر كفاءة من نموذج Llama 70B. يحافظ على أداء قوي في مهام توليد النصوص مع تقليل استهلاك الحوسبة لتسهيل النشر والبحث. يتم تشغيله بواسطة Groq باستخدام وحدة معالجة اللغة المخصصة (LPU) لتوفير استدلال سريع وفعال."
+    "description": "DeepSeek R1 Distill Llama 70B هو نموذج لغوي ضخم مبني على Llama3.3 70B، وقد تم تحسينه باستخدام نتائج DeepSeek R1، ليحقق أداءً تنافسيًا يعادل النماذج الرائدة الكبيرة."
   },
   "deepseek/deepseek-r1-distill-llama-8b": {
     "description": "DeepSeek R1 Distill Llama 8B هو نموذج لغوي كبير مكرر يعتمد على Llama-3.1-8B-Instruct، تم تدريبه باستخدام مخرجات DeepSeek R1."
@@ -1172,6 +1187,9 @@
   "deepseek/deepseek-r1:free": {
     "description": "DeepSeek-R1 يعزز بشكل كبير من قدرة النموذج على الاستدلال في ظل وجود بيانات محدودة جدًا. قبل تقديم الإجابة النهائية، يقوم النموذج أولاً بإخراج سلسلة من التفكير لتحسين دقة الإجابة النهائية."
   },
+  "deepseek/deepseek-reasoner": {
+    "description": "DeepSeek-V3 Thinking (reasoner) هو نموذج استدلال تجريبي من DeepSeek، مناسب للمهام الاستدلالية عالية التعقيد."
+  },
   "deepseek/deepseek-v3": {
     "description": "نموذج لغة كبير عام سريع مع قدرات استدلال محسنة."
   },
@@ -1478,9 +1496,6 @@
   "gemini-2.0-flash-lite-001": {
     "description": "نموذج جمنّي 2.0 فلاش هو نسخة معدلة، تم تحسينها لتحقيق الكفاءة من حيث التكلفة والحد من التأخير."
   },
-  "gemini-2.0-flash-preview-image-generation": {
-    "description": "نموذج معاينة Gemini 2.0 Flash، يدعم توليد الصور"
-  },
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash هو نموذج Google الأكثر فعالية من حيث التكلفة، ويوفر وظائف شاملة."
   },
@@ -1508,9 +1523,6 @@
   "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"
   },
@@ -1526,6 +1538,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "جيميني 2.5 برو بريڤيو هو أحدث نموذج تفكيري من جوجل، قادر على استنتاج حلول للمشكلات المعقدة في مجالات البرمجة، الرياضيات، والعلوم والتكنولوجيا والهندسة والرياضيات (STEM)، بالإضافة إلى تحليل مجموعات بيانات كبيرة، قواعد بيانات البرمجة، والوثائق باستخدام سياق طويل."
   },
+  "gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) هو نموذج توليد صور من Google، يدعم أيضًا المحادثات متعددة الوسائط."
+  },
+  "gemini-3-pro-image-preview:image": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) هو نموذج توليد صور من Google، يدعم أيضًا المحادثات متعددة الوسائط."
+  },
+  "gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro هو أفضل نموذج لفهم الوسائط المتعددة عالميًا، وأقوى نموذج ذكي من Google حتى الآن، يوفر تأثيرات بصرية غنية وتفاعلية عميقة، وكل ذلك مبني على قدرات استدلال متقدمة."
+  },
   "gemini-flash-latest": {
     "description": "أحدث إصدار من Gemini Flash"
   },
@@ -1650,7 +1671,7 @@
     "description": "يمتلك GLM-Zero-Preview قدرة قوية على الاستدلال المعقد، ويظهر أداءً ممتازًا في مجالات الاستدلال المنطقي، والرياضيات، والبرمجة."
   },
   "google/gemini-2.0-flash": {
-    "description": "Gemini 2.0 Flash يقدم ميزات الجيل التالي وتحسينات تشمل سرعة فائقة، استخدام أدوات مدمجة، توليد متعدد الوسائط، ونافذة سياق تصل إلى مليون رمز."
+    "description": "Gemini 2.0 Flash هو نموذج استدلال عالي الأداء من Google، مناسب للمهام متعددة الوسائط الممتدة."
   },
   "google/gemini-2.0-flash-001": {
     "description": "Gemini 2.0 Flash يقدم ميزات وتحسينات من الجيل التالي، بما في ذلك سرعة فائقة، واستخدام أدوات أصلية، وتوليد متعدد الوسائط، ونافذة سياق تصل إلى 1M توكن."
@@ -1661,14 +1682,23 @@
   "google/gemini-2.0-flash-lite": {
     "description": "Gemini 2.0 Flash Lite يقدم ميزات الجيل التالي وتحسينات تشمل سرعة فائقة، استخدام أدوات مدمجة، توليد متعدد الوسائط، ونافذة سياق تصل إلى مليون رمز."
   },
+  "google/gemini-2.0-flash-lite-001": {
+    "description": "Gemini 2.0 Flash Lite هو إصدار خفيف من عائلة Gemini، لا يفعل وضع التفكير افتراضيًا لتحسين الأداء من حيث التأخير والتكلفة، ويمكن تفعيله عبر المعلمات."
+  },
   "google/gemini-2.5-flash": {
-    "description": "Gemini 2.5 Flash هو نموذج تفكيري يقدم قدرات شاملة ممتازة. مصمم لتحقيق توازن بين السعر والأداء، ويدعم متعدد الوسائط ونافذة سياق تصل إلى مليون رمز."
+    "description": "سلسلة Gemini 2.5 Flash (Lite/Pro/Flash) هي نماذج استدلال من Google تتراوح من تأخير منخفض إلى أداء عالٍ."
+  },
+  "google/gemini-2.5-flash-image": {
+    "description": "Gemini 2.5 Flash Image (Nano Banana) هو نموذج توليد صور من Google، يدعم أيضًا المحادثات متعددة الوسائط."
+  },
+  "google/gemini-2.5-flash-image-free": {
+    "description": "الإصدار المجاني من Gemini 2.5 Flash Image، يدعم توليد الوسائط المتعددة بحدود استخدام معينة."
   },
   "google/gemini-2.5-flash-image-preview": {
     "description": "نموذج تجريبي Gemini 2.5 Flash، يدعم توليد الصور."
   },
   "google/gemini-2.5-flash-lite": {
-    "description": "Gemini 2.5 Flash-Lite هو نموذج متوازن ومنخفض التأخير مع ميزانية تفكير قابلة للتكوين واتصال بالأدوات (مثل البحث في Google والتنفيذ البرمجي). يدعم مدخلات متعددة الوسائط ويوفر نافذة سياق تصل إلى مليون رمز."
+    "description": "Gemini 2.5 Flash Lite هو إصدار خفيف من Gemini 2.5، محسن من حيث التأخير والتكلفة، مناسب للسيناريوهات ذات الإنتاجية العالية."
   },
   "google/gemini-2.5-flash-preview": {
     "description": "Gemini 2.5 Flash هو النموذج الرائد الأكثر تقدمًا من Google، مصمم للاستدلال المتقدم، الترميز، المهام الرياضية والعلمية. يحتوي على قدرة \"التفكير\" المدمجة، مما يمكّنه من تقديم استجابات بدقة أعلى ومعالجة سياقات أكثر تفصيلاً.\n\nملاحظة: يحتوي هذا النموذج على نوعين: التفكير وغير التفكير. تختلف تسعير الإخراج بشكل ملحوظ بناءً على ما إذا كانت قدرة التفكير مفعلة. إذا اخترت النوع القياسي (بدون لاحقة \" :thinking \")، سيتجنب النموذج بشكل صريح توليد رموز التفكير.\n\nلاستغلال قدرة التفكير واستقبال رموز التفكير، يجب عليك اختيار النوع \" :thinking \"، مما سيؤدي إلى تسعير إخراج تفكير أعلى.\n\nبالإضافة إلى ذلك، يمكن تكوين Gemini 2.5 Flash من خلال معلمة \"الحد الأقصى لعدد رموز الاستدلال\"، كما هو موضح في الوثائق (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
@@ -1677,11 +1707,26 @@
     "description": "Gemini 2.5 Flash هو النموذج الرائد الأكثر تقدمًا من Google، مصمم للاستدلال المتقدم، الترميز، المهام الرياضية والعلمية. يحتوي على قدرة \"التفكير\" المدمجة، مما يمكّنه من تقديم استجابات بدقة أعلى ومعالجة سياقات أكثر تفصيلاً.\n\nملاحظة: يحتوي هذا النموذج على نوعين: التفكير وغير التفكير. تختلف تسعير الإخراج بشكل ملحوظ بناءً على ما إذا كانت قدرة التفكير مفعلة. إذا اخترت النوع القياسي (بدون لاحقة \" :thinking \")، سيتجنب النموذج بشكل صريح توليد رموز التفكير.\n\nلاستغلال قدرة التفكير واستقبال رموز التفكير، يجب عليك اختيار النوع \" :thinking \"، مما سيؤدي إلى تسعير إخراج تفكير أعلى.\n\nبالإضافة إلى ذلك، يمكن تكوين Gemini 2.5 Flash من خلال معلمة \"الحد الأقصى لعدد رموز الاستدلال\"، كما هو موضح في الوثائق (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
   },
   "google/gemini-2.5-pro": {
-    "description": "Gemini 2.5 Pro هو نموذج Gemini المتقدم للاستدلال، قادر على حل المشكلات المعقدة. يحتوي على نافذة سياق تصل إلى مليوني رمز، ويدعم مدخلات متعددة الوسائط تشمل النصوص، الصور، الصوت، الفيديو، ومستندات PDF."
+    "description": "Gemini 2.5 Pro هو نموذج استدلال رائد من Google، يدعم السياق الطويل والمهام المعقدة."
+  },
+  "google/gemini-2.5-pro-free": {
+    "description": "الإصدار المجاني من Gemini 2.5 Pro، يدعم سياق طويل متعدد الوسائط بحدود استخدام معينة، مناسب للتجربة وسير العمل الخفيف."
   },
   "google/gemini-2.5-pro-preview": {
     "description": "معاينة Gemini 2.5 Pro هي أحدث نموذج تفكيري من Google، قادر على استنتاج المشكلات المعقدة في مجالات البرمجة والرياضيات والعلوم والتكنولوجيا والهندسة والرياضيات (STEM)، بالإضافة إلى استخدام سياق طويل لتحليل مجموعات البيانات الكبيرة، وقواعد الشيفرة، والوثائق."
   },
+  "google/gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) هو نموذج توليد الصور من Google، ويدعم المحادثات متعددة الوسائط."
+  },
+  "google/gemini-3-pro-image-preview-free": {
+    "description": "الإصدار المجاني من Gemini 3 Pro Image، يدعم توليد الوسائط المتعددة بحدود استخدام معينة."
+  },
+  "google/gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro هو الجيل التالي من نماذج الاستدلال متعددة الوسائط من سلسلة Gemini، قادر على فهم النصوص، الصوت، الصور، الفيديو وغيرها، ويعالج المهام المعقدة ومستودعات الشيفرة الكبيرة."
+  },
+  "google/gemini-3-pro-preview-free": {
+    "description": "الإصدار المجاني من Gemini 3 Pro Preview، يتمتع بنفس قدرات الفهم والاستدلال متعددة الوسائط مثل الإصدار القياسي، لكنه يخضع لقيود الاستخدام المجاني ومعدل الاستجابة، مما يجعله مناسبًا للتجربة والاستخدام منخفض التكرار."
+  },
   "google/gemini-embedding-001": {
     "description": "نموذج تضمين متقدم يقدم أداءً ممتازًا في مهام اللغة الإنجليزية، متعددة اللغات، والبرمجة."
   },
@@ -1907,6 +1952,12 @@
   "grok-4-0709": {
     "description": "Grok 4 من xAI، يتمتع بقدرات استدلال قوية."
   },
+  "grok-4-1-fast-non-reasoning": {
+    "description": "نموذج متعدد الوسائط متقدم، مُحسَّن خصيصًا لاستدعاء أدوات الوكلاء عالية الأداء."
+  },
+  "grok-4-1-fast-reasoning": {
+    "description": "نموذج متعدد الوسائط متقدم، مُحسَّن خصيصًا لاستدعاء أدوات الوكلاء عالية الأداء."
+  },
   "grok-4-fast-non-reasoning": {
     "description": "نحن سعداء بإصدار Grok 4 Fast، وهو أحدث تقدم لدينا في نماذج الاستدلال ذات التكلفة الفعالة."
   },
@@ -2051,21 +2102,36 @@
   "inception/mercury-coder-small": {
     "description": "Mercury Coder Small هو الخيار المثالي لمهام توليد الكود، وتصحيح الأخطاء، وإعادة الهيكلة، مع أدنى تأخير."
   },
-  "inclusionAI/Ling-1T": {
-    "description": "Ling-1T هو أول نموذج رائد من سلسلة \"Ling 2.0\" غير المعتمد على التفكير، يحتوي على تريليون معلمة إجمالية و50 مليار معلمة نشطة لكل رمز. تم بناؤه على بنية Ling 2.0، ويهدف إلى تجاوز حدود الاستدلال الفعال والإدراك القابل للتوسع. تم تدريب Ling-1T-base على أكثر من 200 تريليون رمز عالي الجودة وغني بالاستدلال."
-  },
   "inclusionAI/Ling-flash-2.0": {
     "description": "Ling-flash-2.0 هو النموذج الثالث في سلسلة بنية Ling 2.0 التي أصدرها فريق Bailing في مجموعة Ant. هو نموذج خبراء مختلط (MoE) بحجم إجمالي 100 مليار معلمة، لكنه ينشط فقط 6.1 مليار معلمة لكل رمز (غير متضمنة تمثيلات الكلمات 4.8 مليار). كنموذج خفيف الوزن، أظهر Ling-flash-2.0 أداءً يضاهي أو يتفوق على نماذج كثيفة بحجم 40 مليار معلمة ونماذج MoE أكبر في عدة تقييمات موثوقة. يهدف النموذج إلى استكشاف مسارات عالية الكفاءة من خلال تصميم معماري واستراتيجيات تدريب متقدمة، في ظل القناعة بأن \"النموذج الكبير يعني معلمات كثيرة\"."
   },
   "inclusionAI/Ling-mini-2.0": {
     "description": "Ling-mini-2.0 هو نموذج لغة كبير صغير الحجم وعالي الأداء مبني على بنية MoE. يحتوي على 16 مليار معلمة إجمالية، لكنه ينشط فقط 1.4 مليار معلمة لكل رمز (غير متضمنة التضمين 789 مليون)، مما يحقق سرعة توليد عالية جدًا. بفضل تصميم MoE الفعال وبيانات تدريب ضخمة وعالية الجودة، رغم تنشيط معلمات قليلة، يظهر Ling-mini-2.0 أداءً متقدمًا في المهام اللاحقة يضاهي نماذج LLM كثيفة أقل من 10 مليارات معلمة ونماذج MoE أكبر."
   },
-  "inclusionAI/Ring-1T": {
-    "description": "Ring-1T هو نموذج تفكير مفتوح المصدر بحجم تريليون معلمة، أطلقه فريق Bailing. يعتمد على بنية Ling 2.0 ونموذج Ling-1T-base، ويحتوي على تريليون معلمة إجمالية و50 مليار معلمة نشطة، ويدعم نافذة سياق تصل إلى 128 ألف. تم تحسينه من خلال تعلم التعزيز القابل للتحقق على نطاق واسع."
-  },
   "inclusionAI/Ring-flash-2.0": {
     "description": "Ring-flash-2.0 هو نموذج تفكير عالي الأداء محسّن بعمق بناءً على Ling-flash-2.0-base. يستخدم بنية خبراء مختلط (MoE) بحجم إجمالي 100 مليار معلمة، لكنه ينشط فقط 6.1 مليار معلمة في كل استدلال. يحل النموذج من خلال خوارزمية icepop المبتكرة مشكلة عدم استقرار نماذج MoE الكبيرة في تدريب التعلم المعزز (RL)، مما يسمح بتحسين مستمر لقدرات الاستدلال المعقدة خلال التدريب طويل الأمد. حقق Ring-flash-2.0 تقدمًا ملحوظًا في مسابقات الرياضيات، توليد الشيفرة، والاستدلال المنطقي، متفوقًا على أفضل النماذج الكثيفة التي تقل عن 40 مليار معلمة، وقريبًا من نماذج MoE مفتوحة المصدر الأكبر ونماذج التفكير عالية الأداء المغلقة المصدر. رغم تركيزه على الاستدلال المعقد، يظهر أداءً ممتازًا في مهام الكتابة الإبداعية. بالإضافة إلى ذلك، وبفضل تصميمه المعماري الفعال، يوفر Ring-flash-2.0 أداءً قويًا مع استدلال عالي السرعة، مما يقلل بشكل كبير من تكلفة نشر نماذج التفكير في بيئات ذات حمل عالٍ."
   },
+  "inclusionai/ling-1t": {
+    "description": "Ling-1T هو نموذج MoE بسعة 1 تريليون من inclusionAI، محسن للمهام الاستدلالية المكثفة والسياقات الواسعة."
+  },
+  "inclusionai/ling-flash-2.0": {
+    "description": "Ling-flash-2.0 هو نموذج MoE من inclusionAI، محسن من حيث الكفاءة وأداء الاستدلال، مناسب للمهام المتوسطة إلى الكبيرة."
+  },
+  "inclusionai/ling-mini-2.0": {
+    "description": "Ling-mini-2.0 هو نموذج MoE خفيف الوزن من inclusionAI، يقلل التكاليف بشكل كبير مع الحفاظ على قدرات الاستدلال."
+  },
+  "inclusionai/ming-flash-omini-preview": {
+    "description": "Ming-flash-omni Preview هو نموذج متعدد الوسائط من inclusionAI، يدعم إدخال الصوت، الصور والفيديو، مع تحسينات في عرض الصور والتعرف على الصوت."
+  },
+  "inclusionai/ring-1t": {
+    "description": "Ring-1T هو نموذج MoE بسعة تريليون من inclusionAI، مصمم للمهام الاستدلالية واسعة النطاق والبحثية."
+  },
+  "inclusionai/ring-flash-2.0": {
+    "description": "Ring-flash-2.0 هو إصدار من نموذج Ring من inclusionAI موجه لسيناريوهات الإنتاجية العالية، يركز على السرعة وكفاءة التكلفة."
+  },
+  "inclusionai/ring-mini-2.0": {
+    "description": "Ring-mini-2.0 هو إصدار خفيف الوزن عالي الإنتاجية من نموذج MoE من inclusionAI، مخصص لسيناريوهات التوازي العالي."
+  },
   "internlm/internlm2_5-7b-chat": {
     "description": "InternLM2.5 يوفر حلول حوار ذكية في عدة سيناريوهات."
   },
@@ -2117,6 +2183,12 @@
   "kimi-k2-instruct": {
     "description": "Kimi K2 Instruct، نموذج الاستدلال الرسمي من Kimi، يدعم السياق الطويل، البرمجة، الأسئلة والأجوبة، وغيرها من السيناريوهات."
   },
+  "kimi-k2-thinking": {
+    "description": "نموذج التفكير طويل المدى K2، يدعم سياق 256k، واستدعاء الأدوات المتعدد الخطوات والتفكير، بارع في حل المشكلات المعقدة."
+  },
+  "kimi-k2-thinking-turbo": {
+    "description": "الإصدار السريع من نموذج التفكير طويل المدى K2، يدعم سياق 256k، بارع في الاستدلال العميق، وسرعة إخراج تصل إلى 60-100 رمز في الثانية."
+  },
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 هو نموذج أساسي بمعمارية MoE يتمتع بقدرات قوية للغاية في البرمجة وقدرات الوكيل (Agent)، بإجمالي معلمات يبلغ 1 تريليون والمعلمات المُفعَّلة 32 مليار. في اختبارات الأداء المعيارية للفئات الرئيسية مثل الاستدلال المعرفي العام والبرمجة والرياضيات والوكلاء (Agent)، تفوق أداء نموذج K2 على النماذج المفتوحة المصدر السائدة الأخرى."
   },
@@ -2129,6 +2201,9 @@
   "kimi-thinking-preview": {
     "description": "نموذج kimi-thinking-preview هو نموذج تفكير متعدد الوسائط يتمتع بقدرات استدلال متعددة الوسائط وعامة، مقدم من الجانب المظلم للقمر، يتقن الاستدلال العميق ويساعد في حل المزيد من المسائل الصعبة."
   },
+  "kuaishou/kat-coder-pro-v1": {
+    "description": "KAT-Coder-Pro-V1 (مجاني لفترة محدودة) يركز على فهم الشيفرة والبرمجة التلقائية، مخصص لمهام البرمجة الفعالة."
+  },
   "learnlm-1.5-pro-experimental": {
     "description": "LearnLM هو نموذج لغوي تجريبي محدد المهام، تم تدريبه ليتماشى مع مبادئ علوم التعلم، يمكنه اتباع التعليمات النظامية في سيناريوهات التعليم والتعلم، ويعمل كمدرب خبير."
   },
@@ -2225,6 +2300,9 @@
   "megrez-3b-instruct": {
     "description": "Megrez 3B Instruct هو نموذج صغير الحجم وعالي الكفاءة أطلقته شركة Wuwen Xinqiong."
   },
+  "meituan/longcat-flash-chat": {
+    "description": "نموذج أساسي غير تأملي مفتوح المصدر من Meituan، مُحسَّن للتفاعل الحواري ومهام الوكلاء الذكيين، ويتميز في استدعاء الأدوات وسيناريوهات التفاعل المعقدة متعددة الجولات."
+  },
   "meta-llama-3-70b-instruct": {
     "description": "نموذج قوي بحجم 70 مليار معلمة يتفوق في التفكير، والترميز، وتطبيقات اللغة الواسعة."
   },
@@ -2456,6 +2534,12 @@
   "minimax-m2": {
     "description": "MiniMax M2 هو نموذج لغوي كبير وفعّال، تم تطويره خصيصًا لتلبية احتياجات الترميز وتدفقات عمل الوكلاء."
   },
+  "minimax/minimax-m2": {
+    "description": "MiniMax-M2 هو نموذج عالي الكفاءة في البرمجة ومهام الوكلاء، مناسب لمجموعة متنوعة من السيناريوهات الهندسية."
+  },
+  "minimaxai/minimax-m2": {
+    "description": "MiniMax-M2 هو نموذج خبراء مختلط (MoE) مدمج وسريع وفعّال من حيث التكلفة، يحتوي على 230 مليار معلمة إجمالية و10 مليارات معلمة نشطة، صُمم لتحقيق أداء فائق في مهام الترميز والوكالة، مع الحفاظ على ذكاء عام قوي. يتميز هذا النموذج بأداء ممتاز في تحرير الملفات المتعددة، ودورة الترميز-التنفيذ-الإصلاح، والتحقق من الاختبارات والإصلاح، وسلاسل الأدوات المعقدة ذات الروابط الطويلة، مما يجعله خيارًا مثاليًا لسير عمل المطورين."
+  },
   "ministral-3b-latest": {
     "description": "Ministral 3B هو نموذج حافة عالمي المستوى من Mistral."
   },
@@ -2600,12 +2684,21 @@
   "moonshotai/kimi-k2": {
     "description": "Kimi K2 هو نموذج لغة كبير مختلط الخبراء (MoE) ضخم طورته Moonshot AI، يحتوي على تريليون معلمة إجمالية و32 مليار معلمة نشطة في كل تمرير أمامي. مُحسّن لقدرات الوكيل، بما في ذلك استخدام الأدوات المتقدمة، الاستدلال، وتركيب الكود."
   },
+  "moonshotai/kimi-k2-0711": {
+    "description": "Kimi K2 0711 هو إصدار Instruct من سلسلة Kimi، مناسب لسيناريوهات الشيفرة عالية الجودة واستدعاء الأدوات."
+  },
   "moonshotai/kimi-k2-0905": {
-    "description": "نموذج kimi-k2-0905-preview يدعم طول سياق 256k، يتمتع بقدرات ترميز وكيل أقوى، وجمالية وعملية أفضل في الشيفرة الأمامية، وفهم سياق محسن."
+    "description": "Kimi K2 0905 هو تحديث لسلسلة Kimi، يعزز السياق وقدرات الاستدلال، ومحسن لسيناريوهات البرمجة."
   },
   "moonshotai/kimi-k2-instruct-0905": {
     "description": "نموذج kimi-k2-0905-preview يدعم طول سياق 256k، يتمتع بقدرات ترميز وكيل أقوى، وجمالية وعملية أفضل في الشيفرة الأمامية، وفهم سياق محسن."
   },
+  "moonshotai/kimi-k2-thinking": {
+    "description": "Kimi K2 Thinking هو نموذج تفكير من Moonshot محسن لمهام الاستدلال العميق، يتمتع بقدرات وكيل عامة."
+  },
+  "moonshotai/kimi-k2-thinking-turbo": {
+    "description": "Kimi K2 Thinking Turbo هو الإصدار السريع من Kimi K2 Thinking، يقلل بشكل كبير من زمن الاستجابة مع الحفاظ على قدرات الاستدلال العميق."
+  },
   "morph/morph-v3-fast": {
     "description": "Morph يقدم نموذج ذكاء اصطناعي مخصص يطبق تغييرات الكود المقترحة من نماذج متقدمة مثل Claude أو GPT-4o على ملفات الكود الحالية بسرعة فائقة - أكثر من 4500 رمز في الثانية. يعمل كخطوة نهائية في سير عمل الترميز بالذكاء الاصطناعي. يدعم 16k رمز إدخال و16k رمز إخراج."
   },
@@ -2688,28 +2781,49 @@
     "description": "gpt-4-turbo من OpenAI يمتلك معرفة عامة واسعة وخبرة ميدانية، مما يمكنه من اتباع تعليمات اللغة الطبيعية المعقدة وحل المشكلات بدقة. تاريخ المعرفة حتى أبريل 2023، ونافذة سياق تصل إلى 128,000 رمز."
   },
   "openai/gpt-4.1": {
-    "description": "GPT 4.1 هو النموذج الرائد من OpenAI، مناسب للمهام المعقدة. مثالي لحل المشكلات متعددة المجالات."
+    "description": "سلسلة GPT-4.1 توفر سياقًا أوسع وقدرات أقوى في الهندسة والاستدلال."
   },
   "openai/gpt-4.1-mini": {
-    "description": "GPT 4.1 mini يوازن بين الذكاء والسرعة والتكلفة، مما يجعله نموذجًا جذابًا للعديد من حالات الاستخدام."
+    "description": "GPT-4.1 Mini يقدم زمن استجابة أقل وتكلفة أفضل، مناسب للمهام ذات السياق المتوسط."
   },
   "openai/gpt-4.1-nano": {
-    "description": "GPT-4.1 nano هو أسرع وأكفأ نموذج GPT 4.1 من حيث التكلفة."
+    "description": "GPT-4.1 Nano هو خيار منخفض التكلفة وزمن استجابة منخفض جدًا، مناسب للمحادثات القصيرة المتكررة أو سيناريوهات التصنيف."
   },
   "openai/gpt-4o": {
-    "description": "GPT-4o من OpenAI يمتلك معرفة عامة واسعة وخبرة ميدانية، قادر على اتباع تعليمات اللغة الطبيعية المعقدة وحل المشكلات بدقة. يقدم أداءً مماثلًا لـ GPT-4 Turbo عبر API أسرع وأرخص."
+    "description": "سلسلة GPT-4o هي نموذج Omni من OpenAI، يدعم إدخال نصوص + صور وإخراج نصي."
   },
   "openai/gpt-4o-mini": {
-    "description": "GPT-4o mini من OpenAI هو أصغر نموذج متقدم وأكثر كفاءة من حيث التكلفة. متعدد الوسائط (يقبل نصوصًا أو صورًا ويخرج نصًا)، وأكثر ذكاءً من gpt-3.5-turbo، مع سرعة مماثلة."
+    "description": "GPT-4o-mini هو النسخة الصغيرة والسريعة من GPT-4o، مناسب لسيناريوهات الوسائط المختلطة منخفضة التأخير."
   },
   "openai/gpt-5": {
-    "description": "GPT-5 هو النموذج الرائد من OpenAI، يتفوق في الاستدلال المعقد، المعرفة الواقعية الواسعة، المهام المكثفة للكود، والوكالة متعددة الخطوات."
+    "description": "GPT-5 هو نموذج عالي الأداء من OpenAI، مناسب لمجموعة واسعة من مهام الإنتاج والبحث."
+  },
+  "openai/gpt-5-chat": {
+    "description": "GPT-5 Chat هو إصدار فرعي من GPT-5 مُحسَّن لسيناريوهات المحادثة، يقلل من التأخير لتحسين تجربة التفاعل."
+  },
+  "openai/gpt-5-codex": {
+    "description": "GPT-5-Codex هو إصدار مُحسَّن من GPT-5 مخصص لسيناريوهات البرمجة، مناسب لسير عمل البرمجة على نطاق واسع."
   },
   "openai/gpt-5-mini": {
-    "description": "GPT-5 mini هو نموذج محسّن من حيث التكلفة، يقدم أداءً ممتازًا في مهام الاستدلال والدردشة. يوفر توازنًا مثاليًا بين السرعة والتكلفة والقدرة."
+    "description": "GPT-5 Mini هو النسخة المصغرة من عائلة GPT-5، مناسب للسيناريوهات منخفضة التكلفة وزمن الاستجابة."
   },
   "openai/gpt-5-nano": {
-    "description": "GPT-5 nano هو نموذج عالي الإنتاجية، يتفوق في المهام البسيطة مثل التعليمات أو التصنيف."
+    "description": "GPT-5 Nano هو النسخة فائقة الصغر من العائلة، مناسب للسيناريوهات التي تتطلب تكلفة وزمن استجابة منخفضين للغاية."
+  },
+  "openai/gpt-5-pro": {
+    "description": "GPT-5 Pro هو النموذج الرائد من OpenAI، يوفر قدرات استدلال وتوليد أكواد متقدمة ووظائف على مستوى المؤسسات، ويدعم التوجيه أثناء الاختبار واستراتيجيات أمان أكثر صرامة."
+  },
+  "openai/gpt-5.1": {
+    "description": "GPT-5.1 هو أحدث نموذج رائد في سلسلة GPT-5، يتميز بتحسينات ملحوظة في الاستدلال العام، اتباع التعليمات، وطبيعية الحوار، ومناسب لمجموعة واسعة من المهام."
+  },
+  "openai/gpt-5.1-chat": {
+    "description": "GPT-5.1 Chat هو عضو خفيف من عائلة GPT-5.1، مُحسَّن للمحادثات منخفضة التأخير مع الحفاظ على قدرات استدلال وتنفيذ تعليمات قوية."
+  },
+  "openai/gpt-5.1-codex": {
+    "description": "GPT-5.1-Codex هو إصدار مُحسَّن من GPT-5.1 مخصص لهندسة البرمجيات وسير عمل البرمجة، مناسب لإعادة هيكلة واسعة النطاق، تصحيح الأخطاء المعقدة، ومهام البرمجة الذاتية طويلة الأمد."
+  },
+  "openai/gpt-5.1-codex-mini": {
+    "description": "GPT-5.1-Codex-Mini هو النسخة الصغيرة والمعجلة من GPT-5.1-Codex، أكثر ملاءمة لسيناريوهات البرمجة الحساسة للتكلفة والتأخير."
   },
   "openai/gpt-oss-120b": {
     "description": "نموذج لغة كبير عام عالي الكفاءة، يتمتع بقدرات استدلال قوية وقابلة للتحكم."
@@ -2736,7 +2850,7 @@
     "description": "o3-mini عالي المستوى من حيث الاستدلال، يقدم ذكاءً عاليًا بنفس تكلفة وأهداف التأخير مثل o1-mini."
   },
   "openai/o4-mini": {
-    "description": "o4-mini من OpenAI يقدم استدلالًا سريعًا وفعالًا من حيث التكلفة، مع أداء ممتاز بالنسبة لحجمه، خاصة في الرياضيات (الأفضل في اختبار AIME)، الترميز، والمهام البصرية."
+    "description": "OpenAI o4-mini هو نموذج استدلال صغير وفعال من OpenAI، مناسب لسيناريوهات منخفضة التأخير."
   },
   "openai/o4-mini-high": {
     "description": "o4-mini إصدار عالي من حيث مستوى الاستدلال، تم تحسينه للاستدلال السريع والفعال، ويظهر كفاءة وأداء عاليين في المهام البرمجية والرؤية."
@@ -2940,7 +3054,7 @@
     "description": "نموذج قوي للبرمجة متوسطة الحجم، يدعم طول سياق يصل إلى 32K، بارع في البرمجة متعددة اللغات."
   },
   "qwen/qwen3-14b": {
-    "description": "Qwen3-14B هو نموذج لغوي سببي مكثف يحتوي على 14.8 مليار معلمة، مصمم للاستدلال المعقد والحوار الفعال. يدعم التبديل بسلاسة بين نمط \"التفكير\" المستخدم في الرياضيات، والبرمجة، والاستدلال المنطقي، ونمط \"غير التفكير\" المستخدم في الحوار العام. تم ضبط هذا النموذج ليكون مناسبًا للامتثال للتعليمات، واستخدام أدوات الوكلاء، والكتابة الإبداعية، واستخدامه عبر أكثر من 100 لغة ولهجة. يدعم بشكل أصلي معالجة 32K رمز، ويمكن توسيعها باستخدام التمديد القائم على YaRN إلى 131K رمز."
+    "description": "Qwen3-14B هو إصدار 14B من سلسلة Qwen، مناسب للاستدلال العام وسيناريوهات المحادثة."
   },
   "qwen/qwen3-14b:free": {
     "description": "Qwen3-14B هو نموذج لغوي سببي مكثف يحتوي على 14.8 مليار معلمة، مصمم للاستدلال المعقد والحوار الفعال. يدعم التبديل بسلاسة بين نمط \"التفكير\" المستخدم في الرياضيات، والبرمجة، والاستدلال المنطقي، ونمط \"غير التفكير\" المستخدم في الحوار العام. تم ضبط هذا النموذج ليكون مناسبًا للامتثال للتعليمات، واستخدام أدوات الوكلاء، والكتابة الإبداعية، واستخدامه عبر أكثر من 100 لغة ولهجة. يدعم بشكل أصلي معالجة 32K رمز، ويمكن توسيعها باستخدام التمديد القائم على YaRN إلى 131K رمز."
@@ -2948,6 +3062,12 @@
   "qwen/qwen3-235b-a22b": {
     "description": "Qwen3-235B-A22B هو نموذج مختلط خبير (MoE) يحتوي على 235 مليار معلمة تم تطويره بواسطة Qwen، حيث يتم تنشيط 22 مليار معلمة في كل تمرير للأمام. يدعم التبديل بسلاسة بين نمط \"التفكير\" المستخدم في الاستدلال المعقد، والرياضيات، ومهام البرمجة، ونمط \"غير التفكير\" المستخدم في الحوار العام. يظهر هذا النموذج قدرات استدلال قوية، ودعمًا للغات المتعددة (أكثر من 100 لغة ولهجة)، وقدرات متقدمة في الامتثال للتعليمات واستدعاء أدوات الوكلاء. يدعم بشكل أصلي معالجة نافذة سياق من 32K رمز، ويمكن توسيعها باستخدام التمديد القائم على YaRN إلى 131K رمز."
   },
+  "qwen/qwen3-235b-a22b-2507": {
+    "description": "Qwen3-235B-A22B-Instruct-2507 هو إصدار Instruct من سلسلة Qwen3، يجمع بين دعم التعليمات متعددة اللغات وسيناريوهات السياق الطويل."
+  },
+  "qwen/qwen3-235b-a22b-thinking-2507": {
+    "description": "Qwen3-235B-A22B-Thinking-2507 هو إصدار Thinking من Qwen3، مُعزز لمهام الرياضيات المعقدة والاستدلال."
+  },
   "qwen/qwen3-235b-a22b:free": {
     "description": "Qwen3-235B-A22B هو نموذج مختلط خبير (MoE) يحتوي على 235 مليار معلمة تم تطويره بواسطة Qwen، حيث يتم تنشيط 22 مليار معلمة في كل تمرير للأمام. يدعم التبديل بسلاسة بين نمط \"التفكير\" المستخدم في الاستدلال المعقد، والرياضيات، ومهام البرمجة، ونمط \"غير التفكير\" المستخدم في الحوار العام. يظهر هذا النموذج قدرات استدلال قوية، ودعمًا للغات المتعددة (أكثر من 100 لغة ولهجة)، وقدرات متقدمة في الامتثال للتعليمات واستدعاء أدوات الوكلاء. يدعم بشكل أصلي معالجة نافذة سياق من 32K رمز، ويمكن توسيعها باستخدام التمديد القائم على YaRN إلى 131K رمز."
   },
@@ -2966,6 +3086,21 @@
   "qwen/qwen3-8b:free": {
     "description": "Qwen3-8B هو نموذج لغوي سببي مكثف يحتوي على 8.2 مليار معلمة، مصمم للمهام التي تتطلب استدلالًا مكثفًا والحوار الفعال. يدعم التبديل بسلاسة بين نمط \"التفكير\" المستخدم في الرياضيات والترميز والاستدلال المنطقي، ونمط \"غير التفكير\" المستخدم في الحوار العام. تم ضبط هذا النموذج ليكون مناسبًا للامتثال للتعليمات، ودمج الوكلاء، والكتابة الإبداعية، واستخدامه عبر أكثر من 100 لغة ولهجة. يدعم بشكل أصلي نافذة سياق من 32K رمز، ويمكن توسيعها إلى 131K رمز عبر YaRN."
   },
+  "qwen/qwen3-coder": {
+    "description": "Qwen3-Coder هو جزء من عائلة مولدات الأكواد في Qwen3، بارع في فهم وتوليد الأكواد داخل المستندات الطويلة."
+  },
+  "qwen/qwen3-coder-plus": {
+    "description": "Qwen3-Coder-Plus هو نموذج وكيل برمجي مُحسَّن خصيصًا من سلسلة Qwen، يدعم استدعاء أدوات أكثر تعقيدًا وجلسات طويلة الأمد."
+  },
+  "qwen/qwen3-max": {
+    "description": "Qwen3 Max هو النموذج المتقدم من سلسلة Qwen3، مناسب للاستدلال متعدد اللغات وتكامل الأدوات."
+  },
+  "qwen/qwen3-max-preview": {
+    "description": "Qwen3 Max (معاينة) هو إصدار Max من سلسلة Qwen، موجه للاستدلال المتقدم وتكامل الأدوات (نسخة تجريبية)."
+  },
+  "qwen/qwen3-vl-plus": {
+    "description": "Qwen3 VL-Plus هو الإصدار المعزز بصريًا من Qwen3، يعزز قدرات الاستدلال متعدد الوسائط ومعالجة الفيديو."
+  },
   "qwen2": {
     "description": "Qwen2 هو نموذج لغوي كبير من الجيل الجديد من Alibaba، يدعم أداءً ممتازًا لتلبية احتياجات التطبيقات المتنوعة."
   },
@@ -3260,9 +3395,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 تريليون توكن مختلط نص-صورة، مغطياً أكثر من عشر لغات. حقق النموذج أداءً متقدماً بين نماذج المصدر المفتوح في عدة معايير قياسية تشمل الرياضيات والبرمجة والمهام متعددة الوسائط."
   },
@@ -3344,6 +3476,9 @@
   "vercel/v0-1.5-md": {
     "description": "الوصول إلى النموذج خلف v0 لتوليد، إصلاح، وتحسين تطبيقات الويب الحديثة، مع استدلال مخصص للأطر المعينة ومعرفة حديثة."
   },
+  "volcengine/doubao-seed-code": {
+    "description": "Doubao-Seed-Code هو نموذج كبير من محرك Byte Volcano مُحسَّن لبرمجة الوكلاء (Agentic Programming)، ويؤدي أداءً ممتازًا في معايير متعددة للبرمجة والوكلاء، ويدعم سياقًا يصل إلى 256K."
+  },
   "wan2.2-t2i-flash": {
     "description": "نسخة Wanxiang 2.2 فائقة السرعة، أحدث نموذج حاليًا. تم تحسين الإبداع، الاستقرار، والواقعية بشكل شامل، مع سرعة توليد عالية وقيمة ممتازة مقابل التكلفة."
   },
@@ -3371,6 +3506,24 @@
   "wizardlm2:8x22b": {
     "description": "WizardLM 2 هو نموذج لغوي تقدمه Microsoft AI، يتميز بأداء ممتاز في الحوار المعقد، واللغات المتعددة، والاستدلال، والمساعدين الذكيين."
   },
+  "x-ai/grok-4": {
+    "description": "Grok 4 هو النموذج الرائد من xAI، يوفر قدرات استدلال قوية ودعمًا متعدد الوسائط."
+  },
+  "x-ai/grok-4-fast": {
+    "description": "Grok 4 Fast هو نموذج عالي الإنتاجية ومنخفض التكلفة من xAI (يدعم نافذة سياق 2M)، مناسب للسيناريوهات التي تتطلب تزامنًا عاليًا وسياقًا طويلًا."
+  },
+  "x-ai/grok-4-fast-non-reasoning": {
+    "description": "Grok 4 Fast (بدون استدلال) هو نموذج متعدد الوسائط عالي الإنتاجية ومنخفض التكلفة من xAI (يدعم نافذة سياق 2M)، موجه للسيناريوهات الحساسة للتأخير والتكلفة والتي لا تتطلب تفعيل الاستدلال داخل النموذج. يتوفر بجانب إصدار Grok 4 Fast مع الاستدلال، ويمكن تفعيل الاستدلال عند الحاجة عبر معامل reasoning enable في واجهة API. قد يتم استخدام المطالبات والإكمالات من قبل xAI أو OpenRouter لتحسين النماذج المستقبلية."
+  },
+  "x-ai/grok-4.1-fast": {
+    "description": "Grok 4.1 Fast هو نموذج عالي الإنتاجية ومنخفض التكلفة من xAI (يدعم نافذة سياق 2M)، مناسب للسيناريوهات التي تتطلب تزامنًا عاليًا وسياقًا طويلًا."
+  },
+  "x-ai/grok-4.1-fast-non-reasoning": {
+    "description": "Grok 4.1 Fast (بدون استدلال) هو نموذج متعدد الوسائط عالي الإنتاجية ومنخفض التكلفة من xAI (يدعم نافذة سياق 2M)، موجه للسيناريوهات الحساسة للتأخير والتكلفة والتي لا تتطلب تفعيل الاستدلال داخل النموذج. يتوفر بجانب إصدار Grok 4.1 Fast مع الاستدلال، ويمكن تفعيل الاستدلال عند الحاجة عبر معامل reasoning enable في واجهة API. قد يتم استخدام المطالبات والإكمالات من قبل xAI أو OpenRouter لتحسين النماذج المستقبلية."
+  },
+  "x-ai/grok-code-fast-1": {
+    "description": "Grok Code Fast 1 هو نموذج سريع للبرمجة من xAI، ينتج أكواد قابلة للقراءة ومتوافقة مع متطلبات الهندسة."
+  },
   "x1": {
     "description": "سيتم ترقية نموذج Spark X1 بشكل أكبر، حيث ستحقق المهام العامة مثل الاستدلال، وتوليد النصوص، وفهم اللغة نتائج تتماشى مع OpenAI o1 و DeepSeek R1."
   },
@@ -3431,6 +3584,15 @@
   "yi-vision-v2": {
     "description": "نموذج مهام بصرية معقدة، يوفر فهمًا عالي الأداء وقدرات تحليلية بناءً على صور متعددة."
   },
+  "z-ai/glm-4.5": {
+    "description": "GLM 4.5 هو النموذج الرائد من Z.AI، يدعم أوضاع استدلال هجينة ومُحسَّن للمهام الهندسية وسياقات طويلة."
+  },
+  "z-ai/glm-4.5-air": {
+    "description": "GLM 4.5 Air هو النسخة الخفيفة من GLM 4.5، مناسب للسيناريوهات الحساسة للتكلفة مع الحفاظ على قدرات استدلال قوية."
+  },
+  "z-ai/glm-4.6": {
+    "description": "GLM 4.6 هو النموذج الرائد من Z.AI، يعزز طول السياق وقدرات الترميز."
+  },
   "zai-org/GLM-4.5": {
     "description": "GLM-4.5 هو نموذج أساسي مصمم لتطبيقات الوكلاء الذكية، يستخدم بنية Mixture-of-Experts (MoE). تم تحسينه بعمق في مجالات استدعاء الأدوات، تصفح الويب، هندسة البرمجيات، وبرمجة الواجهة الأمامية، ويدعم التكامل السلس مع وكلاء الكود مثل Claude Code وRoo Code. يستخدم وضع استدلال مختلط ليتكيف مع سيناريوهات الاستدلال المعقدة والاستخدام اليومي."
   },
@@ -3451,5 +3613,8 @@
   },
   "zai/glm-4.5v": {
     "description": "GLM-4.5V مبني على نموذج GLM-4.5-Air الأساسي، يرث التقنيات المثبتة من GLM-4.1V-Thinking، ويوسعها بفعالية من خلال بنية MoE القوية التي تضم 106 مليار معلمة."
+  },
+  "zenmux/auto": {
+    "description": "ميزة التوجيه التلقائي من ZenMux تختار تلقائيًا أفضل نموذج من حيث الأداء والتكلفة من بين النماذج المدعومة بناءً على محتوى طلبك."
   }
 }

locales/ar/plugin.json

@@ -1,4 +1,38 @@
 {
+  "builtins": {
+    "lobe-knowledge-base": {
+      "apiName": {
+        "readKnowledge": "قراءة محتوى قاعدة المعرفة",
+        "searchKnowledgeBase": "البحث في قاعدة المعرفة"
+      },
+      "title": "قاعدة المعرفة"
+    },
+    "lobe-local-system": {
+      "apiName": {
+        "editLocalFile": "تحرير الملف",
+        "getCommandOutput": "الحصول على مخرجات الكود",
+        "globLocalFiles": "البحث عن الملفات",
+        "grepContent": "البحث في المحتوى",
+        "killCommand": "إيقاف تنفيذ الكود",
+        "listLocalFiles": "عرض قائمة الملفات",
+        "moveLocalFiles": "نقل الملفات",
+        "readLocalFile": "قراءة محتوى الملف",
+        "renameLocalFile": "إعادة تسمية",
+        "runCommand": "تنفيذ الكود",
+        "searchLocalFiles": "البحث في الملفات",
+        "writeLocalFile": "كتابة إلى الملف"
+      },
+      "title": "النظام المحلي"
+    },
+    "lobe-web-browsing": {
+      "apiName": {
+        "crawlMultiPages": "قراءة محتوى عدة صفحات",
+        "crawlSinglePage": "قراءة محتوى الصفحة",
+        "search": "البحث في الصفحات"
+      },
+      "title": "البحث عبر الإنترنت"
+    }
+  },
   "confirm": "تأكيد",
   "debug": {
     "arguments": "معلمات الاستدعاء",
@@ -251,23 +285,6 @@
     "content": "جارٍ استدعاء الإضافة...",
     "plugin": "تشغيل الإضافة..."
   },
-  "localSystem": {
-    "apiName": {
-      "editLocalFile": "تحرير الملف",
-      "getCommandOutput": "الحصول على مخرجات الأوامر",
-      "globLocalFiles": "البحث عن الملفات المطابقة",
-      "grepContent": "البحث في المحتوى",
-      "killCommand": "إيقاف تنفيذ الأمر",
-      "listLocalFiles": "عرض قائمة الملفات",
-      "moveLocalFiles": "نقل الملفات",
-      "readLocalFile": "قراءة محتوى الملف",
-      "renameLocalFile": "إعادة تسمية",
-      "runCommand": "تشغيل الأمر",
-      "searchLocalFiles": "بحث في الملفات",
-      "writeLocalFile": "كتابة في الملف"
-    },
-    "title": "النظام المحلي"
-  },
   "mcpInstall": {
     "CHECKING_INSTALLATION": "جارٍ فحص بيئة التثبيت...",
     "COMPLETED": "اكتمل التثبيت",
@@ -375,11 +392,6 @@
     "warning": "⚠️ يرجى التأكد من ثقتك بمصدر هذه الإضافة، الإضافات الخبيثة قد تضر بأمان نظامك."
   },
   "search": {
-    "apiName": {
-      "crawlMultiPages": "قراءة محتوى عدة صفحات",
-      "crawlSinglePage": "قراءة محتوى الصفحة",
-      "search": "البحث في الصفحة"
-    },
     "config": {
       "addKey": "إضافة مفتاح",
       "close": "حذف",

locales/ar/providers.json

@@ -191,6 +191,9 @@
   "xinference": {
     "description": "Xorbits Inference (Xinference) هو منصة مفتوحة المصدر مصممة لتبسيط تشغيل ودمج نماذج الذكاء الاصطناعي المتنوعة. باستخدام Xinference، يمكنك تشغيل الاستدلال على نماذج LLM مفتوحة المصدر، ونماذج التضمين، والنماذج متعددة الوسائط سواء في السحابة أو في البيئات المحلية، وإنشاء تطبيقات ذكاء اصطناعي قوية."
   },
+  "zenmux": {
+    "description": "ZenMux هو منصة موحدة لتجميع خدمات الذكاء الاصطناعي، تدعم العديد من واجهات خدمات الذكاء الاصطناعي الرائدة مثل OpenAI وAnthropic وGoogle VertexAI. توفر قدرة توجيه مرنة تتيح لك التبديل وإدارة نماذج الذكاء الاصطناعي المختلفة بسهولة."
+  },
   "zeroone": {
     "description": "01.AI تركز على تقنيات الذكاء الاصطناعي في عصر الذكاء الاصطناعي 2.0، وتعزز الابتكار والتطبيقات \"الإنسان + الذكاء الاصطناعي\"، باستخدام نماذج قوية وتقنيات ذكاء اصطناعي متقدمة لتعزيز إنتاجية البشر وتحقيق تمكين التكنولوجيا."
   },

locales/ar/tool.json

@@ -14,7 +14,21 @@
     "images": "الصور:",
     "prompt": "كلمة تلميح"
   },
+  "lobe-knowledge-base": {
+    "readKnowledge": {
+      "meta": {
+        "chars": "عدد الأحرف",
+        "lines": "عدد السطور"
+      }
+    }
+  },
   "localFiles": {
+    "editFile": {
+      "newString": "استبدال بـ",
+      "oldString": "البحث عن",
+      "replaceAll": "استبدال جميع المطابقات",
+      "replaceFirst": "استبدال أول مطابقة فقط"
+    },
     "file": "ملف",
     "folder": "مجلد",
     "moveFiles": {
@@ -34,7 +48,12 @@
     "readFile": "قراءة الملف",
     "readFileError": "فشل في قراءة الملف، يرجى التحقق من صحة مسار الملف",
     "readFiles": "قراءة الملفات",
-    "readFilesError": "فشل في قراءة الملفات، يرجى التحقق من صحة مسار الملف"
+    "readFilesError": "فشل في قراءة الملفات، يرجى التحقق من صحة مسار الملف",
+    "writeFile": {
+      "characters": "أحرف",
+      "preview": "معاينة المحتوى",
+      "truncated": "تم الاقتطاع"
+    }
   },
   "search": {
     "createNewSearch": "إنشاء سجل بحث جديد",

locales/bg-BG/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "Превключвател за дълбоко мислене"
     },
+    "thinkingLevel": {
+      "title": "Ниво на мислене"
+    },
     "title": "Разширени функции на модела",
     "urlContext": {
       "desc": "Когато е включено, автоматично ще се анализират уеб връзки, за да се получи реалното съдържание на уеб страницата",
@@ -330,6 +333,11 @@
     "screenshot": "Екранна снимка",
     "settings": "Настройки за експортиране",
     "text": "Текст",
+    "widthMode": {
+      "label": "Режим на ширина",
+      "narrow": "Режим за тесен екран",
+      "wide": "Режим за широк екран"
+    },
     "withBackground": "Включи фоново изображение",
     "withFooter": "Включи долен колонтитул",
     "withPluginInfo": "Включи информация за плъгина",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "Въведете причина за отхвърляне, за да помогнете на агента да разбере и подобри бъдещите действия",
       "rejectTitle": "Отхвърляне на това извикване на инструмент",
       "rejectedWithReason": "Това извикване на инструмент беше умишлено отхвърлено: {{reason}}",
+      "toolAbort": "Този инструмент беше отменен от потребителя",
       "toolRejected": "Това извикване на инструмент беше умишлено отхвърлено"
     }
   },

locales/bg-BG/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "Затвори",
+  "cmdk": {
+    "about": "Относно",
+    "communitySupport": "Общностна поддръжка",
+    "discover": "Открий",
+    "knowledgeBase": "База знания",
+    "navigate": "Навигация",
+    "newAgent": "Създай агент",
+    "noResults": "Няма намерени резултати",
+    "openSettings": "Отвори настройките",
+    "painting": "AI Рисуване",
+    "searchPlaceholder": "Въведете команда или търсене...",
+    "settings": "Настройки",
+    "starOnGitHub": "Дайте ни звезда в GitHub",
+    "submitIssue": "Подайте проблем",
+    "theme": "Тема",
+    "themeAuto": "Следвай системата",
+    "themeDark": "Тъмен режим",
+    "themeLight": "Светъл режим",
+    "toOpen": "Отвори",
+    "toSelect": "Избери"
+  },
   "confirm": "Потвърди",
   "contact": "Свържете се с нас",
   "copy": "Копирай",
@@ -283,6 +304,7 @@
     "business": "Бизнес сътрудничество",
     "support": "Поддръжка по имейл"
   },
+  "new": "Нов",
   "oauth": "SSO Вход",
   "officialSite": "Официален сайт",
   "ok": "Добре",

locales/bg-BG/error.json

@@ -102,7 +102,7 @@
       "SPII": "Вашето съдържание може да съдържа чувствителна лична информация. За да защитите поверителността, моля, премахнете съответната чувствителна информация и опитайте отново.",
       "default": "Съдържанието е блокирано: {{blockReason}}。请调整您的请求内容后重试。"
     },
-    "InsufficientQuota": "Съжаляваме, квотата за този ключ е достигнала лимита. Моля, проверете баланса на акаунта си или увеличете квотата на ключа и опитайте отново.",
+    "InsufficientQuota": "Съжаляваме, но квотата за този ключ е изчерпана. Моля, проверете дали имате достатъчен баланс в акаунта си или увеличете квотата на ключа и опитайте отново.",
     "InvalidAccessCode": "Невалиден или празен код за достъп. Моля, въведете правилния код за достъп или добавете персонализиран API ключ.",
     "InvalidBedrockCredentials": "Удостоверяването на Bedrock е неуспешно. Моля, проверете AccessKeyId/SecretAccessKey и опитайте отново.",
     "InvalidClerkUser": "很抱歉，你当前尚未登录，请先登录或注册账号后继续操作",
@@ -131,7 +131,7 @@
     "PluginServerError": "Заявката към сървъра на плъгина върна грешка. Моля, проверете файла на манифеста на плъгина, конфигурацията на плъгина или изпълнението на сървъра въз основа на информацията за грешката по-долу",
     "PluginSettingsInvalid": "Този плъгин трябва да бъде конфигуриран правилно, преди да може да се използва. Моля, проверете дали конфигурацията ви е правилна",
     "ProviderBizError": "Грешка в услугата на {{provider}}, моля проверете следната информация или опитайте отново",
-    "QuotaLimitReached": "Съжаляваме, но текущото използване на токени или брой на заявките е достигнало лимита на квотата за този ключ. Моля, увеличете квотата на ключа или опитайте отново по-късно.",
+    "QuotaLimitReached": "Съжаляваме, но текущото използване на токени или броят на заявките е достигнало лимита на квотата за този ключ. Моля, увеличете квотата на ключа или опитайте отново по-късно.",
     "StreamChunkError": "Грешка при парсирането на съобщение от потокова заявка. Моля, проверете дали текущият API интерфейс отговаря на стандартите или се свържете с вашия доставчик на API за консултация.",
     "SubscriptionKeyMismatch": "Съжаляваме, но поради случайна системна грешка, текущото използване на абонамента временно е невалидно. Моля, кликнете върху бутона по-долу, за да възстановите абонамента, или се свържете с нас по имейл за поддръжка.",
     "SubscriptionPlanLimit": "Вашият абонаментен план е изчерпан, не можете да използвате тази функция. Моля, надстройте до по-висок план или конфигурирайте персонализиран модел API, за да продължите да използвате.",

locales/bg-BG/file.json

@@ -55,10 +55,10 @@
   },
   "documentList": {
     "copyContent": "Копиране на цялото съдържание",
-    "documentCount": "Общо {{count}} документа",
     "duplicate": "Създаване на копие",
-    "empty": "Все още няма документи. Натиснете бутона по-горе, за да създадете първия си документ",
+    "empty": "Все още няма документи. Щракнете върху бутона по-горе, за да създадете първия си документ.",
     "noResults": "Няма намерени съвпадащи документи",
+    "pageCount": "Общо {{count}} документа",
     "selectNote": "Изберете документ, за да започнете редактиране",
     "untitled": "Без заглавие"
   },
@@ -70,7 +70,6 @@
       "uploadFile": "Качване на файл",
       "uploadFolder": "Качване на папка"
     },
-    "newDocumentButton": "Нов документ",
     "newNoteDialog": {
       "cancel": "Отказ",
       "editTitle": "Редактиране на документ",
@@ -83,14 +82,15 @@
       "title": "Нов документ",
       "updateSuccess": "Документът беше обновен успешно"
     },
+    "newPageButton": "Създай нов документ",
     "uploadButton": "Качване"
   },
   "home": {
     "getStarted": "Започнете",
     "greeting": "Начало",
     "quickActions": "Бързи действия",
-    "recentDocuments": "Скорошни документи",
     "recentFiles": "Скорошни файлове",
+    "recentPages": "Скорошни документи",
     "subtitle": "Добре дошли в базата знания. Започнете да управлявате вашите документи оттук",
     "uploadEntries": {
       "files": {
@@ -102,8 +102,8 @@
       "knowledgeBase": {
         "title": "Създай база знания"
       },
-      "newDocument": {
-        "title": "Създай нов документ"
+      "newPage": {
+        "title": "Създаване на нов документ"
       }
     }
   },
@@ -116,8 +116,8 @@
     "title": "База знания"
   },
   "menu": {
-    "allDocuments": "Всички документи",
-    "allFiles": "Всички файлове"
+    "allFiles": "Всички файлове",
+    "allPages": "Всички документи"
   },
   "networkError": "Неуспешно получаване на базата от знания, моля, проверете интернет връзката и опитайте отново",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "Изтеглете файла",
     "unsupportedFileAndContact": "Този формат на файла не поддържа онлайн преглед. Ако имате нужда от преглед, моля, <1>свържете се с нас</1>."
   },
-  "searchDocumentPlaceholder": "Търсене на документи",
   "searchFilePlaceholder": "Търсене на файл",
+  "searchPagePlaceholder": "Търсене на документи",
   "tab": {
     "all": "Всички",
     "audios": "Аудио",
@@ -156,9 +156,7 @@
     "websites": "Уебсайтове"
   },
   "title": "База знания",
-  "toggleLeftPanel": {
-    "title": "Покажи/Скрий лявото панел"
-  },
+  "toggleLeftPanel": "Показване/скриване на лявия панел",
   "uploadDock": {
     "body": {
       "collapse": "Скрий",

locales/bg-BG/hotkey.json

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

locales/bg-BG/image.json

@@ -37,6 +37,14 @@
         "standard": "Стандартно"
       }
     },
+    "resolution": {
+      "label": "Резолюция",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "Семена",
       "random": "Случаен семенен код"

locales/bg-BG/modelProvider.json

@@ -295,7 +295,7 @@
       },
       "helpDoc": "Ръководство за конфигуриране",
       "responsesApi": {
-        "desc": "Използва новия формат на заявките на OpenAI, отключващ функции като вериги на мислене и други усъвършенствани възможности",
+        "desc": "Използва новия формат за заявки на OpenAI, отключвайки разширени функции като вериги на мисълта (поддържа се само от моделите на OpenAI)",
         "title": "Използване на Responses API стандарта"
       },
       "waitingForMore": "Още модели са в <1>планиране</1>, моля, очаквайте"

locales/bg-BG/models.json

@@ -236,6 +236,9 @@
   "MiniMaxAI/MiniMax-M1-80k": {
     "description": "MiniMax-M1 е мащабен модел за разсъждение с отворени тегла и смесено внимание, с 456 милиарда параметри, като всеки токен активира около 45.9 милиарда параметри. Моделът поддържа естествено контекст с дължина до 1 милион токена и чрез механизма за светкавично внимание спестява 75% от изчисленията при задачи с генериране на 100 хиляди токена в сравнение с DeepSeek R1. Освен това MiniMax-M1 използва MoE (смесен експертен) архитектура, комбинирайки CISPO алгоритъм и ефективно обучение с подсилване с дизайн на смесено внимание, постигащи водещи в индустрията резултати при дълги входни разсъждения и реални софтуерни инженерни сценарии."
   },
+  "MiniMaxAI/MiniMax-M2": {
+    "description": "MiniMax-M2 преосмисля ефективността на интелигентните агенти. Това е компактен, бърз и икономичен MoE модел с общо 230 милиарда параметъра и 10 милиарда активни параметъра, създаден за постигане на върхова производителност при кодиране и задачи, свързани с интелигентни агенти, като същевременно поддържа силен общ интелект. Със само 10 милиарда активни параметъра, MiniMax-M2 предлага производителност, сравнима с тази на мащабни модели, което го прави идеален избор за приложения с висока ефективност."
+  },
   "Moonshot-Kimi-K2-Instruct": {
     "description": "Общ брой параметри 1 трилион, активирани параметри 32 милиарда. Сред немисловните модели постига водещи резултати в областта на актуални знания, математика и кодиране, с по-добри възможности за универсални агентски задачи. Специално оптимизиран за агентски задачи, не само отговаря на въпроси, но и може да предприема действия. Най-подходящ за импровизирани, универсални разговори и агентски преживявания, модел с рефлексна скорост без нужда от дълго мислене."
   },
@@ -717,25 +720,28 @@
     "description": "Claude 3 Opus е най-интелигентният модел на Anthropic с водещи на пазара резултати при изключително сложни задачи. Той се справя с отворени подсказки и непознати сценарии с изключителна плавност и човешко разбиране."
   },
   "anthropic/claude-3.5-haiku": {
-    "description": "Claude 3.5 Haiku е следващото поколение на нашия най-бърз модел. Със скорост, подобна на Claude 3 Haiku, той подобрява всяка компетентност и надминава предишния ни най-голям модел Claude 3 Opus в много интелигентни бенчмаркове."
+    "description": "Claude 3.5 Haiku предлага подобрени възможности за скорост, точност при програмиране и използване на инструменти. Подходящ за сценарии с високи изисквания към бързодействие и взаимодействие с инструменти."
   },
   "anthropic/claude-3.5-sonnet": {
-    "description": "Claude 3.5 Sonnet постига идеален баланс между интелигентност и скорост — особено за корпоративни натоварвания. Той предлага мощна производителност на по-ниска цена в сравнение с конкурентите и е проектиран за висока издръжливост при мащабни AI внедрявания."
+    "description": "Claude 3.5 Sonnet е бърз и ефективен модел от семейството Sonnet, предлагащ по-добра производителност при програмиране и логическо разсъждение. Някои версии постепенно ще бъдат заменени от Sonnet 3.7 и други."
   },
   "anthropic/claude-3.7-sonnet": {
-    "description": "Claude 3.7 Sonnet е първият хибриден разсъдъчен модел и най-интелигентният модел на Anthropic досега. Той предлага водещи резултати в кодиране, генериране на съдържание, анализ на данни и планиране, изграждайки се върху софтуерните инженерни и компютърни умения на предшественика си Claude 3.5 Sonnet."
+    "description": "Claude 3.7 Sonnet е надградена версия от серията Sonnet, предлагаща по-силни възможности за логическо разсъждение и програмиране, подходяща за сложни корпоративни задачи."
+  },
+  "anthropic/claude-haiku-4.5": {
+    "description": "Claude Haiku 4.5 е високопроизводителен и бърз модел на Anthropic, който съчетава висока точност с изключително ниска латентност."
   },
   "anthropic/claude-opus-4": {
-    "description": "Claude Opus 4 е най-мощният модел на Anthropic досега и най-добрият кодов модел в света, водещ в SWE-bench (72.5%) и Terminal-bench (43.2%). Той осигурява устойчива производителност за дългосрочни задачи, изискващи фокус и хиляди стъпки, като може да работи непрекъснато часове — значително разширявайки възможностите на AI агентите."
+    "description": "Opus 4 е флагманският модел на Anthropic, проектиран за сложни задачи и корпоративни приложения."
   },
   "anthropic/claude-opus-4.1": {
-    "description": "Claude Opus 4.1 е plug-and-play алтернатива на Opus 4, осигуряваща изключителна производителност и точност за реални кодови и агентски задачи. Opus 4.1 повишава водещата кодова производителност до 74.5% в SWE-bench Verified и обработва сложни многостъпкови проблеми с по-голяма прецизност и внимание към детайлите."
+    "description": "Opus 4.1 е висок клас модел на Anthropic, оптимизиран за програмиране, сложни логически задачи и продължителни процеси."
   },
   "anthropic/claude-sonnet-4": {
-    "description": "Claude Sonnet 4 значително подобрява водещите в индустрията възможности на Sonnet 3.7, с отлични резултати в кодиране и постига водещи 72.7% в SWE-bench. Моделът балансира производителност и ефективност, подходящ е за вътрешни и външни случаи и предлага по-голям контрол чрез подобрена управляемост."
+    "description": "Claude Sonnet 4 е хибриден модел за разсъждение от Anthropic, предлагащ комбинирани възможности за мисловни и немисловни задачи."
   },
   "anthropic/claude-sonnet-4.5": {
-    "description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic досега."
+    "description": "Claude Sonnet 4.5 е най-новият хибриден модел за разсъждение на Anthropic, оптимизиран за сложни логически задачи и програмиране."
   },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B е голям езиков модел с 72 милиарда параметри и 16 милиарда активирани параметри, базиран на архитектурата с групирани смесени експерти (MoGE). Той групира експертите по време на избора им и ограничава активацията на токените да активират равен брой експерти във всяка група, което осигурява балансирано натоварване на експертите и значително подобрява ефективността на разгръщане на модела на платформата Ascend."
@@ -758,6 +764,9 @@
   "baidu/ERNIE-4.5-300B-A47B": {
     "description": "ERNIE-4.5-300B-A47B е голям езиков модел, разработен от Baidu, базиран на архитектурата с хибридни експерти (MoE). Моделът има общо 300 милиарда параметри, но при инференция активира само 47 милиарда параметри на токен, което осигурява висока производителност и изчислителна ефективност. Като един от основните модели в серията ERNIE 4.5, той демонстрира изключителни способности в задачи като разбиране на текст, генериране, разсъждение и програмиране. Моделът използва иновативен мултимодален хетерогенен MoE метод за предварително обучение, който чрез съвместно обучение на текстови и визуални модалности значително подобрява цялостните му възможности, особено в следването на инструкции и запаметяването на световни знания."
   },
+  "baidu/ernie-5.0-thinking-preview": {
+    "description": "ERNIE 5.0 Thinking Preview е ново поколение мултимодален модел на Baidu, способен на разбиране на различни модалности, следване на инструкции, творчество, отговаряне на фактически въпроси и използване на инструменти."
+  },
   "c4ai-aya-expanse-32b": {
     "description": "Aya Expanse е високопроизводителен многоезичен модел с 32B, проектиран да предизвика представянето на едноезични модели чрез иновации в настройката на инструкции, арбитраж на данни, обучение на предпочитания и комбиниране на модели. Той поддържа 23 езика."
   },
@@ -866,6 +875,9 @@
   "codex-mini-latest": {
     "description": "codex-mini-latest е фина настройка на o4-mini, специално предназначена за Codex CLI. За директна употреба чрез API препоръчваме да започнете с gpt-4.1."
   },
+  "cogito-2.1:671b": {
+    "description": "Cogito v2.1 671B е американски отворен езиков модел с безплатна търговска употреба, отличаващ се с производителност, съпоставима с водещите модели, по-висока ефективност при обработка на токени, 128k дълъг контекст и мощни общи способности."
+  },
   "cogview-4": {
     "description": "CogView-4 е първият отворен модел за генериране на изображения с текст на китайски, разработен от Zhipu, който значително подобрява разбирането на семантиката, качеството на генериране на изображения и способността за генериране на текст на китайски и английски език. Поддържа двуезичен вход на произволна дължина на китайски и английски и може да генерира изображения с произволна резолюция в зададения диапазон."
   },
@@ -1136,6 +1148,9 @@
   "deepseek-vl2-small": {
     "description": "DeepSeek VL2 Small, олекотена мултимодална версия, подходяща за среди с ограничени ресурси и висока едновременност."
   },
+  "deepseek/deepseek-chat": {
+    "description": "DeepSeek-V3 е високопроизводителен хибриден модел за разсъждение от екипа на DeepSeek, подходящ за сложни задачи и интеграция с инструменти."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 е експертен смесен модел с 685B параметри, последната итерация на флагманската серия чат модели на екипа DeepSeek.\n\nТой наследява модела [DeepSeek V3](/deepseek/deepseek-chat-v3) и показва отлични резултати в различни задачи."
   },
@@ -1143,19 +1158,19 @@
     "description": "DeepSeek V3 е експертен смесен модел с 685B параметри, последната итерация на флагманската серия чат модели на екипа DeepSeek.\n\nТой наследява модела [DeepSeek V3](/deepseek/deepseek-chat-v3) и показва отлични резултати в различни задачи."
   },
   "deepseek/deepseek-chat-v3.1": {
-    "description": "DeepSeek-V3.1 е голям хибриден модел за разсъждение, който поддържа 128K дълъг контекст и ефективно превключване на режими, постигащ изключителна производителност и скорост при използване на инструменти, генериране на код и сложни задачи за разсъждение."
+    "description": "DeepSeek-V3.1 е хибриден модел за разсъждение с дълъг контекст от DeepSeek, поддържащ комбинирани мисловни и немисловни режими и интеграция с инструменти."
   },
   "deepseek/deepseek-r1": {
     "description": "DeepSeek R1 моделът е получил малка версия ъпгрейд, текущата версия е DeepSeek-R1-0528. В последната актуализация DeepSeek R1 значително подобри дълбочината и способността за разсъждение чрез използване на увеличени изчислителни ресурси и въвеждане на алгоритмични оптимизации след обучението. Моделът постига отлични резултати в множество бенчмаркове като математика, програмиране и обща логика, като общата му производителност вече се доближава до водещи модели като O3 и Gemini 2.5 Pro."
   },
   "deepseek/deepseek-r1-0528": {
-    "description": "DeepSeek-R1 значително подобрява способността за разсъждение на модела дори с много малко анотирани данни. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да повиши точността на крайния отговор."
+    "description": "DeepSeek R1 0528 е обновен вариант на DeepSeek, фокусиран върху отвореност и дълбочина на разсъждение."
   },
   "deepseek/deepseek-r1-0528:free": {
     "description": "DeepSeek-R1 значително подобрява способността за разсъждение на модела дори с много малко анотирани данни. Преди да изведе окончателния отговор, моделът първо генерира мисловна верига, за да повиши точността на крайния отговор."
   },
   "deepseek/deepseek-r1-distill-llama-70b": {
-    "description": "DeepSeek-R1-Distill-Llama-70B е дистилиран и по-ефективен вариант на 70B Llama модела. Той запазва силна производителност при генериране на текст, намалявайки изчислителните разходи за по-лесно внедряване и изследване. Обслужва се от Groq с помощта на техния персонализиран хардуер за езикова обработка (LPU), осигурявайки бързо и ефективно разсъждение."
+    "description": "DeepSeek R1 Distill Llama 70B е голям езиков модел, базиран на Llama3.3 70B, който използва фино настройване, извлечено от DeepSeek R1, за да постигне конкурентна производителност, съпоставима с водещите мащабни модели."
   },
   "deepseek/deepseek-r1-distill-llama-8b": {
     "description": "DeepSeek R1 Distill Llama 8B е дестилиран голям езиков модел, базиран на Llama-3.1-8B-Instruct, обучен с изхода на DeepSeek R1."
@@ -1172,6 +1187,9 @@
   "deepseek/deepseek-r1:free": {
     "description": "DeepSeek-R1 значително подобри способността на модела за разсъждение при наличието на много малко маркирани данни. Преди да предостави окончателния отговор, моделът първо ще изведе част от съдържанието на веригата на мислене, за да повиши точността на окончателния отговор."
   },
+  "deepseek/deepseek-reasoner": {
+    "description": "DeepSeek-V3 Thinking (reasoner) е експериментален модел за разсъждение от DeepSeek, подходящ за задачи с висока сложност."
+  },
   "deepseek/deepseek-v3": {
     "description": "Бърз универсален голям езиков модел с подобрени способности за разсъждение."
   },
@@ -1478,9 +1496,6 @@
   "gemini-2.0-flash-lite-001": {
     "description": "Gemini 2.0 Flash е вариант на модела, оптимизиран за икономичност и ниска латентност."
   },
-  "gemini-2.0-flash-preview-image-generation": {
-    "description": "Gemini 2.0 Flash предварителен модел, поддържащ генериране на изображения"
-  },
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash е най-ефективният модел на Google, предлагащ пълна функционалност."
   },
@@ -1508,9 +1523,6 @@
   "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"
   },
@@ -1526,6 +1538,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview е най-напредналият мисловен модел на Google, способен да разсъждава върху сложни проблеми в областта на кодирането, математиката и STEM, както и да анализира големи набори от данни, кодови бази и документи с дълъг контекст."
   },
+  "gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) е модел за генериране на изображения от Google, който поддържа и мултимодален диалог."
+  },
+  "gemini-3-pro-image-preview:image": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) е модел за генериране на изображения от Google, който поддържа и мултимодален диалог."
+  },
+  "gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro е най-добрият в света модел за мултимодално разбиране, както и най-мощният интелигентен агент и модел за програмиране на атмосфера от Google досега. Предлага богати визуални ефекти и дълбока интерактивност, базирани на най-съвременни логически способности."
+  },
   "gemini-flash-latest": {
     "description": "Последно издание на Gemini Flash"
   },
@@ -1650,7 +1671,7 @@
     "description": "GLM-Zero-Preview притежава мощни способности за сложни разсъждения, показвайки отлични резултати в логическото разсъждение, математиката и програмирането."
   },
   "google/gemini-2.0-flash": {
-    "description": "Gemini 2.0 Flash предлага следващо поколение функции и подобрения, включително изключителна скорост, вградена употреба на инструменти, мултимодално генериране и контекстен прозорец от 1 милион токена."
+    "description": "Gemini 2.0 Flash е високопроизводителен модел за разсъждение от Google, подходящ за разширени мултимодални задачи."
   },
   "google/gemini-2.0-flash-001": {
     "description": "Gemini 2.0 Flash предлага следващо поколение функции и подобрения, включително изключителна скорост, нативна употреба на инструменти, многомодално генериране и контекстен прозорец от 1M токена."
@@ -1661,14 +1682,23 @@
   "google/gemini-2.0-flash-lite": {
     "description": "Gemini 2.0 Flash Lite предлага следващо поколение функции и подобрения, включително изключителна скорост, вградена употреба на инструменти, мултимодално генериране и контекстен прозорец от 1 милион токена."
   },
+  "google/gemini-2.0-flash-lite-001": {
+    "description": "Gemini 2.0 Flash Lite е олекотена версия от семейството Gemini, по подразбиране без активирано разсъждение за по-ниска латентност и разходи, но може да бъде активирано чрез параметри."
+  },
   "google/gemini-2.5-flash": {
-    "description": "Gemini 2.5 Flash е мислещ модел, който предлага отлични всеобхватни възможности. Той е проектиран да балансира цена и производителност, поддържайки мултимодалност и контекстен прозорец от 1 милион токена."
+    "description": "Серията Gemini 2.5 Flash (Lite/Pro/Flash) са модели на Google с ниска до висока латентност и производителност за разсъждение."
+  },
+  "google/gemini-2.5-flash-image": {
+    "description": "Gemini 2.5 Flash Image (Nano Banana) е модел за генериране на изображения от Google, който поддържа и мултимодален диалог."
+  },
+  "google/gemini-2.5-flash-image-free": {
+    "description": "Безплатна версия на Gemini 2.5 Flash Image, поддържа ограничено количество мултимодално генериране."
   },
   "google/gemini-2.5-flash-image-preview": {
     "description": "Gemini 2.5 Flash експериментален модел, поддържащ генериране на изображения."
   },
   "google/gemini-2.5-flash-lite": {
-    "description": "Gemini 2.5 Flash-Lite е балансиран, с ниска латентност модел с конфигурируем бюджет за мислене и свързаност с инструменти (например Google Search grounding и изпълнение на код). Поддържа мултимодален вход и предлага контекстен прозорец от 1 милион токена."
+    "description": "Gemini 2.5 Flash Lite е олекотена версия на Gemini 2.5, оптимизирана за ниска латентност и разходи, подходяща за сценарии с висок трафик."
   },
   "google/gemini-2.5-flash-preview": {
     "description": "Gemini 2.5 Flash е най-напредналият основен модел на Google, проектиран за напреднали разсъждения, кодиране, математика и научни задачи. Той включва вградена способност за \"мислене\", което му позволява да предоставя отговори с по-висока точност и детайлна обработка на контекста.\n\nЗабележка: Този модел има два варианта: с мислене и без мислене. Цените на изхода значително варират в зависимост от активирането на способността за мислене. Ако изберете стандартния вариант (без суфикс \":thinking\"), моделът ще избягва генерирането на токени за мислене.\n\nЗа да се възползвате от способността за мислене и да получите токени за мислене, трябва да изберете варианта \":thinking\", което ще доведе до по-високи цени на изхода за мислене.\n\nОсвен това, Gemini 2.5 Flash може да бъде конфигуриран чрез параметъра \"максимален брой токени за разсъждение\", както е описано в документацията (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
@@ -1677,11 +1707,26 @@
     "description": "Gemini 2.5 Flash е най-напредналият основен модел на Google, проектиран за напреднали разсъждения, кодиране, математика и научни задачи. Той включва вградена способност за \"мислене\", което му позволява да предоставя отговори с по-висока точност и детайлна обработка на контекста.\n\nЗабележка: Този модел има два варианта: с мислене и без мислене. Цените на изхода значително варират в зависимост от активирането на способността за мислене. Ако изберете стандартния вариант (без суфикс \":thinking\"), моделът ще избягва генерирането на токени за мислене.\n\nЗа да се възползвате от способността за мислене и да получите токени за мислене, трябва да изберете варианта \":thinking\", което ще доведе до по-високи цени на изхода за мислене.\n\nОсвен това, Gemini 2.5 Flash може да бъде конфигуриран чрез параметъра \"максимален брой токени за разсъждение\", както е описано в документацията (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
   },
   "google/gemini-2.5-pro": {
-    "description": "Gemini 2.5 Pro е нашият най-напреднал разсъдъчен Gemini модел, способен да решава сложни проблеми. Той разполага с контекстен прозорец от 2 милиона токена и поддържа мултимодален вход, включително текст, изображения, аудио, видео и PDF документи."
+    "description": "Gemini 2.5 Pro е флагманският модел за разсъждение на Google, поддържащ дълъг контекст и сложни задачи."
+  },
+  "google/gemini-2.5-pro-free": {
+    "description": "Безплатна версия на Gemini 2.5 Pro, поддържа ограничен мултимодален дълъг контекст, подходяща за тестване и леки работни потоци."
   },
   "google/gemini-2.5-pro-preview": {
     "description": "Gemini 2.5 Pro Preview е най-усъвършенстваният мисловен модел на Google, способен да извършва разсъждения върху сложни проблеми в областта на кодирането, математиката и STEM, както и да анализира големи набори от данни, кодови бази и документи с дълъг контекст."
   },
+  "google/gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) е модел на Google за генериране на изображения, който поддържа мултимодален диалог."
+  },
+  "google/gemini-3-pro-image-preview-free": {
+    "description": "Безплатна версия на Gemini 3 Pro Image, поддържа ограничено количество мултимодално генериране."
+  },
+  "google/gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro е следващото поколение мултимодален модел за разсъждение от серията Gemini, способен да разбира текст, аудио, изображения, видео и други входове, и да обработва сложни задачи и големи кодови бази."
+  },
+  "google/gemini-3-pro-preview-free": {
+    "description": "Безплатна предварителна версия на Gemini 3 Pro, предлага същите мултимодални възможности за разбиране и разсъждение като стандартната версия, но с ограничения в безплатния лимит и скорост, по-подходяща за тестване и нискочестотна употреба."
+  },
   "google/gemini-embedding-001": {
     "description": "Водещ модел за вграждане с отлична производителност при задачи на английски, многоезични и кодови задачи."
   },
@@ -1907,6 +1952,12 @@
   "grok-4-0709": {
     "description": "Grok 4 от xAI, с мощни способности за разсъждение."
   },
+  "grok-4-1-fast-non-reasoning": {
+    "description": "Модерен мултимодален модел, специално оптимизиран за високоефективно използване на агентски инструменти."
+  },
+  "grok-4-1-fast-reasoning": {
+    "description": "Модерен мултимодален модел, специално оптимизиран за високоефективно използване на агентски инструменти."
+  },
   "grok-4-fast-non-reasoning": {
     "description": "С удоволствие представяме Grok 4 Fast, нашият най-нов напредък в модели за разсъждение с висока ефективност на разходите."
   },
@@ -2051,21 +2102,36 @@
   "inception/mercury-coder-small": {
     "description": "Mercury Coder Small е идеален за задачи по генериране, отстраняване на грешки и рефакториране на код с минимална латентност."
   },
-  "inclusionAI/Ling-1T": {
-    "description": "Ling-1T е първият флагмански non-thinking модел от серията „Ling 2.0“, с общо 1 трилион параметри и около 50 милиарда активни параметри на токен. Изграден върху архитектурата Ling 2.0, Ling-1T цели да преодолее границите на ефективното разсъждение и мащабируемото познание. Ling-1T-base е обучен върху над 20 трилиона висококачествени, интензивно логически токени."
-  },
   "inclusionAI/Ling-flash-2.0": {
     "description": "Ling-flash-2.0 е третият модел от серията Ling 2.0 архитектури, публикуван от екипа на Ant Group Bailing. Това е модел с хибридни експерти (MoE) с общо 100 милиарда параметри, но при всеки токен активира само 6.1 милиарда параметри (без вграждания – 4.8 милиарда). Като леко конфигуриран модел, Ling-flash-2.0 показва в множество авторитетни оценки производителност, сравнима или дори превъзхождаща плътни (Dense) модели с 40 милиарда параметри и по-големи MoE модели. Моделът е предназначен да изследва пътища за висока ефективност чрез изключителен дизайн на архитектурата и стратегии за обучение, в контекста на общоприетото схващане, че „големият модел е равен на големи параметри“."
   },
   "inclusionAI/Ling-mini-2.0": {
     "description": "Ling-mini-2.0 е малък, но високопроизводителен голям езиков модел, базиран на MoE архитектура. Той има общо 16 милиарда параметри, но при всеки токен активира само 1.4 милиарда (без вграждания – 789 милиона), което осигурява изключително бърза генерация. Благодарение на ефективния MoE дизайн и големия обем висококачествени тренировъчни данни, въпреки че активираните параметри са само 1.4 милиарда, Ling-mini-2.0 демонстрира върхова производителност в downstream задачи, сравнима с плътни LLM под 10 милиарда параметри и по-големи MoE модели."
   },
-  "inclusionAI/Ring-1T": {
-    "description": "Ring-1T е отворен модел за мислене с трилион параметри, разработен от екипа на Bailing. Базиран е на архитектурата Ling 2.0 и основния модел Ling-1T-base, с общо 1 трилион параметри и 50 милиарда активни параметри, поддържащ контекстуален прозорец до 128K. Моделът е оптимизиран чрез мащабно обучение с проверими награди и подсилено обучение."
-  },
   "inclusionAI/Ring-flash-2.0": {
     "description": "Ring-flash-2.0 е високопроизводителен мисловен модел, дълбоко оптимизиран на базата на Ling-flash-2.0-base. Той използва MoE архитектура с общо 100 милиарда параметри, но при всяко извод активира само 6.1 милиарда параметри. Моделът решава нестабилността на големите MoE модели при обучение с подсилено учене (RL) чрез уникалния алгоритъм icepop, което позволява непрекъснато подобряване на сложните разсъждения при дългосрочно обучение. Ring-flash-2.0 постига значителни пробиви в множество трудни бенчмаркове като математически състезания, генериране на код и логически разсъждения. Неговата производителност не само превъзхожда топ плътни модели с по-малко от 40 милиарда параметри, но и се сравнява с по-големи отворени MoE модели и затворени високопроизводителни мисловни модели. Въпреки че е фокусиран върху сложни разсъждения, моделът се представя отлично и в творческо писане. Благодарение на ефективния си архитектурен дизайн, Ring-flash-2.0 осигурява висока производителност и бърз извод, значително намалявайки разходите за внедряване на мисловни модели при висока паралелност."
   },
+  "inclusionai/ling-1t": {
+    "description": "Ling-1T е MoE модел с 1 трилион параметъра от inclusionAI, оптимизиран за интензивни логически задачи и мащабен контекст."
+  },
+  "inclusionai/ling-flash-2.0": {
+    "description": "Ling-flash-2.0 е MoE модел от inclusionAI, оптимизиран за ефективност и логическа производителност, подходящ за средни и големи задачи."
+  },
+  "inclusionai/ling-mini-2.0": {
+    "description": "Ling-mini-2.0 е олекотен MoE модел от inclusionAI, който значително намалява разходите, като запазва логическите си способности."
+  },
+  "inclusionai/ming-flash-omini-preview": {
+    "description": "Ming-flash-omni Preview е мултимодален модел от inclusionAI, поддържащ вход от глас, изображения и видео, с подобрени възможности за визуализация и разпознаване на реч."
+  },
+  "inclusionai/ring-1t": {
+    "description": "Ring-1T е MoE модел за разсъждение с трилион параметри от inclusionAI, подходящ за мащабни логически и изследователски задачи."
+  },
+  "inclusionai/ring-flash-2.0": {
+    "description": "Ring-flash-2.0 е вариант на модела Ring от inclusionAI, насочен към сценарии с висок трафик, с акцент върху скорост и разходна ефективност."
+  },
+  "inclusionai/ring-mini-2.0": {
+    "description": "Ring-mini-2.0 е олекотена версия на MoE модела от inclusionAI с висока пропускателна способност, предназначена за паралелни сценарии."
+  },
   "internlm/internlm2_5-7b-chat": {
     "description": "InternLM2.5 предлага интелигентни решения за диалог в множество сценарии."
   },
@@ -2117,6 +2183,12 @@
   "kimi-k2-instruct": {
     "description": "Kimi K2 Instruct, официален модел за извеждане от Kimi, поддържащ дълъг контекст, програмиране, въпроси и отговори и други сценарии."
   },
+  "kimi-k2-thinking": {
+    "description": "K2 е модел за дълбоко разсъждение, поддържащ 256k контекст, многократни стъпки за използване на инструменти и мисловни процеси, способен да решава по-сложни проблеми."
+  },
+  "kimi-k2-thinking-turbo": {
+    "description": "Ускорена версия на модела K2 за дълбоко разсъждение, поддържа 256k контекст и предлага скорост на изход от 60–100 токена в секунда при запазване на дълбоките логически способности."
+  },
   "kimi-k2-turbo-preview": {
     "description": "Kimi-k2 е базов модел с MoE архитектура, който притежава изключителни възможности за работа с код и агентни функции. Общият брой параметри е 1T, а активните параметри са 32B. В бенчмарковете за основни категории като общо знание и разсъждение, програмиране, математика и агентни задачи, моделът K2 превъзхожда другите водещи отворени модели."
   },
@@ -2129,6 +2201,9 @@
   "kimi-thinking-preview": {
     "description": "Моделът kimi-thinking-preview, предоставен от „Тъмната страна на Луната“, е мултимодален мисловен модел с възможности за мултимодално и общо разсъждение, който е експерт в дълбокото разсъждение и помага за решаването на по-сложни задачи."
   },
+  "kuaishou/kat-coder-pro-v1": {
+    "description": "KAT-Coder-Pro-V1 (временно безплатен) е фокусиран върху разбиране на код и автоматизирано програмиране, предназначен за ефективни задачи с програмен агент."
+  },
   "learnlm-1.5-pro-experimental": {
     "description": "LearnLM е експериментален езиков модел, специфичен за задачи, обучен да отговаря на принципите на научното обучение, способен да следва системни инструкции в учебни и обучителни сценарии, да действа като експертен ментор и др."
   },
@@ -2225,6 +2300,9 @@
   "megrez-3b-instruct": {
     "description": "Megrez 3B Instruct е ефективен модел с малък брой параметри, разработен от Wuwen Xinqiong."
   },
+  "meituan/longcat-flash-chat": {
+    "description": "Longcat Flash Chat е с отворен код от Meituan и представлява базов модел без мисловни процеси, оптимизиран за диалогови взаимодействия и задачи на интелигентни агенти, с изключителна ефективност при използване на инструменти и в сложни многократни взаимодействия."
+  },
   "meta-llama-3-70b-instruct": {
     "description": "Мощен модел с 70 милиарда параметри, отличаващ се в разсъждения, кодиране и широки езикови приложения."
   },
@@ -2456,6 +2534,12 @@
   "minimax-m2": {
     "description": "MiniMax M2 е ефективен голям езиков модел, създаден специално за кодиране и работни процеси с агенти."
   },
+  "minimax/minimax-m2": {
+    "description": "MiniMax-M2 е високоефективен модел с отлично представяне при кодиране и агентски задачи, подходящ за различни инженерни приложения."
+  },
+  "minimaxai/minimax-m2": {
+    "description": "MiniMax-M2 е компактен, бърз и икономичен хибриден експертен (MoE) модел с общо 230 милиарда параметъра и 10 милиарда активни параметъра, създаден за постигане на върхова производителност при кодиране и задачи, свързани с интелигентни агенти, като същевременно поддържа силен общ интелект. Моделът се отличава с отлична работа при редактиране на множество файлове, затворен цикъл кодиране-изпълнение-поправка, тестване и валидиране на поправки, както и при сложни дълговерижни инструментални процеси, което го прави идеален избор за работния процес на разработчиците."
+  },
   "ministral-3b-latest": {
     "description": "Ministral 3B е световен лидер сред моделите на Mistral."
   },
@@ -2600,12 +2684,21 @@
   "moonshotai/kimi-k2": {
     "description": "Kimi K2 е голям смесен експертен (MoE) езиков модел с 1 трилион общи параметри и 32 милиарда активни параметри на преден проход, разработен от Moonshot AI. Оптимизиран е за агентски способности, включително усъвършенствано използване на инструменти, разсъждения и синтез на код."
   },
+  "moonshotai/kimi-k2-0711": {
+    "description": "Kimi K2 0711 е Instruct версия от серията Kimi, подходяща за висококачествено програмиране и използване на инструменти."
+  },
   "moonshotai/kimi-k2-0905": {
-    "description": "Моделът kimi-k2-0905-preview има контекстна дължина от 256k, с по-силни способности за агентно кодиране, по-изразителна естетика и практичност на фронтенд кода, както и по-добро разбиране на контекста."
+    "description": "Kimi K2 0905 е актуализация от серията Kimi, подобряваща контекстуалната обработка и логическите възможности, оптимизирана за кодиране."
   },
   "moonshotai/kimi-k2-instruct-0905": {
     "description": "Моделът kimi-k2-0905-preview има контекстна дължина от 256k, с по-силни способности за агентно кодиране, по-изразителна естетика и практичност на фронтенд кода, както и по-добро разбиране на контекста."
   },
+  "moonshotai/kimi-k2-thinking": {
+    "description": "Kimi K2 Thinking е модел за дълбоко разсъждение, оптимизиран от Moonshot, с универсални способности на агент."
+  },
+  "moonshotai/kimi-k2-thinking-turbo": {
+    "description": "Kimi K2 Thinking Turbo е ускорена версия на Kimi K2 Thinking, която запазва дълбоките логически възможности при значително по-ниска латентност."
+  },
   "morph/morph-v3-fast": {
     "description": "Morph предоставя специализиран AI модел, който прилага препоръчаните от водещи модели (като Claude или GPT-4o) промени в кода към съществуващите ви файлове БЪРЗО - над 4500+ токена в секунда. Той служи като последна стъпка в AI кодовия работен поток. Поддържа 16k входни и 16k изходни токена."
   },
@@ -2688,28 +2781,49 @@
     "description": "gpt-4-turbo от OpenAI притежава обширни общи знания и експертиза в различни области, което му позволява да следва сложни инструкции на естествен език и да решава точно трудни проблеми. Знанията му са актуални до април 2023 г., а контекстният прозорец е 128 000 токена."
   },
   "openai/gpt-4.1": {
-    "description": "GPT 4.1 е водещият модел на OpenAI, подходящ за сложни задачи. Изключително подходящ за решаване на проблеми в различни области."
+    "description": "Серията GPT-4.1 предлага по-голям контекст и по-силни инженерни и логически способности."
   },
   "openai/gpt-4.1-mini": {
-    "description": "GPT 4.1 mini постига баланс между интелигентност, скорост и цена, което го прави привлекателен модел за много случаи на употреба."
+    "description": "GPT-4.1 Mini предлага по-ниска латентност и по-добро съотношение цена/качество, подходящ за средни по дължина контексти."
   },
   "openai/gpt-4.1-nano": {
-    "description": "GPT-4.1 nano е най-бързият и икономичен модел от серията GPT 4.1."
+    "description": "GPT-4.1 Nano е изключително икономичен и с ниска латентност, подходящ за чести кратки диалози или класификационни задачи."
   },
   "openai/gpt-4o": {
-    "description": "GPT-4o от OpenAI притежава обширни общи знания и експертиза в различни области, способен да следва сложни инструкции на естествен език и да решава точно трудни проблеми. Предлага производителност, съпоставима с GPT-4 Turbo, но с по-бърз и по-евтин API."
+    "description": "Серията GPT-4o е Omni модел на OpenAI, поддържащ вход от текст + изображение и изход в текстов формат."
   },
   "openai/gpt-4o-mini": {
-    "description": "GPT-4o mini от OpenAI е техният най-напреднал и икономичен малък модел. Той е мултимодален (приема текст или изображения като вход и генерира текст) и е по-интелигентен от gpt-3.5-turbo, като същевременно е също толкова бърз."
+    "description": "GPT-4o-mini е бърза и компактна версия на GPT-4o, подходяща за нисколатентни мултимодални сценарии."
   },
   "openai/gpt-5": {
-    "description": "GPT-5 е водещият езиков модел на OpenAI, отличаващ се в сложни разсъждения, обширни знания за реалния свят, задачи с интензивен код и многостъпкови агентски задачи."
+    "description": "GPT-5 е високопроизводителен модел на OpenAI, подходящ за широк спектър от производствени и изследователски задачи."
+  },
+  "openai/gpt-5-chat": {
+    "description": "GPT-5 Chat е подмодел на GPT-5, оптимизиран за диалогови сценарии с по-ниска латентност и по-добро взаимодействие."
+  },
+  "openai/gpt-5-codex": {
+    "description": "GPT-5-Codex е вариант на GPT-5, допълнително оптимизиран за програмиране, подходящ за мащабни работни потоци с код."
   },
   "openai/gpt-5-mini": {
-    "description": "GPT-5 mini е оптимизиран по отношение на разходите модел, който се представя отлично при задачи за разсъждение и чат. Предлага най-добрия баланс между скорост, цена и способности."
+    "description": "GPT-5 Mini е олекотена версия от семейството GPT-5, предназначена за нисколатентни и нискобюджетни приложения."
   },
   "openai/gpt-5-nano": {
-    "description": "GPT-5 nano е модел с висок пропускателен капацитет, който се справя отлично с прости инструкции или задачи за класификация."
+    "description": "GPT-5 Nano е ултракомпактна версия от семейството, подходяща за сценарии с изключително високи изисквания към разходи и латентност."
+  },
+  "openai/gpt-5-pro": {
+    "description": "GPT-5 Pro е флагманският модел на OpenAI, предлагащ усъвършенствано разсъждение, генериране на код и корпоративни функции, с поддръжка на маршрутизиране при тестване и стриктни политики за сигурност."
+  },
+  "openai/gpt-5.1": {
+    "description": "GPT-5.1 е най-новият флагмански модел от серията GPT-5, с значителни подобрения в общото разсъждение, следване на инструкции и естественост на диалога, подходящ за широк спектър от задачи."
+  },
+  "openai/gpt-5.1-chat": {
+    "description": "GPT-5.1 Chat е лек член на семейството GPT-5.1, оптимизиран за диалози с ниска латентност, като същевременно запазва силни логически и изпълнителни способности."
+  },
+  "openai/gpt-5.1-codex": {
+    "description": "GPT-5.1-Codex е вариант на GPT-5.1, оптимизиран за софтуерно инженерство и работни потоци с код, подходящ за мащабни рефакторинги, сложна отстраняване на грешки и дългосрочно автономно кодиране."
+  },
+  "openai/gpt-5.1-codex-mini": {
+    "description": "GPT-5.1-Codex-Mini е компактна и ускорена версия на GPT-5.1-Codex, по-подходяща за кодиране в среди, чувствителни към латентност и разходи."
   },
   "openai/gpt-oss-120b": {
     "description": "Изключително способен универсален голям езиков модел с мощни и контролируеми способности за разсъждение."
@@ -2736,7 +2850,7 @@
     "description": "o3-mini high е версия с високо ниво на разсъждение, която предлага висока интелигентност при същите разходи и цели за закъснение като o1-mini."
   },
   "openai/o4-mini": {
-    "description": "o4-mini на OpenAI предлага бързо и икономично разсъждение с отлична производителност за своя размер, особено в математика (най-добър в AIME бенчмарка), кодиране и визуални задачи."
+    "description": "OpenAI o4-mini е компактен и ефективен логически модел, подходящ за нисколатентни приложения."
   },
   "openai/o4-mini-high": {
     "description": "o4-mini версия с високо ниво на извеждане, оптимизирана за бързо и ефективно извеждане, показваща изключителна ефективност и производителност в задачи по кодиране и визуализация."
@@ -2940,7 +3054,7 @@
     "description": "Мощен среден модел за код, поддържащ 32K дължина на контекста, специализиран в многоезично програмиране."
   },
   "qwen/qwen3-14b": {
-    "description": "Qwen3-14B е плътен езиков модел с 14.8 милиарда параметри от серията Qwen3, проектиран за сложни разсъждения и ефективен диалог. Той поддържа безпроблемно преминаване между режим на \"разсъждение\" за математика, програмиране и логическо разсъждение и режим на \"неразсъждение\" за общи разговори. Моделът е фино настроен за следване на инструкции, използване на инструменти за агенти, креативно писане и многоезични задачи на над 100 езика и диалекта. Той нативно обработва контекст от 32K токена и може да бъде разширен до 131K токена с помощта на разширение, базирано на YaRN."
+    "description": "Qwen3-14B е 14B версия от серията Qwen, подходяща за стандартни логически и диалогови задачи."
   },
   "qwen/qwen3-14b:free": {
     "description": "Qwen3-14B е плътен езиков модел с 14.8 милиарда параметри от серията Qwen3, проектиран за сложни разсъждения и ефективен диалог. Той поддържа безпроблемно преминаване между режим на \"разсъждение\" за математика, програмиране и логическо разсъждение и режим на \"неразсъждение\" за общи разговори. Моделът е фино настроен за следване на инструкции, използване на инструменти за агенти, креативно писане и многоезични задачи на над 100 езика и диалекта. Той нативно обработва контекст от 32K токена и може да бъде разширен до 131K токена с помощта на разширение, базирано на YaRN."
@@ -2948,6 +3062,12 @@
   "qwen/qwen3-235b-a22b": {
     "description": "Qwen3-235B-A22B е модел с 235B параметри, разработен от Qwen, с експертна смесена (MoE) архитектура, активираща 22B параметри при всяко напредване. Той поддържа безпроблемно преминаване между режим на \"разсъждение\" за сложни разсъждения, математика и кодиране и режим на \"неразсъждение\" за ефективен общ диалог. Моделът демонстрира силни способности за разсъждение, многоезична поддръжка (над 100 езика и диалекта), напреднало следване на инструкции и способности за извикване на инструменти за агенти. Той нативно обработва контекстен прозорец от 32K токена и може да бъде разширен до 131K токена с помощта на разширение, базирано на YaRN."
   },
+  "qwen/qwen3-235b-a22b-2507": {
+    "description": "Qwen3-235B-A22B-Instruct-2507 е Instruct версия от серията Qwen3, съчетаваща многоезични инструкции и дълъг контекст."
+  },
+  "qwen/qwen3-235b-a22b-thinking-2507": {
+    "description": "Qwen3-235B-A22B-Thinking-2507 е Thinking вариант от Qwen3, подсилен за сложни математически и логически задачи."
+  },
   "qwen/qwen3-235b-a22b:free": {
     "description": "Qwen3-235B-A22B е модел с 235B параметри, разработен от Qwen, с експертна смесена (MoE) архитектура, активираща 22B параметри при всяко напредване. Той поддържа безпроблемно преминаване между режим на \"разсъждение\" за сложни разсъждения, математика и кодиране и режим на \"неразсъждение\" за ефективен общ диалог. Моделът демонстрира силни способности за разсъждение, многоезична поддръжка (над 100 езика и диалекта), напреднало следване на инструкции и способности за извикване на инструменти за агенти. Той нативно обработва контекстен прозорец от 32K токена и може да бъде разширен до 131K токена с помощта на разширение, базирано на YaRN."
   },
@@ -2966,6 +3086,21 @@
   "qwen/qwen3-8b:free": {
     "description": "Qwen3-8B е плътен езиков модел с 8.2 милиарда параметри от серията Qwen3, проектиран за задачи с интензивно разсъждение и ефективен диалог. Той поддържа безпроблемно преминаване между режим на \"разсъждение\" за математика, програмиране и логическо разсъждение и режим на \"неразсъждение\" за общи разговори. Моделът е фино настроен за следване на инструкции, интеграция на агенти, креативно писане и многоезично използване на над 100 езика и диалекта. Той нативно поддържа контекстен прозорец от 32K токена и може да бъде разширен до 131K токена чрез YaRN."
   },
+  "qwen/qwen3-coder": {
+    "description": "Qwen3-Coder е генератор на код от семейството Qwen3, специализиран в разбиране и генериране на код в дълги документи."
+  },
+  "qwen/qwen3-coder-plus": {
+    "description": "Qwen3-Coder-Plus е специално оптимизиран агент за кодиране от серията Qwen, поддържащ по-сложни инструментални операции и дългосрочни сесии."
+  },
+  "qwen/qwen3-max": {
+    "description": "Qwen3 Max е висок клас логически модел от серията Qwen3, подходящ за многоезично разсъждение и интеграция с инструменти."
+  },
+  "qwen/qwen3-max-preview": {
+    "description": "Qwen3 Max (предварителен преглед) е Max версията от серията Qwen, насочена към усъвършенствано разсъждение и интеграция с инструменти."
+  },
+  "qwen/qwen3-vl-plus": {
+    "description": "Qwen3 VL-Plus е визуално подсилена версия от Qwen3, подобряваща мултимодалното разсъждение и обработката на видео."
+  },
   "qwen2": {
     "description": "Qwen2 е новото поколение голям езиков модел на Alibaba, предлагащ отлична производителност за разнообразни приложения."
   },
@@ -3260,9 +3395,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 трилиона смесени текстово-изображенчески токена, обхващайки повече от десет езика. Моделът постига водещи резултати сред отворените модели в множество бенчмаркове, включително математика, код и мултимодални задачи."
   },
@@ -3344,6 +3476,9 @@
   "vercel/v0-1.5-md": {
     "description": "Достъп до модела зад v0 за генериране, поправка и оптимизация на модерни уеб приложения с разсъждения, специфични за рамки, и актуални знания."
   },
+  "volcengine/doubao-seed-code": {
+    "description": "Doubao-Seed-Code е голям модел на ByteDance Volcano Engine, оптимизиран за Agentic Programming, с отлично представяне в множество програмни и агентски бенчмаркове и поддръжка на 256K контекст."
+  },
   "wan2.2-t2i-flash": {
     "description": "Wanxiang 2.2 експресна версия, най-новият модел към момента. Комплексно подобрение в креативност, стабилност и реализъм, с бърза скорост на генериране и висока цена-ефективност."
   },
@@ -3371,6 +3506,24 @@
   "wizardlm2:8x22b": {
     "description": "WizardLM 2 е езиков модел, предоставен от Microsoft AI, който се отличава в сложни диалози, многоезичност, разсъждение и интелигентни асистенти."
   },
+  "x-ai/grok-4": {
+    "description": "Grok 4 е флагманският логически модел на xAI, предлагащ мощни логически и мултимодални възможности."
+  },
+  "x-ai/grok-4-fast": {
+    "description": "Grok 4 Fast е високопроизводителен и икономичен модел на xAI (с поддръжка на 2M контекстен прозорец), подходящ за приложения с висока едновременност и дълъг контекст."
+  },
+  "x-ai/grok-4-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) е високопроизводителен и икономичен мултимодален модел на xAI (с поддръжка на 2M контекстен прозорец), предназначен за сценарии, чувствителни към латентност и разходи, но без нужда от вътрешно разсъждение. Съществува паралелно с reasoning версията на Grok 4 Fast и позволява активиране на разсъждение чрез параметъра reasoning enable в API. Подадените заявки и отговори може да бъдат използвани от xAI или OpenRouter за подобряване на бъдещи модели."
+  },
+  "x-ai/grok-4.1-fast": {
+    "description": "Grok 4 Fast е високопроизводителен и икономичен модел на xAI (с поддръжка на 2M контекстен прозорец), подходящ за приложения с висока едновременност и дълъг контекст."
+  },
+  "x-ai/grok-4.1-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) е високопроизводителен и икономичен мултимодален модел на xAI (с поддръжка на 2M контекстен прозорец), предназначен за сценарии, чувствителни към латентност и разходи, но без нужда от вътрешно разсъждение. Съществува паралелно с reasoning версията на Grok 4 Fast и позволява активиране на разсъждение чрез параметъра reasoning enable в API. Подадените заявки и отговори може да бъдат използвани от xAI или OpenRouter за подобряване на бъдещи модели."
+  },
+  "x-ai/grok-code-fast-1": {
+    "description": "Grok Code Fast 1 е бърз кодов модел на xAI, предлагащ четим и инженерно пригоден изход."
+  },
   "x1": {
     "description": "Моделът Spark X1 ще бъде допълнително обновен, като на базата на водещите в страната резултати в математически задачи, ще постигне ефекти в общи задачи като разсъждение, генериране на текст и разбиране на език, сравними с OpenAI o1 и DeepSeek R1."
   },
@@ -3431,6 +3584,15 @@
   "yi-vision-v2": {
     "description": "Модел за сложни визуални задачи, предлагащ висока производителност в разбирането и анализа на базата на множество изображения."
   },
+  "z-ai/glm-4.5": {
+    "description": "GLM 4.5 е флагманският модел на Z.AI, поддържащ хибриден режим на разсъждение и оптимизиран за инженерни и дългоконтекстови задачи."
+  },
+  "z-ai/glm-4.5-air": {
+    "description": "GLM 4.5 Air е олекотена версия на GLM 4.5, подходяща за сценарии с ограничен бюджет, като същевременно запазва силни логически възможности."
+  },
+  "z-ai/glm-4.6": {
+    "description": "GLM 4.6 е флагманският модел на Z.AI, с разширен контекст и подобрени кодиращи способности."
+  },
   "zai-org/GLM-4.5": {
     "description": "GLM-4.5 е базов модел, специално създаден за интелигентни агенти, използващ архитектура с микс от експерти (Mixture-of-Experts). Той е дълбоко оптимизиран за използване на инструменти, уеб браузване, софтуерно инженерство и фронтенд програмиране, и поддържа безпроблемна интеграция с кодови агенти като Claude Code и Roo Code. GLM-4.5 използва смесен режим на разсъждение, подходящ за сложни и ежедневни приложения."
   },
@@ -3451,5 +3613,8 @@
   },
   "zai/glm-4.5v": {
     "description": "GLM-4.5V е изграден върху основния модел GLM-4.5-Air, наследявайки проверените технологии на GLM-4.1V-Thinking и постига ефективно мащабиране чрез мощната MoE архитектура с 106 милиарда параметри."
+  },
+  "zenmux/auto": {
+    "description": "Функцията за автоматично маршрутизиране на ZenMux автоматично избира най-добрия модел с най-добро съотношение цена/качество и представяне според съдържанието на вашата заявка от поддържаните модели."
   }
 }

locales/bg-BG/plugin.json

@@ -1,4 +1,38 @@
 {
+  "builtins": {
+    "lobe-knowledge-base": {
+      "apiName": {
+        "readKnowledge": "Прочети съдържанието на базата знания",
+        "searchKnowledgeBase": "Търси в базата знания"
+      },
+      "title": "База знания"
+    },
+    "lobe-local-system": {
+      "apiName": {
+        "editLocalFile": "Редактирай файл",
+        "getCommandOutput": "Вземи изхода от кода",
+        "globLocalFiles": "Търси съвпадащи файлове",
+        "grepContent": "Търси съдържание",
+        "killCommand": "Прекрати изпълнението на кода",
+        "listLocalFiles": "Преглед на списъка с файлове",
+        "moveLocalFiles": "Премести файлове",
+        "readLocalFile": "Прочети съдържанието на файла",
+        "renameLocalFile": "Преименувай",
+        "runCommand": "Изпълни код",
+        "searchLocalFiles": "Търси файлове",
+        "writeLocalFile": "Запиши файл"
+      },
+      "title": "Локална система"
+    },
+    "lobe-web-browsing": {
+      "apiName": {
+        "crawlMultiPages": "Прочети съдържание от няколко страници",
+        "crawlSinglePage": "Прочети съдържание от страница",
+        "search": "Търси страница"
+      },
+      "title": "Търсене в интернет"
+    }
+  },
   "confirm": "Потвърждавам",
   "debug": {
     "arguments": "Параметри на извикване",
@@ -251,23 +285,6 @@
     "content": "Извикване на плъгина...",
     "plugin": "Плъгинът работи..."
   },
-  "localSystem": {
-    "apiName": {
-      "editLocalFile": "Редактиране на файл",
-      "getCommandOutput": "Получаване на изход от командата",
-      "globLocalFiles": "Търсене на съвпадащи файлове",
-      "grepContent": "Търсене на съдържание",
-      "killCommand": "Прекратяване на изпълнението на командата",
-      "listLocalFiles": "Преглед на списък с файлове",
-      "moveLocalFiles": "Преместване на файлове",
-      "readLocalFile": "Четене на съдържание на файл",
-      "renameLocalFile": "Преименуване",
-      "runCommand": "Изпълни код",
-      "searchLocalFiles": "Търсене на файлове",
-      "writeLocalFile": "Запис в файл"
-    },
-    "title": "Локална система"
-  },
   "mcpInstall": {
     "CHECKING_INSTALLATION": "Проверка на инсталационната среда...",
     "COMPLETED": "Инсталацията е завършена",
@@ -375,11 +392,6 @@
     "warning": "⚠️ Моля, уверете се, че имате доверие на източника на този плъгин, злонамерени плъгини могат да застрашат сигурността на вашата система."
   },
   "search": {
-    "apiName": {
-      "crawlMultiPages": "Четене на съдържание от множество страници",
-      "crawlSinglePage": "Четене на съдържание от страница",
-      "search": "Търсене на страници"
-    },
     "config": {
       "addKey": "Добавяне на ключ",
       "close": "Изтриване",

locales/bg-BG/providers.json

@@ -191,6 +191,9 @@
   "xinference": {
     "description": "Xorbits Inference (Xinference) е платформа с отворен код, предназначена да опрости изпълнението и интегрирането на различни AI модели. С Xinference можете да използвате всякакви LLM с отворен код, модели за вграждане и мултимодални модели за извършване на изводи в облак или локална среда, както и да създавате мощни AI приложения."
   },
+  "zenmux": {
+    "description": "ZenMux е унифицирана платформа за агрегиране на AI услуги, поддържаща множество водещи AI интерфейси като OpenAI, Anthropic, Google VertexAI и други. Тя предлага гъвкави възможности за маршрутизиране, които ви позволяват лесно да превключвате и управлявате различни AI модели."
+  },
   "zeroone": {
     "description": "01.AI се фокусира върху технологии за изкуствен интелект от ерата на AI 2.0, активно насърчавайки иновации и приложения на \"човек + изкуствен интелект\", използвайки мощни модели и напреднали AI технологии за повишаване на производителността на човека и реализиране на технологично овластяване."
   },

locales/bg-BG/tool.json

@@ -14,7 +14,21 @@
     "images": "Изображения:",
     "prompt": "подсказка"
   },
+  "lobe-knowledge-base": {
+    "readKnowledge": {
+      "meta": {
+        "chars": "Брой знаци",
+        "lines": "Брой редове"
+      }
+    }
+  },
   "localFiles": {
+    "editFile": {
+      "newString": "Замени с",
+      "oldString": "Търсене на съдържание",
+      "replaceAll": "Замени всички съвпадения",
+      "replaceFirst": "Замени само първото съвпадение"
+    },
     "file": "Файл",
     "folder": "Папка",
     "moveFiles": {
@@ -34,7 +48,12 @@
     "readFile": "Прочети файл",
     "readFileError": "Неуспешно четене на файла, моля, проверете дали пътят към файла е правилен",
     "readFiles": "Прочети файлове",
-    "readFilesError": "Неуспешно четене на файловете, моля, проверете дали пътят към файловете е правилен"
+    "readFilesError": "Неуспешно четене на файловете, моля, проверете дали пътят към файловете е правилен",
+    "writeFile": {
+      "characters": "Знаци",
+      "preview": "Преглед на съдържанието",
+      "truncated": "Съкратено"
+    }
   },
   "search": {
     "createNewSearch": "Създаване на нова търсене",

locales/de-DE/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "Tiefdenk-Schalter"
     },
+    "thinkingLevel": {
+      "title": "Denkebene"
+    },
     "title": "Modell Erweiterungsfunktionen",
     "urlContext": {
       "desc": "Wenn aktiviert, werden Webseiten-Links automatisch analysiert, um den tatsächlichen Webseiteninhalt zu erfassen",
@@ -330,6 +333,11 @@
     "screenshot": "Screenshot",
     "settings": "Exporteinstellungen",
     "text": "Text",
+    "widthMode": {
+      "label": "Breitenmodus",
+      "narrow": "Schmalbildmodus",
+      "wide": "Breitbildmodus"
+    },
     "withBackground": "Mit Hintergrundbild",
     "withFooter": "Mit Fußzeile",
     "withPluginInfo": "Mit Plugin-Informationen",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "Die Angabe eines Ablehnungsgrundes hilft dem Agenten, zukünftige Aktionen zu verbessern",
       "rejectTitle": "Tool-Ausführung ablehnen",
       "rejectedWithReason": "Die Tool-Ausführung wurde abgelehnt: {{reason}}",
+      "toolAbort": "Dieser Werkzeugaufruf wurde vom Benutzer abgebrochen",
       "toolRejected": "Die Tool-Ausführung wurde abgelehnt"
     }
   },

locales/de-DE/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "Schließen",
+  "cmdk": {
+    "about": "Über",
+    "communitySupport": "Community-Support",
+    "discover": "Entdecken",
+    "knowledgeBase": "Wissensdatenbank",
+    "navigate": "Navigieren",
+    "newAgent": "Neuen Assistenten erstellen",
+    "noResults": "Keine Ergebnisse gefunden",
+    "openSettings": "Einstellungen öffnen",
+    "painting": "KI-Malerei",
+    "searchPlaceholder": "Befehl eingeben oder suchen...",
+    "settings": "Einstellungen",
+    "starOnGitHub": "Gib uns einen Stern auf GitHub",
+    "submitIssue": "Problem melden",
+    "theme": "Design",
+    "themeAuto": "Systemeinstellung folgen",
+    "themeDark": "Dunkles Design",
+    "themeLight": "Helles Design",
+    "toOpen": "Öffnen",
+    "toSelect": "Auswählen"
+  },
   "confirm": "Bestätigen",
   "contact": "Kontakt",
   "copy": "Kopieren",
@@ -283,6 +304,7 @@
     "business": "Geschäftliche Zusammenarbeit",
     "support": "E-Mail-Support"
   },
+  "new": "Neu",
   "oauth": "SSO-Anmeldung",
   "officialSite": "Offizielle Website",
   "ok": "OK",

locales/de-DE/error.json

@@ -102,7 +102,7 @@
       "SPII": "Ihr Inhalt könnte sensible personenbezogene Daten enthalten. Zum Schutz der Privatsphäre entfernen Sie bitte diese Informationen und versuchen Sie es erneut.",
       "default": "Inhalt blockiert: {{blockReason}}. Bitte passen Sie Ihre Anfrage an und versuchen Sie es erneut."
     },
-    "InsufficientQuota": "Es tut uns leid, das Kontingent (Quota) für diesen Schlüssel ist erreicht. Bitte überprüfen Sie Ihr Kontoguthaben oder erhöhen Sie das Kontingent des Schlüssels und versuchen Sie es erneut.",
+    "InsufficientQuota": "Es tut uns leid, das Kontingent dieses Schlüssels wurde erreicht. Bitte überprüfen Sie, ob Ihr Kontostand ausreichend ist, oder erhöhen Sie das Kontingent des Schlüssels und versuchen Sie es erneut.",
     "InvalidAccessCode": "Das Passwort ist ungültig oder leer. Bitte geben Sie das richtige Zugangspasswort ein oder fügen Sie einen benutzerdefinierten API-Schlüssel hinzu.",
     "InvalidBedrockCredentials": "Die Bedrock-Authentifizierung ist fehlgeschlagen. Bitte überprüfen Sie AccessKeyId/SecretAccessKey und versuchen Sie es erneut.",
     "InvalidClerkUser": "Entschuldigung, du bist derzeit nicht angemeldet. Bitte melde dich an oder registriere ein Konto, um fortzufahren.",
@@ -131,7 +131,7 @@
     "PluginServerError": "Fehler bei der Serveranfrage des Plugins. Bitte überprüfen Sie die Fehlerinformationen unten in Ihrer Plugin-Beschreibungsdatei, Plugin-Konfiguration oder Serverimplementierung",
     "PluginSettingsInvalid": "Das Plugin muss korrekt konfiguriert werden, um verwendet werden zu können. Bitte überprüfen Sie Ihre Konfiguration auf Richtigkeit",
     "ProviderBizError": "Fehler bei der Anforderung des {{provider}}-Dienstes. Bitte überprüfen Sie die folgenden Informationen oder versuchen Sie es erneut.",
-    "QuotaLimitReached": "Es tut uns leid, die aktuelle Token-Nutzung oder die Anzahl der Anfragen hat das Kontingent (Quota) für diesen Schlüssel erreicht. Bitte erhöhen Sie das Kontingent für diesen Schlüssel oder versuchen Sie es später erneut.",
+    "QuotaLimitReached": "Es tut uns leid, die Anzahl der Token oder Anfragen hat das Kontingent dieses Schlüssels erreicht. Bitte erhöhen Sie das Kontingent des Schlüssels oder versuchen Sie es später erneut.",
     "StreamChunkError": "Fehler beim Parsen des Nachrichtenchunks der Streaming-Anfrage. Bitte überprüfen Sie, ob die aktuelle API-Schnittstelle den Standards entspricht, oder wenden Sie sich an Ihren API-Anbieter.",
     "SubscriptionKeyMismatch": "Es tut uns leid, aufgrund eines vorübergehenden Systemfehlers ist das aktuelle Abonnement vorübergehend ungültig. Bitte klicken Sie auf die Schaltfläche unten, um das Abonnement wiederherzustellen, oder kontaktieren Sie uns per E-Mail für Unterstützung.",
     "SubscriptionPlanLimit": "Ihr Abonnementspunktestand ist erschöpft, Sie können diese Funktion nicht nutzen. Bitte upgraden Sie auf einen höheren Plan oder konfigurieren Sie die benutzerdefinierte Modell-API, um weiterhin zu verwenden.",

locales/de-DE/file.json

@@ -55,11 +55,11 @@
   },
   "documentList": {
     "copyContent": "Gesamten Inhalt kopieren",
-    "documentCount": "Insgesamt {{count}} Dokumente",
     "duplicate": "Kopie erstellen",
-    "empty": "Noch keine Dokumente vorhanden. Klicken Sie oben, um Ihr erstes Dokument zu erstellen.",
+    "empty": "Noch keine Dokumente vorhanden. Klicke auf die Schaltfläche oben, um dein erstes Dokument zu erstellen.",
     "noResults": "Keine passenden Dokumente gefunden",
-    "selectNote": "Wählen Sie ein Dokument zum Bearbeiten",
+    "pageCount": "Insgesamt {{count}} Dokumente",
+    "selectNote": "Wähle ein Dokument aus, um mit der Bearbeitung zu beginnen",
     "untitled": "Ohne Titel"
   },
   "empty": "Keine hochgeladenen Dateien/Ordner vorhanden",
@@ -70,7 +70,6 @@
       "uploadFile": "Datei hochladen",
       "uploadFolder": "Ordner hochladen"
     },
-    "newDocumentButton": "Neues Dokument",
     "newNoteDialog": {
       "cancel": "Abbrechen",
       "editTitle": "Dokument bearbeiten",
@@ -83,14 +82,15 @@
       "title": "Neues Dokument",
       "updateSuccess": "Dokument erfolgreich aktualisiert"
     },
+    "newPageButton": "Neues Dokument erstellen",
     "uploadButton": "Hochladen"
   },
   "home": {
     "getStarted": "Loslegen",
     "greeting": "Loslegen",
     "quickActions": "Schnellaktionen",
-    "recentDocuments": "Kürzlich verwendete Dokumente",
     "recentFiles": "Kürzlich verwendete Dateien",
+    "recentPages": "Kürzlich geöffnete Dokumente",
     "subtitle": "Willkommen im Wissensspeicher. Beginnen Sie hier mit der Verwaltung Ihrer Dokumente.",
     "uploadEntries": {
       "files": {
@@ -102,8 +102,8 @@
       "knowledgeBase": {
         "title": "Neue Wissensdatenbank"
       },
-      "newDocument": {
-        "title": "Neues Dokument"
+      "newPage": {
+        "title": "Neues Dokument erstellen"
       }
     }
   },
@@ -116,8 +116,8 @@
     "title": "Wissensdatenbank"
   },
   "menu": {
-    "allDocuments": "Alle Dokumente",
-    "allFiles": "Alle Dateien"
+    "allFiles": "Alle Dateien",
+    "allPages": "Alle Dokumente"
   },
   "networkError": "Fehler beim Abrufen der Wissensdatenbank. Bitte überprüfen Sie Ihre Netzwerkverbindung und versuchen Sie es erneut.",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "Datei herunterladen",
     "unsupportedFileAndContact": "Dieses Dateiformat wird derzeit nicht für die Online-Vorschau unterstützt. Wenn Sie eine Vorschau wünschen, können Sie uns gerne <1>Feedback geben</1>."
   },
-  "searchDocumentPlaceholder": "Dokumente durchsuchen",
   "searchFilePlaceholder": "Datei suchen",
+  "searchPagePlaceholder": "Dokumente durchsuchen",
   "tab": {
     "all": "Alle",
     "audios": "Audio",
@@ -156,9 +156,7 @@
     "websites": "Webseiten"
   },
   "title": "Wissensdatenbank",
-  "toggleLeftPanel": {
-    "title": "Linkes Panel einblenden/ausblenden"
-  },
+  "toggleLeftPanel": "Seitenleiste ein-/ausblenden",
   "uploadDock": {
     "body": {
       "collapse": "Einklappen",

locales/de-DE/hotkey.json

@@ -7,6 +7,10 @@
     "desc": "Aktuelle Nachrichten und hochgeladene Dateien im Gespräch löschen",
     "title": "Gesprächsnachrichten löschen"
   },
+  "commandPalette": {
+    "desc": "Öffne die globale Befehlspalette für schnellen Zugriff auf Funktionen",
+    "title": "Befehlspalette"
+  },
   "deleteAndRegenerateMessage": {
     "desc": "Letzte Nachricht löschen und neu generieren",
     "title": "Löschen und neu generieren"

locales/de-DE/image.json

@@ -37,6 +37,14 @@
         "standard": "Standard"
       }
     },
+    "resolution": {
+      "label": "Auflösung",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "Seed",
       "random": "Zufälliger Seed"

locales/de-DE/modelProvider.json

@@ -295,7 +295,7 @@
       },
       "helpDoc": "Konfigurationsanleitung",
       "responsesApi": {
-        "desc": "Verwendet das neue Anforderungsformat von OpenAI, um fortgeschrittene Funktionen wie Chain-of-Thought freizuschalten",
+        "desc": "Verwendet das neue Anforderungsformat von OpenAI, um erweiterte Funktionen wie Chain-of-Thought freizuschalten (nur mit OpenAI-Modellen kompatibel)",
         "title": "Verwendung des Responses API-Standards"
       },
       "waitingForMore": "Weitere Modelle werden <1>geplant</1>, bitte warten Sie"

locales/de-DE/models.json

@@ -236,6 +236,9 @@
   "MiniMaxAI/MiniMax-M1-80k": {
     "description": "MiniMax-M1 ist ein groß angelegtes hybrides Aufmerksamkeits-Inferenzmodell mit offenen Gewichten, das 456 Milliarden Parameter umfasst und etwa 45,9 Milliarden Parameter pro Token aktiviert. Das Modell unterstützt nativ einen ultralangen Kontext von 1 Million Tokens und spart durch den Blitz-Attention-Mechanismus bei Aufgaben mit 100.000 Tokens im Vergleich zu DeepSeek R1 75 % der Fließkommaoperationen ein. Gleichzeitig verwendet MiniMax-M1 eine MoE-Architektur (Mixture of Experts) und kombiniert den CISPO-Algorithmus mit einem hybriden Aufmerksamkeitsdesign für effizientes verstärkendes Lernen, was in der Langzeiteingabe-Inferenz und realen Software-Engineering-Szenarien branchenführende Leistung erzielt."
   },
+  "MiniMaxAI/MiniMax-M2": {
+    "description": "MiniMax-M2 definiert Effizienz für Agenten neu. Es handelt sich um ein kompaktes, schnelles und kosteneffizientes MoE-Modell mit insgesamt 230 Milliarden Parametern und 10 Milliarden aktiven Parametern. Es wurde für Spitzenleistungen bei Codierungs- und Agentenaufgaben entwickelt und bewahrt gleichzeitig eine starke allgemeine Intelligenz. Mit nur 10 Milliarden aktiven Parametern bietet MiniMax-M2 eine Leistung, die mit groß angelegten Modellen vergleichbar ist, und ist damit die ideale Wahl für Anwendungen mit hohen Effizienzanforderungen."
+  },
   "Moonshot-Kimi-K2-Instruct": {
     "description": "Mit insgesamt 1 Billion Parametern und 32 Milliarden aktivierten Parametern erreicht dieses nicht-denkende Modell Spitzenleistungen in den Bereichen aktuelles Wissen, Mathematik und Programmierung und ist besonders für allgemeine Agentenaufgaben optimiert. Es wurde speziell für Agentenaufgaben verfeinert, kann nicht nur Fragen beantworten, sondern auch Aktionen ausführen. Ideal für spontane, allgemeine Gespräche und Agentenerfahrungen, ist es ein reflexartiges Modell ohne lange Denkzeiten."
   },
@@ -717,25 +720,28 @@
     "description": "Claude 3 Opus ist das intelligenteste Modell von Anthropic mit marktführender Leistung bei hochkomplexen Aufgaben. Es meistert offene Eingabeaufforderungen und unbekannte Szenarien mit herausragender Flüssigkeit und menschenähnlichem Verständnis."
   },
   "anthropic/claude-3.5-haiku": {
-    "description": "Claude 3.5 Haiku ist die nächste Generation unseres schnellsten Modells. Mit ähnlicher Geschwindigkeit wie Claude 3 Haiku wurde Claude 3.5 Haiku in allen Kompetenzbereichen verbessert und übertrifft in vielen Intelligenz-Benchmarks unser bisher größtes Modell Claude 3 Opus."
+    "description": "Claude 3.5 Haiku bietet verbesserte Geschwindigkeit, höhere Genauigkeit beim Programmieren und effizientere Werkzeugnutzung. Ideal für Szenarien mit hohen Anforderungen an Geschwindigkeit und Tool-Interaktion."
   },
   "anthropic/claude-3.5-sonnet": {
-    "description": "Claude 3.5 Sonnet erreicht eine ideale Balance zwischen Intelligenz und Geschwindigkeit – besonders für Unternehmens-Workloads. Im Vergleich zu ähnlichen Produkten bietet es starke Leistung zu geringeren Kosten und ist für hohe Belastbarkeit bei großflächigen KI-Einsätzen konzipiert."
+    "description": "Claude 3.5 Sonnet ist ein schnelles und effizientes Modell der Sonnet-Familie mit verbesserter Programmier- und Schlussfolgerungsleistung. Einige Versionen werden schrittweise durch Sonnet 3.7 ersetzt."
   },
   "anthropic/claude-3.7-sonnet": {
-    "description": "Claude 3.7 Sonnet ist das erste hybride Inferenzmodell und das intelligenteste Modell von Anthropic bisher. Es bietet modernste Leistung bei Codierung, Inhaltserstellung, Datenanalyse und Planungsaufgaben und baut auf den Software-Engineering- und Computerfähigkeiten seines Vorgängers Claude 3.5 Sonnet auf."
+    "description": "Claude 3.7 Sonnet ist die weiterentwickelte Version der Sonnet-Reihe mit leistungsstärkeren Fähigkeiten in den Bereichen Schlussfolgerung und Programmierung – ideal für komplexe Unternehmensaufgaben."
+  },
+  "anthropic/claude-haiku-4.5": {
+    "description": "Claude Haiku 4.5 ist ein leistungsstarkes und schnelles Modell von Anthropic mit extrem niedriger Latenz bei gleichzeitig hoher Genauigkeit."
   },
   "anthropic/claude-opus-4": {
-    "description": "Claude Opus 4 ist das leistungsstärkste Modell von Anthropic und das weltweit beste Codierungsmodell mit Spitzenwerten bei SWE-bench (72,5 %) und Terminal-bench (43,2 %). Es bietet anhaltende Leistung für langfristige Aufgaben mit tausenden Schritten und kann stundenlang ununterbrochen arbeiten – was die Fähigkeiten von KI-Agenten erheblich erweitert."
+    "description": "Opus 4 ist das Flaggschiffmodell von Anthropic, entwickelt für komplexe Aufgaben und unternehmensweite Anwendungen."
   },
   "anthropic/claude-opus-4.1": {
-    "description": "Claude Opus 4.1 ist ein Plug-and-Play-Ersatz für Opus 4 und bietet herausragende Leistung und Präzision für praktische Codierungs- und Agentenaufgaben. Opus 4.1 hebt die modernste Codierungsleistung auf 74,5 % bei SWE-bench Verified und behandelt komplexe mehrstufige Probleme mit höherer Genauigkeit und Detailgenauigkeit."
+    "description": "Opus 4.1 ist ein High-End-Modell von Anthropic, optimiert für Programmierung, komplexe Schlussfolgerungen und dauerhafte Aufgaben."
   },
   "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."
+    "description": "Claude Sonnet 4 ist eine hybride Schlussfolgerungsversion von Anthropic, die sowohl kognitive als auch nicht-kognitive Fähigkeiten kombiniert."
   },
   "anthropic/claude-sonnet-4.5": {
-    "description": "Claude Sonnet 4.5 ist das bisher intelligenteste Modell von Anthropic."
+    "description": "Claude Sonnet 4.5 ist das neueste hybride Schlussfolgerungsmodell von Anthropic, optimiert für komplexe Logik und Programmierung."
   },
   "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."
@@ -758,6 +764,9 @@
   "baidu/ERNIE-4.5-300B-A47B": {
     "description": "ERNIE-4.5-300B-A47B ist ein von Baidu entwickeltes großes Sprachmodell, das auf einer Mixture-of-Experts (MoE)-Architektur basiert. Das Modell verfügt über insgesamt 300 Milliarden Parameter, aktiviert jedoch bei der Inferenz nur 47 Milliarden Parameter pro Token, was eine starke Leistung bei gleichzeitig hoher Rechen-effizienz gewährleistet. Als eines der Kernmodelle der ERNIE 4.5-Serie zeigt es herausragende Fähigkeiten in Textverständnis, -generierung, Schlussfolgerung und Programmierung. Das Modell verwendet eine innovative multimodale heterogene MoE-Vortrainingsmethode, die durch gemeinsames Training von Text- und visuellen Modalitäten die Gesamtleistung verbessert, insbesondere bei der Befolgung von Anweisungen und dem Erinnern von Weltwissen."
   },
+  "baidu/ernie-5.0-thinking-preview": {
+    "description": "ERNIE 5.0 Thinking Preview ist Baidus neue Generation eines nativen multimodalen Wenxin-Modells, spezialisiert auf multimodales Verständnis, Befolgen von Anweisungen, kreative Aufgaben, Faktenfragen und Tool-Nutzung."
+  },
   "c4ai-aya-expanse-32b": {
     "description": "Aya Expanse ist ein leistungsstarkes 32B mehrsprachiges Modell, das darauf abzielt, die Leistung von einsprachigen Modellen durch innovative Ansätze wie Anweisungsoptimierung, Datenarbitrage, Präferenztraining und Modellfusion herauszufordern. Es unterstützt 23 Sprachen."
   },
@@ -866,6 +875,9 @@
   "codex-mini-latest": {
     "description": "codex-mini-latest ist eine feinabgestimmte Version von o4-mini, speziell für Codex CLI entwickelt. Für die direkte Nutzung über die API empfehlen wir den Start mit gpt-4.1."
   },
+  "cogito-2.1:671b": {
+    "description": "Cogito v2.1 671B ist ein frei kommerziell nutzbares Open-Source-Sprachmodell aus den USA mit leistungsstarker Performance, hoher Token-Effizienz, 128k Kontextlänge und umfassenden Fähigkeiten."
+  },
   "cogview-4": {
     "description": "CogView-4 ist das erste von Zhipu entwickelte Open-Source-Text-zu-Bild-Modell, das die Generierung chinesischer Schriftzeichen unterstützt. Es bietet umfassende Verbesserungen in den Bereichen semantisches Verständnis, Bildgenerierungsqualität und die Fähigkeit, chinesische und englische Schriftzeichen zu erzeugen. Es unterstützt mehrsprachige Eingaben beliebiger Länge in Chinesisch und Englisch und kann Bilder in beliebiger Auflösung innerhalb eines vorgegebenen Bereichs erzeugen."
   },
@@ -1136,6 +1148,9 @@
   "deepseek-vl2-small": {
     "description": "DeepSeek VL2 Small, eine leichte multimodale Version, geeignet für ressourcenbeschränkte und hochparallele Szenarien."
   },
+  "deepseek/deepseek-chat": {
+    "description": "DeepSeek-V3 ist ein leistungsstarkes hybrides Schlussfolgerungsmodell des DeepSeek-Teams, geeignet für komplexe Aufgaben und Tool-Integration."
+  },
   "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."
   },
@@ -1143,19 +1158,19 @@
     "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."
   },
   "deepseek/deepseek-chat-v3.1": {
-    "description": "DeepSeek-V3.1 ist ein großes hybrides Inferenzmodell, das 128K langen Kontext und effizienten Moduswechsel unterstützt. Es erzielt herausragende Leistung und Geschwindigkeit bei Tool-Aufrufen, Codegenerierung und komplexen Inferenzaufgaben."
+    "description": "DeepSeek-V3.1 ist ein hybrides Schlussfolgerungsmodell mit langem Kontext von DeepSeek, das sowohl kognitive als auch nicht-kognitive Modi sowie Tool-Integration unterstützt."
   },
   "deepseek/deepseek-r1": {
     "description": "Das DeepSeek R1 Modell wurde in einer kleinen Version aktualisiert, aktuell DeepSeek-R1-0528. Das neueste Update verbessert die Inferenztiefe und -fähigkeit erheblich durch erhöhte Rechenressourcen und nachträgliche algorithmische Optimierungen. Das Modell zeigt hervorragende Leistungen in Mathematik, Programmierung und allgemeiner Logik und nähert sich führenden Modellen wie O3 und Gemini 2.5 Pro an."
   },
   "deepseek/deepseek-r1-0528": {
-    "description": "DeepSeek-R1 verbessert die Modellschlussfolgerungsfähigkeit erheblich, selbst bei sehr begrenzten annotierten Daten. Vor der Ausgabe der endgültigen Antwort generiert das Modell eine Denkprozesskette, um die Genauigkeit der Antwort zu erhöhen."
+    "description": "DeepSeek R1 0528 ist eine aktualisierte Variante von DeepSeek mit Fokus auf Open-Source-Nutzung und tiefgreifender Schlussfolgerung."
   },
   "deepseek/deepseek-r1-0528:free": {
     "description": "DeepSeek-R1 verbessert die Modellschlussfolgerungsfähigkeit erheblich, selbst bei sehr begrenzten annotierten Daten. Vor der Ausgabe der endgültigen Antwort generiert das Modell eine Denkprozesskette, um die Genauigkeit der Antwort zu erhöhen."
   },
   "deepseek/deepseek-r1-distill-llama-70b": {
-    "description": "DeepSeek-R1-Distill-Llama-70B ist eine destillierte, effizientere Variante des 70B Llama Modells. Es behält starke Leistung bei Textgenerierungsaufgaben bei und reduziert den Rechenaufwand für einfachere Bereitstellung und Forschung. Betrieben von Groq mit deren maßgeschneiderter Language Processing Unit (LPU) Hardware für schnelle und effiziente Inferenz."
+    "description": "DeepSeek R1 Distill Llama 70B ist ein großes Sprachmodell auf Basis von Llama3.3 70B. Durch Feintuning mit den Ausgaben von DeepSeek R1 erreicht es eine konkurrenzfähige Leistung, die mit führenden Großmodellen vergleichbar ist."
   },
   "deepseek/deepseek-r1-distill-llama-8b": {
     "description": "DeepSeek R1 Distill Llama 8B ist ein distilliertes großes Sprachmodell, das auf Llama-3.1-8B-Instruct basiert und durch Training mit den Ausgaben von DeepSeek R1 erstellt wurde."
@@ -1172,6 +1187,9 @@
   "deepseek/deepseek-r1:free": {
     "description": "DeepSeek-R1 hat die Schlussfolgerungsfähigkeiten des Modells erheblich verbessert, selbst bei nur wenigen gekennzeichneten Daten. Bevor das Modell die endgültige Antwort ausgibt, gibt es zunächst eine Denkprozesskette aus, um die Genauigkeit der endgültigen Antwort zu erhöhen."
   },
+  "deepseek/deepseek-reasoner": {
+    "description": "DeepSeek-V3 Thinking (Reasoner) ist ein experimentelles Modell von DeepSeek für hochkomplexe Schlussfolgerungsaufgaben."
+  },
   "deepseek/deepseek-v3": {
     "description": "Schnelles, universelles großes Sprachmodell mit verbesserter Inferenzfähigkeit."
   },
@@ -1478,9 +1496,6 @@
   "gemini-2.0-flash-lite-001": {
     "description": "Gemini 2.0 Flash ist eine Modellvariante, die auf Kosteneffizienz und niedrige Latenz optimiert ist."
   },
-  "gemini-2.0-flash-preview-image-generation": {
-    "description": "Gemini 2.0 Flash Vorschau-Modell, unterstützt die Bildgenerierung"
-  },
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash ist Googles kosteneffizientestes Modell und bietet umfassende Funktionen."
   },
@@ -1508,9 +1523,6 @@
   "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"
   },
@@ -1526,6 +1538,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview ist Googles fortschrittlichstes Denkmodell, das komplexe Probleme in den Bereichen Code, Mathematik und MINT-Fächer lösen kann und große Datensätze, Codebasen und Dokumente mit langem Kontext analysiert."
   },
+  "gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) ist ein Bildgenerierungsmodell von Google mit Unterstützung für multimodale Dialoge."
+  },
+  "gemini-3-pro-image-preview:image": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) ist ein Bildgenerierungsmodell von Google mit Unterstützung für multimodale Dialoge."
+  },
+  "gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro ist das weltweit führende Modell für multimodales Verständnis und Googles bisher leistungsstärkstes Agenten- und Ambient-Programming-Modell mit fortschrittlicher Logik, visueller Darstellung und Interaktivität."
+  },
   "gemini-flash-latest": {
     "description": "Neueste Version von Gemini Flash"
   },
@@ -1650,7 +1671,7 @@
     "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."
   },
   "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."
+    "description": "Gemini 2.0 Flash ist ein leistungsstarkes Schlussfolgerungsmodell von Google, geeignet für erweiterte multimodale Aufgaben."
   },
   "google/gemini-2.0-flash-001": {
     "description": "Gemini 2.0 Flash bietet nächste Generation Funktionen und Verbesserungen, einschließlich außergewöhnlicher Geschwindigkeit, nativer Werkzeugnutzung, multimodaler Generierung und einem Kontextfenster von 1M Tokens."
@@ -1661,14 +1682,23 @@
   "google/gemini-2.0-flash-lite": {
     "description": "Gemini 2.0 Flash Lite bietet Funktionen der nächsten Generation und Verbesserungen, darunter herausragende Geschwindigkeit, integrierte Werkzeugnutzung, multimodale Generierung und ein Kontextfenster von 1 Million Tokens."
   },
+  "google/gemini-2.0-flash-lite-001": {
+    "description": "Gemini 2.0 Flash Lite ist die leichte Version der Gemini-Familie. Standardmäßig ist das Denken deaktiviert, um Latenz und Kosten zu optimieren, kann aber über Parameter aktiviert werden."
+  },
   "google/gemini-2.5-flash": {
-    "description": "Gemini 2.5 Flash ist ein Denkmodell mit hervorragenden umfassenden Fähigkeiten. Es ist auf ein ausgewogenes Verhältnis von Preis und Leistung ausgelegt und unterstützt multimodale Eingaben sowie ein Kontextfenster von 1 Million Tokens."
+    "description": "Die Gemini 2.5 Flash-Serie (Lite/Pro/Flash) umfasst Googles Modelle mit niedriger bis hoher Latenz für leistungsstarke Schlussfolgerung."
+  },
+  "google/gemini-2.5-flash-image": {
+    "description": "Gemini 2.5 Flash Image (Nano Banana) ist Googles Bildgenerierungsmodell mit Unterstützung für multimodale Dialoge."
+  },
+  "google/gemini-2.5-flash-image-free": {
+    "description": "Kostenlose Version von Gemini 2.5 Flash Image mit begrenztem Kontingent für multimodale Generierung."
   },
   "google/gemini-2.5-flash-image-preview": {
     "description": "Gemini 2.5 Flash Experimentelles Modell, unterstützt Bildgenerierung"
   },
   "google/gemini-2.5-flash-lite": {
-    "description": "Gemini 2.5 Flash-Lite ist ein ausgewogenes, latenzarmes Modell mit konfigurierbarem Denkbudget und Werkzeuganbindung (z. B. Google Search Grounding und Codeausführung). Es unterstützt multimodale Eingaben und bietet ein Kontextfenster von 1 Million Tokens."
+    "description": "Gemini 2.5 Flash Lite ist die leichte Version von Gemini 2.5, optimiert für niedrige Latenz und Kosten – ideal für Szenarien mit hohem Durchsatz."
   },
   "google/gemini-2.5-flash-preview": {
     "description": "Gemini 2.5 Flash ist Googles fortschrittlichstes Hauptmodell, das für fortgeschrittenes Denken, Codierung, Mathematik und wissenschaftliche Aufgaben entwickelt wurde. Es enthält die eingebaute Fähigkeit zu \"denken\", was es ihm ermöglicht, Antworten mit höherer Genauigkeit und detaillierter Kontextverarbeitung zu liefern.\n\nHinweis: Dieses Modell hat zwei Varianten: Denken und Nicht-Denken. Die Ausgabepreise variieren erheblich, je nachdem, ob die Denkfähigkeit aktiviert ist oder nicht. Wenn Sie die Standardvariante (ohne den Suffix \":thinking\") wählen, wird das Modell ausdrücklich vermeiden, Denk-Tokens zu generieren.\n\nUm die Denkfähigkeit zu nutzen und Denk-Tokens zu erhalten, müssen Sie die \":thinking\"-Variante wählen, was zu höheren Preisen für Denk-Ausgaben führt.\n\nDarüber hinaus kann Gemini 2.5 Flash über den Parameter \"maximale Tokenanzahl für das Denken\" konfiguriert werden, wie in der Dokumentation beschrieben (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
@@ -1677,11 +1707,26 @@
     "description": "Gemini 2.5 Flash ist Googles fortschrittlichstes Hauptmodell, das für fortgeschrittenes Denken, Codierung, Mathematik und wissenschaftliche Aufgaben entwickelt wurde. Es enthält die eingebaute Fähigkeit zu \"denken\", was es ihm ermöglicht, Antworten mit höherer Genauigkeit und detaillierter Kontextverarbeitung zu liefern.\n\nHinweis: Dieses Modell hat zwei Varianten: Denken und Nicht-Denken. Die Ausgabepreise variieren erheblich, je nachdem, ob die Denkfähigkeit aktiviert ist oder nicht. Wenn Sie die Standardvariante (ohne den Suffix \":thinking\") wählen, wird das Modell ausdrücklich vermeiden, Denk-Tokens zu generieren.\n\nUm die Denkfähigkeit zu nutzen und Denk-Tokens zu erhalten, müssen Sie die \":thinking\"-Variante wählen, was zu höheren Preisen für Denk-Ausgaben führt.\n\nDarüber hinaus kann Gemini 2.5 Flash über den Parameter \"maximale Tokenanzahl für das Denken\" konfiguriert werden, wie in der Dokumentation beschrieben (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
   },
   "google/gemini-2.5-pro": {
-    "description": "Gemini 2.5 Pro ist unser fortschrittlichstes Inferenz-Gemini-Modell, das komplexe Probleme lösen kann. Es verfügt über ein Kontextfenster von 2 Millionen Tokens und unterstützt multimodale Eingaben, darunter Text, Bilder, Audio, Video und PDF-Dokumente."
+    "description": "Gemini 2.5 Pro ist Googles Flaggschiffmodell für Schlussfolgerung mit Unterstützung für lange Kontexte und komplexe Aufgaben."
+  },
+  "google/gemini-2.5-pro-free": {
+    "description": "Kostenlose Version von Gemini 2.5 Pro mit begrenztem Kontingent für multimodale Langkontextverarbeitung – ideal für Tests und leichte Workflows."
   },
   "google/gemini-2.5-pro-preview": {
     "description": "Gemini 2.5 Pro Preview ist Googles fortschrittlichstes Denkmodell, das in der Lage ist, komplexe Probleme in den Bereichen Code, Mathematik und MINT zu analysieren sowie große Datensätze, Codebasen und Dokumente mit langem Kontext zu untersuchen."
   },
+  "google/gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) ist ein von Google entwickeltes Bildgenerierungsmodell, das gleichzeitig multimodale Dialoge unterstützt."
+  },
+  "google/gemini-3-pro-image-preview-free": {
+    "description": "Kostenlose Vorschauversion von Gemini 3 Pro Image mit begrenztem Kontingent für multimodale Generierung."
+  },
+  "google/gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro ist das nächste Generation-Modell der Gemini-Reihe für multimodale Schlussfolgerung. Es versteht Text, Audio, Bilder und Videos und bewältigt komplexe Aufgaben und große Codebasen."
+  },
+  "google/gemini-3-pro-preview-free": {
+    "description": "Kostenlose Vorschauversion von Gemini 3 Pro mit denselben multimodalen Fähigkeiten wie die Standardversion, jedoch mit Einschränkungen bei Kontingent und Geschwindigkeit – ideal für Tests und gelegentliche Nutzung."
+  },
   "google/gemini-embedding-001": {
     "description": "Modernstes Einbettungsmodell mit hervorragender Leistung bei englischen, mehrsprachigen und Code-Aufgaben."
   },
@@ -1907,6 +1952,12 @@
   "grok-4-0709": {
     "description": "xAI's Grok 4 mit starker Schlussfolgerungsfähigkeit."
   },
+  "grok-4-1-fast-non-reasoning": {
+    "description": "Modernes multimodales Modell, speziell optimiert für die Nutzung leistungsstarker Agenten-Tools."
+  },
+  "grok-4-1-fast-reasoning": {
+    "description": "Modernes multimodales Modell, speziell optimiert für die Nutzung leistungsstarker Agenten-Tools."
+  },
   "grok-4-fast-non-reasoning": {
     "description": "Wir freuen uns, Grok 4 Fast vorzustellen, unseren neuesten Fortschritt bei kosteneffizienten Inferenzmodellen."
   },
@@ -2051,21 +2102,36 @@
   "inception/mercury-coder-small": {
     "description": "Mercury Coder Small ist ideal für Codegenerierung, Debugging und Refactoring-Aufgaben mit minimaler Latenz."
   },
-  "inclusionAI/Ling-1T": {
-    "description": "Ling-1T ist das erste Flaggschiffmodell der „Ling 2.0“-Reihe ohne Denkfunktion (non-thinking), mit insgesamt einer Billion Parametern und etwa 50 Milliarden aktiven Parametern pro Token. Es basiert auf der Ling 2.0-Architektur und zielt darauf ab, die Grenzen effizienter Schlussfolgerung und skalierbarer Kognition zu durchbrechen. Ling-1T-base wurde mit über 20 Billionen hochwertigen, reasoning-intensiven Tokens trainiert."
-  },
   "inclusionAI/Ling-flash-2.0": {
     "description": "Ling-flash-2.0 ist das dritte Modell der Ling 2.0 Architekturserie, veröffentlicht vom Ant Group Bailing Team. Es handelt sich um ein Mixture-of-Experts (MoE)-Modell mit insgesamt 100 Milliarden Parametern, wobei pro Token nur 6,1 Milliarden Parameter aktiviert werden (ohne Wortvektoren 4,8 Milliarden). Als leichtgewichtige Konfiguration zeigt Ling-flash-2.0 in mehreren renommierten Benchmarks Leistungen, die mit 40-Milliarden-Dense-Modellen und größeren MoE-Modellen vergleichbar oder überlegen sind. Das Modell zielt darauf ab, durch exzellentes Architekturdesign und Trainingsstrategien effiziente Wege zu erforschen, um die gängige Annahme „großes Modell = viele Parameter“ zu hinterfragen."
   },
   "inclusionAI/Ling-mini-2.0": {
     "description": "Ling-mini-2.0 ist ein kleines, leistungsstarkes Sprachmodell basierend auf der MoE-Architektur. Es verfügt über 16 Milliarden Gesamtparameter, aktiviert jedoch pro Token nur 1,4 Milliarden (ohne Einbettungen 789 Millionen), was eine sehr hohe Generierungsgeschwindigkeit ermöglicht. Dank effizientem MoE-Design und großem, hochwertigem Trainingsdatensatz zeigt Ling-mini-2.0 trotz der geringen aktivierten Parameter eine Spitzenleistung, die mit dichten LLMs unter 10 Milliarden und größeren MoE-Modellen in nachgelagerten Aufgaben vergleichbar ist."
   },
-  "inclusionAI/Ring-1T": {
-    "description": "Ring-1T ist ein Open-Source-Modell für kognitives Denken im Billionen-Parameter-Maßstab, veröffentlicht vom Bailing-Team. Es basiert auf der Ling 2.0-Architektur und dem Ling-1T-base-Modell, mit insgesamt einer Billion Parametern und 50 Milliarden aktiven Parametern. Es unterstützt ein Kontextfenster von bis zu 128K und wurde durch groß angelegtes, verifizierbares, belohnungsbasiertes Reinforcement Learning optimiert."
-  },
   "inclusionAI/Ring-flash-2.0": {
     "description": "Ring-flash-2.0 ist ein hochleistungsfähiges Denkmodell, das auf Ling-flash-2.0-base tief optimiert wurde. Es verwendet eine Mixture-of-Experts (MoE)-Architektur mit insgesamt 100 Milliarden Parametern, aktiviert jedoch bei jeder Inferenz nur 6,1 Milliarden Parameter. Durch den innovativen Icepop-Algorithmus löst es die Instabilitätsprobleme großer MoE-Modelle im Reinforcement Learning (RL) Training und verbessert kontinuierlich seine komplexen Inferenzfähigkeiten über lange Trainingszyklen. Ring-flash-2.0 erzielt bedeutende Durchbrüche in anspruchsvollen Benchmarks wie Mathematikwettbewerben, Codegenerierung und logischem Schließen. Seine Leistung übertrifft nicht nur dichte Spitzenmodelle unter 40 Milliarden Parametern, sondern ist auch vergleichbar mit größeren Open-Source-MoE-Modellen und proprietären Hochleistungs-Denkmodellen. Obwohl es auf komplexe Inferenz spezialisiert ist, zeigt es auch bei kreativen Schreibaufgaben hervorragende Ergebnisse. Dank seiner effizienten Architektur bietet Ring-flash-2.0 starke Leistung bei gleichzeitig hoher Inferenzgeschwindigkeit und senkt deutlich die Bereitstellungskosten in hochparallelen Szenarien."
   },
+  "inclusionai/ling-1t": {
+    "description": "Ling-1T ist das 1T MoE-Modell von inclusionAI, optimiert für hochintensive Schlussfolgerungsaufgaben und große Kontexte."
+  },
+  "inclusionai/ling-flash-2.0": {
+    "description": "Ling-flash-2.0 ist ein MoE-Modell von inclusionAI, das Effizienz und Schlussfolgerungsleistung für mittelgroße bis große Aufgaben optimiert."
+  },
+  "inclusionai/ling-mini-2.0": {
+    "description": "Ling-mini-2.0 ist ein leichtgewichtiges MoE-Modell von inclusionAI, das bei reduzierten Kosten dennoch starke Schlussfolgerungsfähigkeiten bietet."
+  },
+  "inclusionai/ming-flash-omini-preview": {
+    "description": "Ming-flash-omni Preview ist ein multimodales Modell von inclusionAI mit Unterstützung für Sprache, Bilder und Videos – optimiert für Bildwiedergabe und Spracherkennung."
+  },
+  "inclusionai/ring-1t": {
+    "description": "Ring-1T ist das trillionenparametrige MoE-Denkmodell von inclusionAI, geeignet für groß angelegte Schlussfolgerung und Forschung."
+  },
+  "inclusionai/ring-flash-2.0": {
+    "description": "Ring-flash-2.0 ist eine Variante des Ring-Modells von inclusionAI für Szenarien mit hohem Durchsatz, mit Fokus auf Geschwindigkeit und Kosteneffizienz."
+  },
+  "inclusionai/ring-mini-2.0": {
+    "description": "Ring-mini-2.0 ist die leichtgewichtige Hochdurchsatzversion des MoE-Modells von inclusionAI, ideal für parallele Nutzungsszenarien."
+  },
   "internlm/internlm2_5-7b-chat": {
     "description": "InternLM2.5 bietet intelligente Dialoglösungen in mehreren Szenarien."
   },
@@ -2117,6 +2183,12 @@
   "kimi-k2-instruct": {
     "description": "Kimi K2 Instruct, das offizielle Inferenzmodell von Kimi mit Unterstützung für Langkontext, Code, QA und mehr."
   },
+  "kimi-k2-thinking": {
+    "description": "K2 ist ein Langzeit-Denkmodell mit Unterstützung für 256k Kontext, mehrstufige Tool-Nutzung und komplexe Problemlösung."
+  },
+  "kimi-k2-thinking-turbo": {
+    "description": "Turbo-Version des K2 Langzeit-Denkmodells mit 256k Kontext, spezialisiert auf tiefgreifende Schlussfolgerung und einer Ausgabegeschwindigkeit von 60–100 Tokens pro Sekunde."
+  },
   "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."
   },
@@ -2129,6 +2201,9 @@
   "kimi-thinking-preview": {
     "description": "Das kimi-thinking-preview Modell von Moon’s Dark Side ist ein multimodales Denkmodell mit Fähigkeiten zu multimodalem und allgemeinem logischem Denken. Es ist spezialisiert auf tiefgehende Schlussfolgerungen und hilft dabei, komplexere und schwierigere Aufgaben zu lösen."
   },
+  "kuaishou/kat-coder-pro-v1": {
+    "description": "KAT-Coder-Pro-V1 (zeitlich begrenzt kostenlos) ist auf Codeverständnis und automatisierte Programmierung spezialisiert – ideal für effiziente Programmieragenten."
+  },
   "learnlm-1.5-pro-experimental": {
     "description": "LearnLM ist ein experimentelles, aufgabenorientiertes Sprachmodell, das darauf trainiert wurde, den Prinzipien der Lernwissenschaft zu entsprechen und in Lehr- und Lernszenarien systematische Anweisungen zu befolgen, als Expertenmentor zu fungieren usw."
   },
@@ -2225,6 +2300,9 @@
   "megrez-3b-instruct": {
     "description": "Megrez 3B Instruct ist ein effizientes Modell mit geringer Parameteranzahl, entwickelt von Wuwen Xinqiong."
   },
+  "meituan/longcat-flash-chat": {
+    "description": "Ein von Meituan entwickeltes Open-Source-Basismodell, das speziell für dialogorientierte Interaktionen und agentenbasierte Aufgaben optimiert wurde und sich besonders bei Werkzeugaufrufen und komplexen mehrstufigen Dialogszenarien auszeichnet."
+  },
   "meta-llama-3-70b-instruct": {
     "description": "Ein leistungsstarkes Modell mit 70 Milliarden Parametern, das in den Bereichen Schlussfolgerungen, Programmierung und breiten Sprachanwendungen herausragt."
   },
@@ -2456,6 +2534,12 @@
   "minimax-m2": {
     "description": "MiniMax M2 ist ein leistungsstarkes, effizientes Sprachmodell, das speziell für Programmier- und Agenten-Workflows entwickelt wurde."
   },
+  "minimax/minimax-m2": {
+    "description": "MiniMax-M2 ist ein kosteneffizientes Modell mit starker Leistung in den Bereichen Programmierung und Agentenaufgaben – geeignet für vielfältige technische Szenarien."
+  },
+  "minimaxai/minimax-m2": {
+    "description": "MiniMax-M2 ist ein kompaktes, schnelles und kosteneffizientes Mixture-of-Experts (MoE)-Modell mit 230 Milliarden Gesamtparametern und 10 Milliarden aktiven Parametern. Es wurde für höchste Leistung bei Codierungs- und Agentenaufgaben entwickelt und bietet gleichzeitig eine starke allgemeine Intelligenz. Das Modell überzeugt bei Aufgaben wie der Bearbeitung mehrerer Dateien, dem Code-Ausführen-Fehlerbeheben-Zyklus, Testverifikation und -korrektur sowie bei komplexen, lang verknüpften Toolchains – und ist damit die ideale Wahl für Entwickler-Workflows."
+  },
   "ministral-3b-latest": {
     "description": "Ministral 3B ist das weltbeste Edge-Modell von Mistral."
   },
@@ -2600,12 +2684,21 @@
   "moonshotai/kimi-k2": {
     "description": "Kimi K2 ist ein von Moonshot AI entwickeltes großes gemischtes Experten (MoE) Sprachmodell mit insgesamt 1 Billion Parametern und 32 Milliarden aktiven Parametern pro Vorwärtsdurchlauf. Es ist auf Agentenfähigkeiten optimiert, einschließlich fortgeschrittener Werkzeugnutzung, Inferenz und Code-Synthese."
   },
+  "moonshotai/kimi-k2-0711": {
+    "description": "Kimi K2 0711 ist die Instruct-Version der Kimi-Reihe, optimiert für hochwertige Codegenerierung und Tool-Nutzung."
+  },
   "moonshotai/kimi-k2-0905": {
-    "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."
+    "description": "Kimi K2 0905 ist das Update vom 5. September der Kimi-Reihe mit erweitertem Kontext und verbesserter Schlussfolgerungsleistung – ideal für Programmieraufgaben."
   },
   "moonshotai/kimi-k2-instruct-0905": {
     "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."
   },
+  "moonshotai/kimi-k2-thinking": {
+    "description": "Kimi K2 Thinking ist ein Denkmodell von Moonshot, optimiert für tiefgreifende Schlussfolgerung mit allgemeinen Agentenfähigkeiten."
+  },
+  "moonshotai/kimi-k2-thinking-turbo": {
+    "description": "Kimi K2 Thinking Turbo ist die Hochgeschwindigkeitsversion von Kimi K2 Thinking mit reduzierter Antwortlatenz bei gleichbleibender Schlussfolgerungsleistung."
+  },
   "morph/morph-v3-fast": {
     "description": "Morph bietet ein spezialisiertes KI-Modell, das von führenden Modellen wie Claude oder GPT-4o vorgeschlagene Codeänderungen schnell auf Ihre bestehenden Code-Dateien anwendet – mit über 4500 Tokens pro Sekunde. Es fungiert als letzter Schritt im KI-Codierungsworkflow und unterstützt 16k Eingabe- und 16k Ausgabe-Tokens."
   },
@@ -2688,28 +2781,49 @@
     "description": "OpenAIs gpt-4-turbo verfügt über umfangreiches Allgemeinwissen und Fachkenntnisse, kann komplexen natürlichen Sprachbefehlen folgen und schwierige Probleme präzise lösen. Wissensstand bis April 2023, Kontextfenster von 128.000 Tokens."
   },
   "openai/gpt-4.1": {
-    "description": "GPT 4.1 ist das Flaggschiffmodell von OpenAI, geeignet für komplexe Aufgaben. Es ist hervorragend für interdisziplinäre Problemlösungen."
+    "description": "Die GPT-4.1-Serie bietet erweiterten Kontext und verbesserte Fähigkeiten in den Bereichen Technik und Schlussfolgerung."
   },
   "openai/gpt-4.1-mini": {
-    "description": "GPT 4.1 mini bietet eine ausgewogene Kombination aus Intelligenz, Geschwindigkeit und Kosten und ist damit für viele Anwendungsfälle attraktiv."
+    "description": "GPT-4.1 Mini bietet geringere Latenz und ein besseres Preis-Leistungs-Verhältnis – ideal für mittellange Kontexte."
   },
   "openai/gpt-4.1-nano": {
-    "description": "GPT-4.1 nano ist das schnellste und kosteneffizienteste Modell der GPT 4.1 Reihe."
+    "description": "GPT-4.1 Nano ist eine extrem kostengünstige und latenzarme Option – ideal für häufige Kurzdialoge oder Klassifizierungsaufgaben."
   },
   "openai/gpt-4o": {
-    "description": "GPT-4o von OpenAI verfügt über umfangreiches Allgemeinwissen und Fachkenntnisse, kann komplexen natürlichen Sprachbefehlen folgen und schwierige Probleme präzise lösen. Es bietet die Leistung von GPT-4 Turbo mit schnellerem und kostengünstigerem API-Zugriff."
+    "description": "Die GPT-4o-Serie ist OpenAIs Omni-Modell mit Unterstützung für Text- und Bildeingaben sowie Textausgaben."
   },
   "openai/gpt-4o-mini": {
-    "description": "GPT-4o mini von OpenAI ist ihr fortschrittlichstes und kosteneffizientestes kleines Modell. Es ist multimodal (akzeptiert Text- oder Bildeingaben und gibt Text aus) und intelligenter als gpt-3.5-turbo, bei gleicher Geschwindigkeit."
+    "description": "GPT-4o-mini ist die schnelle, kompakte Version von GPT-4o – ideal für latenzarme multimodale Szenarien."
   },
   "openai/gpt-5": {
-    "description": "GPT-5 ist OpenAIs Flaggschiff-Sprachmodell mit herausragender Leistung bei komplexer Inferenz, umfangreichem Weltwissen, codeintensiven und mehrstufigen Agentenaufgaben."
+    "description": "GPT-5 ist ein leistungsstarkes Modell von OpenAI, geeignet für eine Vielzahl von Produktions- und Forschungsaufgaben."
+  },
+  "openai/gpt-5-chat": {
+    "description": "GPT-5 Chat ist eine auf Konversation optimierte Variante von GPT-5 mit reduzierter Latenz für bessere Interaktion."
+  },
+  "openai/gpt-5-codex": {
+    "description": "GPT-5-Codex ist eine auf Programmierung spezialisierte Variante von GPT-5 – ideal für groß angelegte Code-Workflows."
   },
   "openai/gpt-5-mini": {
-    "description": "GPT-5 mini ist ein kostenoptimiertes Modell mit hervorragender Leistung bei Inferenz- und Chat-Aufgaben. Es bietet die beste Balance zwischen Geschwindigkeit, Kosten und Fähigkeiten."
+    "description": "GPT-5 Mini ist die kompakte Version der GPT-5-Familie – ideal für latenz- und kostensensitive Szenarien."
   },
   "openai/gpt-5-nano": {
-    "description": "GPT-5 nano ist ein Modell mit hohem Durchsatz, das bei einfachen Anweisungen oder Klassifizierungsaufgaben hervorragende Leistungen zeigt."
+    "description": "GPT-5 Nano ist die ultrakompakte Version der Familie – ideal für Szenarien mit extrem hohen Anforderungen an Kosten und Latenz."
+  },
+  "openai/gpt-5-pro": {
+    "description": "GPT-5 Pro ist das Flaggschiffmodell von OpenAI mit erweiterten Fähigkeiten in Schlussfolgerung, Codegenerierung und Unternehmensfunktionen – inklusive Routing und strenger Sicherheitsrichtlinien im Testmodus."
+  },
+  "openai/gpt-5.1": {
+    "description": "GPT-5.1 ist das neueste Flaggschiff der GPT-5-Serie mit deutlichen Verbesserungen in allgemeiner Schlussfolgerung, Befolgen von Anweisungen und natürlicher Konversation – geeignet für vielfältige Aufgaben."
+  },
+  "openai/gpt-5.1-chat": {
+    "description": "GPT-5.1 Chat ist das leichte Mitglied der GPT-5.1-Familie, optimiert für latenzarme Konversation bei gleichzeitig starker Schlussfolgerung und Befehlsausführung."
+  },
+  "openai/gpt-5.1-codex": {
+    "description": "GPT-5.1-Codex ist eine auf Softwareentwicklung und Programmier-Workflows spezialisierte Variante von GPT-5.1 – ideal für große Refactorings, komplexe Debugging-Aufgaben und langfristige autonome Codierung."
+  },
+  "openai/gpt-5.1-codex-mini": {
+    "description": "GPT-5.1-Codex-Mini ist die kompakte, beschleunigte Version von GPT-5.1-Codex – ideal für kostensensitive und latenzarme Programmieraufgaben."
   },
   "openai/gpt-oss-120b": {
     "description": "Extrem leistungsfähiges universelles großes Sprachmodell mit starker, kontrollierbarer Inferenzfähigkeit."
@@ -2736,7 +2850,7 @@
     "description": "o3-mini high ist eine hochintelligente Version mit dem gleichen Kosten- und Verzögerungsziel wie o1-mini."
   },
   "openai/o4-mini": {
-    "description": "OpenAIs o4-mini bietet schnelle, kosteneffiziente Inferenz mit hervorragender Leistung für seine Größe, insbesondere bei Mathematik (beste Leistung im AIME-Benchmark), Codierung und visuellen Aufgaben."
+    "description": "OpenAI o4-mini ist ein kleines, effizientes Schlussfolgerungsmodell von OpenAI – ideal für latenzarme Szenarien."
   },
   "openai/o4-mini-high": {
     "description": "o4-mini Hochleistungsmodell, optimiert für schnelle und effektive Inferenz, zeigt in Programmier- und visuellen Aufgaben eine hohe Effizienz und Leistung."
@@ -2940,7 +3054,7 @@
     "description": "Leistungsstarkes, mittelgroßes Codierungsmodell, das 32K Kontextlängen unterstützt und in der mehrsprachigen Programmierung versiert ist."
   },
   "qwen/qwen3-14b": {
-    "description": "Qwen3-14B ist ein kompaktes, 14,8 Milliarden Parameter umfassendes kausales Sprachmodell aus der Qwen3-Serie, das speziell für komplexe Inferenz und effiziente Dialoge entwickelt wurde. Es unterstützt den nahtlosen Wechsel zwischen dem \"Denk\"-Modus für Mathematik, Programmierung und logische Inferenz und dem \"Nicht-Denk\"-Modus für allgemeine Gespräche. Dieses Modell wurde feinabgestimmt und kann für die Befolgung von Anweisungen, die Nutzung von Agentenwerkzeugen, kreatives Schreiben sowie mehrsprachige Aufgaben in über 100 Sprachen und Dialekten verwendet werden. Es verarbeitet nativ 32K Token-Kontext und kann mithilfe von YaRN auf 131K Token erweitert werden."
+    "description": "Qwen3-14B ist die 14B-Version der Qwen-Reihe – geeignet für allgemeine Schlussfolgerung und Konversation."
   },
   "qwen/qwen3-14b:free": {
     "description": "Qwen3-14B ist ein kompaktes, 14,8 Milliarden Parameter umfassendes kausales Sprachmodell aus der Qwen3-Serie, das speziell für komplexe Inferenz und effiziente Dialoge entwickelt wurde. Es unterstützt den nahtlosen Wechsel zwischen dem \"Denk\"-Modus für Mathematik, Programmierung und logische Inferenz und dem \"Nicht-Denk\"-Modus für allgemeine Gespräche. Dieses Modell wurde feinabgestimmt und kann für die Befolgung von Anweisungen, die Nutzung von Agentenwerkzeugen, kreatives Schreiben sowie mehrsprachige Aufgaben in über 100 Sprachen und Dialekten verwendet werden. Es verarbeitet nativ 32K Token-Kontext und kann mithilfe von YaRN auf 131K Token erweitert werden."
@@ -2948,6 +3062,12 @@
   "qwen/qwen3-235b-a22b": {
     "description": "Qwen3-235B-A22B ist ein 235B Parameter Expertenmischungsmodell (MoE), das von Qwen entwickelt wurde und bei jedem Vorwärtsdurchlauf 22B Parameter aktiviert. Es unterstützt den nahtlosen Wechsel zwischen dem \"Denk\"-Modus für komplexe Inferenz, Mathematik und Programmieraufgaben und dem \"Nicht-Denk\"-Modus für allgemeine Gespräche. Dieses Modell zeigt starke Inferenzfähigkeiten, mehrsprachige Unterstützung (über 100 Sprachen und Dialekte), fortgeschrittene Befolgung von Anweisungen und die Nutzung von Agentenwerkzeugen. Es verarbeitet nativ ein Kontextfenster von 32K Token und kann mithilfe von YaRN auf 131K Token erweitert werden."
   },
+  "qwen/qwen3-235b-a22b-2507": {
+    "description": "Qwen3-235B-A22B-Instruct-2507 ist die Instruct-Version der Qwen3-Reihe – geeignet für mehrsprachige Anweisungen und Langkontextverarbeitung."
+  },
+  "qwen/qwen3-235b-a22b-thinking-2507": {
+    "description": "Qwen3-235B-A22B-Thinking-2507 ist die Thinking-Variante von Qwen3 – verstärkt für komplexe mathematische und logische Aufgaben."
+  },
   "qwen/qwen3-235b-a22b:free": {
     "description": "Qwen3-235B-A22B ist ein 235B Parameter Expertenmischungsmodell (MoE), das von Qwen entwickelt wurde und bei jedem Vorwärtsdurchlauf 22B Parameter aktiviert. Es unterstützt den nahtlosen Wechsel zwischen dem \"Denk\"-Modus für komplexe Inferenz, Mathematik und Programmieraufgaben und dem \"Nicht-Denk\"-Modus für allgemeine Gespräche. Dieses Modell zeigt starke Inferenzfähigkeiten, mehrsprachige Unterstützung (über 100 Sprachen und Dialekte), fortgeschrittene Befolgung von Anweisungen und die Nutzung von Agentenwerkzeugen. Es verarbeitet nativ ein Kontextfenster von 32K Token und kann mithilfe von YaRN auf 131K Token erweitert werden."
   },
@@ -2966,6 +3086,21 @@
   "qwen/qwen3-8b:free": {
     "description": "Qwen3-8B ist ein kompaktes, 8,2 Milliarden Parameter umfassendes kausales Sprachmodell aus der Qwen3-Serie, das speziell für inferenzintensive Aufgaben und effiziente Dialoge entwickelt wurde. Es unterstützt den nahtlosen Wechsel zwischen dem \"Denk\"-Modus für Mathematik, Programmierung und logische Inferenz und dem \"Nicht-Denk\"-Modus für allgemeine Gespräche. Dieses Modell wurde feinabgestimmt und kann für die Befolgung von Anweisungen, die Integration von Agenten, kreatives Schreiben sowie die mehrsprachige Nutzung in über 100 Sprachen und Dialekten verwendet werden. Es unterstützt nativ ein Kontextfenster von 32K Token und kann über YaRN auf 131K Token erweitert werden."
   },
+  "qwen/qwen3-coder": {
+    "description": "Qwen3-Coder ist die Codegenerierungsfamilie von Qwen3 – spezialisiert auf Codeverständnis und -erzeugung in langen Dokumenten."
+  },
+  "qwen/qwen3-coder-plus": {
+    "description": "Qwen3-Coder-Plus ist ein speziell optimiertes Codierungsmodell der Qwen-Reihe – unterstützt komplexe Tool-Nutzung und langfristige Sitzungen."
+  },
+  "qwen/qwen3-max": {
+    "description": "Qwen3 Max ist das High-End-Schlussfolgerungsmodell der Qwen3-Reihe – geeignet für mehrsprachige Logik und Tool-Integration."
+  },
+  "qwen/qwen3-max-preview": {
+    "description": "Qwen3 Max (Preview) ist die Vorschauversion des Max-Modells der Qwen-Reihe – ausgelegt für fortgeschrittene Logik und Tool-Integration."
+  },
+  "qwen/qwen3-vl-plus": {
+    "description": "Qwen3 VL-Plus ist die visuell erweiterte Version von Qwen3 – mit verbesserter multimodaler Logik und Videobearbeitungsfähigkeiten."
+  },
   "qwen2": {
     "description": "Qwen2 ist das neue große Sprachmodell von Alibaba, das mit hervorragender Leistung eine Vielzahl von Anwendungsanforderungen unterstützt."
   },
@@ -3260,9 +3395,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."
   },
@@ -3344,6 +3476,9 @@
   "vercel/v0-1.5-md": {
     "description": "Zugriff auf das Modell hinter v0 zur Generierung, Reparatur und Optimierung moderner Webanwendungen mit frameworkspezifischer Inferenz und aktuellem Wissen."
   },
+  "volcengine/doubao-seed-code": {
+    "description": "Doubao-Seed-Code ist ein großes Modell der Byte Volcano Engine, optimiert für Agentic Programming – mit starker Leistung in Programmier- und Agentenbenchmarks und Unterstützung für 256K Kontext."
+  },
   "wan2.2-t2i-flash": {
     "description": "Wanxiang 2.2 Turbo-Version, das aktuell neueste Modell. Es bietet umfassende Verbesserungen in Kreativität, Stabilität und realistischer Textur, erzeugt schnell und bietet ein hervorragendes Preis-Leistungs-Verhältnis."
   },
@@ -3371,6 +3506,24 @@
   "wizardlm2:8x22b": {
     "description": "WizardLM 2 ist ein Sprachmodell von Microsoft AI, das in komplexen Dialogen, mehrsprachigen Anwendungen, Schlussfolgerungen und intelligenten Assistenten besonders gut abschneidet."
   },
+  "x-ai/grok-4": {
+    "description": "Grok 4 ist das Flaggschiffmodell von xAI mit leistungsstarker Logik und multimodalen Fähigkeiten."
+  },
+  "x-ai/grok-4-fast": {
+    "description": "Grok 4 Fast ist ein Modell von xAI mit hohem Durchsatz und niedrigen Kosten (unterstützt 2M Kontextfenster) – ideal für hochparallele und langkontextuelle Szenarien."
+  },
+  "x-ai/grok-4-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) ist ein multimodales Modell von xAI mit hohem Durchsatz und niedrigen Kosten (unterstützt 2M Kontextfenster), ausgelegt für latenz- und kostensensitive Szenarien ohne interne Schlussfolgerung. Die Reasoning-Funktion kann bei Bedarf über den API-Parameter aktiviert werden. Prompts und Completions können von xAI oder OpenRouter zur Verbesserung zukünftiger Modelle verwendet werden."
+  },
+  "x-ai/grok-4.1-fast": {
+    "description": "Grok 4 Fast ist ein Modell von xAI mit hohem Durchsatz und niedrigen Kosten (unterstützt 2M Kontextfenster) – ideal für hochparallele und langkontextuelle Szenarien."
+  },
+  "x-ai/grok-4.1-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) ist ein multimodales Modell von xAI mit hohem Durchsatz und niedrigen Kosten (unterstützt 2M Kontextfenster), ausgelegt für latenz- und kostensensitive Szenarien ohne interne Schlussfolgerung. Die Reasoning-Funktion kann bei Bedarf über den API-Parameter aktiviert werden. Prompts und Completions können von xAI oder OpenRouter zur Verbesserung zukünftiger Modelle verwendet werden."
+  },
+  "x-ai/grok-code-fast-1": {
+    "description": "Grok Code Fast 1 ist ein schnelles Codierungsmodell von xAI mit gut lesbarer und engineering-tauglicher Ausgabe."
+  },
   "x1": {
     "description": "Das Spark X1 Modell wird weiter verbessert und erreicht in allgemeinen Aufgaben wie Schlussfolgerungen, Textgenerierung und Sprachverständnis Ergebnisse, die mit OpenAI o1 und DeepSeek R1 vergleichbar sind, basierend auf der bereits führenden Leistung in mathematischen Aufgaben."
   },
@@ -3431,6 +3584,15 @@
   "yi-vision-v2": {
     "description": "Ein Modell für komplexe visuelle Aufgaben, das leistungsstarke Verständnis- und Analysefähigkeiten auf der Grundlage mehrerer Bilder bietet."
   },
+  "z-ai/glm-4.5": {
+    "description": "GLM 4.5 ist das Flaggschiffmodell von Z.AI mit Unterstützung für hybrides Schlussfolgern – optimiert für technische und langkontextuelle Aufgaben."
+  },
+  "z-ai/glm-4.5-air": {
+    "description": "GLM 4.5 Air ist die leichte Version von GLM 4.5 – ideal für kostensensitive Szenarien bei gleichbleibender Schlussfolgerungsleistung."
+  },
+  "z-ai/glm-4.6": {
+    "description": "GLM 4.6 ist das Flaggschiffmodell von Z.AI mit erweitertem Kontext und verbesserter Codierungsleistung."
+  },
   "zai-org/GLM-4.5": {
     "description": "GLM-4.5 ist ein speziell für Agentenanwendungen entwickeltes Basismodell mit Mixture-of-Experts-Architektur. Es ist tief optimiert für Werkzeugaufrufe, Web-Browsing, Softwareentwicklung und Frontend-Programmierung und unterstützt nahtlos die Integration in Code-Agenten wie Claude Code und Roo Code. GLM-4.5 verwendet einen hybriden Inferenzmodus und ist für komplexe Schlussfolgerungen sowie den Alltagsgebrauch geeignet."
   },
@@ -3451,5 +3613,8 @@
   },
   "zai/glm-4.5v": {
     "description": "GLM-4.5V basiert auf dem GLM-4.5-Air Basismodell, übernimmt bewährte Techniken von GLM-4.1V-Thinking und skaliert effektiv mit einer leistungsstarken MoE-Architektur mit 106 Milliarden Parametern."
+  },
+  "zenmux/auto": {
+    "description": "Die automatische Routing-Funktion von ZenMux wählt basierend auf deiner Anfrage automatisch das derzeit leistungsstärkste und kosteneffizienteste Modell aus den unterstützten Optionen aus."
   }
 }

locales/de-DE/plugin.json

@@ -1,4 +1,38 @@
 {
+  "builtins": {
+    "lobe-knowledge-base": {
+      "apiName": {
+        "readKnowledge": "Wissensdatenbank lesen",
+        "searchKnowledgeBase": "Wissensdatenbank durchsuchen"
+      },
+      "title": "Wissensdatenbank"
+    },
+    "lobe-local-system": {
+      "apiName": {
+        "editLocalFile": "Datei bearbeiten",
+        "getCommandOutput": "Codeausgabe abrufen",
+        "globLocalFiles": "Dateien durchsuchen",
+        "grepContent": "Inhalt durchsuchen",
+        "killCommand": "Codeausführung beenden",
+        "listLocalFiles": "Dateiliste anzeigen",
+        "moveLocalFiles": "Dateien verschieben",
+        "readLocalFile": "Dateiinhalt lesen",
+        "renameLocalFile": "Datei umbenennen",
+        "runCommand": "Code ausführen",
+        "searchLocalFiles": "Dateien suchen",
+        "writeLocalFile": "In Datei schreiben"
+      },
+      "title": "Lokales System"
+    },
+    "lobe-web-browsing": {
+      "apiName": {
+        "crawlMultiPages": "Inhalte mehrerer Seiten lesen",
+        "crawlSinglePage": "Seiteninhalt lesen",
+        "search": "Seiten durchsuchen"
+      },
+      "title": "Websuche"
+    }
+  },
   "confirm": "Bestätigen",
   "debug": {
     "arguments": "Aufrufparameter",
@@ -251,23 +285,6 @@
     "content": "Plugin wird aufgerufen...",
     "plugin": "Plugin läuft..."
   },
-  "localSystem": {
-    "apiName": {
-      "editLocalFile": "Datei bearbeiten",
-      "getCommandOutput": "Codeausgabe abrufen",
-      "globLocalFiles": "Dateien durchsuchen",
-      "grepContent": "Inhalt durchsuchen",
-      "killCommand": "Codeausführung beenden",
-      "listLocalFiles": "Dateiliste anzeigen",
-      "moveLocalFiles": "Dateien verschieben",
-      "readLocalFile": "Dateiinhalt lesen",
-      "renameLocalFile": "Datei umbenennen",
-      "runCommand": "Befehl ausführen",
-      "searchLocalFiles": "Dateien suchen",
-      "writeLocalFile": "Datei schreiben"
-    },
-    "title": "Lokales System"
-  },
   "mcpInstall": {
     "CHECKING_INSTALLATION": "Installationsumgebung wird geprüft...",
     "COMPLETED": "Installation abgeschlossen",
@@ -375,11 +392,6 @@
     "warning": "⚠️ Bitte stellen Sie sicher, dass Sie der Quelle dieses Plugins vertrauen. Bösartige Plugins können die Systemsicherheit gefährden."
   },
   "search": {
-    "apiName": {
-      "crawlMultiPages": "Mehrere Seiteninhalt lesen",
-      "crawlSinglePage": "Seiteninhalt lesen",
-      "search": "Seite durchsuchen"
-    },
     "config": {
       "addKey": "Schlüssel hinzufügen",
       "close": "Löschen",

locales/de-DE/providers.json

@@ -191,6 +191,9 @@
   "xinference": {
     "description": "Xorbits Inference (Xinference) ist eine Open-Source-Plattform zur Vereinfachung der Ausführung und Integration verschiedener KI-Modelle. Mit Xinference können Sie beliebige Open-Source-LLMs, Embedding-Modelle und multimodale Modelle in der Cloud oder lokal ausführen, um leistungsstarke KI-Anwendungen zu erstellen."
   },
+  "zenmux": {
+    "description": "ZenMux ist eine einheitliche Plattform zur Aggregation von KI-Diensten, die Schnittstellen zu führenden KI-Anbietern wie OpenAI, Anthropic und Google VertexAI unterstützt. Sie bietet flexible Routing-Funktionen, mit denen Sie mühelos zwischen verschiedenen KI-Modellen wechseln und diese verwalten können."
+  },
   "zeroone": {
     "description": "01.AI konzentriert sich auf die künstliche Intelligenz-Technologie der AI 2.0-Ära und fördert aktiv die Innovation und Anwendung von 'Mensch + künstliche Intelligenz', indem sie leistungsstarke Modelle und fortschrittliche KI-Technologien einsetzt, um die Produktivität der Menschen zu steigern und technologische Befähigung zu erreichen."
   },

locales/de-DE/tool.json

@@ -14,7 +14,21 @@
     "images": "Bilder:",
     "prompt": "Hinweiswort"
   },
+  "lobe-knowledge-base": {
+    "readKnowledge": {
+      "meta": {
+        "chars": "Zeichenanzahl",
+        "lines": "Zeilenzahl"
+      }
+    }
+  },
   "localFiles": {
+    "editFile": {
+      "newString": "Ersetzen durch",
+      "oldString": "Suchbegriff",
+      "replaceAll": "Alle Vorkommen ersetzen",
+      "replaceFirst": "Nur erstes Vorkommen ersetzen"
+    },
     "file": "Datei",
     "folder": "Ordner",
     "moveFiles": {
@@ -34,7 +48,12 @@
     "readFile": "Datei lesen",
     "readFileError": "Fehler beim Lesen der Datei, bitte überprüfen Sie den Dateipfad",
     "readFiles": "Dateien lesen",
-    "readFilesError": "Fehler beim Lesen der Dateien, bitte überprüfen Sie den Dateipfad"
+    "readFilesError": "Fehler beim Lesen der Dateien, bitte überprüfen Sie den Dateipfad",
+    "writeFile": {
+      "characters": "Zeichen",
+      "preview": "Vorschau des Inhalts",
+      "truncated": "Abgeschnitten"
+    }
   },
   "search": {
     "createNewSearch": "Neue Suchanfrage erstellen",

locales/en-US/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "Deep Thinking Switch"
     },
+    "thinkingLevel": {
+      "title": "Level of Thinking"
+    },
     "title": "Model Extension Features",
     "urlContext": {
       "desc": "When enabled, web links will be automatically parsed to retrieve the actual webpage context content",
@@ -330,6 +333,11 @@
     "screenshot": "Screenshot",
     "settings": "Export Settings",
     "text": "Text",
+    "widthMode": {
+      "label": "Width Mode",
+      "narrow": "Narrow",
+      "wide": "Wide"
+    },
     "withBackground": "Include Background Image",
     "withFooter": "Include Footer",
     "withPluginInfo": "Include Plugin Information",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "Providing a reason will help the Agent understand and improve future actions",
       "rejectTitle": "Reject This Tool Invocation",
       "rejectedWithReason": "This tool invocation was actively rejected: {{reason}}",
+      "toolAbort": "This tool invocation was canceled by the user",
       "toolRejected": "This tool invocation was actively rejected"
     }
   },

locales/en-US/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "Close",
+  "cmdk": {
+    "about": "About",
+    "communitySupport": "Community Support",
+    "discover": "Discover",
+    "knowledgeBase": "Knowledge Base",
+    "navigate": "Navigate",
+    "newAgent": "Create New Assistant",
+    "noResults": "No results found",
+    "openSettings": "Open Settings",
+    "painting": "AI Painting",
+    "searchPlaceholder": "Enter a command or search...",
+    "settings": "Settings",
+    "starOnGitHub": "Star us on GitHub",
+    "submitIssue": "Submit Issue",
+    "theme": "Theme",
+    "themeAuto": "Auto",
+    "themeDark": "Dark",
+    "themeLight": "Light",
+    "toOpen": "to Open",
+    "toSelect": "to Select"
+  },
   "confirm": "Confirm",
   "contact": "Contact Us",
   "copy": "Copy",
@@ -283,6 +304,7 @@
     "business": "Business Cooperation",
     "support": "Email Support"
   },
+  "new": "NEW",
   "oauth": "SSO Login",
   "officialSite": "Official Website",
   "ok": "OK",

locales/en-US/error.json

@@ -102,7 +102,7 @@
       "SPII": "Your content may contain sensitive personally identifiable information (PII). To protect privacy, please remove any sensitive details and try again.",
       "default": "Content blocked: {{blockReason}}. Please adjust your request and try again."
     },
-    "InsufficientQuota": "Sorry, the quota for this key has been reached. Please check your account balance or increase the key quota and try again.",
+    "InsufficientQuota": "Sorry, the quota for this key has been reached. Please check if your account balance is sufficient or try again after increasing the key's quota.",
     "InvalidAccessCode": "Invalid access code or empty. Please enter the correct access code or add a custom API Key.",
     "InvalidBedrockCredentials": "Bedrock authentication failed. Please check the AccessKeyId/SecretAccessKey and retry.",
     "InvalidClerkUser": "Sorry, you are not currently logged in. Please log in or register an account to continue.",
@@ -131,7 +131,7 @@
     "PluginServerError": "Plugin server request returned an error. Please check your plugin manifest file, plugin configuration, or server implementation based on the error information below",
     "PluginSettingsInvalid": "This plugin needs to be correctly configured before it can be used. Please check if your configuration is correct",
     "ProviderBizError": "Error requesting {{provider}} service, please troubleshoot or retry based on the following information",
-    "QuotaLimitReached": "We apologize, but the current token usage or number of requests has reached the quota limit for this key. Please increase the quota for this key or try again later.",
+    "QuotaLimitReached": "Sorry, the token usage or request count has reached the quota limit for this key. Please increase the key's quota or try again later.",
     "StreamChunkError": "Error parsing the message chunk of the streaming request. Please check if the current API interface complies with the standard specifications, or contact your API provider for assistance.",
     "SubscriptionKeyMismatch": "We apologize for the inconvenience. Due to a temporary system malfunction, your current subscription usage is inactive. Please click the button below to restore your subscription, or contact us via email for support.",
     "SubscriptionPlanLimit": "Your subscription points have been exhausted, and you cannot use this feature. Please upgrade to a higher plan or configure a custom model API to continue using it.",

locales/en-US/file.json

@@ -38,8 +38,8 @@
     "editedBy": "Edited by {{name}}",
     "editorPlaceholder": "Type document content, press / to open command menu",
     "empty": {
-      "createNewDocument": "Create New Document",
-      "title": "Select a document to start",
+      "createNewDocument": "Create New Page",
+      "title": "Select a page to start",
       "uploadMarkdown": "Upload Markdown File"
     },
     "linkCopied": "Link copied",
@@ -55,22 +55,21 @@
   },
   "documentList": {
     "copyContent": "Copy All",
-    "documentCount": "Total {{count}} documents",
     "duplicate": "Duplicate",
     "empty": "No documents yet. Click the button above to create your first one.",
     "noResults": "No matching documents found.",
-    "selectNote": "Select a document to start editing.",
+    "pageCount": "{{count}} pages in total",
+    "selectNote": "Select a document to start editing",
     "untitled": "Untitled"
   },
   "empty": "No files or folders have been uploaded yet.",
   "header": {
     "actions": {
       "newFolder": "New Folder",
-      "newPage": "New Document",
+      "newPage": "New Page",
       "uploadFile": "Upload File",
       "uploadFolder": "Upload Folder"
     },
-    "newDocumentButton": "New Document",
     "newNoteDialog": {
       "cancel": "Cancel",
       "editTitle": "Edit Document",
@@ -80,17 +79,18 @@
       "save": "Save",
       "saveError": "Failed to save the document. Please try again.",
       "saveSuccess": "Document saved successfully.",
-      "title": "New Document",
+      "title": "New Page",
       "updateSuccess": "Document updated successfully."
     },
+    "newPageButton": "New Page",
     "uploadButton": "Upload"
   },
   "home": {
     "getStarted": "Get Started",
     "greeting": "Get Started",
     "quickActions": "Quick Actions",
-    "recentDocuments": "Recent Documents",
     "recentFiles": "Recent Files",
+    "recentPages": "Recent Documents",
     "subtitle": "Welcome to your knowledge base. Start managing your documents here.",
     "uploadEntries": {
       "files": {
@@ -102,8 +102,8 @@
       "knowledgeBase": {
         "title": "Create Knowledge Base"
       },
-      "newDocument": {
-        "title": "Create Document"
+      "newPage": {
+        "title": "New Page"
       }
     }
   },
@@ -116,8 +116,8 @@
     "title": "Knowledge Base"
   },
   "menu": {
-    "allDocuments": "All Documents",
-    "allFiles": "All Files"
+    "allFiles": "All Files",
+    "allPages": "All Documents"
   },
   "networkError": "Failed to retrieve the knowledge base. Please check your network connection and try again.",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "Download File",
     "unsupportedFileAndContact": "This file format is not currently supported for online preview. If you have a request for previewing, feel free to <1>contact us</1>."
   },
-  "searchDocumentPlaceholder": "Search documents",
   "searchFilePlaceholder": "Search Files",
+  "searchPagePlaceholder": "Search Pages",
   "tab": {
     "all": "All",
     "audios": "Audio",
@@ -156,9 +156,7 @@
     "websites": "Websites"
   },
   "title": "Knowledge Base",
-  "toggleLeftPanel": {
-    "title": "Show/Hide Left Panel"
-  },
+  "toggleLeftPanel": "Show/Hide Left Panel",
   "uploadDock": {
     "body": {
       "collapse": "Collapse",

locales/en-US/hotkey.json

@@ -7,6 +7,10 @@
     "desc": "Clear the messages and uploaded files from the current conversation",
     "title": "Clear Conversation Messages"
   },
+  "commandPalette": {
+    "desc": "Open the global command palette for quick access to features",
+    "title": "Command Palette"
+  },
   "deleteAndRegenerateMessage": {
     "desc": "Delete the last message and regenerate",
     "title": "Delete and Regenerate"

locales/en-US/image.json

@@ -37,6 +37,14 @@
         "standard": "Standard"
       }
     },
+    "resolution": {
+      "label": "Resolution",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "Seed",
       "random": "Random Seed"

locales/en-US/modelProvider.json

@@ -295,7 +295,7 @@
       },
       "helpDoc": "Configuration Guide",
       "responsesApi": {
-        "desc": "Utilizes OpenAI's next-generation request format specification to unlock advanced features like chain of thought",
+        "desc": "Uses OpenAI's next-generation request format specification to unlock advanced features like chain-of-thought (supported by OpenAI models only)",
         "title": "Use Responses API Specification"
       },
       "waitingForMore": "More models are currently <1>planned for integration</1>, please stay tuned"

locales/en-US/models.json

@@ -236,6 +236,9 @@
   "MiniMaxAI/MiniMax-M1-80k": {
     "description": "MiniMax-M1 is a large-scale hybrid attention inference model with open-source weights, featuring 456 billion parameters, with approximately 45.9 billion parameters activated per token. The model natively supports ultra-long contexts of up to 1 million tokens and, through lightning attention mechanisms, reduces floating-point operations by 75% compared to DeepSeek R1 in tasks generating 100,000 tokens. Additionally, MiniMax-M1 employs a Mixture of Experts (MoE) architecture, combining the CISPO algorithm with an efficient reinforcement learning training design based on hybrid attention, achieving industry-leading performance in long-input inference and real-world software engineering scenarios."
   },
+  "MiniMaxAI/MiniMax-M2": {
+    "description": "MiniMax-M2 redefines efficiency for intelligent agents. It is a compact, fast, and cost-effective Mixture of Experts (MoE) model with 230 billion total parameters and 10 billion active parameters. Designed for top-tier performance in coding and agent tasks, it also maintains strong general intelligence. With only 10 billion active parameters, MiniMax-M2 delivers performance comparable to large-scale models, making it an ideal choice for high-efficiency applications."
+  },
   "Moonshot-Kimi-K2-Instruct": {
     "description": "With a total of 1 trillion parameters and 32 billion activated parameters, this non-thinking model achieves top-tier performance in cutting-edge knowledge, mathematics, and coding, excelling in general agent tasks. It is carefully optimized for agent tasks, capable not only of answering questions but also taking actions. Ideal for improvisational, general chat, and agent experiences, it is a reflex-level model requiring no prolonged thinking."
   },
@@ -717,25 +720,28 @@
     "description": "Claude 3 Opus is Anthropic's smartest model, delivering market-leading performance on highly complex tasks. It navigates open-ended prompts and novel scenarios with exceptional fluency and human-like understanding."
   },
   "anthropic/claude-3.5-haiku": {
-    "description": "Claude 3.5 Haiku is the next generation of our fastest model. Matching the speed of Claude 3 Haiku, it improves across every skill set and surpasses our previous largest model Claude 3 Opus on many intelligence benchmarks."
+    "description": "Claude 3.5 Haiku offers enhanced speed, coding accuracy, and tool usage. Ideal for scenarios requiring high performance in speed and tool interaction."
   },
   "anthropic/claude-3.5-sonnet": {
-    "description": "Claude 3.5 Sonnet strikes an ideal balance between intelligence and speed—especially for enterprise workloads. It delivers powerful performance at lower cost compared to peers and is designed for high durability in large-scale AI deployments."
+    "description": "Claude 3.5 Sonnet is a fast and efficient model in the Sonnet family, offering improved coding and reasoning performance. Some versions will gradually be replaced by models like Sonnet 3.7."
   },
   "anthropic/claude-3.7-sonnet": {
-    "description": "Claude 3.7 Sonnet is the first hybrid reasoning model and Anthropic's smartest model to date. It offers state-of-the-art performance in coding, content generation, data analysis, and planning tasks, building on the software engineering and computer usage capabilities of its predecessor Claude 3.5 Sonnet."
+    "description": "Claude 3.7 Sonnet is an upgraded model in the Sonnet series, delivering stronger reasoning and coding capabilities, suitable for complex enterprise-level tasks."
+  },
+  "anthropic/claude-haiku-4.5": {
+    "description": "Claude Haiku 4.5 is a high-performance, low-latency model from Anthropic that maintains high accuracy."
   },
   "anthropic/claude-opus-4": {
-    "description": "Claude Opus 4 is Anthropic's most powerful model yet and the world's best coding model, leading on SWE-bench (72.5%) and Terminal-bench (43.2%). It provides sustained performance for long-term tasks requiring focused effort and thousands of steps, capable of continuous operation for hours—significantly extending AI agent capabilities."
+    "description": "Opus 4 is Anthropic’s flagship model, designed for complex tasks and enterprise-grade applications."
   },
   "anthropic/claude-opus-4.1": {
-    "description": "Claude Opus 4.1 is a plug-and-play alternative to Opus 4, delivering excellent performance and accuracy for practical coding and agent tasks. Opus 4.1 advances state-of-the-art coding performance to 74.5% on SWE-bench Verified, handling complex multi-step problems with greater rigor and attention to detail."
+    "description": "Opus 4.1 is a premium model from Anthropic, optimized for programming, complex reasoning, and sustained tasks."
   },
   "anthropic/claude-sonnet-4": {
-    "description": "Claude Sonnet 4 significantly improves upon the industry-leading capabilities of Sonnet 3.7, excelling in coding with state-of-the-art 72.7% on SWE-bench. The model balances performance and efficiency, suitable for both internal and external use cases, and offers enhanced controllability for greater command over outcomes."
+    "description": "Claude Sonnet 4 is Anthropic’s hybrid reasoning model, offering a blend of cognitive and non-cognitive capabilities."
   },
   "anthropic/claude-sonnet-4.5": {
-    "description": "Claude Sonnet 4.5 is Anthropic's most intelligent model to date."
+    "description": "Claude Sonnet 4.5 is Anthropic’s latest hybrid reasoning model, optimized for complex reasoning and coding tasks."
   },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B is a sparse large language model with 72 billion parameters and 16 billion activated parameters. It is based on the Group Mixture of Experts (MoGE) architecture, which groups experts during the expert selection phase and constrains tokens to activate an equal number of experts within each group, achieving expert load balancing and significantly improving deployment efficiency on the Ascend platform."
@@ -758,6 +764,9 @@
   "baidu/ERNIE-4.5-300B-A47B": {
     "description": "ERNIE-4.5-300B-A47B is a large language model developed by Baidu based on a Mixture of Experts (MoE) architecture. The model has a total of 300 billion parameters, but only activates 47 billion parameters per token during inference, balancing powerful performance with computational efficiency. As a core model in the ERNIE 4.5 series, it demonstrates outstanding capabilities in text understanding, generation, reasoning, and programming tasks. The model employs an innovative multimodal heterogeneous MoE pretraining method, jointly training text and visual modalities to effectively enhance overall capabilities, especially excelling in instruction following and world knowledge retention."
   },
+  "baidu/ernie-5.0-thinking-preview": {
+    "description": "ERNIE 5.0 Thinking Preview is Baidu’s next-generation native multimodal Wenxin model, excelling in multimodal understanding, instruction following, content creation, factual Q&A, and tool usage."
+  },
   "c4ai-aya-expanse-32b": {
     "description": "Aya Expanse is a high-performance 32B multilingual model designed to challenge the performance of single-language models through innovations in instruction tuning, data arbitrage, preference training, and model merging. It supports 23 languages."
   },
@@ -866,6 +875,9 @@
   "codex-mini-latest": {
     "description": "codex-mini-latest is a fine-tuned version of o4-mini, specifically designed for Codex CLI. For direct API usage, we recommend starting with gpt-4.1."
   },
+  "cogito-2.1:671b": {
+    "description": "Cogito v2.1 671B is a U.S.-based open-source large language model available for free commercial use. It offers top-tier performance, high token inference efficiency, 128k long context, and robust general capabilities."
+  },
   "cogview-4": {
     "description": "CogView-4 is Zhipu's first open-source text-to-image model supporting Chinese character generation. It offers comprehensive improvements in semantic understanding, image generation quality, and bilingual Chinese-English text generation capabilities. It supports bilingual input of any length and can generate images at any resolution within a specified range."
   },
@@ -1136,6 +1148,9 @@
   "deepseek-vl2-small": {
     "description": "DeepSeek VL2 Small, a lightweight multimodal version designed for resource-constrained and high-concurrency scenarios."
   },
+  "deepseek/deepseek-chat": {
+    "description": "DeepSeek-V3 is a high-performance hybrid reasoning model from the DeepSeek team, suitable for complex tasks and tool integration."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 is a 685B parameter expert mixture model, the latest iteration in the DeepSeek team's flagship chat model series.\n\nIt inherits from the [DeepSeek V3](/deepseek/deepseek-chat-v3) model and performs excellently across various tasks."
   },
@@ -1143,19 +1158,19 @@
     "description": "DeepSeek V3 is a 685B parameter expert mixture model, the latest iteration in the DeepSeek team's flagship chat model series.\n\nIt inherits from the [DeepSeek V3](/deepseek/deepseek-chat-v3) model and performs excellently across various tasks."
   },
   "deepseek/deepseek-chat-v3.1": {
-    "description": "DeepSeek-V3.1 is a large hybrid reasoning model supporting 128K long context and efficient mode switching, delivering outstanding performance and speed in tool invocation, code generation, and complex reasoning tasks."
+    "description": "DeepSeek-V3.1 is a long-context hybrid reasoning model from DeepSeek, supporting cognitive/non-cognitive hybrid modes and tool integration."
   },
   "deepseek/deepseek-r1": {
     "description": "The DeepSeek R1 model has undergone minor version upgrades, currently at DeepSeek-R1-0528. The latest update significantly enhances inference depth and capability by leveraging increased compute resources and post-training algorithmic optimizations. The model performs excellently on benchmarks in mathematics, programming, and general logic, with overall performance approaching leading models like O3 and Gemini 2.5 Pro."
   },
   "deepseek/deepseek-r1-0528": {
-    "description": "DeepSeek-R1 greatly improves model reasoning capabilities with minimal labeled data. Before outputting the final answer, the model first generates a chain of thought to enhance answer accuracy."
+    "description": "DeepSeek R1 0528 is an updated variant from DeepSeek, focused on open-source usability and deep reasoning."
   },
   "deepseek/deepseek-r1-0528:free": {
     "description": "DeepSeek-R1 greatly improves model reasoning capabilities with minimal labeled data. Before outputting the final answer, the model first generates a chain of thought to enhance answer accuracy."
   },
   "deepseek/deepseek-r1-distill-llama-70b": {
-    "description": "DeepSeek-R1-Distill-Llama-70B is a distilled, more efficient variant of the 70B Llama model. It maintains strong performance on text generation tasks while reducing computational overhead for easier deployment and research. Served by Groq using its custom Language Processing Unit (LPU) hardware for fast, efficient inference."
+    "description": "DeepSeek R1 Distill Llama 70B is a large language model based on Llama3.3 70B. Fine-tuned using outputs from DeepSeek R1, it achieves competitive performance on par with leading-edge large models."
   },
   "deepseek/deepseek-r1-distill-llama-8b": {
     "description": "DeepSeek R1 Distill Llama 8B is a distilled large language model based on Llama-3.1-8B-Instruct, trained using outputs from DeepSeek R1."
@@ -1172,6 +1187,9 @@
   "deepseek/deepseek-r1:free": {
     "description": "DeepSeek-R1 significantly enhances model reasoning capabilities with minimal labeled data. Before outputting the final answer, the model first provides a chain of thought to improve the accuracy of the final response."
   },
+  "deepseek/deepseek-reasoner": {
+    "description": "DeepSeek-V3 Thinking (reasoner) is an experimental reasoning model from DeepSeek, designed for high-complexity reasoning tasks."
+  },
   "deepseek/deepseek-v3": {
     "description": "A fast, general-purpose large language model with enhanced reasoning capabilities."
   },
@@ -1478,9 +1496,6 @@
   "gemini-2.0-flash-lite-001": {
     "description": "Gemini 2.0 Flash is a variant of the model optimized for cost-effectiveness and low latency."
   },
-  "gemini-2.0-flash-preview-image-generation": {
-    "description": "Gemini 2.0 Flash preview model, supports image generation"
-  },
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash is Google's most cost-effective model, offering comprehensive capabilities."
   },
@@ -1508,9 +1523,6 @@
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview is Google's most cost-effective model, offering a comprehensive set of features."
   },
-  "gemini-2.5-flash-preview-05-20": {
-    "description": "Gemini 2.5 Flash Preview is Google's most cost-effective model, offering comprehensive capabilities."
-  },
   "gemini-2.5-flash-preview-09-2025": {
     "description": "Preview release (September 25th, 2025) of Gemini 2.5 Flash"
   },
@@ -1526,6 +1538,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview is Google's most advanced cognitive model, capable of reasoning through complex problems in code, mathematics, and STEM fields, as well as analyzing large datasets, codebases, and documents using long-context understanding."
   },
+  "gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) is Google’s image generation model, also supporting multimodal dialogue."
+  },
+  "gemini-3-pro-image-preview:image": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) is Google’s image generation model, also supporting multimodal dialogue."
+  },
+  "gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro is the world’s leading multimodal understanding model and Google’s most powerful agent and ambient programming model to date, offering rich visual output and deep interactivity, all built on cutting-edge reasoning capabilities."
+  },
   "gemini-flash-latest": {
     "description": "Latest release of Gemini Flash"
   },
@@ -1650,7 +1671,7 @@
     "description": "GLM-Zero-Preview possesses strong complex reasoning abilities, excelling in logical reasoning, mathematics, programming, and other fields."
   },
   "google/gemini-2.0-flash": {
-    "description": "Gemini 2.0 Flash offers next-generation features and improvements, including exceptional speed, built-in tool usage, multimodal generation, and a 1 million token context window."
+    "description": "Gemini 2.0 Flash is Google’s high-performance reasoning model, suitable for extended multimodal tasks."
   },
   "google/gemini-2.0-flash-001": {
     "description": "Gemini 2.0 Flash offers next-generation features and improvements, including exceptional speed, native tool usage, multimodal generation, and a 1M token context window."
@@ -1661,14 +1682,23 @@
   "google/gemini-2.0-flash-lite": {
     "description": "Gemini 2.0 Flash Lite provides next-generation features and improvements, including exceptional speed, built-in tool usage, multimodal generation, and a 1 million token context window."
   },
+  "google/gemini-2.0-flash-lite-001": {
+    "description": "Gemini 2.0 Flash Lite is a lightweight version of the Gemini family. By default, it disables reasoning to improve latency and cost efficiency, but it can be enabled via parameters."
+  },
   "google/gemini-2.5-flash": {
-    "description": "Gemini 2.5 Flash is a thoughtful model delivering excellent comprehensive capabilities. It is designed to balance price and performance, supporting multimodal inputs and a 1 million token context window."
+    "description": "The Gemini 2.5 Flash (Lite/Pro/Flash) series are Google’s reasoning models ranging from low-latency to high-performance."
+  },
+  "google/gemini-2.5-flash-image": {
+    "description": "Gemini 2.5 Flash Image (Nano Banana) is Google’s image generation model, also supporting multimodal dialogue."
+  },
+  "google/gemini-2.5-flash-image-free": {
+    "description": "Gemini 2.5 Flash Image Free Edition supports limited multimodal generation."
   },
   "google/gemini-2.5-flash-image-preview": {
     "description": "Gemini 2.5 Flash experimental model, supporting image generation."
   },
   "google/gemini-2.5-flash-lite": {
-    "description": "Gemini 2.5 Flash-Lite is a balanced, low-latency model with configurable reasoning budget and tool connectivity (e.g., Google Search grounding and code execution). It supports multimodal inputs and offers a 1 million token context window."
+    "description": "Gemini 2.5 Flash Lite is a lightweight version of Gemini 2.5, optimized for latency and cost, ideal for high-throughput scenarios."
   },
   "google/gemini-2.5-flash-preview": {
     "description": "Gemini 2.5 Flash is Google's most advanced flagship model, designed for advanced reasoning, coding, mathematics, and scientific tasks. It includes built-in 'thinking' capabilities that allow it to provide responses with higher accuracy and detailed context handling.\n\nNote: This model has two variants: thinking and non-thinking. Output pricing varies significantly based on whether the thinking capability is activated. If you choose the standard variant (without the ':thinking' suffix), the model will explicitly avoid generating thinking tokens.\n\nTo leverage the thinking capability and receive thinking tokens, you must select the ':thinking' variant, which will incur higher thinking output pricing.\n\nAdditionally, Gemini 2.5 Flash can be configured via the 'maximum tokens for reasoning' parameter, as described in the documentation (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
@@ -1677,11 +1707,26 @@
     "description": "Gemini 2.5 Flash is Google's most advanced flagship model, designed for advanced reasoning, coding, mathematics, and scientific tasks. It includes built-in 'thinking' capabilities that allow it to provide responses with higher accuracy and detailed context handling.\n\nNote: This model has two variants: thinking and non-thinking. Output pricing varies significantly based on whether the thinking capability is activated. If you choose the standard variant (without the ':thinking' suffix), the model will explicitly avoid generating thinking tokens.\n\nTo leverage the thinking capability and receive thinking tokens, you must select the ':thinking' variant, which will incur higher thinking output pricing.\n\nAdditionally, Gemini 2.5 Flash can be configured via the 'maximum tokens for reasoning' parameter, as described in the documentation (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
   },
   "google/gemini-2.5-pro": {
-    "description": "Gemini 2.5 Pro is our most advanced reasoning Gemini model, capable of solving complex problems. It features a 2 million token context window and supports multimodal inputs including text, images, audio, video, and PDF documents."
+    "description": "Gemini 2.5 Pro is Google’s flagship reasoning model, supporting long context and complex tasks."
+  },
+  "google/gemini-2.5-pro-free": {
+    "description": "Gemini 2.5 Pro Free Edition supports limited multimodal long-context usage, ideal for trials and lightweight workflows."
   },
   "google/gemini-2.5-pro-preview": {
     "description": "Gemini 2.5 Pro Preview is Google's most advanced thinking model, capable of reasoning through complex problems in code, mathematics, and STEM fields, as well as analyzing large datasets, codebases, and documents using extended context."
   },
+  "google/gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) is Google's image generation model, which also supports multimodal conversations."
+  },
+  "google/gemini-3-pro-image-preview-free": {
+    "description": "Gemini 3 Pro Image Free Edition supports limited multimodal generation."
+  },
+  "google/gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro is the next-generation multimodal reasoning model in the Gemini series, capable of understanding text, audio, images, and video, and handling complex tasks and large codebases."
+  },
+  "google/gemini-3-pro-preview-free": {
+    "description": "Gemini 3 Pro Free Preview offers the same multimodal understanding and reasoning capabilities as the standard version, but with usage and rate limitations, making it more suitable for exploration and low-frequency use."
+  },
   "google/gemini-embedding-001": {
     "description": "A state-of-the-art embedding model delivering excellent performance on English, multilingual, and code tasks."
   },
@@ -1907,6 +1952,12 @@
   "grok-4-0709": {
     "description": "xAI's Grok 4, featuring strong reasoning capabilities."
   },
+  "grok-4-1-fast-non-reasoning": {
+    "description": "Cutting-edge multimodal model optimized specifically for high-performance agent tool invocation."
+  },
+  "grok-4-1-fast-reasoning": {
+    "description": "Cutting-edge multimodal model optimized specifically for high-performance agent tool invocation."
+  },
   "grok-4-fast-non-reasoning": {
     "description": "We are excited to release Grok 4 Fast, our latest advancement in cost-effective reasoning models."
   },
@@ -2051,21 +2102,36 @@
   "inception/mercury-coder-small": {
     "description": "Mercury Coder Small is ideal for code generation, debugging, and refactoring tasks, offering minimal latency."
   },
-  "inclusionAI/Ling-1T": {
-    "description": "Ling-1T is the first flagship non-thinking model in the 'Ling 2.0' series, featuring 1 trillion total parameters and approximately 50 billion active parameters per token. Built on the Ling 2.0 architecture, Ling-1T aims to push the boundaries of efficient reasoning and scalable cognition. Ling-1T-base is trained on over 20 trillion high-quality, reasoning-intensive tokens."
-  },
   "inclusionAI/Ling-flash-2.0": {
     "description": "Ling-flash-2.0 is the third model in the Ling 2.0 architecture series released by Ant Group's Bailing team. It is a mixture-of-experts (MoE) model with a total of 100 billion parameters, but activates only 6.1 billion parameters per token (4.8 billion non-embedding). As a lightweight configuration model, Ling-flash-2.0 demonstrates performance comparable to or surpassing 40-billion-parameter dense models and larger MoE models across multiple authoritative benchmarks. The model aims to explore efficient pathways under the consensus that \"large models equal large parameters\" through extreme architectural design and training strategies."
   },
   "inclusionAI/Ling-mini-2.0": {
     "description": "Ling-mini-2.0 is a small-sized, high-performance large language model based on the MoE architecture. It has 16 billion total parameters but activates only 1.4 billion per token (789 million non-embedding), achieving extremely high generation speed. Thanks to the efficient MoE design and large-scale high-quality training data, despite activating only 1.4 billion parameters, Ling-mini-2.0 still delivers top-tier performance comparable to dense LLMs under 10 billion parameters and larger MoE models on downstream tasks."
   },
-  "inclusionAI/Ring-1T": {
-    "description": "Ring-1T is a trillion-parameter open-source cognitive model released by the Bailing team. It is trained on the Ling 2.0 architecture and the Ling-1T-base model, with 1 trillion total parameters and 50 billion active parameters. It supports context windows up to 128K and is optimized through large-scale verifiable reward reinforcement learning."
-  },
   "inclusionAI/Ring-flash-2.0": {
     "description": "Ring-flash-2.0 is a high-performance reasoning model deeply optimized based on Ling-flash-2.0-base. It employs a mixture-of-experts (MoE) architecture with a total of 100 billion parameters but activates only 6.1 billion parameters per inference. The model uses the proprietary icepop algorithm to solve the instability issues of MoE large models during reinforcement learning (RL) training, enabling continuous improvement of complex reasoning capabilities over long training cycles. Ring-flash-2.0 has achieved significant breakthroughs in challenging benchmarks such as math competitions, code generation, and logical reasoning. Its performance not only surpasses top dense models under 40 billion parameters but also rivals larger open-source MoE models and closed-source high-performance reasoning models. Although focused on complex reasoning, it also performs well in creative writing tasks. Additionally, thanks to its efficient architecture, Ring-flash-2.0 delivers strong performance with high-speed inference, significantly reducing deployment costs for reasoning models in high-concurrency scenarios."
   },
+  "inclusionai/ling-1t": {
+    "description": "Ling-1T is inclusionAI’s 1T MoE large model, optimized for high-intensity reasoning tasks and large-scale context."
+  },
+  "inclusionai/ling-flash-2.0": {
+    "description": "Ling-flash-2.0 is inclusionAI’s MoE model, optimized for efficiency and reasoning performance, suitable for medium to large-scale tasks."
+  },
+  "inclusionai/ling-mini-2.0": {
+    "description": "Ling-mini-2.0 is a lightweight MoE model from inclusionAI, significantly reducing cost while maintaining reasoning capabilities."
+  },
+  "inclusionai/ming-flash-omini-preview": {
+    "description": "Ming-flash-omni Preview is inclusionAI’s multimodal model supporting voice, image, and video input, with enhanced image rendering and speech recognition capabilities."
+  },
+  "inclusionai/ring-1t": {
+    "description": "Ring-1T is inclusionAI’s trillion-parameter MoE reasoning model, designed for large-scale reasoning and research tasks."
+  },
+  "inclusionai/ring-flash-2.0": {
+    "description": "Ring-flash-2.0 is a high-throughput variant of the Ring model from inclusionAI, emphasizing speed and cost efficiency."
+  },
+  "inclusionai/ring-mini-2.0": {
+    "description": "Ring-mini-2.0 is a high-throughput, lightweight MoE version from inclusionAI, primarily used in concurrent scenarios."
+  },
   "internlm/internlm2_5-7b-chat": {
     "description": "InternLM2.5 offers intelligent dialogue solutions across multiple scenarios."
   },
@@ -2117,6 +2183,12 @@
   "kimi-k2-instruct": {
     "description": "Kimi K2 Instruct, the official Kimi inference model supporting long context, code, Q&A, and more."
   },
+  "kimi-k2-thinking": {
+    "description": "K2 Long Thinking Model supports 256k context, multi-step tool usage, and deep reasoning, excelling at solving complex problems."
+  },
+  "kimi-k2-thinking-turbo": {
+    "description": "The high-speed version of the K2 Long Thinking Model supports 256k context and deep reasoning, with output speeds of 60–100 tokens per second."
+  },
   "kimi-k2-turbo-preview": {
     "description": "Kimi-K2 is a Mixture-of-Experts (MoE) foundation model with exceptional coding and agent capabilities, featuring 1T total parameters and 32B activated parameters. In benchmark evaluations across core categories — general knowledge reasoning, programming, mathematics, and agent tasks — the K2 model outperforms other leading open-source models."
   },
@@ -2129,6 +2201,9 @@
   "kimi-thinking-preview": {
     "description": "kimi-thinking-preview is a multimodal thinking model provided by Dark Side of the Moon, featuring multimodal and general reasoning abilities. It excels at deep reasoning to help solve more complex and challenging problems."
   },
+  "kuaishou/kat-coder-pro-v1": {
+    "description": "KAT-Coder-Pro-V1 (limited-time free) focuses on code understanding and automated programming, designed for efficient coding agent tasks."
+  },
   "learnlm-1.5-pro-experimental": {
     "description": "LearnLM is an experimental, task-specific language model trained to align with learning science principles, capable of following systematic instructions in teaching and learning scenarios, acting as an expert tutor, among other roles."
   },
@@ -2225,6 +2300,9 @@
   "megrez-3b-instruct": {
     "description": "Megrez 3B Instruct is a compact and efficient model developed by Wuwen Xinqiong."
   },
+  "meituan/longcat-flash-chat": {
+    "description": "An open-source foundational model from Meituan, optimized for conversational interactions and agent-based tasks. Excels in tool usage and complex multi-turn dialogue scenarios."
+  },
   "meta-llama-3-70b-instruct": {
     "description": "A powerful 70-billion parameter model excelling in reasoning, coding, and broad language applications."
   },
@@ -2456,6 +2534,12 @@
   "minimax-m2": {
     "description": "MiniMax M2 is a high-efficiency large language model built for coding and agent-based workflows."
   },
+  "minimax/minimax-m2": {
+    "description": "MiniMax-M2 is a cost-effective model with strong performance in coding and agent tasks, suitable for various engineering scenarios."
+  },
+  "minimaxai/minimax-m2": {
+    "description": "MiniMax-M2 is a compact, fast, and cost-efficient Mixture of Experts (MoE) model with 230 billion total parameters and 10 billion active parameters. It is engineered for top performance in coding and agent tasks while maintaining robust general intelligence. Excelling in multi-file editing, code-run-debug loops, test validation and repair, and complex long-chain tool integrations, it is an ideal choice for developer workflows."
+  },
   "ministral-3b-latest": {
     "description": "Ministral 3B is Mistral's top-tier edge model."
   },
@@ -2600,12 +2684,21 @@
   "moonshotai/kimi-k2": {
     "description": "Kimi K2 is a large-scale Mixture of Experts (MoE) language model developed by Moonshot AI, with a total of 1 trillion parameters and 32 billion active parameters per forward pass. It is optimized for agent capabilities, including advanced tool use, reasoning, and code synthesis."
   },
+  "moonshotai/kimi-k2-0711": {
+    "description": "Kimi K2 0711 is the Instruct version of the Kimi series, ideal for high-quality coding and tool usage scenarios."
+  },
   "moonshotai/kimi-k2-0905": {
-    "description": "The kimi-k2-0905-preview model has a context length of 256k, featuring stronger Agentic Coding capabilities, more outstanding aesthetics and practicality of frontend code, and better context understanding."
+    "description": "Kimi K2 0905 is the September 5th update of the Kimi series, with expanded context and improved reasoning and coding performance."
   },
   "moonshotai/kimi-k2-instruct-0905": {
     "description": "The kimi-k2-0905-preview model has a context length of 256k, featuring stronger Agentic Coding capabilities, more outstanding aesthetics and practicality of frontend code, and better context understanding."
   },
+  "moonshotai/kimi-k2-thinking": {
+    "description": "Kimi K2 Thinking is Moonshot’s optimized model for deep reasoning tasks, equipped with general agent capabilities."
+  },
+  "moonshotai/kimi-k2-thinking-turbo": {
+    "description": "Kimi K2 Thinking Turbo is the high-speed version of Kimi K2 Thinking, maintaining deep reasoning capabilities while significantly reducing response latency."
+  },
   "morph/morph-v3-fast": {
     "description": "Morph offers a specialized AI model that applies code changes suggested by cutting-edge models like Claude or GPT-4o to your existing code files FAST - 4500+ tokens/second. It acts as the final step in the AI coding workflow. Supports 16k input tokens and 16k output tokens."
   },
@@ -2688,28 +2781,49 @@
     "description": "OpenAI's gpt-4-turbo features broad general knowledge and domain expertise, enabling it to follow complex natural language instructions and accurately solve difficult problems. Its knowledge cutoff is April 2023, with a 128,000 token context window."
   },
   "openai/gpt-4.1": {
-    "description": "GPT 4.1 is OpenAI's flagship model, suited for complex tasks. It excels at cross-domain problem solving."
+    "description": "The GPT-4.1 series offers extended context and enhanced engineering and reasoning capabilities."
   },
   "openai/gpt-4.1-mini": {
-    "description": "GPT 4.1 mini balances intelligence, speed, and cost, making it an attractive model for many use cases."
+    "description": "GPT-4.1 Mini provides lower latency and better cost-efficiency, suitable for medium-context scenarios."
   },
   "openai/gpt-4.1-nano": {
-    "description": "GPT-4.1 nano is the fastest and most cost-effective GPT 4.1 model."
+    "description": "GPT-4.1 Nano is a low-cost, low-latency option ideal for high-frequency short conversations or classification tasks."
   },
   "openai/gpt-4o": {
-    "description": "GPT-4o from OpenAI has broad general knowledge and domain expertise, capable of following complex natural language instructions and accurately solving challenging problems. It matches GPT-4 Turbo's performance with a faster, cheaper API."
+    "description": "The GPT-4o series is OpenAI’s Omni model, supporting text + image input and text output."
   },
   "openai/gpt-4o-mini": {
-    "description": "GPT-4o mini from OpenAI is their most advanced and cost-effective small model. It is multimodal (accepting text or image inputs and outputting text) and more intelligent than gpt-3.5-turbo, while maintaining similar speed."
+    "description": "GPT-4o-mini is a fast, compact version of GPT-4o, suitable for low-latency multimodal scenarios."
   },
   "openai/gpt-5": {
-    "description": "GPT-5 is OpenAI's flagship language model, excelling in complex reasoning, extensive real-world knowledge, code-intensive, and multi-step agent tasks."
+    "description": "GPT-5 is OpenAI’s high-performance model, suitable for a wide range of production and research tasks."
+  },
+  "openai/gpt-5-chat": {
+    "description": "GPT-5 Chat is a GPT-5 variant optimized for conversational scenarios, reducing latency to enhance interaction."
+  },
+  "openai/gpt-5-codex": {
+    "description": "GPT-5-Codex is a GPT-5 variant further optimized for coding tasks, ideal for large-scale code workflows."
   },
   "openai/gpt-5-mini": {
-    "description": "GPT-5 mini is a cost-optimized model performing well on reasoning/chat tasks. It offers the best balance of speed, cost, and capability."
+    "description": "GPT-5 Mini is a compact version of the GPT-5 family, suitable for low-latency, low-cost scenarios."
   },
   "openai/gpt-5-nano": {
-    "description": "GPT-5 nano is a high-throughput model excelling at simple instruction or classification tasks."
+    "description": "GPT-5 Nano is the ultra-compact version in the family, ideal for scenarios with strict cost and latency requirements."
+  },
+  "openai/gpt-5-pro": {
+    "description": "GPT-5 Pro is OpenAI’s flagship model, offering advanced reasoning, code generation, and enterprise-grade features, with support for test-time routing and stricter safety policies."
+  },
+  "openai/gpt-5.1": {
+    "description": "GPT-5.1 is the latest flagship model in the GPT-5 series, significantly improved in general reasoning, instruction following, and conversational naturalness, suitable for a wide range of tasks."
+  },
+  "openai/gpt-5.1-chat": {
+    "description": "GPT-5.1 Chat is a lightweight member of the GPT-5.1 family, optimized for low-latency conversations while retaining strong reasoning and instruction execution capabilities."
+  },
+  "openai/gpt-5.1-codex": {
+    "description": "GPT-5.1-Codex is a GPT-5.1 variant optimized for software engineering and coding workflows, ideal for large-scale refactoring, complex debugging, and long-term autonomous coding tasks."
+  },
+  "openai/gpt-5.1-codex-mini": {
+    "description": "GPT-5.1-Codex-Mini is a smaller, faster version of GPT-5.1-Codex, better suited for latency- and cost-sensitive coding scenarios."
   },
   "openai/gpt-oss-120b": {
     "description": "An extremely capable general-purpose large language model with powerful, controllable reasoning abilities."
@@ -2736,7 +2850,7 @@
     "description": "O3-mini high inference level version provides high intelligence at the same cost and latency targets as o1-mini."
   },
   "openai/o4-mini": {
-    "description": "OpenAI's o4-mini offers fast, cost-effective reasoning with excellent performance for its size, especially in mathematics (best in AIME benchmark), coding, and visual tasks."
+    "description": "OpenAI o4-mini is a compact and efficient reasoning model from OpenAI, ideal for low-latency scenarios."
   },
   "openai/o4-mini-high": {
     "description": "o4-mini high inference level version, optimized for fast and efficient inference, demonstrating high efficiency and performance in coding and visual tasks."
@@ -2940,7 +3054,7 @@
     "description": "A powerful medium-sized code model supporting 32K context length, proficient in multilingual programming."
   },
   "qwen/qwen3-14b": {
-    "description": "Qwen3-14B is a dense 14.8 billion parameter causal language model in the Qwen3 series, designed for complex reasoning and efficient dialogue. It supports seamless switching between a 'thinking' mode for tasks such as mathematics, programming, and logical reasoning, and a 'non-thinking' mode for general conversation. This model is fine-tuned for instruction following, agent tool usage, creative writing, and multilingual tasks across more than 100 languages and dialects. It natively handles a 32K token context and can be extended to 131K tokens using YaRN."
+    "description": "Qwen3-14B is the 14B version in the Qwen series, suitable for general reasoning and dialogue tasks."
   },
   "qwen/qwen3-14b:free": {
     "description": "Qwen3-14B is a dense 14.8 billion parameter causal language model in the Qwen3 series, designed for complex reasoning and efficient dialogue. It supports seamless switching between a 'thinking' mode for tasks such as mathematics, programming, and logical reasoning, and a 'non-thinking' mode for general conversation. This model is fine-tuned for instruction following, agent tool usage, creative writing, and multilingual tasks across more than 100 languages and dialects. It natively handles a 32K token context and can be extended to 131K tokens using YaRN."
@@ -2948,6 +3062,12 @@
   "qwen/qwen3-235b-a22b": {
     "description": "Qwen3-235B-A22B is a 235 billion parameter mixture of experts (MoE) model developed by Qwen, activating 22 billion parameters per forward pass. It supports seamless switching between a 'thinking' mode for complex reasoning, mathematics, and coding tasks, and a 'non-thinking' mode for general conversational efficiency. This model showcases strong reasoning capabilities, multilingual support (over 100 languages and dialects), advanced instruction following, and agent tool invocation capabilities. It natively handles a 32K token context window and can be extended to 131K tokens using YaRN."
   },
+  "qwen/qwen3-235b-a22b-2507": {
+    "description": "Qwen3-235B-A22B-Instruct-2507 is an Instruct version in the Qwen3 series, supporting multilingual instructions and long-context scenarios."
+  },
+  "qwen/qwen3-235b-a22b-thinking-2507": {
+    "description": "Qwen3-235B-A22B-Thinking-2507 is a Thinking variant of Qwen3, enhanced for complex math and reasoning tasks."
+  },
   "qwen/qwen3-235b-a22b:free": {
     "description": "Qwen3-235B-A22B is a 235 billion parameter mixture of experts (MoE) model developed by Qwen, activating 22 billion parameters per forward pass. It supports seamless switching between a 'thinking' mode for complex reasoning, mathematics, and coding tasks, and a 'non-thinking' mode for general conversational efficiency. This model showcases strong reasoning capabilities, multilingual support (over 100 languages and dialects), advanced instruction following, and agent tool invocation capabilities. It natively handles a 32K token context window and can be extended to 131K tokens using YaRN."
   },
@@ -2966,6 +3086,21 @@
   "qwen/qwen3-8b:free": {
     "description": "Qwen3-8B is a dense 8.2 billion parameter causal language model in the Qwen3 series, designed for reasoning-intensive tasks and efficient dialogue. It supports seamless switching between a 'thinking' mode for mathematics, coding, and logical reasoning, and a 'non-thinking' mode for general conversation. This model is fine-tuned for instruction following, agent integration, creative writing, and multilingual use across more than 100 languages and dialects. It natively supports a 32K token context window and can be extended to 131K tokens via YaRN."
   },
+  "qwen/qwen3-coder": {
+    "description": "Qwen3-Coder is the code generation family in Qwen3, excelling at understanding and generating code within long documents."
+  },
+  "qwen/qwen3-coder-plus": {
+    "description": "Qwen3-Coder-Plus is a specially optimized coding agent model in the Qwen series, supporting more complex tool usage and long-term conversations."
+  },
+  "qwen/qwen3-max": {
+    "description": "Qwen3 Max is a high-end reasoning model in the Qwen3 series, suitable for multilingual reasoning and tool integration."
+  },
+  "qwen/qwen3-max-preview": {
+    "description": "Qwen3 Max (preview) is the preview version of the Max model in the Qwen series, designed for advanced reasoning and tool integration."
+  },
+  "qwen/qwen3-vl-plus": {
+    "description": "Qwen3 VL-Plus is a vision-enhanced version of Qwen3, improving multimodal reasoning and video processing capabilities."
+  },
   "qwen2": {
     "description": "Qwen2 is Alibaba's next-generation large-scale language model, supporting diverse application needs with excellent performance."
   },
@@ -3260,9 +3395,6 @@
   "step-r1-v-mini": {
     "description": "This model is a powerful reasoning model with strong image understanding capabilities, able to process both image and text information, generating text content after deep reasoning. It excels in visual reasoning while also possessing first-tier capabilities in mathematics, coding, and text reasoning. The context length is 100k."
   },
-  "step3": {
-    "description": "Step3 is a multimodal model developed by StepStar, offering advanced visual understanding capabilities."
-  },
   "stepfun-ai/step3": {
     "description": "Step3 is a cutting-edge multimodal reasoning model released by StepFun. It is built on a mixture-of-experts (MoE) architecture with 321B total parameters and 38B active parameters. The model adopts an end-to-end design to minimize decoding cost while delivering top-tier performance in visual-language reasoning. Through the combined design of Multi-Matrix Factorized Attention (MFA) and Attention-FFN Decoupling (AFD), Step3 maintains exceptional efficiency on both high-end and low-end accelerators. During pretraining, Step3 processed over 20 trillion text tokens and 4 trillion image-text mixed tokens, covering more than a dozen languages. The model achieves leading performance among open-source models across benchmarks in mathematics, code, and multimodal tasks."
   },
@@ -3344,6 +3476,9 @@
   "vercel/v0-1.5-md": {
     "description": "Access the model behind v0 to generate, fix, and optimize modern web applications, with framework-specific reasoning and up-to-date knowledge."
   },
+  "volcengine/doubao-seed-code": {
+    "description": "Doubao-Seed-Code is a large model from ByteDance Volcano Engine optimized for Agentic Programming, excelling in various programming and agent benchmarks, supporting 256K context."
+  },
   "wan2.2-t2i-flash": {
     "description": "Wanxiang 2.2 Flash version, the latest model currently available. Fully upgraded in creativity, stability, and realism, with fast generation speed and high cost-effectiveness."
   },
@@ -3371,6 +3506,24 @@
   "wizardlm2:8x22b": {
     "description": "WizardLM 2 is a language model provided by Microsoft AI, excelling in complex dialogues, multilingual capabilities, reasoning, and intelligent assistant applications."
   },
+  "x-ai/grok-4": {
+    "description": "Grok 4 is xAI’s flagship reasoning model, offering powerful reasoning and multimodal capabilities."
+  },
+  "x-ai/grok-4-fast": {
+    "description": "Grok 4 Fast is xAI’s high-throughput, low-cost model (supports 2M context window), ideal for high-concurrency and long-context scenarios."
+  },
+  "x-ai/grok-4-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) is xAI’s high-throughput, low-cost multimodal model (supports 2M context window), designed for latency- and cost-sensitive scenarios that do not require internal reasoning. It runs alongside the reasoning version of Grok 4 Fast and can enable reasoning via the API’s reasoning enable parameter. Prompts and completions may be used by xAI or OpenRouter to improve future models."
+  },
+  "x-ai/grok-4.1-fast": {
+    "description": "Grok 4 Fast is xAI’s high-throughput, low-cost model (supports 2M context window), ideal for high-concurrency and long-context scenarios."
+  },
+  "x-ai/grok-4.1-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) is xAI’s high-throughput, low-cost multimodal model (supports 2M context window), designed for latency- and cost-sensitive scenarios that do not require internal reasoning. It runs alongside the reasoning version of Grok 4 Fast and can enable reasoning via the API’s reasoning enable parameter. Prompts and completions may be used by xAI or OpenRouter to improve future models."
+  },
+  "x-ai/grok-code-fast-1": {
+    "description": "Grok Code Fast 1 is xAI’s fast code model, delivering readable and production-ready output."
+  },
   "x1": {
     "description": "The Spark X1 model will undergo further upgrades, achieving results in reasoning, text generation, and language understanding tasks that match OpenAI o1 and DeepSeek R1, building on its leading position in domestic mathematical tasks."
   },
@@ -3431,6 +3584,15 @@
   "yi-vision-v2": {
     "description": "A complex visual task model that provides high-performance understanding and analysis capabilities based on multiple images."
   },
+  "z-ai/glm-4.5": {
+    "description": "GLM 4.5 is Z.AI’s flagship model, supporting hybrid reasoning and optimized for engineering and long-context tasks."
+  },
+  "z-ai/glm-4.5-air": {
+    "description": "GLM 4.5 Air is a lightweight version of GLM 4.5, suitable for cost-sensitive scenarios while retaining strong reasoning capabilities."
+  },
+  "z-ai/glm-4.6": {
+    "description": "GLM 4.6 is Z.AI’s flagship model, with extended context length and enhanced coding capabilities."
+  },
   "zai-org/GLM-4.5": {
     "description": "GLM-4.5 is a foundational model designed specifically for agent applications, using a Mixture-of-Experts (MoE) architecture. It is deeply optimized for tool invocation, web browsing, software engineering, and front-end programming, supporting seamless integration with code agents like Claude Code and Roo Code. GLM-4.5 employs a hybrid inference mode, adaptable to complex reasoning and everyday use scenarios."
   },
@@ -3451,5 +3613,8 @@
   },
   "zai/glm-4.5v": {
     "description": "GLM-4.5V is built on the GLM-4.5-Air foundational model, inheriting the proven techniques of GLM-4.1V-Thinking while achieving efficient scaling through a powerful 106 billion parameter MoE architecture."
+  },
+  "zenmux/auto": {
+    "description": "ZenMux’s auto-routing feature automatically selects the best-performing and most cost-effective model from supported options based on your request."
   }
 }

locales/en-US/plugin.json

@@ -1,4 +1,38 @@
 {
+  "builtins": {
+    "lobe-knowledge-base": {
+      "apiName": {
+        "readKnowledge": "Read Knowledge Base Content",
+        "searchKnowledgeBase": "Search Knowledge Base"
+      },
+      "title": "Knowledge Base"
+    },
+    "lobe-local-system": {
+      "apiName": {
+        "editLocalFile": "Edit File",
+        "getCommandOutput": "Get Command Output",
+        "globLocalFiles": "Search Files by Pattern",
+        "grepContent": "Search Content",
+        "killCommand": "Terminate Command Execution",
+        "listLocalFiles": "View File List",
+        "moveLocalFiles": "Move Files",
+        "readLocalFile": "Read File Content",
+        "renameLocalFile": "Rename File",
+        "runCommand": "Execute Command",
+        "searchLocalFiles": "Search Files",
+        "writeLocalFile": "Write to File"
+      },
+      "title": "Local System"
+    },
+    "lobe-web-browsing": {
+      "apiName": {
+        "crawlMultiPages": "Read Multiple Pages",
+        "crawlSinglePage": "Read Page Content",
+        "search": "Search Web Pages"
+      },
+      "title": "Web Browsing"
+    }
+  },
   "confirm": "Confirm",
   "debug": {
     "arguments": "Call Arguments",
@@ -251,23 +285,6 @@
     "content": "Calling plugin...",
     "plugin": "Plugin running..."
   },
-  "localSystem": {
-    "apiName": {
-      "getCommandOutput": "Get Code Output",
-      "globLocalFiles": "Match Files",
-      "grepContent": "Search Content",
-      "killCommand": "Kill Code Execution",
-      "listLocalFiles": "View File List",
-      "moveLocalFiles": "Move Files",
-      "readLocalFile": "Read File Content",
-      "renameLocalFile": "Rename",
-      "runCommand": "Run Code",
-      "searchLocalFiles": "Search Files",
-      "writeLocalFile": "Write File",
-      "editLocalFile": "Edit File"
-    },
-    "title": "Local System"
-  },
   "mcpInstall": {
     "CHECKING_INSTALLATION": "Checking installation environment...",
     "COMPLETED": "Installation completed",
@@ -375,11 +392,6 @@
     "warning": "⚠️ Please confirm you trust the source of this plugin. Malicious plugins may harm your system security."
   },
   "search": {
-    "apiName": {
-      "crawlMultiPages": "Read Multiple Pages Content",
-      "crawlSinglePage": "Read Page Content",
-      "search": "Search Pages"
-    },
     "config": {
       "addKey": "Add Key",
       "close": "Delete",

locales/en-US/providers.json

@@ -191,6 +191,9 @@
   "xinference": {
     "description": "Xorbits Inference (Xinference) is an open-source platform designed to simplify the deployment and integration of diverse AI models. With Xinference, you can leverage any open-source LLM, embedding model, or multimodal model to perform inference in cloud or on-premises environments, enabling the creation of powerful AI applications."
   },
+  "zenmux": {
+    "description": "ZenMux is a unified AI service aggregation platform that supports a variety of mainstream AI service interfaces, including OpenAI, Anthropic, and Google VertexAI. It offers flexible routing capabilities, allowing you to easily switch between and manage different AI models."
+  },
   "zeroone": {
     "description": "01.AI focuses on AI 2.0 era technologies, vigorously promoting the innovation and application of 'human + artificial intelligence', using powerful models and advanced AI technologies to enhance human productivity and achieve technological empowerment."
   },

locales/en-US/tool.json

@@ -14,7 +14,21 @@
     "images": "Images:",
     "prompt": "Prompt"
   },
+  "lobe-knowledge-base": {
+    "readKnowledge": {
+      "meta": {
+        "chars": "Character Count",
+        "lines": "Line Count"
+      }
+    }
+  },
   "localFiles": {
+    "editFile": {
+      "newString": "Replace with",
+      "oldString": "Find",
+      "replaceAll": "Replace all occurrences",
+      "replaceFirst": "Replace first occurrence only"
+    },
     "file": "File",
     "folder": "Folder",
     "moveFiles": {
@@ -34,7 +48,12 @@
     "readFile": "Read File",
     "readFileError": "Failed to read file, please check if the file path is correct",
     "readFiles": "Read Files",
-    "readFilesError": "Failed to read files, please check if the file path is correct"
+    "readFilesError": "Failed to read files, please check if the file path is correct",
+    "writeFile": {
+      "characters": "characters",
+      "preview": "Content Preview",
+      "truncated": "truncated"
+    }
   },
   "search": {
     "createNewSearch": "Create a new search record",

locales/es-ES/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "Interruptor de pensamiento profundo"
     },
+    "thinkingLevel": {
+      "title": "Nivel de pensamiento"
+    },
     "title": "Funcionalidad de extensión del modelo",
     "urlContext": {
       "desc": "Al activarlo, se analizarán automáticamente los enlaces web para obtener el contenido contextual real de la página",
@@ -330,6 +333,11 @@
     "screenshot": "Captura de pantalla",
     "settings": "Configuración de exportación",
     "text": "Texto",
+    "widthMode": {
+      "label": "Modo de ancho",
+      "narrow": "Modo de pantalla estrecha",
+      "wide": "Modo de pantalla ancha"
+    },
     "withBackground": "Incluir imagen de fondo",
     "withFooter": "Incluir pie de página",
     "withPluginInfo": "Incluir información del plugin",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "Ingresar una razón ayudará al agente a comprender y mejorar futuras acciones",
       "rejectTitle": "Rechazar esta ejecución de herramienta",
       "rejectedWithReason": "Esta ejecución de herramienta fue rechazada: {{reason}}",
+      "toolAbort": "La llamada a la herramienta fue cancelada por el usuario",
       "toolRejected": "Esta ejecución de herramienta fue rechazada"
     }
   },

locales/es-ES/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "Cerrar",
+  "cmdk": {
+    "about": "Acerca de",
+    "communitySupport": "Soporte de la comunidad",
+    "discover": "Descubrir",
+    "knowledgeBase": "Base de conocimientos",
+    "navigate": "Navegar",
+    "newAgent": "Nuevo asistente",
+    "noResults": "No se encontraron resultados",
+    "openSettings": "Abrir configuración",
+    "painting": "Dibujo con IA",
+    "searchPlaceholder": "Escribe un comando o busca...",
+    "settings": "Configuración",
+    "starOnGitHub": "Danos una estrella en GitHub",
+    "submitIssue": "Informar de un problema",
+    "theme": "Tema",
+    "themeAuto": "Seguir el sistema",
+    "themeDark": "Modo oscuro",
+    "themeLight": "Modo claro",
+    "toOpen": "Abrir",
+    "toSelect": "Seleccionar"
+  },
   "confirm": "Confirmar",
   "contact": "Contacto",
   "copy": "Copiar",
@@ -283,6 +304,7 @@
     "business": "Colaboración Comercial",
     "support": "Soporte por Correo"
   },
+  "new": "Nuevo",
   "oauth": "Inicio de sesión SSO",
   "officialSite": "Sitio oficial",
   "ok": "Aceptar",

locales/es-ES/error.json

@@ -102,7 +102,7 @@
       "SPII": "Su contenido podría contener información personal sensible. Para proteger la privacidad, elimine la información sensible y vuelva a intentarlo.",
       "default": "Contenido bloqueado: {{blockReason}}. Ajuste su solicitud y vuelva a intentarlo."
     },
-    "InsufficientQuota": "Lo sentimos, la cuota de esta clave ha alcanzado su límite. Por favor, verifique si el saldo de su cuenta es suficiente o aumente la cuota de la clave y vuelva a intentarlo.",
+    "InsufficientQuota": "Lo sentimos, la cuota de esta clave ha alcanzado su límite. Por favor, verifica si el saldo de tu cuenta es suficiente o aumenta la cuota de la clave antes de intentarlo nuevamente.",
     "InvalidAccessCode": "La contraseña no es válida o está vacía. Por favor, introduce una contraseña de acceso válida o añade una clave API personalizada",
     "InvalidBedrockCredentials": "La autenticación de Bedrock no se ha completado con éxito, por favor, verifica AccessKeyId/SecretAccessKey e inténtalo de nuevo",
     "InvalidClerkUser": "Lo siento mucho, actualmente no has iniciado sesión. Por favor, inicia sesión o regístrate antes de continuar.",
@@ -131,7 +131,7 @@
     "PluginServerError": "Error al recibir la respuesta del servidor del complemento. Verifique el archivo de descripción del complemento, la configuración del complemento o la implementación del servidor según la información de error a continuación",
     "PluginSettingsInvalid": "Este complemento necesita una configuración correcta antes de poder usarse. Verifique si su configuración es correcta",
     "ProviderBizError": "Se produjo un error al solicitar el servicio de {{provider}}, por favor, revise la siguiente información o inténtelo de nuevo",
-    "QuotaLimitReached": "Lo sentimos, el uso actual de tokens o el número de solicitudes ha alcanzado el límite de cuota de esta clave. Por favor, aumenta la cuota de esta clave o intenta de nuevo más tarde.",
+    "QuotaLimitReached": "Lo sentimos, el uso de tokens o el número de solicitudes ha alcanzado el límite de cuota de esta clave. Por favor, aumenta la cuota de la clave o inténtalo más tarde.",
     "StreamChunkError": "Error de análisis del bloque de mensajes de la solicitud en streaming. Por favor, verifica si la API actual cumple con las normas estándar o contacta a tu proveedor de API para más información.",
     "SubscriptionKeyMismatch": "Lo sentimos, debido a un fallo ocasional del sistema, el uso de la suscripción actual ha dejado de ser válido temporalmente. Por favor, haga clic en el botón de abajo para restaurar la suscripción o contáctenos por correo electrónico para obtener soporte.",
     "SubscriptionPlanLimit": "Se han agotado sus puntos de suscripción, no puede utilizar esta función. Por favor, actualice a un plan superior o configure la API del modelo personalizado para continuar.",

locales/es-ES/file.json

@@ -55,10 +55,10 @@
   },
   "documentList": {
     "copyContent": "Copiar todo el contenido",
-    "documentCount": "Total de {{count}} documentos",
     "duplicate": "Crear una copia",
-    "empty": "No hay documentos. Haz clic en el botón de arriba para crear tu primer documento",
+    "empty": "Aún no hay documentos. Haz clic en el botón de arriba para crear tu primer documento.",
     "noResults": "No se encontraron documentos coincidentes",
+    "pageCount": "Total de {{count}} documentos",
     "selectNote": "Selecciona un documento para comenzar a editar",
     "untitled": "Sin título"
   },
@@ -70,7 +70,6 @@
       "uploadFile": "Subir archivo",
       "uploadFolder": "Subir carpeta"
     },
-    "newDocumentButton": "Nuevo documento",
     "newNoteDialog": {
       "cancel": "Cancelar",
       "editTitle": "Editar documento",
@@ -83,14 +82,15 @@
       "title": "Nuevo documento",
       "updateSuccess": "Documento actualizado con éxito"
     },
+    "newPageButton": "Nuevo documento",
     "uploadButton": "Subir"
   },
   "home": {
     "getStarted": "Comenzar",
     "greeting": "Comenzar",
     "quickActions": "Acciones rápidas",
-    "recentDocuments": "Documentos recientes",
     "recentFiles": "Archivos recientes",
+    "recentPages": "Páginas recientes",
     "subtitle": "Bienvenido a tu base de conocimientos. Comienza aquí a gestionar tus documentos y notas",
     "uploadEntries": {
       "files": {
@@ -102,7 +102,7 @@
       "knowledgeBase": {
         "title": "Nueva base de conocimientos"
       },
-      "newDocument": {
+      "newPage": {
         "title": "Nuevo documento"
       }
     }
@@ -116,8 +116,8 @@
     "title": "Base de conocimientos"
   },
   "menu": {
-    "allDocuments": "Todos los documentos",
-    "allFiles": "Todos los archivos"
+    "allFiles": "Todos los archivos",
+    "allPages": "Todos los documentos"
   },
   "networkError": "Error al obtener la base de conocimientos, por favor verifica la conexión a internet y vuelve a intentarlo",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "Descargar archivo",
     "unsupportedFileAndContact": "Este formato de archivo no es compatible con la vista previa en línea. Si desea solicitar una vista previa, no dude en <1>contactarnos</1>."
   },
-  "searchDocumentPlaceholder": "Buscar documentos",
   "searchFilePlaceholder": "Buscar archivo",
+  "searchPagePlaceholder": "Buscar documentos",
   "tab": {
     "all": "Todo",
     "audios": "Audios",
@@ -156,9 +156,7 @@
     "websites": "Sitios web"
   },
   "title": "Base de conocimientos",
-  "toggleLeftPanel": {
-    "title": "Mostrar/Ocultar panel izquierdo"
-  },
+  "toggleLeftPanel": "Mostrar/Ocultar panel izquierdo",
   "uploadDock": {
     "body": {
       "collapse": "Colapsar",

locales/es-ES/hotkey.json

@@ -7,6 +7,10 @@
     "desc": "Eliminar los mensajes y archivos subidos de la conversación actual",
     "title": "Eliminar mensajes de la conversación"
   },
+  "commandPalette": {
+    "desc": "Abre el panel de comandos global para acceder rápidamente a las funciones",
+    "title": "Panel de Comandos"
+  },
   "deleteAndRegenerateMessage": {
     "desc": "Eliminar el último mensaje y volver a generarlo",
     "title": "Eliminar y regenerar"

locales/es-ES/image.json

@@ -37,6 +37,14 @@
         "standard": "Estándar"
       }
     },
+    "resolution": {
+      "label": "Resolución",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "Semilla",
       "random": "Semilla aleatoria"

locales/es-ES/modelProvider.json

@@ -295,7 +295,7 @@
       },
       "helpDoc": "Guía de configuración",
       "responsesApi": {
-        "desc": "Utiliza el nuevo formato de solicitud de OpenAI para desbloquear características avanzadas como cadenas de pensamiento",
+        "desc": "Adopta el nuevo formato de solicitud de OpenAI, desbloqueando funciones avanzadas como la cadena de pensamiento (solo compatible con modelos de OpenAI)",
         "title": "Uso de la especificación Responses API"
       },
       "waitingForMore": "Más modelos están en <1>planificación de integración</1>, por favor, espera"

locales/es-ES/models.json

@@ -236,6 +236,9 @@
   "MiniMaxAI/MiniMax-M1-80k": {
     "description": "MiniMax-M1 es un modelo de inferencia de atención mixta a gran escala con pesos de código abierto, que cuenta con 456 mil millones de parámetros, activando aproximadamente 45.9 mil millones de parámetros por token. El modelo soporta de forma nativa contextos ultra largos de hasta 1 millón de tokens y, gracias a su mecanismo de atención relámpago, reduce en un 75 % las operaciones de punto flotante en tareas de generación de 100 mil tokens en comparación con DeepSeek R1. Además, MiniMax-M1 utiliza una arquitectura MoE (Mezcla de Expertos), combinando el algoritmo CISPO y un diseño de atención mixta para un entrenamiento eficiente mediante aprendizaje reforzado, logrando un rendimiento líder en la industria en inferencia con entradas largas y escenarios reales de ingeniería de software."
   },
+  "MiniMaxAI/MiniMax-M2": {
+    "description": "MiniMax-M2 redefine la eficiencia para los agentes inteligentes. Es un modelo MoE compacto, rápido y rentable, con un total de 230 mil millones de parámetros y 10 mil millones de parámetros activos. Está diseñado para ofrecer un rendimiento de primer nivel en tareas de codificación y agentes, manteniendo al mismo tiempo una inteligencia general sólida. Con solo 10 mil millones de parámetros activos, MiniMax-M2 ofrece un rendimiento comparable al de modelos a gran escala, lo que lo convierte en una opción ideal para aplicaciones de alta eficiencia."
+  },
   "Moonshot-Kimi-K2-Instruct": {
     "description": "Con un total de 1 billón de parámetros y 32 mil millones de parámetros activados, este modelo no reflexivo alcanza niveles de vanguardia en conocimiento avanzado, matemáticas y codificación, destacando en tareas generales de agentes. Optimizado para tareas de agentes, no solo responde preguntas sino que también puede actuar. Ideal para conversaciones improvisadas, chat general y experiencias de agentes, es un modelo de nivel reflexivo que no requiere largos tiempos de pensamiento."
   },
@@ -717,25 +720,28 @@
     "description": "Claude 3 Opus es el modelo más inteligente de Anthropic, con un rendimiento líder en el mercado en tareas altamente complejas. Navega indicaciones abiertas y escenarios inéditos con fluidez excepcional y comprensión humana."
   },
   "anthropic/claude-3.5-haiku": {
-    "description": "Claude 3.5 Haiku es la siguiente generación de nuestro modelo más rápido. Con una velocidad similar a Claude 3 Haiku, Claude 3.5 Haiku mejora en cada conjunto de habilidades y supera a nuestro modelo más grande anterior, Claude 3 Opus, en muchas pruebas de referencia de inteligencia."
+    "description": "Claude 3.5 Haiku ofrece capacidades mejoradas en velocidad, precisión de codificación y uso de herramientas. Ideal para escenarios con altas exigencias de velocidad e interacción con herramientas."
   },
   "anthropic/claude-3.5-sonnet": {
-    "description": "Claude 3.5 Sonnet logra un equilibrio ideal entre inteligencia y velocidad, especialmente para cargas de trabajo empresariales. Ofrece un rendimiento potente a menor costo en comparación con productos similares y está diseñado para alta durabilidad en implementaciones de IA a gran escala."
+    "description": "Claude 3.5 Sonnet es un modelo rápido y eficiente de la familia Sonnet, con mejor rendimiento en codificación y razonamiento. Algunas versiones serán reemplazadas gradualmente por Sonnet 3.7 y otros."
   },
   "anthropic/claude-3.7-sonnet": {
-    "description": "Claude 3.7 Sonnet es el primer modelo de razonamiento híbrido y el más inteligente de Anthropic hasta la fecha. Ofrece un rendimiento de vanguardia en codificación, generación de contenido, análisis de datos y tareas de planificación, construido sobre las capacidades de ingeniería de software y computación de su predecesor Claude 3.5 Sonnet."
+    "description": "Claude 3.7 Sonnet es una versión mejorada de la serie Sonnet, con capacidades superiores de razonamiento y codificación, ideal para tareas empresariales complejas."
+  },
+  "anthropic/claude-haiku-4.5": {
+    "description": "Claude Haiku 4.5 es un modelo rápido y de alto rendimiento de Anthropic, que mantiene una alta precisión con una latencia extremadamente baja."
   },
   "anthropic/claude-opus-4": {
-    "description": "Claude Opus 4 es el modelo más potente de Anthropic y el mejor modelo de codificación del mundo, liderando en SWE-bench (72.5%) y Terminal-bench (43.2%). Proporciona rendimiento sostenido para tareas a largo plazo que requieren esfuerzo concentrado y miles de pasos, capaz de trabajar continuamente durante horas, ampliando significativamente las capacidades de los agentes de IA."
+    "description": "Opus 4 es el modelo insignia de Anthropic, diseñado para tareas complejas y aplicaciones empresariales."
   },
   "anthropic/claude-opus-4.1": {
-    "description": "Claude Opus 4.1 es una alternativa plug-and-play a Opus 4, que ofrece un rendimiento y precisión excepcionales para tareas prácticas de codificación y agentes. Eleva el rendimiento de codificación de vanguardia a un 74.5% verificado en SWE-bench y maneja problemas complejos de múltiples pasos con mayor rigor y atención al detalle."
+    "description": "Opus 4.1 es un modelo avanzado de Anthropic, optimizado para programación, razonamiento complejo y tareas continuas."
   },
   "anthropic/claude-sonnet-4": {
-    "description": "Claude Sonnet 4 mejora significativamente las capacidades líderes de Sonnet 3.7, destacándose en codificación con un rendimiento de vanguardia del 72.7% en SWE-bench. El modelo equilibra rendimiento y eficiencia, adecuado para casos de uso internos y externos, y ofrece mayor control mediante una mejor capacidad de control."
+    "description": "Claude Sonnet 4 es una versión de razonamiento híbrido de Anthropic, que combina capacidades de pensamiento y no pensamiento."
   },
   "anthropic/claude-sonnet-4.5": {
-    "description": "Claude Sonnet 4.5 es el modelo más inteligente de Anthropic hasta la fecha."
+    "description": "Claude Sonnet 4.5 es el último modelo de razonamiento híbrido de Anthropic, optimizado para razonamiento complejo y codificación."
   },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B es un modelo de lenguaje grande disperso con 72 mil millones de parámetros y 16 mil millones de parámetros activados. Está basado en la arquitectura de expertos mixtos agrupados (MoGE), que agrupa expertos durante la selección y restringe la activación de un número igual de expertos por grupo para cada token, logrando un balance de carga entre expertos y mejorando significativamente la eficiencia de despliegue en la plataforma Ascend."
@@ -758,6 +764,9 @@
   "baidu/ERNIE-4.5-300B-A47B": {
     "description": "ERNIE-4.5-300B-A47B es un modelo de lenguaje grande desarrollado por Baidu basado en la arquitectura de expertos mixtos (MoE). Cuenta con un total de 300 mil millones de parámetros, pero durante la inferencia solo activa 47 mil millones por token, equilibrando un rendimiento potente con eficiencia computacional. Como uno de los modelos centrales de la serie ERNIE 4.5, destaca en tareas de comprensión, generación, razonamiento y programación de texto. Emplea un innovador método de preentrenamiento multimodal heterogéneo MoE, que combina entrenamiento conjunto de texto y visión, mejorando la capacidad integral del modelo, especialmente en el seguimiento de instrucciones y la memoria de conocimientos del mundo."
   },
+  "baidu/ernie-5.0-thinking-preview": {
+    "description": "ERNIE 5.0 Thinking Preview es el nuevo modelo multimodal nativo de Baidu, especializado en comprensión multimodal, seguimiento de instrucciones, creación, preguntas y respuestas basadas en hechos y uso de herramientas."
+  },
   "c4ai-aya-expanse-32b": {
     "description": "Aya Expanse es un modelo multilingüe de alto rendimiento de 32B, diseñado para desafiar el rendimiento de los modelos monolingües a través de innovaciones en ajuste por instrucciones, arbitraje de datos, entrenamiento de preferencias y fusión de modelos. Soporta 23 idiomas."
   },
@@ -866,6 +875,9 @@
   "codex-mini-latest": {
     "description": "codex-mini-latest es una versión ajustada de o4-mini, diseñada específicamente para Codex CLI. Para uso directo a través de la API, recomendamos comenzar con gpt-4.1."
   },
+  "cogito-2.1:671b": {
+    "description": "Cogito v2.1 671B es un modelo de lenguaje grande de código abierto estadounidense con licencia comercial gratuita. Ofrece un rendimiento comparable a los mejores modelos, mayor eficiencia de inferencia por token, contexto largo de 128k y potentes capacidades generales."
+  },
   "cogview-4": {
     "description": "CogView-4 es el primer modelo de generación de imágenes a partir de texto de código abierto de Zhipu que admite la generación de caracteres chinos. Ofrece mejoras integrales en la comprensión semántica, la calidad de generación de imágenes y la capacidad de generar texto en chino e inglés. Soporta entradas bilingües en chino e inglés de cualquier longitud y puede generar imágenes en cualquier resolución dentro del rango especificado."
   },
@@ -1136,6 +1148,9 @@
   "deepseek-vl2-small": {
     "description": "DeepSeek VL2 Small, versión multimodal ligera, adecuada para entornos con recursos limitados y escenarios de alta concurrencia."
   },
+  "deepseek/deepseek-chat": {
+    "description": "DeepSeek-V3 es un modelo de razonamiento híbrido de alto rendimiento del equipo DeepSeek, adecuado para tareas complejas e integración con herramientas."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 es un modelo experto de mezcla de 685B parámetros, la última iteración de la serie de modelos de chat insignia del equipo de DeepSeek.\n\nHereda el modelo [DeepSeek V3](/deepseek/deepseek-chat-v3) y se desempeña excepcionalmente en diversas tareas."
   },
@@ -1143,19 +1158,19 @@
     "description": "DeepSeek V3 es un modelo experto de mezcla de 685B parámetros, la última iteración de la serie de modelos de chat insignia del equipo de DeepSeek.\n\nHereda el modelo [DeepSeek V3](/deepseek/deepseek-chat-v3) y se desempeña excepcionalmente en diversas tareas."
   },
   "deepseek/deepseek-chat-v3.1": {
-    "description": "DeepSeek-V3.1 es un modelo híbrido de razonamiento grande que soporta contexto largo de 128K y cambio eficiente de modos, logrando un rendimiento y velocidad sobresalientes en llamadas a herramientas, generación de código y tareas complejas de razonamiento."
+    "description": "DeepSeek-V3.1 es un modelo de razonamiento híbrido con contexto largo de DeepSeek, compatible con modos de pensamiento/no pensamiento e integración de herramientas."
   },
   "deepseek/deepseek-r1": {
     "description": "El modelo DeepSeek R1 ha recibido una actualización menor, actualmente en la versión DeepSeek-R1-0528. En la última actualización, DeepSeek R1 mejora significativamente la profundidad y capacidad de razonamiento al aprovechar recursos computacionales aumentados y mecanismos de optimización algorítmica post-entrenamiento. El modelo destaca en evaluaciones de referencia en matemáticas, programación y lógica general, acercándose al rendimiento de modelos líderes como O3 y Gemini 2.5 Pro."
   },
   "deepseek/deepseek-r1-0528": {
-    "description": "DeepSeek-R1 mejora enormemente la capacidad de razonamiento del modelo con muy pocos datos etiquetados. Antes de generar la respuesta final, el modelo produce una cadena de pensamiento para aumentar la precisión de la respuesta."
+    "description": "DeepSeek R1 0528 es una variante actualizada de DeepSeek, centrada en la disponibilidad de código abierto y profundidad de razonamiento."
   },
   "deepseek/deepseek-r1-0528:free": {
     "description": "DeepSeek-R1 mejora enormemente la capacidad de razonamiento del modelo con muy pocos datos etiquetados. Antes de generar la respuesta final, el modelo produce una cadena de pensamiento para aumentar la precisión de la respuesta."
   },
   "deepseek/deepseek-r1-distill-llama-70b": {
-    "description": "DeepSeek-R1-Distill-Llama-70B es una variante destilada y más eficiente del modelo Llama de 70B. Mantiene un rendimiento sólido en tareas de generación de texto, reduciendo el costo computacional para facilitar su despliegue e investigación. Operado por Groq con su hardware personalizado de unidad de procesamiento de lenguaje (LPU) para ofrecer inferencia rápida y eficiente."
+    "description": "DeepSeek R1 Distill Llama 70B es un modelo de lenguaje de gran escala basado en Llama3.3 70B. Este modelo ha sido ajustado finamente utilizando las salidas de DeepSeek R1, logrando un rendimiento competitivo comparable al de los modelos más avanzados del mercado."
   },
   "deepseek/deepseek-r1-distill-llama-8b": {
     "description": "DeepSeek R1 Distill Llama 8B es un modelo de lenguaje grande destilado basado en Llama-3.1-8B-Instruct, entrenado utilizando la salida de DeepSeek R1."
@@ -1172,6 +1187,9 @@
   "deepseek/deepseek-r1:free": {
     "description": "DeepSeek-R1 mejora significativamente la capacidad de razonamiento del modelo con muy pocos datos etiquetados. Antes de proporcionar la respuesta final, el modelo genera una cadena de pensamiento para mejorar la precisión de la respuesta final."
   },
+  "deepseek/deepseek-reasoner": {
+    "description": "DeepSeek-V3 Thinking (reasoner) es un modelo experimental de razonamiento de DeepSeek, diseñado para tareas de razonamiento de alta complejidad."
+  },
   "deepseek/deepseek-v3": {
     "description": "Modelo de lenguaje grande universal rápido con capacidades de razonamiento mejoradas."
   },
@@ -1478,9 +1496,6 @@
   "gemini-2.0-flash-lite-001": {
     "description": "Variante del modelo Gemini 2.0 Flash, optimizada para objetivos como la rentabilidad y la baja latencia."
   },
-  "gemini-2.0-flash-preview-image-generation": {
-    "description": "Modelo de vista previa Gemini 2.0 Flash, que admite la generación de imágenes"
-  },
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash es el modelo de mejor relación calidad-precio de Google, que ofrece funcionalidades completas."
   },
@@ -1508,9 +1523,6 @@
   "gemini-2.5-flash-preview-04-17": {
     "description": "Gemini 2.5 Flash Preview es el modelo más rentable de Google, que ofrece una funcionalidad completa."
   },
-  "gemini-2.5-flash-preview-05-20": {
-    "description": "Gemini 2.5 Flash Preview es el modelo de mejor relación calidad-precio de Google, que ofrece funcionalidades completas."
-  },
   "gemini-2.5-flash-preview-09-2025": {
     "description": "Versión preliminar (25 de septiembre de 2025) de Gemini 2.5 Flash"
   },
@@ -1526,6 +1538,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview es el modelo de pensamiento más avanzado de Google, capaz de razonar sobre problemas complejos en código, matemáticas y áreas STEM, así como analizar grandes conjuntos de datos, bases de código y documentos utilizando contextos extensos."
   },
+  "gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) es el modelo de generación de imágenes de Google, compatible con diálogos multimodales."
+  },
+  "gemini-3-pro-image-preview:image": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) es el modelo de generación de imágenes de Google, compatible con diálogos multimodales."
+  },
+  "gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro es el mejor modelo de comprensión multimodal del mundo, y el agente más potente de Google hasta la fecha. Ofrece efectos visuales más ricos e interacciones más profundas, todo basado en capacidades de razonamiento de vanguardia."
+  },
   "gemini-flash-latest": {
     "description": "Última versión de Gemini Flash"
   },
@@ -1650,7 +1671,7 @@
     "description": "GLM-Zero-Preview posee una poderosa capacidad de razonamiento complejo, destacándose en áreas como razonamiento lógico, matemáticas y programación."
   },
   "google/gemini-2.0-flash": {
-    "description": "Gemini 2.0 Flash ofrece funcionalidades de próxima generación y mejoras, incluyendo velocidad sobresaliente, uso integrado de herramientas, generación multimodal y una ventana de contexto de 1 millón de tokens."
+    "description": "Gemini 2.0 Flash es un modelo de razonamiento de alto rendimiento de Google, adecuado para tareas multimodales extendidas."
   },
   "google/gemini-2.0-flash-001": {
     "description": "Gemini 2.0 Flash ofrece funciones y mejoras de próxima generación, incluyendo velocidad excepcional, uso de herramientas nativas, generación multimodal y una ventana de contexto de 1M tokens."
@@ -1661,14 +1682,23 @@
   "google/gemini-2.0-flash-lite": {
     "description": "Gemini 2.0 Flash Lite ofrece funcionalidades de próxima generación y mejoras, incluyendo velocidad sobresaliente, uso integrado de herramientas, generación multimodal y una ventana de contexto de 1 millón de tokens."
   },
+  "google/gemini-2.0-flash-lite-001": {
+    "description": "Gemini 2.0 Flash Lite es la versión ligera de la familia Gemini. Por defecto, el razonamiento está desactivado para mejorar la latencia y el coste, pero puede activarse mediante parámetros."
+  },
   "google/gemini-2.5-flash": {
-    "description": "Gemini 2.5 Flash es un modelo de pensamiento que ofrece capacidades integrales sobresalientes. Está diseñado para equilibrar precio y rendimiento, soportando multimodalidad y una ventana de contexto de 1 millón de tokens."
+    "description": "La serie Gemini 2.5 Flash (Lite/Pro/Flash) son modelos de razonamiento de Google que van desde baja latencia hasta alto rendimiento."
+  },
+  "google/gemini-2.5-flash-image": {
+    "description": "Gemini 2.5 Flash Image (Nano Banana) es el modelo de generación de imágenes de Google, compatible con diálogos multimodales."
+  },
+  "google/gemini-2.5-flash-image-free": {
+    "description": "Versión gratuita de Gemini 2.5 Flash Image, compatible con generación multimodal con cuota limitada."
   },
   "google/gemini-2.5-flash-image-preview": {
     "description": "Modelo experimental Gemini 2.5 Flash, compatible con generación de imágenes."
   },
   "google/gemini-2.5-flash-lite": {
-    "description": "Gemini 2.5 Flash-Lite es un modelo equilibrado y de baja latencia, con presupuesto de pensamiento configurable y conectividad de herramientas (por ejemplo, búsqueda de Google y ejecución de código). Soporta entradas multimodales y ofrece una ventana de contexto de 1 millón de tokens."
+    "description": "Gemini 2.5 Flash Lite es la versión ligera de Gemini 2.5, optimizada para latencia y coste, ideal para escenarios de alto rendimiento."
   },
   "google/gemini-2.5-flash-preview": {
     "description": "Gemini 2.5 Flash es el modelo principal más avanzado de Google, diseñado para razonamiento avanzado, codificación, matemáticas y tareas científicas. Incluye la capacidad de 'pensar' incorporada, lo que le permite proporcionar respuestas con mayor precisión y un manejo más detallado del contexto.\n\nNota: Este modelo tiene dos variantes: con pensamiento y sin pensamiento. La fijación de precios de salida varía significativamente según si la capacidad de pensamiento está activada. Si elige la variante estándar (sin el sufijo ':thinking'), el modelo evitará explícitamente generar tokens de pensamiento.\n\nPara aprovechar la capacidad de pensamiento y recibir tokens de pensamiento, debe elegir la variante ':thinking', lo que resultará en un precio de salida de pensamiento más alto.\n\nAdemás, Gemini 2.5 Flash se puede configurar a través del parámetro 'número máximo de tokens de razonamiento', como se describe en la documentación (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
@@ -1677,11 +1707,26 @@
     "description": "Gemini 2.5 Flash es el modelo principal más avanzado de Google, diseñado para razonamiento avanzado, codificación, matemáticas y tareas científicas. Incluye la capacidad de 'pensar' incorporada, lo que le permite proporcionar respuestas con mayor precisión y un manejo más detallado del contexto.\n\nNota: Este modelo tiene dos variantes: con pensamiento y sin pensamiento. La fijación de precios de salida varía significativamente según si la capacidad de pensamiento está activada. Si elige la variante estándar (sin el sufijo ':thinking'), el modelo evitará explícitamente generar tokens de pensamiento.\n\nPara aprovechar la capacidad de pensamiento y recibir tokens de pensamiento, debe elegir la variante ':thinking', lo que resultará en un precio de salida de pensamiento más alto.\n\nAdemás, Gemini 2.5 Flash se puede configurar a través del parámetro 'número máximo de tokens de razonamiento', como se describe en la documentación (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
   },
   "google/gemini-2.5-pro": {
-    "description": "Gemini 2.5 Pro es nuestro modelo Gemini de inferencia más avanzado, capaz de resolver problemas complejos. Cuenta con una ventana de contexto de 2 millones de tokens y soporta entradas multimodales, incluyendo texto, imágenes, audio, video y documentos PDF."
+    "description": "Gemini 2.5 Pro es el modelo de razonamiento insignia de Google, compatible con contexto largo y tareas complejas."
+  },
+  "google/gemini-2.5-pro-free": {
+    "description": "Versión gratuita de Gemini 2.5 Pro, compatible con contexto largo multimodal con cuota limitada, ideal para pruebas y flujos de trabajo ligeros."
   },
   "google/gemini-2.5-pro-preview": {
     "description": "Gemini 2.5 Pro Preview es el modelo de pensamiento más avanzado de Google, capaz de razonar sobre problemas complejos en código, matemáticas y áreas STEM, así como de analizar grandes conjuntos de datos, bases de código y documentos utilizando contextos extensos."
   },
+  "google/gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) es el modelo de generación de imágenes de Google, que también admite conversaciones multimodales."
+  },
+  "google/gemini-3-pro-image-preview-free": {
+    "description": "Versión gratuita de Gemini 3 Pro Image, compatible con generación multimodal con cuota limitada."
+  },
+  "google/gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro es la próxima generación de modelos de razonamiento multimodal de la serie Gemini, capaz de comprender texto, audio, imágenes, vídeo y más, y manejar tareas complejas y grandes bases de código."
+  },
+  "google/gemini-3-pro-preview-free": {
+    "description": "Versión de vista previa gratuita de Gemini 3 Pro, con las mismas capacidades de comprensión y razonamiento multimodal que la versión estándar, pero con limitaciones de cuota y velocidad. Más adecuada para pruebas y uso ocasional."
+  },
   "google/gemini-embedding-001": {
     "description": "Modelo de incrustaciones de última generación con rendimiento sobresaliente en tareas en inglés, multilingües y de código."
   },
@@ -1907,6 +1952,12 @@
   "grok-4-0709": {
     "description": "Grok 4 de xAI, con potentes capacidades de razonamiento."
   },
+  "grok-4-1-fast-non-reasoning": {
+    "description": "Modelo multimodal de vanguardia, optimizado específicamente para llamadas de herramientas de agente de alto rendimiento."
+  },
+  "grok-4-1-fast-reasoning": {
+    "description": "Modelo multimodal de vanguardia, optimizado específicamente para llamadas de herramientas de agente de alto rendimiento."
+  },
   "grok-4-fast-non-reasoning": {
     "description": "Nos complace anunciar Grok 4 Fast, nuestro último avance en modelos de inferencia con alta relación costo-beneficio."
   },
@@ -2051,21 +2102,36 @@
   "inception/mercury-coder-small": {
     "description": "Mercury Coder Small es la opción ideal para tareas de generación, depuración y refactorización de código, con latencia mínima."
   },
-  "inclusionAI/Ling-1T": {
-    "description": "Ling-1T es el primer modelo insignia sin razonamiento de la serie \"Ling 2.0\", con un total de un billón de parámetros y aproximadamente 50 mil millones de parámetros activos por token. Construido sobre la arquitectura Ling 2.0, Ling-1T está diseñado para superar los límites del razonamiento eficiente y la cognición escalable. Ling-1T-base ha sido entrenado con más de 20 billones de tokens de alta calidad y con alta densidad de razonamiento."
-  },
   "inclusionAI/Ling-flash-2.0": {
     "description": "Ling-flash-2.0 es el tercer modelo de la serie Ling 2.0 basado en la arquitectura MoE, lanzado por el equipo Bailing de Ant Group. Cuenta con 100 mil millones de parámetros totales, pero solo activa 6.1 mil millones por token (4.8 mil millones sin incluir embeddings). Como un modelo de configuración ligera, Ling-flash-2.0 demuestra en múltiples evaluaciones oficiales un rendimiento comparable o superior a modelos densos de 40 mil millones y a modelos MoE de mayor escala. Este modelo busca explorar caminos eficientes bajo el consenso de que un modelo grande equivale a muchos parámetros, mediante un diseño arquitectónico y estrategias de entrenamiento extremas."
   },
   "inclusionAI/Ling-mini-2.0": {
     "description": "Ling-mini-2.0 es un modelo de lenguaje grande de alto rendimiento y tamaño reducido basado en arquitectura MoE. Cuenta con 16 mil millones de parámetros totales, pero solo activa 1.4 mil millones por token (789 millones sin incluir embeddings), logrando una velocidad de generación muy alta. Gracias a un diseño MoE eficiente y a un entrenamiento masivo con datos de alta calidad, Ling-mini-2.0 ofrece un rendimiento de primer nivel en tareas downstream, comparable a modelos densos de menos de 10 mil millones y a modelos MoE de mayor escala."
   },
-  "inclusionAI/Ring-1T": {
-    "description": "Ring-1T es un modelo de pensamiento de código abierto a escala de un billón de parámetros, lanzado por el equipo Bailing. Basado en la arquitectura Ling 2.0 y el modelo base Ling-1T, cuenta con un total de un billón de parámetros y 50 mil millones de parámetros activos, y admite una ventana de contexto de hasta 128K. El modelo ha sido optimizado mediante aprendizaje por refuerzo con recompensas verificables a gran escala."
-  },
   "inclusionAI/Ring-flash-2.0": {
     "description": "Ring-flash-2.0 es un modelo de pensamiento de alto rendimiento profundamente optimizado basado en Ling-flash-2.0-base. Utiliza arquitectura MoE con 100 mil millones de parámetros totales, pero solo activa 6.1 mil millones en cada inferencia. Gracias al algoritmo innovador icepop, resuelve la inestabilidad de los grandes modelos MoE en entrenamiento por refuerzo (RL), mejorando continuamente su capacidad de razonamiento complejo en entrenamientos prolongados. Ring-flash-2.0 ha logrado avances significativos en competencias matemáticas, generación de código y razonamiento lógico, superando modelos densos de hasta 40 mil millones de parámetros y equiparándose a modelos MoE de mayor escala y modelos de pensamiento de alto rendimiento cerrados. Aunque está enfocado en razonamiento complejo, también destaca en tareas creativas de escritura. Además, su diseño eficiente permite un rendimiento rápido y reduce significativamente los costos de despliegue en escenarios de alta concurrencia."
   },
+  "inclusionai/ling-1t": {
+    "description": "Ling-1T es el modelo MoE de 1T de inclusionAI, optimizado para tareas de razonamiento intensivo y contexto a gran escala."
+  },
+  "inclusionai/ling-flash-2.0": {
+    "description": "Ling-flash-2.0 es un modelo MoE de inclusionAI, optimizado en eficiencia y rendimiento de razonamiento, adecuado para tareas medianas y grandes."
+  },
+  "inclusionai/ling-mini-2.0": {
+    "description": "Ling-mini-2.0 es un modelo MoE ligero de inclusionAI, que reduce significativamente los costes manteniendo la capacidad de razonamiento."
+  },
+  "inclusionai/ming-flash-omini-preview": {
+    "description": "Ming-flash-omni Preview es un modelo multimodal de inclusionAI, compatible con entradas de voz, imagen y vídeo, optimizado para renderizado de imágenes y reconocimiento de voz."
+  },
+  "inclusionai/ring-1t": {
+    "description": "Ring-1T es el modelo MoE de un billón de parámetros de inclusionAI, diseñado para razonamiento a gran escala y tareas de investigación."
+  },
+  "inclusionai/ring-flash-2.0": {
+    "description": "Ring-flash-2.0 es una variante del modelo Ring de inclusionAI para escenarios de alto rendimiento, centrado en velocidad y eficiencia de costes."
+  },
+  "inclusionai/ring-mini-2.0": {
+    "description": "Ring-mini-2.0 es la versión ligera de alto rendimiento del modelo MoE de inclusionAI, diseñada principalmente para escenarios concurrentes."
+  },
   "internlm/internlm2_5-7b-chat": {
     "description": "InternLM2.5 ofrece soluciones de diálogo inteligente en múltiples escenarios."
   },
@@ -2117,6 +2183,12 @@
   "kimi-k2-instruct": {
     "description": "Kimi K2 Instruct, modelo de inferencia oficial de Kimi, compatible con contexto largo, código, preguntas y respuestas, entre otros escenarios."
   },
+  "kimi-k2-thinking": {
+    "description": "Modelo de pensamiento K2 con contexto de 256k, compatible con llamadas de herramientas en múltiples pasos y razonamiento, especializado en resolver problemas complejos."
+  },
+  "kimi-k2-thinking-turbo": {
+    "description": "Versión rápida del modelo de pensamiento K2, compatible con contexto de 256k, especializado en razonamiento profundo, con velocidad de salida de 60-100 tokens por segundo."
+  },
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 es un modelo base con arquitectura MoE que ofrece potentes capacidades para código y agentes, con 1T parámetros totales y 32B parámetros activados. En las pruebas de referencia en categorías principales como razonamiento de conocimiento general, programación, matemáticas y agentes, el rendimiento del modelo K2 supera al de otros modelos de código abierto más extendidos."
   },
@@ -2129,6 +2201,9 @@
   "kimi-thinking-preview": {
     "description": "El modelo kimi-thinking-preview, proporcionado por la cara oculta de la luna, es un modelo multimodal de pensamiento con capacidades de razonamiento multimodal y general, especializado en razonamiento profundo para ayudar a resolver problemas más complejos."
   },
+  "kuaishou/kat-coder-pro-v1": {
+    "description": "KAT-Coder-Pro-V1 (gratis por tiempo limitado) se centra en la comprensión de código y programación automatizada, ideal para tareas de agente de programación eficiente."
+  },
   "learnlm-1.5-pro-experimental": {
     "description": "LearnLM es un modelo de lenguaje experimental y específico para tareas, entrenado para cumplir con los principios de la ciencia del aprendizaje, capaz de seguir instrucciones sistemáticas en escenarios de enseñanza y aprendizaje, actuando como un tutor experto, entre otros."
   },
@@ -2225,6 +2300,9 @@
   "megrez-3b-instruct": {
     "description": "Megrez 3B Instruct es un modelo eficiente de bajo número de parámetros desarrollado por Wuwen Xinqiong."
   },
+  "meituan/longcat-flash-chat": {
+    "description": "Modelo base no reflexivo de código abierto de Meituan, optimizado para interacciones conversacionales y tareas de agentes inteligentes, con un rendimiento destacado en llamadas a herramientas y escenarios complejos de múltiples turnos."
+  },
   "meta-llama-3-70b-instruct": {
     "description": "Un poderoso modelo de 70 mil millones de parámetros que sobresale en razonamiento, codificación y amplias aplicaciones de lenguaje."
   },
@@ -2456,6 +2534,12 @@
   "minimax-m2": {
     "description": "MiniMax M2 es un modelo de lenguaje grande y eficiente, diseñado para flujos de trabajo de codificación y agentes."
   },
+  "minimax/minimax-m2": {
+    "description": "MiniMax-M2 es un modelo de alto rendimiento y rentabilidad, excelente en tareas de codificación y agentes, adecuado para diversos escenarios de ingeniería."
+  },
+  "minimaxai/minimax-m2": {
+    "description": "MiniMax-M2 es un modelo de expertos mixtos (MoE) compacto, rápido y rentable, con un total de 230 mil millones de parámetros y 10 mil millones de parámetros activos. Está diseñado para ofrecer un rendimiento de primer nivel en tareas de codificación y agentes, manteniendo una inteligencia general robusta. El modelo destaca en edición de múltiples archivos, ciclos cerrados de codificación-ejecución-corrección, verificación y corrección de pruebas, así como en complejas cadenas de herramientas de enlaces largos, lo que lo convierte en una opción ideal para los flujos de trabajo de los desarrolladores."
+  },
   "ministral-3b-latest": {
     "description": "Ministral 3B es el modelo de borde de primer nivel mundial de Mistral."
   },
@@ -2600,12 +2684,21 @@
   "moonshotai/kimi-k2": {
     "description": "Kimi K2 es un modelo de lenguaje de expertos mixtos (MoE) a gran escala desarrollado por Moonshot AI, con un total de un billón de parámetros y 32 mil millones de parámetros activos por pasada. Está optimizado para capacidades de agente, incluyendo uso avanzado de herramientas, razonamiento y síntesis de código."
   },
+  "moonshotai/kimi-k2-0711": {
+    "description": "Kimi K2 0711 es la versión Instruct de la serie Kimi, adecuada para escenarios de código de alta calidad y llamadas de herramientas."
+  },
   "moonshotai/kimi-k2-0905": {
-    "description": "El modelo kimi-k2-0905-preview tiene una longitud de contexto de 256k, con una mayor capacidad de codificación agentiva, una estética y funcionalidad mejoradas en el código frontend, y una mejor comprensión del contexto."
+    "description": "Kimi K2 0905 es la actualización 0905 de la serie Kimi, con mejoras en contexto y rendimiento de razonamiento, optimizado para codificación."
   },
   "moonshotai/kimi-k2-instruct-0905": {
     "description": "El modelo kimi-k2-0905-preview tiene una longitud de contexto de 256k, con una mayor capacidad de codificación agentiva, una estética y funcionalidad mejoradas en el código frontend, y una mejor comprensión del contexto."
   },
+  "moonshotai/kimi-k2-thinking": {
+    "description": "Kimi K2 Thinking es un modelo de pensamiento optimizado por Moonshot para tareas de razonamiento profundo, con capacidades generales de agente."
+  },
+  "moonshotai/kimi-k2-thinking-turbo": {
+    "description": "Kimi K2 Thinking Turbo es la versión rápida de Kimi K2 Thinking, que mantiene el razonamiento profundo con una latencia de respuesta significativamente reducida."
+  },
   "morph/morph-v3-fast": {
     "description": "Morph ofrece un modelo de IA especializado que aplica rápidamente los cambios de código sugeridos por modelos de vanguardia como Claude o GPT-4o a sus archivos de código existentes, con una velocidad de más de 4500 tokens por segundo. Actúa como el último paso en el flujo de trabajo de codificación de IA. Soporta 16k tokens de entrada y 16k tokens de salida."
   },
@@ -2688,28 +2781,49 @@
     "description": "gpt-4-turbo de OpenAI posee un amplio conocimiento general y experiencia en dominios, permitiéndole seguir instrucciones complejas en lenguaje natural y resolver problemas difíciles con precisión. Su fecha de corte de conocimiento es abril de 2023 y tiene una ventana de contexto de 128,000 tokens."
   },
   "openai/gpt-4.1": {
-    "description": "GPT 4.1 es el modelo insignia de OpenAI, adecuado para tareas complejas. Es excelente para resolver problemas interdisciplinarios."
+    "description": "La serie GPT-4.1 ofrece mayor contexto y capacidades mejoradas de ingeniería y razonamiento."
   },
   "openai/gpt-4.1-mini": {
-    "description": "GPT 4.1 mini equilibra inteligencia, velocidad y costo, convirtiéndolo en un modelo atractivo para muchos casos de uso."
+    "description": "GPT-4.1 Mini ofrece menor latencia y mejor relación calidad-precio, ideal para líneas de contexto medio."
   },
   "openai/gpt-4.1-nano": {
-    "description": "GPT-4.1 nano es el modelo GPT 4.1 más rápido y rentable."
+    "description": "GPT-4.1 Nano es una opción de muy bajo coste y baja latencia, adecuada para diálogos cortos frecuentes o tareas de clasificación."
   },
   "openai/gpt-4o": {
-    "description": "GPT-4o de OpenAI tiene un amplio conocimiento general y experiencia en dominios, capaz de seguir instrucciones complejas en lenguaje natural y resolver problemas difíciles con precisión. Ofrece un rendimiento equivalente a GPT-4 Turbo con una API más rápida y económica."
+    "description": "La serie GPT-4o es el modelo Omni de OpenAI, compatible con entrada de texto + imagen y salida de texto."
   },
   "openai/gpt-4o-mini": {
-    "description": "GPT-4o mini de OpenAI es su modelo pequeño más avanzado y rentable. Es multimodal (acepta entradas de texto o imagen y produce texto) y es más inteligente que gpt-3.5-turbo, manteniendo la misma velocidad."
+    "description": "GPT-4o-mini es la versión rápida y compacta de GPT-4o, ideal para escenarios mixtos de texto e imagen con baja latencia."
   },
   "openai/gpt-5": {
-    "description": "GPT-5 es el modelo de lenguaje insignia de OpenAI, sobresaliendo en razonamiento complejo, amplio conocimiento del mundo real, tareas intensivas en código y tareas de agente de múltiples pasos."
+    "description": "GPT-5 es el modelo de alto rendimiento de OpenAI, adecuado para una amplia gama de tareas de producción e investigación."
+  },
+  "openai/gpt-5-chat": {
+    "description": "GPT-5 Chat es una subversión de GPT-5 optimizada para escenarios conversacionales, con menor latencia para mejorar la experiencia interactiva."
+  },
+  "openai/gpt-5-codex": {
+    "description": "GPT-5-Codex es una variante de GPT-5 optimizada para codificación, ideal para flujos de trabajo de código a gran escala."
   },
   "openai/gpt-5-mini": {
-    "description": "GPT-5 mini es un modelo optimizado en costos que sobresale en tareas de razonamiento y chat. Ofrece el mejor equilibrio entre velocidad, costo y capacidad."
+    "description": "GPT-5 Mini es la versión compacta de la familia GPT-5, adecuada para escenarios de baja latencia y bajo coste."
   },
   "openai/gpt-5-nano": {
-    "description": "GPT-5 nano es un modelo de alto rendimiento que sobresale en tareas simples de instrucciones o clasificación."
+    "description": "GPT-5 Nano es la versión ultra compacta de la familia, ideal para escenarios con requisitos muy estrictos de coste y latencia."
+  },
+  "openai/gpt-5-pro": {
+    "description": "GPT-5 Pro es el modelo insignia de OpenAI, con capacidades avanzadas de razonamiento, generación de código y funciones empresariales, compatible con enrutamiento de pruebas y políticas de seguridad más rigurosas."
+  },
+  "openai/gpt-5.1": {
+    "description": "GPT-5.1 es el último modelo insignia de la serie GPT-5, con mejoras significativas en razonamiento general, seguimiento de instrucciones y naturalidad en el diálogo, adecuado para una amplia gama de tareas."
+  },
+  "openai/gpt-5.1-chat": {
+    "description": "GPT-5.1 Chat es el miembro ligero de la familia GPT-5.1, optimizado para diálogos de baja latencia, manteniendo sólidas capacidades de razonamiento y ejecución de instrucciones."
+  },
+  "openai/gpt-5.1-codex": {
+    "description": "GPT-5.1-Codex es una variante de GPT-5.1 optimizada para ingeniería de software y flujos de trabajo de codificación, ideal para refactorización a gran escala, depuración compleja y codificación autónoma prolongada."
+  },
+  "openai/gpt-5.1-codex-mini": {
+    "description": "GPT-5.1-Codex-Mini es la versión compacta y acelerada de GPT-5.1-Codex, más adecuada para escenarios de codificación sensibles a latencia y coste."
   },
   "openai/gpt-oss-120b": {
     "description": "Modelo de lenguaje grande universal extremadamente competente con capacidades de razonamiento potentes y controlables."
@@ -2736,7 +2850,7 @@
     "description": "o3-mini de alto nivel de razonamiento proporciona alta inteligencia con los mismos objetivos de costo y latencia que o1-mini."
   },
   "openai/o4-mini": {
-    "description": "o4-mini de OpenAI ofrece inferencia rápida y rentable, con un rendimiento sobresaliente para su tamaño, especialmente en matemáticas (destacando en la prueba de referencia AIME), codificación y tareas visuales."
+    "description": "OpenAI o4-mini es un modelo de razonamiento compacto y eficiente de OpenAI, ideal para escenarios de baja latencia."
   },
   "openai/o4-mini-high": {
     "description": "Versión de alto nivel de inferencia de o4-mini, optimizada para una inferencia rápida y efectiva, mostrando una alta eficiencia y rendimiento en tareas de codificación y visuales."
@@ -2940,7 +3054,7 @@
     "description": "Poderoso modelo de código de tamaño mediano, que soporta longitudes de contexto de 32K, experto en programación multilingüe."
   },
   "qwen/qwen3-14b": {
-    "description": "Qwen3-14B es un modelo de lenguaje causal denso de 14.8 mil millones de parámetros en la serie Qwen3, diseñado para razonamiento complejo y diálogos eficientes. Soporta un cambio sin problemas entre un modo de 'pensamiento' para tareas de matemáticas, programación y razonamiento lógico, y un modo 'no reflexivo' para diálogos generales. Este modelo ha sido ajustado para seguir instrucciones, utilizar herramientas de agentes, escribir creativamente y realizar tareas multilingües en más de 100 idiomas y dialectos. Maneja de forma nativa un contexto de 32K tokens y se puede expandir a 131K tokens utilizando extensiones basadas en YaRN."
+    "description": "Qwen3-14B es la versión de 14B de la serie Qwen, adecuada para razonamiento general y escenarios conversacionales."
   },
   "qwen/qwen3-14b:free": {
     "description": "Qwen3-14B es un modelo de lenguaje causal denso de 14.8 mil millones de parámetros en la serie Qwen3, diseñado para razonamiento complejo y diálogos eficientes. Soporta un cambio sin problemas entre un modo de 'pensamiento' para tareas de matemáticas, programación y razonamiento lógico, y un modo 'no reflexivo' para diálogos generales. Este modelo ha sido ajustado para seguir instrucciones, utilizar herramientas de agentes, escribir creativamente y realizar tareas multilingües en más de 100 idiomas y dialectos. Maneja de forma nativa un contexto de 32K tokens y se puede expandir a 131K tokens utilizando extensiones basadas en YaRN."
@@ -2948,6 +3062,12 @@
   "qwen/qwen3-235b-a22b": {
     "description": "Qwen3-235B-A22B es un modelo de mezcla de expertos (MoE) de 235B parámetros desarrollado por Qwen, que activa 22B parámetros en cada pasada hacia adelante. Soporta un cambio sin problemas entre un modo de 'pensamiento' para razonamiento complejo, matemáticas y tareas de código, y un modo 'no reflexivo' para eficiencia en diálogos generales. Este modelo demuestra una fuerte capacidad de razonamiento, soporte multilingüe (más de 100 idiomas y dialectos), y habilidades avanzadas de seguimiento de instrucciones y llamadas a herramientas de agentes. Maneja de forma nativa una ventana de contexto de 32K tokens y se puede expandir a 131K tokens utilizando extensiones basadas en YaRN."
   },
+  "qwen/qwen3-235b-a22b-2507": {
+    "description": "Qwen3-235B-A22B-Instruct-2507 es la versión Instruct de la serie Qwen3, compatible con instrucciones multilingües y escenarios de contexto largo."
+  },
+  "qwen/qwen3-235b-a22b-thinking-2507": {
+    "description": "Qwen3-235B-A22B-Thinking-2507 es la variante de pensamiento de Qwen3, reforzada para tareas complejas de matemáticas y razonamiento."
+  },
   "qwen/qwen3-235b-a22b:free": {
     "description": "Qwen3-235B-A22B es un modelo de mezcla de expertos (MoE) de 235B parámetros desarrollado por Qwen, que activa 22B parámetros en cada pasada hacia adelante. Soporta un cambio sin problemas entre un modo de 'pensamiento' para razonamiento complejo, matemáticas y tareas de código, y un modo 'no reflexivo' para eficiencia en diálogos generales. Este modelo demuestra una fuerte capacidad de razonamiento, soporte multilingüe (más de 100 idiomas y dialectos), y habilidades avanzadas de seguimiento de instrucciones y llamadas a herramientas de agentes. Maneja de forma nativa una ventana de contexto de 32K tokens y se puede expandir a 131K tokens utilizando extensiones basadas en YaRN."
   },
@@ -2966,6 +3086,21 @@
   "qwen/qwen3-8b:free": {
     "description": "Qwen3-8B es un modelo de lenguaje causal denso de 8.2 mil millones de parámetros en la serie Qwen3, diseñado para tareas intensivas en razonamiento y diálogos eficientes. Soporta un cambio sin problemas entre un modo de 'pensamiento' para matemáticas, codificación y razonamiento lógico, y un modo 'no reflexivo' para diálogos generales. Este modelo ha sido ajustado para seguir instrucciones, integrar agentes, escribir creativamente y utilizar más de 100 idiomas y dialectos. Soporta de forma nativa una ventana de contexto de 32K tokens y se puede expandir a 131K tokens a través de YaRN."
   },
+  "qwen/qwen3-coder": {
+    "description": "Qwen3-Coder es la familia de generadores de código de Qwen3, especializada en comprensión y generación de código en documentos largos."
+  },
+  "qwen/qwen3-coder-plus": {
+    "description": "Qwen3-Coder-Plus es un modelo de agente de codificación especialmente optimizado de la serie Qwen, compatible con llamadas de herramientas más complejas y conversaciones prolongadas."
+  },
+  "qwen/qwen3-max": {
+    "description": "Qwen3 Max es el modelo de razonamiento avanzado de la serie Qwen3, adecuado para razonamiento multilingüe e integración de herramientas."
+  },
+  "qwen/qwen3-max-preview": {
+    "description": "Qwen3 Max (preview) es la versión Max de la serie Qwen orientada a razonamiento avanzado e integración de herramientas (versión preliminar)."
+  },
+  "qwen/qwen3-vl-plus": {
+    "description": "Qwen3 VL-Plus es la versión mejorada en visión de Qwen3, con capacidades mejoradas de razonamiento multimodal y procesamiento de vídeo."
+  },
   "qwen2": {
     "description": "Qwen2 es el nuevo modelo de lenguaje a gran escala de Alibaba, que ofrece un rendimiento excepcional para satisfacer diversas necesidades de aplicación."
   },
@@ -3260,9 +3395,6 @@
   "step-r1-v-mini": {
     "description": "Este modelo es un gran modelo de inferencia con una poderosa capacidad de comprensión de imágenes, capaz de procesar información de imágenes y texto, generando contenido textual tras un profundo razonamiento. Este modelo destaca en el campo del razonamiento visual, además de poseer capacidades de razonamiento matemático, de código y textual de primer nivel. La longitud del contexto es de 100k."
   },
-  "step3": {
-    "description": "Step3 es un modelo multimodal desarrollado por StepStar, con potentes capacidades de comprensión visual."
-  },
   "stepfun-ai/step3": {
     "description": "Step3 es un modelo de inferencia multimodal de vanguardia publicado por 阶跃星辰 (StepFun), construido sobre una arquitectura Mixture-of-Experts (MoE) con 321B de parámetros totales y 38B de parámetros de activación. El modelo presenta un diseño de extremo a extremo orientado a minimizar el coste de decodificación, al tiempo que ofrece un rendimiento de primer nivel en razonamiento visual-lingüístico. Gracias al diseño sinérgico entre la atención por descomposición de múltiples matrices (MFA) y el desacoplamiento atención‑FFN (AFD), Step3 mantiene una eficiencia sobresaliente tanto en aceleradores de gama alta como de gama baja. En la fase de preentrenamiento, Step3 procesó más de 20T de tokens de texto y 4T de tokens mixtos imagen-texto, abarcando más de una decena de idiomas. El modelo ha alcanzado niveles líderes entre los modelos de código abierto en múltiples benchmarks, incluidos matemáticas, código y tareas multimodales."
   },
@@ -3344,6 +3476,9 @@
   "vercel/v0-1.5-md": {
     "description": "Acceso al modelo detrás de v0 para generar, reparar y optimizar aplicaciones web modernas, con razonamiento específico para frameworks y conocimiento actualizado."
   },
+  "volcengine/doubao-seed-code": {
+    "description": "Doubao-Seed-Code es el modelo de Byte Volcengine optimizado para programación agentica, con excelente rendimiento en múltiples benchmarks de programación y agentes, compatible con contexto de 256K."
+  },
   "wan2.2-t2i-flash": {
     "description": "Versión ultra rápida Wanxiang 2.2, el modelo más reciente. Mejora integral en creatividad, estabilidad y realismo, con velocidad de generación rápida y alta relación calidad-precio."
   },
@@ -3371,6 +3506,24 @@
   "wizardlm2:8x22b": {
     "description": "WizardLM 2 es un modelo de lenguaje proporcionado por Microsoft AI, que destaca en diálogos complejos, multilingües, razonamiento y asistentes inteligentes."
   },
+  "x-ai/grok-4": {
+    "description": "Grok 4 es el modelo de razonamiento insignia de xAI, con potentes capacidades de razonamiento y multimodalidad."
+  },
+  "x-ai/grok-4-fast": {
+    "description": "Grok 4 Fast es un modelo de alto rendimiento y bajo coste de xAI (compatible con ventana de contexto de 2M), ideal para escenarios de alta concurrencia y contexto largo."
+  },
+  "x-ai/grok-4-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) es un modelo multimodal de alto rendimiento y bajo coste de xAI (compatible con ventana de contexto de 2M), diseñado para escenarios sensibles a latencia y coste que no requieren razonamiento interno. Funciona junto con la versión con razonamiento de Grok 4 Fast, y se puede activar el razonamiento mediante el parámetro reasoning enable en la API. Los prompts y completions pueden ser utilizados por xAI u OpenRouter para mejorar modelos futuros."
+  },
+  "x-ai/grok-4.1-fast": {
+    "description": "Grok 4 Fast es un modelo de alto rendimiento y bajo coste de xAI (compatible con ventana de contexto de 2M), ideal para escenarios de alta concurrencia y contexto largo."
+  },
+  "x-ai/grok-4.1-fast-non-reasoning": {
+    "description": "Grok 4 Fast (Non-Reasoning) es un modelo multimodal de alto rendimiento y bajo coste de xAI (compatible con ventana de contexto de 2M), diseñado para escenarios sensibles a latencia y coste que no requieren razonamiento interno. Funciona junto con la versión con razonamiento de Grok 4 Fast, y se puede activar el razonamiento mediante el parámetro reasoning enable en la API. Los prompts y completions pueden ser utilizados por xAI u OpenRouter para mejorar modelos futuros."
+  },
+  "x-ai/grok-code-fast-1": {
+    "description": "Grok Code Fast 1 es el modelo rápido de código de xAI, con salidas legibles y adaptadas a la ingeniería."
+  },
   "x1": {
     "description": "El modelo Spark X1 se actualizará aún más, logrando resultados en tareas generales como razonamiento, generación de texto y comprensión del lenguaje que se comparan con OpenAI o1 y DeepSeek R1, además de liderar en tareas matemáticas en el país."
   },
@@ -3431,6 +3584,15 @@
   "yi-vision-v2": {
     "description": "Modelo para tareas visuales complejas, que ofrece capacidades de comprensión y análisis de alto rendimiento basadas en múltiples imágenes."
   },
+  "z-ai/glm-4.5": {
+    "description": "GLM 4.5 es el modelo insignia de Z.AI, compatible con modo de razonamiento híbrido y optimizado para ingeniería y tareas de contexto largo."
+  },
+  "z-ai/glm-4.5-air": {
+    "description": "GLM 4.5 Air es la versión ligera de GLM 4.5, adecuada para escenarios sensibles a costes, manteniendo una fuerte capacidad de razonamiento."
+  },
+  "z-ai/glm-4.6": {
+    "description": "GLM 4.6 es el modelo insignia de Z.AI, con contexto extendido y capacidades de codificación mejoradas."
+  },
   "zai-org/GLM-4.5": {
     "description": "GLM-4.5 es un modelo base diseñado para aplicaciones de agentes inteligentes, utilizando arquitectura Mixture-of-Experts (MoE). Está profundamente optimizado para llamadas a herramientas, navegación web, ingeniería de software y programación frontend, soportando integración fluida con agentes de código como Claude Code y Roo Code. GLM-4.5 emplea un modo de inferencia híbrido que se adapta a escenarios de razonamiento complejo y uso cotidiano."
   },
@@ -3451,5 +3613,8 @@
   },
   "zai/glm-4.5v": {
     "description": "GLM-4.5V está construido sobre el modelo base GLM-4.5-Air, heredando la tecnología verificada de GLM-4.1V-Thinking y logrando una escalabilidad eficiente mediante una potente arquitectura MoE de 106 mil millones de parámetros."
+  },
+  "zenmux/auto": {
+    "description": "La función de enrutamiento automático de ZenMux selecciona automáticamente el modelo con mejor rendimiento y relación calidad-precio entre los modelos compatibles según el contenido de tu solicitud."
   }
 }

locales/es-ES/plugin.json

@@ -1,4 +1,38 @@
 {
+  "builtins": {
+    "lobe-knowledge-base": {
+      "apiName": {
+        "readKnowledge": "Leer contenido de la base de conocimientos",
+        "searchKnowledgeBase": "Buscar en la base de conocimientos"
+      },
+      "title": "Base de conocimientos"
+    },
+    "lobe-local-system": {
+      "apiName": {
+        "editLocalFile": "Editar archivo",
+        "getCommandOutput": "Obtener salida del código",
+        "globLocalFiles": "Buscar archivos por patrón",
+        "grepContent": "Buscar contenido",
+        "killCommand": "Detener ejecución del código",
+        "listLocalFiles": "Ver lista de archivos",
+        "moveLocalFiles": "Mover archivos",
+        "readLocalFile": "Leer contenido del archivo",
+        "renameLocalFile": "Renombrar archivo",
+        "runCommand": "Ejecutar código",
+        "searchLocalFiles": "Buscar archivos",
+        "writeLocalFile": "Escribir archivo"
+      },
+      "title": "Sistema local"
+    },
+    "lobe-web-browsing": {
+      "apiName": {
+        "crawlMultiPages": "Leer contenido de múltiples páginas",
+        "crawlSinglePage": "Leer contenido de la página",
+        "search": "Buscar en la web"
+      },
+      "title": "Búsqueda en línea"
+    }
+  },
   "confirm": "Confirmar",
   "debug": {
     "arguments": "Parámetros de llamada",
@@ -251,23 +285,6 @@
     "content": "Llamando al plugin...",
     "plugin": "Plugin en ejecución..."
   },
-  "localSystem": {
-    "apiName": {
-      "editLocalFile": "Editar archivo",
-      "getCommandOutput": "Obtener salida del código",
-      "globLocalFiles": "Buscar archivos coincidentes",
-      "grepContent": "Buscar contenido",
-      "killCommand": "Detener ejecución del código",
-      "listLocalFiles": "Ver lista de archivos",
-      "moveLocalFiles": "Mover archivos",
-      "readLocalFile": "Leer contenido del archivo",
-      "renameLocalFile": "Renombrar",
-      "runCommand": "Ejecutar código",
-      "searchLocalFiles": "Buscar archivos",
-      "writeLocalFile": "Escribir archivo"
-    },
-    "title": "Sistema local"
-  },
   "mcpInstall": {
     "CHECKING_INSTALLATION": "Verificando entorno de instalación...",
     "COMPLETED": "Instalación completada",
@@ -375,11 +392,6 @@
     "warning": "⚠️ Por favor confirme que confía en la fuente de este plugin, plugins maliciosos pueden comprometer la seguridad de su sistema."
   },
   "search": {
-    "apiName": {
-      "crawlMultiPages": "Leer contenido de múltiples páginas",
-      "crawlSinglePage": "Leer contenido de página",
-      "search": "Buscar página"
-    },
     "config": {
       "addKey": "Agregar clave",
       "close": "Eliminar",

locales/es-ES/providers.json

@@ -191,6 +191,9 @@
   "xinference": {
     "description": "Xorbits Inference (Xinference) es una plataforma de código abierto diseñada para simplificar la ejecución e integración de diversos modelos de IA. Con Xinference, puedes utilizar cualquier modelo LLM de código abierto, modelos de incrustación y modelos multimodales para ejecutar inferencias en entornos locales o en la nube, y crear potentes aplicaciones de IA."
   },
+  "zenmux": {
+    "description": "ZenMux es una plataforma unificada de agregación de servicios de IA que admite interfaces de servicios de IA líderes como OpenAI, Anthropic y Google VertexAI. Ofrece capacidades de enrutamiento flexibles que le permiten cambiar y gestionar fácilmente diferentes modelos de IA."
+  },
   "zeroone": {
     "description": "01.AI se centra en la tecnología de inteligencia artificial de la era 2.0, promoviendo enérgicamente la innovación y aplicación de 'humano + inteligencia artificial', utilizando modelos extremadamente potentes y tecnologías de IA avanzadas para mejorar la productividad humana y lograr el empoderamiento tecnológico."
   },

locales/es-ES/tool.json

@@ -14,7 +14,21 @@
     "images": "Imágenes:",
     "prompt": "Palabra de aviso"
   },
+  "lobe-knowledge-base": {
+    "readKnowledge": {
+      "meta": {
+        "chars": "Número de caracteres",
+        "lines": "Número de líneas"
+      }
+    }
+  },
   "localFiles": {
+    "editFile": {
+      "newString": "Reemplazar con",
+      "oldString": "Buscar",
+      "replaceAll": "Reemplazar todas las coincidencias",
+      "replaceFirst": "Reemplazar solo la primera coincidencia"
+    },
     "file": "Archivo",
     "folder": "Carpeta",
     "moveFiles": {
@@ -34,7 +48,12 @@
     "readFile": "Leer archivo",
     "readFileError": "Error al leer el archivo, por favor verifica si la ruta del archivo es correcta",
     "readFiles": "Leer archivos",
-    "readFilesError": "Error al leer los archivos, por favor verifica si la ruta del archivo es correcta"
+    "readFilesError": "Error al leer los archivos, por favor verifica si la ruta del archivo es correcta",
+    "writeFile": {
+      "characters": "caracteres",
+      "preview": "Vista previa del contenido",
+      "truncated": "Truncado"
+    }
   },
   "search": {
     "createNewSearch": "Crear un nuevo registro de búsqueda",

locales/fa-IR/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "کلید تفکر عمیق"
     },
+    "thinkingLevel": {
+      "title": "سطح تفکر"
+    },
     "title": "ویژگی‌های گسترش مدل",
     "urlContext": {
       "desc": "با فعال‌سازی، لینک‌های وب به‌طور خودکار تجزیه می‌شوند تا محتوای واقعی زمینه وب‌سایت به‌دست آید",
@@ -330,6 +333,11 @@
     "screenshot": "اسکرین‌شات",
     "settings": "تنظیمات خروجی",
     "text": "متن",
+    "widthMode": {
+      "label": "حالت عرض",
+      "narrow": "حالت صفحه باریک",
+      "wide": "حالت صفحه عریض"
+    },
     "withBackground": "شامل تصویر پس‌زمینه",
     "withFooter": "شامل پاورقی",
     "withPluginInfo": "شامل اطلاعات افزونه",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "وارد کردن دلیل رد به Agent کمک می‌کند تا اقدامات بعدی را بهینه کند",
       "rejectTitle": "رد این فراخوانی ابزار",
       "rejectedWithReason": "این فراخوانی ابزار با دلیل زیر رد شد:{{reason}}",
+      "toolAbort": "این فراخوانی ابزار توسط کاربر لغو شد",
       "toolRejected": "این فراخوانی ابزار به‌صورت دستی رد شد"
     }
   },

locales/fa-IR/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "بستن",
+  "cmdk": {
+    "about": "درباره",
+    "communitySupport": "پشتیبانی جامعه",
+    "discover": "کشف",
+    "knowledgeBase": "پایگاه دانش",
+    "navigate": "ناوبری",
+    "newAgent": "دستیار جدید",
+    "noResults": "نتیجه‌ای یافت نشد",
+    "openSettings": "باز کردن تنظیمات",
+    "painting": "نقاشی با هوش مصنوعی",
+    "searchPlaceholder": "دستور وارد کنید یا جستجو کنید...",
+    "settings": "تنظیمات",
+    "starOnGitHub": "به ما در GitHub ستاره بدهید",
+    "submitIssue": "ارسال مشکل",
+    "theme": "تم",
+    "themeAuto": "همگام با سیستم",
+    "themeDark": "حالت تیره",
+    "themeLight": "حالت روشن",
+    "toOpen": "باز کردن",
+    "toSelect": "انتخاب"
+  },
   "confirm": "تأیید",
   "contact": "تماس با ما",
   "copy": "کپی",
@@ -283,6 +304,7 @@
     "business": "همکاری تجاری",
     "support": "پشتیبانی ایمیل"
   },
+  "new": "جدید",
   "oauth": "ورود با SSO",
   "officialSite": "وب‌سایت رسمی",
   "ok": "تأیید",

locales/fa-IR/error.json

@@ -102,7 +102,7 @@
       "SPII": "محتوای شما ممکن است شامل اطلاعات هویتی حساس فردی باشد. برای محافظت از حریم خصوصی، لطفاً اطلاعات حساس را حذف کرده و دوباره تلاش کنید.",
       "default": "محتوا مسدود شد: {{blockReason}}。لطفاً محتوای درخواست خود را اصلاح کرده و دوباره تلاش کنید."
     },
-    "InsufficientQuota": "متأسفیم، سهمیه این کلید به حداکثر رسیده است، لطفاً موجودی حساب خود را بررسی کرده یا سهمیه کلید را افزایش دهید و دوباره تلاش کنید",
+    "InsufficientQuota": "متأسفیم، سهمیه این کلید به حداکثر رسیده است. لطفاً موجودی حساب خود را بررسی کرده یا پس از افزایش سهمیه کلید دوباره تلاش کنید.",
     "InvalidAccessCode": "رمز عبور نادرست یا خالی است، لطفاً رمز عبور صحیح را وارد کنید یا API Key سفارشی اضافه کنید",
     "InvalidBedrockCredentials": "اعتبارسنجی Bedrock ناموفق بود، لطفاً AccessKeyId/SecretAccessKey را بررسی کرده و دوباره تلاش کنید",
     "InvalidClerkUser": "متأسفیم، شما هنوز وارد نشده‌اید، لطفاً ابتدا وارد شوید یا ثبت‌نام کنید و سپس ادامه دهید",
@@ -131,7 +131,7 @@
     "PluginServerError": "درخواست سرور افزونه با خطا مواجه شد، لطفاً بر اساس اطلاعات زیر فایل توصیف افزونه، پیکربندی افزونه یا پیاده‌سازی سرور را بررسی کنید",
     "PluginSettingsInvalid": "این افزونه نیاز به پیکربندی صحیح دارد تا قابل استفاده باشد، لطفاً پیکربندی خود را بررسی کنید",
     "ProviderBizError": "درخواست به سرویس {{provider}} با خطا مواجه شد، لطفاً بر اساس اطلاعات زیر بررسی کنید یا دوباره تلاش کنید",
-    "QuotaLimitReached": "متأسفیم، میزان استفاده از توکن یا تعداد درخواست‌های شما به حد مجاز این کلید رسیده است، لطفاً سهمیه کلید را افزایش دهید یا بعداً دوباره تلاش کنید",
+    "QuotaLimitReached": "متأسفیم، میزان استفاده از توکن یا تعداد درخواست‌ها به حداکثر سهمیه این کلید رسیده است. لطفاً سهمیه کلید را افزایش داده یا بعداً دوباره تلاش کنید.",
     "StreamChunkError": "خطا در تجزیه بلوک پیام درخواست جریانی، لطفاً بررسی کنید که آیا API فعلی با استانداردها مطابقت دارد یا با ارائه‌دهنده API خود تماس بگیرید",
     "SubscriptionKeyMismatch": "متأسفیم، به دلیل یک نقص موقتی در سیستم، مصرف فعلی اشتراک به طور موقت غیر فعال شده است. لطفاً بر روی دکمه زیر کلیک کنید تا اشتراک خود را بازیابی کنید، یا با ما از طریق ایمیل تماس بگیرید تا از ما پشتیبانی دریافت کنید.",
     "SubscriptionPlanLimit": "نقاط اشتراک شما تمام شده است و نمی‌توانید از این ویژگی استفاده کنید. لطفاً به یک طرح بالاتر ارتقا دهید یا پس از پیکربندی API مدل سفارشی، به استفاده ادامه دهید.",

locales/fa-IR/file.json

@@ -55,11 +55,11 @@
   },
   "documentList": {
     "copyContent": "کپی کل محتوا",
-    "documentCount": "مجموع {{count}} سند",
     "duplicate": "ایجاد نسخه مشابه",
-    "empty": "هیچ سندی موجود نیست، برای ایجاد اولین سند خود روی دکمه بالا کلیک کنید",
-    "noResults": "سندی مطابق با جستجو یافت نشد",
-    "selectNote": "برای ویرایش یک سند انتخاب کنید",
+    "empty": "هنوز هیچ سندی وجود ندارد، برای ایجاد اولین سند خود روی دکمه بالا کلیک کنید",
+    "noResults": "هیچ سندی مطابق با جستجو یافت نشد",
+    "pageCount": "مجموعاً {{count}} سند",
+    "selectNote": "برای ویرایش، یک سند را انتخاب کنید",
     "untitled": "بدون عنوان"
   },
   "empty": "هیچ فایل/پوشه‌ای بارگذاری نشده است",
@@ -70,7 +70,6 @@
       "uploadFile": "بارگذاری فایل",
       "uploadFolder": "بارگذاری پوشه"
     },
-    "newDocumentButton": "سند جدید",
     "newNoteDialog": {
       "cancel": "لغو",
       "editTitle": "ویرایش سند",
@@ -83,14 +82,15 @@
       "title": "سند جدید",
       "updateSuccess": "سند با موفقیت به‌روزرسانی شد"
     },
+    "newPageButton": "ایجاد سند جدید",
     "uploadButton": "بارگذاری"
   },
   "home": {
     "getStarted": "شروع کنید",
     "greeting": "شروع",
     "quickActions": "دسترسی سریع",
-    "recentDocuments": "اسناد اخیر",
     "recentFiles": "فایل‌های اخیر",
+    "recentPages": "اسناد اخیر",
     "subtitle": "به پایگاه دانش خوش آمدید، از اینجا مدیریت اسناد خود را آغاز کنید",
     "uploadEntries": {
       "files": {
@@ -102,7 +102,7 @@
       "knowledgeBase": {
         "title": "ایجاد پایگاه دانش جدید"
       },
-      "newDocument": {
+      "newPage": {
         "title": "ایجاد سند جدید"
       }
     }
@@ -116,8 +116,8 @@
     "title": "پایگاه دانش"
   },
   "menu": {
-    "allDocuments": "همه اسناد",
-    "allFiles": "تمام فایل‌ها"
+    "allFiles": "تمام فایل‌ها",
+    "allPages": "همهٔ نوشته‌ها"
   },
   "networkError": "دریافت مخزن دانش ناموفق بود، لطفاً پس از بررسی اتصال شبکه دوباره تلاش کنید.",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "دانلود فایل",
     "unsupportedFileAndContact": "فرمت این فایل در حال حاضر از پیش‌نمایش آنلاین پشتیبانی نمی‌کند. در صورت نیاز به پیش‌نمایش، لطفاً <1>به ما بازخورد دهید</1>."
   },
-  "searchDocumentPlaceholder": "جستجوی سند",
   "searchFilePlaceholder": "جستجوی فایل",
+  "searchPagePlaceholder": "جستجوی سند",
   "tab": {
     "all": "همه",
     "audios": "صداها",
@@ -156,9 +156,7 @@
     "websites": "وب‌سایت‌ها"
   },
   "title": "پایگاه دانش",
-  "toggleLeftPanel": {
-    "title": "نمایش/پنهان کردن پانل سمت چپ"
-  },
+  "toggleLeftPanel": "نمایش/پنهان‌سازی پنل سمت چپ",
   "uploadDock": {
     "body": {
       "collapse": "بستن",

locales/fa-IR/hotkey.json

@@ -7,6 +7,10 @@
     "desc": "حذف پیام‌ها و فایل‌های بارگذاری شده در جلسه جاری",
     "title": "حذف پیام‌های جلسه"
   },
+  "commandPalette": {
+    "desc": "باز کردن پنل فرمان جهانی برای دسترسی سریع به قابلیت‌ها",
+    "title": "پنل فرمان"
+  },
   "deleteAndRegenerateMessage": {
     "desc": "آخرین پیام را حذف کرده و دوباره تولید کن",
     "title": "حذف و تولید مجدد"

locales/fa-IR/image.json

@@ -37,6 +37,14 @@
         "standard": "استاندارد"
       }
     },
+    "resolution": {
+      "label": "وضوح تصویر",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "بذر",
       "random": "بذر تصادفی"

locales/fa-IR/modelProvider.json

@@ -295,7 +295,7 @@
       },
       "helpDoc": "راهنمای پیکربندی",
       "responsesApi": {
-        "desc": "استفاده از قالب درخواست نسل جدید OpenAI برای باز کردن ویژگی‌های پیشرفته مانند زنجیره تفکر",
+        "desc": "با استفاده از قالب جدید درخواست OpenAI، ویژگی‌های پیشرفته‌ای مانند زنجیره تفکر فعال می‌شود (فقط برای مدل‌های OpenAI پشتیبانی می‌شود)",
         "title": "استفاده از استاندارد Responses API"
       },
       "waitingForMore": "مدل‌های بیشتری در حال <1>برنامه‌ریزی برای اتصال</1> هستند، لطفاً منتظر بمانید"

locales/fa-IR/models.json

@@ -236,6 +236,9 @@
   "MiniMaxAI/MiniMax-M1-80k": {
     "description": "MiniMax-M1 یک مدل استنتاج بزرگ با وزن‌های متن‌باز و توجه ترکیبی است که دارای ۴۵۶ میلیارد پارامتر است و هر توکن می‌تواند حدود ۴۵.۹ میلیارد پارامتر را فعال کند. این مدل به طور بومی از زمینه بسیار طولانی ۱ میلیون توکن پشتیبانی می‌کند و با مکانیزم توجه سریع، در وظایف تولید ۱۰۰ هزار توکن نسبت به DeepSeek R1، ۷۵٪ از محاسبات نقطه شناور را صرفه‌جویی می‌کند. همچنین، MiniMax-M1 از معماری MoE (متخصصان ترکیبی) بهره می‌برد و با ترکیب الگوریتم CISPO و طراحی توجه ترکیبی در آموزش تقویتی کارآمد، عملکرد پیشرو در صنعت را در استنتاج ورودی‌های طولانی و سناریوهای واقعی مهندسی نرم‌افزار ارائه می‌دهد."
   },
+  "MiniMaxAI/MiniMax-M2": {
+    "description": "MiniMax-M2 بهره‌وری را برای عامل‌های هوشمند بازتعریف می‌کند. این یک مدل MoE فشرده، سریع و مقرون‌به‌صرفه است که دارای ۲۳۰ میلیارد پارامتر کلی و ۱۰ میلیارد پارامتر فعال می‌باشد. این مدل برای ارائه عملکردی در سطح بالا در وظایف کدنویسی و عامل‌های هوشمند طراحی شده است، در حالی که هوش عمومی قدرتمندی را نیز حفظ می‌کند. تنها با ۱۰ میلیارد پارامتر فعال، MiniMax-M2 عملکردی هم‌تراز با مدل‌های بسیار بزرگ ارائه می‌دهد و آن را به گزینه‌ای ایده‌آل برای کاربردهای با بهره‌وری بالا تبدیل می‌کند."
+  },
   "Moonshot-Kimi-K2-Instruct": {
     "description": "مدل با 1 تریلیون پارامتر کل و 32 میلیارد پارامتر فعال. در میان مدل‌های غیرتفکری، در دانش پیشرفته، ریاضیات و برنامه‌نویسی در سطح برتر قرار دارد و در وظایف عامل عمومی تخصص دارد. به طور ویژه برای وظایف نمایندگی بهینه شده است، نه تنها قادر به پاسخگویی به سوالات بلکه قادر به انجام اقدامات است. بهترین گزینه برای گفتگوهای بداهه، چت عمومی و تجربه‌های نمایندگی است و یک مدل واکنشی بدون نیاز به تفکر طولانی مدت محسوب می‌شود."
   },
@@ -717,25 +720,28 @@
     "description": "Claude 3 Opus هوشمندترین مدل Anthropic است که در وظایف بسیار پیچیده عملکرد پیشرو در بازار دارد. این مدل می‌تواند با روانی و درک انسانی برجسته، ورودی‌های باز و سناریوهای ناآشنا را مدیریت کند."
   },
   "anthropic/claude-3.5-haiku": {
-    "description": "Claude 3.5 Haiku نسل بعدی سریع‌ترین مدل ما است. با سرعتی مشابه Claude 3 Haiku، در هر مجموعه مهارتی بهبود یافته و در بسیاری از آزمون‌های هوشمندی از مدل بزرگ قبلی ما Claude 3 Opus پیشی گرفته است."
+    "description": "Claude 3.5 Haiku دارای قابلیت‌های پیشرفته در سرعت، دقت کدنویسی و استفاده از ابزارها است. مناسب برای سناریوهایی با نیاز بالا به سرعت و تعامل با ابزارها."
   },
   "anthropic/claude-3.5-sonnet": {
-    "description": "Claude 3.5 Sonnet تعادل ایده‌آلی بین هوشمندی و سرعت برقرار می‌کند - به ویژه برای بارهای کاری شرکتی. در مقایسه با محصولات مشابه، عملکرد قدرتمندی با هزینه کمتر ارائه می‌دهد و برای دوام بالا در استقرارهای گسترده هوش مصنوعی طراحی شده است."
+    "description": "Claude 3.5 Sonnet یک مدل سریع و کارآمد از خانواده Sonnet است که عملکرد بهتری در کدنویسی و استدلال ارائه می‌دهد. برخی نسخه‌ها به تدریج با Sonnet 3.7 و مدل‌های مشابه جایگزین خواهند شد."
   },
   "anthropic/claude-3.7-sonnet": {
-    "description": "Claude 3.7 Sonnet اولین مدل استدلال ترکیبی و هوشمندترین مدل Anthropic تا به امروز است. این مدل عملکرد پیشرفته‌ای در کدنویسی، تولید محتوا، تحلیل داده و برنامه‌ریزی ارائه می‌دهد و بر پایه توانایی‌های مهندسی نرم‌افزار و استفاده از کامپیوتر مدل پیشین خود Claude 3.5 Sonnet ساخته شده است."
+    "description": "Claude 3.7 Sonnet نسخه ارتقاءیافته‌ای از سری Sonnet است که توانایی‌های استدلال و کدنویسی قوی‌تری دارد و برای وظایف پیچیده در سطح سازمانی مناسب است."
+  },
+  "anthropic/claude-haiku-4.5": {
+    "description": "Claude Haiku 4.5 یک مدل سریع و با عملکرد بالا از Anthropic است که با حفظ دقت بالا، تأخیر بسیار کمی دارد."
   },
   "anthropic/claude-opus-4": {
-    "description": "Claude Opus 4 قدرتمندترین مدل Anthropic تا به امروز و بهترین مدل کدنویسی جهان است که در آزمون‌های SWE-bench (72.5%) و Terminal-bench (43.2%) پیشتاز است. این مدل عملکرد مداومی برای وظایف طولانی‌مدت که نیازمند تمرکز و هزاران مرحله هستند ارائه می‌دهد و توانایی‌های نمایندگی هوش مصنوعی را به طور قابل توجهی گسترش می‌دهد."
+    "description": "Opus 4 مدل پرچم‌دار Anthropic است که برای وظایف پیچیده و کاربردهای سازمانی طراحی شده است."
   },
   "anthropic/claude-opus-4.1": {
-    "description": "Claude Opus 4.1 جایگزینی plug-and-play برای Opus 4 است که عملکرد و دقت برجسته‌ای در وظایف کدنویسی و نمایندگی واقعی ارائه می‌دهد. Opus 4.1 عملکرد پیشرفته کدنویسی را به 74.5% در SWE-bench Verified ارتقا داده و مسائل چندمرحله‌ای پیچیده را با دقت و توجه بیشتر به جزئیات مدیریت می‌کند."
+    "description": "Opus 4.1 یک مدل پیشرفته از Anthropic است که برای برنامه‌نویسی، استدلال پیچیده و وظایف مداوم بهینه‌سازی شده است."
   },
   "anthropic/claude-sonnet-4": {
-    "description": "Claude Sonnet 4 بهبود قابل توجهی بر توانایی‌های پیشرو در صنعت Sonnet 3.7 دارد و در کدنویسی عملکرد برجسته‌ای با 72.7% در SWE-bench ارائه می‌دهد. این مدل تعادل بین عملکرد و کارایی را حفظ کرده و برای موارد استفاده داخلی و خارجی مناسب است و با کنترل‌پذیری بهبود یافته، کنترل بیشتری بر نتایج فراهم می‌کند."
+    "description": "Claude Sonnet 4 نسخه‌ای با قابلیت استدلال ترکیبی از Anthropic است که توانایی‌های فکری و غیر فکری را با هم ترکیب می‌کند."
   },
   "anthropic/claude-sonnet-4.5": {
-    "description": "کلود سونت ۴.۵ هوشمندترین مدل تا به امروز شرکت Anthropic است."
+    "description": "Claude Sonnet 4.5 جدیدترین مدل استدلال ترکیبی از Anthropic است که برای استدلال پیچیده و کدنویسی بهینه شده است."
   },
   "ascend-tribe/pangu-pro-moe": {
     "description": "Pangu-Pro-MoE 72B-A16B یک مدل زبان بزرگ پراکنده با 72 میلیارد پارامتر و 16 میلیارد پارامتر فعال است که بر اساس معماری متخصصان ترکیبی گروه‌بندی شده (MoGE) ساخته شده است. در مرحله انتخاب متخصص، متخصصان به گروه‌هایی تقسیم می‌شوند و توکن‌ها در هر گروه به تعداد مساوی متخصصان فعال می‌شوند تا تعادل بار متخصصان حفظ شود، که به طور قابل توجهی کارایی استقرار مدل را در پلتفرم Ascend افزایش می‌دهد."
@@ -758,6 +764,9 @@
   "baidu/ERNIE-4.5-300B-A47B": {
     "description": "ERNIE-4.5-300B-A47B یک مدل زبان بزرگ مبتنی بر معماری متخصصان ترکیبی (MoE) است که توسط شرکت بایدو توسعه یافته است. این مدل دارای 300 میلیارد پارامتر کل است، اما در زمان استنتاج تنها 47 میلیارد پارامتر برای هر توکن فعال می‌شود، که ضمن حفظ عملکرد قدرتمند، کارایی محاسباتی را نیز تضمین می‌کند. به عنوان یکی از مدل‌های اصلی سری ERNIE 4.5، این مدل در وظایف درک متن، تولید، استدلال و برنامه‌نویسی عملکرد برجسته‌ای دارد. این مدل از یک روش پیش‌آموزش نوآورانه چندرسانه‌ای ناهمگن MoE استفاده می‌کند که با آموزش مشترک متن و مدیا تصویری، توانایی کلی مدل را بهبود می‌بخشد، به‌ویژه در زمینه پیروی از دستورالعمل‌ها و حافظه دانش جهانی."
   },
+  "baidu/ernie-5.0-thinking-preview": {
+    "description": "پیش‌نمایش ERNIE 5.0 Thinking مدل چندوجهی نسل جدید Baidu است که در درک چندوجهی، پیروی از دستورات، تولید محتوا، پرسش و پاسخ واقعی و استفاده از ابزارها تخصص دارد."
+  },
   "c4ai-aya-expanse-32b": {
     "description": "Aya Expanse یک مدل چندزبانه با عملکرد بالا و 32B است که با هدف به چالش کشیدن عملکرد مدل‌های تک‌زبانه از طریق بهینه‌سازی دستور، آربیتراژ داده‌ها، آموزش ترجیحات و نوآوری در ادغام مدل‌ها طراحی شده است. این مدل از 23 زبان پشتیبانی می‌کند."
   },
@@ -866,6 +875,9 @@
   "codex-mini-latest": {
     "description": "codex-mini-latest نسخه‌ای تنظیم‌شده از o4-mini است که به‌طور خاص برای Codex CLI طراحی شده است. برای استفاده مستقیم از طریق API، ما توصیه می‌کنیم از gpt-4.1 شروع کنید."
   },
+  "cogito-2.1:671b": {
+    "description": "Cogito v2.1 671B یک مدل زبان بزرگ متن‌باز آمریکایی با قابلیت استفاده تجاری رایگان است که با عملکردی در سطح مدل‌های برتر، بازدهی بالای استدلال توکن، پشتیبانی از 128k زمینه طولانی و توانایی‌های جامع قوی شناخته می‌شود."
+  },
   "cogview-4": {
     "description": "CogView-4 نخستین مدل متن به تصویر متن‌باز Zhizhu است که از تولید حروف چینی پشتیبانی می‌کند. این مدل در درک معنایی، کیفیت تولید تصویر و توانایی تولید متون چینی و انگلیسی به طور جامع بهبود یافته است، از ورودی دوزبانه چینی و انگلیسی با طول دلخواه پشتیبانی می‌کند و قادر است تصاویر با هر وضوحی در محدوده داده شده تولید کند."
   },
@@ -1136,6 +1148,9 @@
   "deepseek-vl2-small": {
     "description": "DeepSeek VL2 Small، نسخه سبک چندوجهی، مناسب برای محیط‌های با منابع محدود و بارگذاری بالا."
   },
+  "deepseek/deepseek-chat": {
+    "description": "DeepSeek-V3 یک مدل استدلال ترکیبی با عملکرد بالا از تیم DeepSeek است که برای وظایف پیچیده و یکپارچه‌سازی ابزارها مناسب است."
+  },
   "deepseek/deepseek-chat-v3-0324": {
     "description": "DeepSeek V3 یک مدل ترکیبی متخصص با 685B پارامتر است و جدیدترین نسخه از سری مدل‌های چت پرچمدار تیم DeepSeek می‌باشد.\n\nاین مدل از [DeepSeek V3](/deepseek/deepseek-chat-v3) به ارث برده و در انواع وظایف عملکرد عالی از خود نشان می‌دهد."
   },
@@ -1143,19 +1158,19 @@
     "description": "DeepSeek V3 یک مدل ترکیبی متخصص با 685B پارامتر است و جدیدترین نسخه از سری مدل‌های چت پرچمدار تیم DeepSeek می‌باشد.\n\nاین مدل از [DeepSeek V3](/deepseek/deepseek-chat-v3) به ارث برده و در انواع وظایف عملکرد عالی از خود نشان می‌دهد."
   },
   "deepseek/deepseek-chat-v3.1": {
-    "description": "DeepSeek-V3.1 یک مدل بزرگ استدلال ترکیبی است که از زمینه طولانی 128K و تغییر حالت کارآمد پشتیبانی می‌کند و در فراخوانی ابزارها، تولید کد و وظایف استدلال پیچیده عملکرد و سرعت برجسته‌ای دارد."
+    "description": "DeepSeek-V3.1 مدل استدلال ترکیبی با زمینه طولانی از DeepSeek است که از حالت‌های ترکیبی فکری/غیرفکری و یکپارچه‌سازی ابزارها پشتیبانی می‌کند."
   },
   "deepseek/deepseek-r1": {
     "description": "مدل DeepSeek R1 به‌روزرسانی‌های جزئی دریافت کرده و نسخه فعلی DeepSeek-R1-0528 است. در آخرین به‌روزرسانی، DeepSeek R1 با بهره‌گیری از منابع محاسباتی افزایش‌یافته و مکانیزم‌های بهینه‌سازی الگوریتمی پس از آموزش، عمق و توان استدلال خود را به طور قابل توجهی بهبود بخشیده است. این مدل در ارزیابی‌های معیار مختلف مانند ریاضیات، برنامه‌نویسی و منطق عمومی عملکرد برجسته‌ای دارد و عملکرد کلی آن اکنون به مدل‌های پیشرو مانند O3 و Gemini 2.5 Pro نزدیک شده است."
   },
   "deepseek/deepseek-r1-0528": {
-    "description": "DeepSeek-R1 با داشتن داده‌های برچسب‌خورده بسیار محدود، توانایی استدلال مدل را به طور چشمگیری افزایش داده است. قبل از ارائه پاسخ نهایی، مدل ابتدا یک زنجیره فکری را تولید می‌کند تا دقت پاسخ نهایی را بهبود بخشد."
+    "description": "DeepSeek R1 0528 نسخه به‌روزشده‌ای از DeepSeek است که بر متن‌باز بودن و عمق استدلال تمرکز دارد."
   },
   "deepseek/deepseek-r1-0528:free": {
     "description": "DeepSeek-R1 با داشتن داده‌های برچسب‌خورده بسیار محدود، توانایی استدلال مدل را به طور چشمگیری افزایش داده است. قبل از ارائه پاسخ نهایی، مدل ابتدا یک زنجیره فکری را تولید می‌کند تا دقت پاسخ نهایی را بهبود بخشد."
   },
   "deepseek/deepseek-r1-distill-llama-70b": {
-    "description": "DeepSeek-R1-Distill-Llama-70B نسخه تقطیر شده و بهینه‌تر مدل 70B Llama است. این مدل در وظایف تولید متن عملکرد قوی خود را حفظ کرده و هزینه محاسباتی را کاهش داده تا استقرار و پژوهش را تسهیل کند. توسط Groq با استفاده از سخت‌افزار واحد پردازش زبان سفارشی (LPU) ارائه می‌شود تا استدلال سریع و کارآمد فراهم کند."
+    "description": "DeepSeek R1 Distill Llama 70B یک مدل زبان بزرگ مبتنی بر Llama3.3 70B است که با استفاده از خروجی‌های تنظیم‌شده DeepSeek R1، به عملکردی رقابتی در سطح مدل‌های پیشرفته بزرگ دست یافته است."
   },
   "deepseek/deepseek-r1-distill-llama-8b": {
     "description": "DeepSeek R1 Distill Llama 8B یک مدل زبان بزرگ تقطیر شده مبتنی بر Llama-3.1-8B-Instruct است که با استفاده از خروجی DeepSeek R1 آموزش دیده است."
@@ -1172,6 +1187,9 @@
   "deepseek/deepseek-r1:free": {
     "description": "DeepSeek-R1 با وجود داده‌های برچسب‌گذاری شده بسیار کم، توانایی استدلال مدل را به طرز چشمگیری افزایش می‌دهد. قبل از ارائه پاسخ نهایی، مدل ابتدا یک زنجیره تفکر را تولید می‌کند تا دقت پاسخ نهایی را افزایش دهد."
   },
+  "deepseek/deepseek-reasoner": {
+    "description": "DeepSeek-V3 Thinking (reasoner) مدل آزمایشی استدلال از DeepSeek است که برای وظایف استدلالی با پیچیدگی بالا مناسب است."
+  },
   "deepseek/deepseek-v3": {
     "description": "مدل زبان بزرگ سریع و عمومی با توان استدلال بهبود یافته."
   },
@@ -1478,9 +1496,6 @@
   "gemini-2.0-flash-lite-001": {
     "description": "مدل متغیر Gemini 2.0 Flash برای بهینه‌سازی هزینه و تأخیر کم طراحی شده است."
   },
-  "gemini-2.0-flash-preview-image-generation": {
-    "description": "مدل پیش‌نمایش Gemini 2.0 Flash، از تولید تصویر پشتیبانی می‌کند"
-  },
   "gemini-2.5-flash": {
     "description": "Gemini 2.5 Flash مدل با بهترین نسبت قیمت به کارایی گوگل است که امکانات جامع را ارائه می‌دهد."
   },
@@ -1508,9 +1523,6 @@
   "gemini-2.5-flash-preview-04-17": {
     "description": "پیش‌نمایش فلش Gemini 2.5 مدل با بهترین قیمت و کیفیت گوگل است که امکانات جامع و کاملی را ارائه می‌دهد."
   },
-  "gemini-2.5-flash-preview-05-20": {
-    "description": "Gemini 2.5 Flash Preview مقرون‌به‌صرفه‌ترین مدل گوگل است که امکانات جامع ارائه می‌دهد."
-  },
   "gemini-2.5-flash-preview-09-2025": {
     "description": "نسخه پیش‌نمایش (25 سپتامبر 2025) از Gemini 2.5 Flash"
   },
@@ -1526,6 +1538,15 @@
   "gemini-2.5-pro-preview-06-05": {
     "description": "Gemini 2.5 Pro Preview پیشرفته‌ترین مدل تفکر گوگل است که قادر به استدلال درباره مسائل پیچیده در حوزه کد، ریاضیات و STEM است و می‌تواند با استفاده از زمینه طولانی، داده‌های بزرگ، مخازن کد و مستندات را تحلیل کند."
   },
+  "gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) مدل تولید تصویر Google است که از گفت‌وگوی چندوجهی نیز پشتیبانی می‌کند."
+  },
+  "gemini-3-pro-image-preview:image": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) مدل تولید تصویر Google است که از گفت‌وگوی چندوجهی نیز پشتیبانی می‌کند."
+  },
+  "gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro بهترین مدل درک چندوجهی در جهان است و قدرتمندترین عامل هوشمند و مدل برنامه‌نویسی زمینه‌ای Google تا به امروز محسوب می‌شود. این مدل جلوه‌های بصری غنی‌تر و تعامل عمیق‌تری را ارائه می‌دهد که همگی بر پایه توانایی‌های پیشرفته استدلال بنا شده‌اند."
+  },
   "gemini-flash-latest": {
     "description": "جدیدترین نسخه Gemini Flash"
   },
@@ -1650,7 +1671,7 @@
     "description": "GLM-Zero-Preview دارای توانایی‌های پیچیده استدلال است و در زمینه‌های استدلال منطقی، ریاضیات، برنامه‌نویسی و غیره عملکرد عالی دارد."
   },
   "google/gemini-2.0-flash": {
-    "description": "Gemini 2.0 Flash ویژگی‌ها و قابلیت‌های نسل بعدی را ارائه می‌دهد، از جمله سرعت عالی، استفاده داخلی از ابزارها، تولید چندرسانه‌ای و پنجره زمینه 1 میلیون توکن."
+    "description": "Gemini 2.0 Flash مدل استدلال با عملکرد بالای Google است که برای وظایف چندوجهی گسترده مناسب است."
   },
   "google/gemini-2.0-flash-001": {
     "description": "Gemini 2.0 Flash ویژگی‌ها و بهبودهای نسل بعدی را ارائه می‌دهد، از جمله سرعت عالی، استفاده از ابزارهای بومی، تولید چندرسانه‌ای و پنجره متن 1M توکن."
@@ -1661,14 +1682,23 @@
   "google/gemini-2.0-flash-lite": {
     "description": "Gemini 2.0 Flash Lite ویژگی‌ها و قابلیت‌های نسل بعدی را ارائه می‌دهد، از جمله سرعت عالی، استفاده داخلی از ابزارها، تولید چندرسانه‌ای و پنجره زمینه 1 میلیون توکن."
   },
+  "google/gemini-2.0-flash-lite-001": {
+    "description": "Gemini 2.0 Flash Lite نسخه سبک خانواده Gemini است که به‌طور پیش‌فرض حالت فکری را غیرفعال کرده تا تأخیر و هزینه را کاهش دهد، اما می‌توان آن را از طریق پارامتر فعال کرد."
+  },
   "google/gemini-2.5-flash": {
-    "description": "Gemini 2.5 Flash یک مدل تفکر است که توانایی‌های جامع برجسته‌ای ارائه می‌دهد. این مدل برای تعادل بین قیمت و عملکرد طراحی شده و از ورودی‌های چندرسانه‌ای و پنجره زمینه 1 میلیون توکن پشتیبانی می‌کند."
+    "description": "سری Gemini 2.5 Flash (Lite/Pro/Flash) مدل‌های استدلال Google با تأخیر کم تا عملکرد بالا هستند."
+  },
+  "google/gemini-2.5-flash-image": {
+    "description": "Gemini 2.5 Flash Image (Nano Banana) مدل تولید تصویر Google است که از گفت‌وگوی چندوجهی نیز پشتیبانی می‌کند."
+  },
+  "google/gemini-2.5-flash-image-free": {
+    "description": "نسخه رایگان Gemini 2.5 Flash Image که از تولید چندوجهی با سهمیه محدود پشتیبانی می‌کند."
   },
   "google/gemini-2.5-flash-image-preview": {
     "description": "مدل آزمایشی Gemini 2.5 Flash با پشتیبانی از تولید تصویر"
   },
   "google/gemini-2.5-flash-lite": {
-    "description": "Gemini 2.5 Flash-Lite یک مدل متعادل و با تأخیر کم است که بودجه تفکر و اتصال ابزار قابل تنظیم (مانند جستجوی Google و اجرای کد) دارد. این مدل از ورودی‌های چندرسانه‌ای پشتیبانی می‌کند و پنجره زمینه 1 میلیون توکن ارائه می‌دهد."
+    "description": "Gemini 2.5 Flash Lite نسخه سبک Gemini 2.5 است که برای تأخیر و هزینه بهینه شده و برای سناریوهای با حجم بالا مناسب است."
   },
   "google/gemini-2.5-flash-preview": {
     "description": "Gemini 2.5 Flash مدل اصلی پیشرفته گوگل است که به طور خاص برای استدلال پیشرفته، کدنویسی، ریاضیات و وظایف علمی طراحی شده است. این مدل دارای قابلیت «تفکر» داخلی است که به آن اجازه می‌دهد پاسخ‌هایی با دقت بالاتر و پردازش زمینه‌ای دقیق‌تری ارائه دهد.\n\nتوجه: این مدل دارای دو واریانت است: تفکر و غیرتفکر. قیمت‌گذاری خروجی بسته به فعال بودن قابلیت تفکر به طور قابل توجهی متفاوت است. اگر شما واریانت استاندارد (بدون پسوند «:thinking») را انتخاب کنید، مدل به وضوح از تولید توکن‌های تفکر اجتناب خواهد کرد.\n\nبرای استفاده از قابلیت تفکر و دریافت توکن‌های تفکر، شما باید واریانت «:thinking» را انتخاب کنید که منجر به قیمت‌گذاری بالاتر خروجی تفکر خواهد شد.\n\nعلاوه بر این، Gemini 2.5 Flash می‌تواند از طریق پارامتر «حداکثر تعداد توکن‌های استدلال» پیکربندی شود، همانطور که در مستندات توضیح داده شده است (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
@@ -1677,11 +1707,26 @@
     "description": "Gemini 2.5 Flash مدل اصلی پیشرفته گوگل است که به طور خاص برای استدلال پیشرفته، کدنویسی، ریاضیات و وظایف علمی طراحی شده است. این مدل دارای قابلیت «تفکر» داخلی است که به آن اجازه می‌دهد پاسخ‌هایی با دقت بالاتر و پردازش زمینه‌ای دقیق‌تری ارائه دهد.\n\nتوجه: این مدل دارای دو واریانت است: تفکر و غیرتفکر. قیمت‌گذاری خروجی بسته به فعال بودن قابلیت تفکر به طور قابل توجهی متفاوت است. اگر شما واریانت استاندارد (بدون پسوند «:thinking») را انتخاب کنید، مدل به وضوح از تولید توکن‌های تفکر اجتناب خواهد کرد.\n\nبرای استفاده از قابلیت تفکر و دریافت توکن‌های تفکر، شما باید واریانت «:thinking» را انتخاب کنید که منجر به قیمت‌گذاری بالاتر خروجی تفکر خواهد شد.\n\nعلاوه بر این، Gemini 2.5 Flash می‌تواند از طریق پارامتر «حداکثر تعداد توکن‌های استدلال» پیکربندی شود، همانطور که در مستندات توضیح داده شده است (https://openrouter.ai/docs/use-cases/reasoning-tokens#max-tokens-for-reasoning)."
   },
   "google/gemini-2.5-pro": {
-    "description": "Gemini 2.5 Pro پیشرفته‌ترین مدل استدلال Gemini ما است که قادر به حل مسائل پیچیده است. این مدل دارای پنجره زمینه 2 میلیون توکن بوده و از ورودی‌های چندرسانه‌ای شامل متن، تصویر، صدا، ویدئو و اسناد PDF پشتیبانی می‌کند."
+    "description": "Gemini 2.5 Pro مدل پرچم‌دار استدلال Google است که از زمینه طولانی و وظایف پیچیده پشتیبانی می‌کند."
+  },
+  "google/gemini-2.5-pro-free": {
+    "description": "نسخه رایگان Gemini 2.5 Pro که از زمینه طولانی چندوجهی با سهمیه محدود پشتیبانی می‌کند و برای آزمایش و جریان‌های کاری سبک مناسب است."
   },
   "google/gemini-2.5-pro-preview": {
     "description": "Gemini 2.5 Pro Preview پیشرفته‌ترین مدل فکری گوگل است که قادر به استدلال درباره مسائل پیچیده در زمینه کد، ریاضیات و حوزه‌های STEM بوده و همچنین می‌تواند با استفاده از متن‌های طولانی، مجموعه‌های داده بزرگ، کدها و مستندات را تحلیل کند."
   },
+  "google/gemini-3-pro-image-preview": {
+    "description": "Gemini 3 Pro Image (Nano Banana Pro) مدل تولید تصویر گوگل است که از گفت‌وگوی چندحالته پشتیبانی می‌کند."
+  },
+  "google/gemini-3-pro-image-preview-free": {
+    "description": "نسخه رایگان Gemini 3 Pro Image که از تولید چندوجهی با سهمیه محدود پشتیبانی می‌کند."
+  },
+  "google/gemini-3-pro-preview": {
+    "description": "Gemini 3 Pro نسل بعدی مدل استدلال چندوجهی از سری Gemini است که توانایی درک متن، صدا، تصویر، ویدیو و دیگر ورودی‌ها را دارد و می‌تواند وظایف پیچیده و مخازن کد بزرگ را پردازش کند."
+  },
+  "google/gemini-3-pro-preview-free": {
+    "description": "نسخه پیش‌نمایش رایگان Gemini 3 Pro با همان توانایی‌های درک و استدلال چندوجهی نسخه استاندارد، اما با محدودیت‌های سهمیه و نرخ، مناسب برای تجربه و استفاده کم‌تکرار."
+  },
   "google/gemini-embedding-001": {
     "description": "مدل جاسازی پیشرفته با عملکرد برجسته در وظایف زبان انگلیسی، چندزبانه و کد."
   },
@@ -1907,6 +1952,12 @@
   "grok-4-0709": {
     "description": "Grok 4 از xAI با توانایی استدلال قدرتمند."
   },
+  "grok-4-1-fast-non-reasoning": {
+    "description": "مدل پیشرفته چندوجهی که به‌طور ویژه برای بهینه‌سازی فراخوانی ابزارهای نماینده با عملکرد بالا طراحی شده است."
+  },
+  "grok-4-1-fast-reasoning": {
+    "description": "مدل پیشرفته چندوجهی که به‌طور ویژه برای بهینه‌سازی فراخوانی ابزارهای نماینده با عملکرد بالا طراحی شده است."
+  },
   "grok-4-fast-non-reasoning": {
     "description": "خوشحالیم که Grok 4 Fast را منتشر می‌کنیم، که جدیدترین پیشرفت ما در زمینه مدل‌های استنتاج با صرفه‌جویی در هزینه است."
   },
@@ -2051,21 +2102,36 @@
   "inception/mercury-coder-small": {
     "description": "Mercury Coder Small انتخاب ایده‌آل برای تولید، اشکال‌زدایی و بازسازی کد با کمترین تأخیر است."
   },
-  "inclusionAI/Ling-1T": {
-    "description": "Ling-1T نخستین مدل پرچم‌دار از سری «灵 2.0» است که در دسته مدل‌های non-thinking قرار دارد. این مدل دارای یک تریلیون پارامتر کلی و حدود ۵۰ میلیارد پارامتر فعال به ازای هر توکن است. بر پایه معماری 灵 2.0 ساخته شده و هدف آن شکستن مرزهای استدلال کارآمد و شناخت مقیاس‌پذیر است. Ling-1T-base با بیش از ۲۰ تریلیون توکن با کیفیت بالا و متمرکز بر استدلال آموزش دیده است."
-  },
   "inclusionAI/Ling-flash-2.0": {
     "description": "Ling-flash-2.0 سومین مدل از سری معماری Ling 2.0 است که توسط تیم Bailing شرکت Ant Group منتشر شده است. این مدل یک مدل متخصص ترکیبی (MoE) با ۱۰۰ میلیارد پارامتر کل است که در هر توکن تنها ۶.۱ میلیارد پارامتر فعال می‌شوند (۴.۸ میلیارد غیر بردار کلمه). به عنوان یک مدل با پیکربندی سبک، Ling-flash-2.0 در چندین ارزیابی معتبر عملکردی برابر یا حتی فراتر از مدل‌های متراکم ۴۰ میلیارد پارامتری و مدل‌های MoE بزرگ‌تر نشان داده است. هدف این مدل کشف مسیرهای کارآمد در چارچوب «مدل بزرگ برابر است با پارامتر بزرگ» از طریق طراحی معماری و استراتژی‌های آموزش بهینه است."
   },
   "inclusionAI/Ling-mini-2.0": {
     "description": "Ling-mini-2.0 یک مدل زبان بزرگ کوچک‌حجم و با عملکرد بالا مبتنی بر معماری MoE است. این مدل دارای ۱۶ میلیارد پارامتر کل است اما در هر توکن تنها ۱.۴ میلیارد پارامتر فعال می‌شوند (۷۸۹ میلیون غیر بردار کلمه)، که سرعت تولید بسیار بالایی را فراهم می‌کند. به لطف طراحی کارآمد MoE و داده‌های آموزشی بزرگ و با کیفیت، با وجود فعال بودن تنها ۱.۴ میلیارد پارامتر، Ling-mini-2.0 در وظایف پایین‌دستی عملکردی در سطح مدل‌های متراکم زیر ۱۰ میلیارد و مدل‌های MoE بزرگ‌تر ارائه می‌دهد."
   },
-  "inclusionAI/Ring-1T": {
-    "description": "Ring-1T یک مدل متن‌باز با مقیاس تریلیونی است که توسط تیم Bailing توسعه یافته است. این مدل بر پایه معماری Ling 2.0 و مدل پایه Ling-1T-base آموزش دیده و دارای یک تریلیون پارامتر کلی و ۵۰ میلیارد پارامتر فعال است. همچنین از پنجره متنی تا ۱۲۸ هزار توکن پشتیبانی می‌کند و با استفاده از یادگیری تقویتی مبتنی بر پاداش‌های قابل تأیید در مقیاس وسیع بهینه‌سازی شده است."
-  },
   "inclusionAI/Ring-flash-2.0": {
     "description": "Ring-flash-2.0 مدلی با عملکرد بالا برای تفکر است که بر پایه Ling-flash-2.0-base بهینه‌سازی عمیق شده است. این مدل از معماری متخصص ترکیبی (MoE) با ۱۰۰ میلیارد پارامتر کل بهره می‌برد اما در هر استنتاج تنها ۶.۱ میلیارد پارامتر فعال می‌شوند. این مدل با الگوریتم ابتکاری icepop مشکل ناپایداری مدل‌های بزرگ MoE در آموزش تقویتی (RL) را حل کرده و توانایی استنتاج پیچیده آن در طول آموزش‌های بلندمدت بهبود می‌یابد. Ring-flash-2.0 در مسابقات ریاضی، تولید کد و استدلال منطقی در چندین بنچمارک دشوار پیشرفت قابل توجهی داشته است و عملکرد آن نه تنها از مدل‌های متراکم برتر زیر ۴۰ میلیارد پارامتر فراتر رفته، بلکه با مدل‌های MoE متن‌باز بزرگ‌تر و مدل‌های تفکر با عملکرد بالا و بسته رقابت می‌کند. اگرچه این مدل بر استنتاج پیچیده تمرکز دارد، در وظایف خلاقانه نوشتاری نیز عملکرد خوبی دارد. علاوه بر این، به لطف طراحی معماری کارآمد، Ring-flash-2.0 ضمن ارائه عملکرد قدرتمند، استنتاج سریع را ممکن ساخته و هزینه استقرار مدل‌های تفکر در شرایط بار بالا را به طور قابل توجهی کاهش می‌دهد."
   },
+  "inclusionai/ling-1t": {
+    "description": "Ling-1T مدل MoE با ظرفیت 1 تریلیون پارامتر از inclusionAI است که برای وظایف استدلالی شدید و زمینه‌های بزرگ بهینه شده است."
+  },
+  "inclusionai/ling-flash-2.0": {
+    "description": "Ling-flash-2.0 مدل MoE از inclusionAI است که برای بهره‌وری و عملکرد استدلالی بهینه شده و برای وظایف متوسط تا بزرگ مناسب است."
+  },
+  "inclusionai/ling-mini-2.0": {
+    "description": "Ling-mini-2.0 نسخه سبک مدل MoE از inclusionAI است که با حفظ توانایی استدلال، هزینه‌ها را به‌طور قابل توجهی کاهش می‌دهد."
+  },
+  "inclusionai/ming-flash-omini-preview": {
+    "description": "Ming-flash-omni Preview مدل چندوجهی از inclusionAI است که از ورودی‌های صوتی، تصویری و ویدیویی پشتیبانی می‌کند و توانایی‌های رندر تصویر و تشخیص صدا را بهینه کرده است."
+  },
+  "inclusionai/ring-1t": {
+    "description": "Ring-1T مدل MoE با ظرفیت تریلیونی از inclusionAI است که برای استدلال در مقیاس بزرگ و وظایف تحقیقاتی مناسب است."
+  },
+  "inclusionai/ring-flash-2.0": {
+    "description": "Ring-flash-2.0 نسخه‌ای از مدل Ring از inclusionAI است که برای سناریوهای با حجم بالا طراحی شده و بر سرعت و بهره‌وری هزینه تأکید دارد."
+  },
+  "inclusionai/ring-mini-2.0": {
+    "description": "Ring-mini-2.0 نسخه سبک و با حجم بالا از مدل MoE inclusionAI است که عمدتاً برای سناریوهای هم‌زمانی بالا استفاده می‌شود."
+  },
   "internlm/internlm2_5-7b-chat": {
     "description": "InternLM2.5 راه‌حل‌های گفتگوی هوشمند در چندین سناریو ارائه می‌دهد."
   },
@@ -2117,6 +2183,12 @@
   "kimi-k2-instruct": {
     "description": "Kimi K2 Instruct، مدل استنتاج رسمی Kimi، پشتیبانی از زمینه بلند، کدنویسی، پرسش و پاسخ و سناریوهای متنوع."
   },
+  "kimi-k2-thinking": {
+    "description": "مدل تفکر طولانی K2 با پشتیبانی از زمینه 256k، قابلیت فراخوانی چندمرحله‌ای ابزارها و تفکر چندگامی، در حل مسائل پیچیده مهارت دارد."
+  },
+  "kimi-k2-thinking-turbo": {
+    "description": "نسخه پرسرعت مدل تفکر طولانی K2 با پشتیبانی از زمینه 256k، مناسب برای استدلال عمیق با سرعت خروجی 60 تا 100 توکن در ثانیه."
+  },
   "kimi-k2-turbo-preview": {
     "description": "kimi-k2 یک مدل پایه با معماری MoE است که دارای توانمندی‌های بسیار قوی در حوزهٔ برنامه‌نویسی و عامل‌ها (Agent) می‌باشد. مجموع پارامترها 1T و پارامترهای فعال‌شده 32B است. در آزمون‌های بنچمارک در دسته‌های اصلی مانند استدلال دانش عمومی، برنامه‌نویسی، ریاضیات و Agent، عملکرد مدل K2 از سایر مدل‌های متن‌باز مرسوم پیشی گرفته است."
   },
@@ -2129,6 +2201,9 @@
   "kimi-thinking-preview": {
     "description": "مدل kimi-thinking-preview که توسط Moon’s Dark Side ارائه شده است، مدلی چندرسانه‌ای با توانایی استدلال چندوجهی و استدلال عمومی است که در استدلال عمیق مهارت دارد و به حل مسائل پیچیده‌تر کمک می‌کند."
   },
+  "kuaishou/kat-coder-pro-v1": {
+    "description": "KAT-Coder-Pro-V1 (رایگان برای مدت محدود) بر درک کد و برنامه‌نویسی خودکار تمرکز دارد و برای وظایف نمایندگی برنامه‌نویسی کارآمد طراحی شده است."
+  },
   "learnlm-1.5-pro-experimental": {
     "description": "LearnLM یک مدل زبانی تجربی و خاص برای وظایف است که برای مطابقت با اصول علم یادگیری آموزش دیده است و می‌تواند در سناریوهای آموزشی و یادگیری از دستورات سیستم پیروی کند و به عنوان مربی متخصص عمل کند."
   },
@@ -2225,6 +2300,9 @@
   "megrez-3b-instruct": {
     "description": "Megrez 3B Instruct یک مدل کم‌پارامتر و کارآمد است که توسط Wuwen Xinqiong ارائه شده است."
   },
+  "meituan/longcat-flash-chat": {
+    "description": "مدل پایه غیرتفکری متن‌باز Meituan که به‌طور ویژه برای تعاملات گفت‌وگویی و وظایف عامل‌ها بهینه‌سازی شده است و در فراخوانی ابزارها و سناریوهای پیچیده چندمرحله‌ای عملکرد برجسته‌ای دارد."
+  },
   "meta-llama-3-70b-instruct": {
     "description": "یک مدل قدرتمند با ۷۰ میلیارد پارامتر که در استدلال، کدنویسی و کاربردهای گسترده زبانی عملکرد برجسته‌ای دارد."
   },
@@ -2456,6 +2534,12 @@
   "minimax-m2": {
     "description": "MiniMax M2 یک مدل زبانی بزرگ و کارآمد است که به‌طور خاص برای کدنویسی و جریان‌های کاری عامل‌محور طراحی شده است."
   },
+  "minimax/minimax-m2": {
+    "description": "MiniMax-M2 مدلی با عملکرد عالی در کدنویسی و وظایف نمایندگی است که برای سناریوهای مهندسی متنوع مناسب است."
+  },
+  "minimaxai/minimax-m2": {
+    "description": "MiniMax-M2 یک مدل فشرده، سریع و مقرون‌به‌صرفه از نوع متخصصان ترکیبی (MoE) است که دارای ۲۳۰ میلیارد پارامتر کلی و ۱۰ میلیارد پارامتر فعال می‌باشد. این مدل برای ارائه عملکردی عالی در وظایف کدنویسی و عامل‌های هوشمند طراحی شده و در عین حال هوش عمومی قدرتمندی را حفظ می‌کند. این مدل در ویرایش چندفایلی، چرخه کدنویسی-اجرا-اصلاح، آزمون و تصحیح، و زنجیره ابزارهای پیچیده و طولانی عملکردی برجسته دارد و گزینه‌ای ایده‌آل برای جریان کاری توسعه‌دهندگان محسوب می‌شود."
+  },
   "ministral-3b-latest": {
     "description": "Ministral 3B مدل پیشرفته و برتر Mistral در سطح جهانی است."
   },
@@ -2600,12 +2684,21 @@
   "moonshotai/kimi-k2": {
     "description": "Kimi K2 مدل زبان بزرگ متخصص ترکیبی (MoE) با مقیاس بزرگ توسعه یافته توسط Moonshot AI است که دارای 1 تریلیون پارامتر کل و 32 میلیارد پارامتر فعال در هر عبور جلو است. این مدل برای توانایی نمایندگی بهینه شده است، از جمله استفاده پیشرفته از ابزارها، استدلال و ترکیب کد."
   },
+  "moonshotai/kimi-k2-0711": {
+    "description": "Kimi K2 0711 نسخه Instruct از سری Kimi است که برای کدهای با کیفیت بالا و فراخوانی ابزارها مناسب است."
+  },
   "moonshotai/kimi-k2-0905": {
-    "description": "مدل پیش‌نمایش kimi-k2-0905 دارای طول متن ۲۵۶ هزار توکنی است و توانایی‌های قوی‌تری در برنامه‌نویسی عامل‌محور، زیبایی و کاربردی بودن کدهای فرانت‌اند و درک بهتر متن دارد."
+    "description": "Kimi K2 0905 به‌روزرسانی نسخه 0905 از سری Kimi است که زمینه و عملکرد استدلال را گسترش داده و برای سناریوهای کدنویسی بهینه شده است."
   },
   "moonshotai/kimi-k2-instruct-0905": {
     "description": "مدل پیش‌نمایش kimi-k2-0905 دارای طول متن ۲۵۶ هزار توکنی است و توانایی‌های قوی‌تری در برنامه‌نویسی عامل‌محور، زیبایی و کاربردی بودن کدهای فرانت‌اند و درک بهتر متن دارد."
   },
+  "moonshotai/kimi-k2-thinking": {
+    "description": "Kimi K2 Thinking مدل تفکری بهینه‌شده از Moonshot برای وظایف استدلال عمیق است که توانایی عامل عمومی را داراست."
+  },
+  "moonshotai/kimi-k2-thinking-turbo": {
+    "description": "Kimi K2 Thinking Turbo نسخه پرسرعت Kimi K2 Thinking است که با حفظ توانایی استدلال عمیق، تأخیر پاسخ را به‌طور قابل توجهی کاهش می‌دهد."
+  },
   "morph/morph-v3-fast": {
     "description": "Morph مدل هوش مصنوعی تخصصی است که تغییرات کد پیشنهادی مدل‌های پیشرفته مانند Claude یا GPT-4o را به فایل‌های کد موجود شما به سرعت اعمال می‌کند — بیش از 4500 توکن در ثانیه. این مدل به عنوان مرحله نهایی در جریان کاری کدنویسی هوش مصنوعی عمل می‌کند و از ورودی و خروجی 16k توکن پشتیبانی می‌کند."
   },
@@ -2688,28 +2781,49 @@
     "description": "gpt-4-turbo از OpenAI دانش عمومی گسترده و تخصص حوزه‌ای دارد که آن را قادر می‌سازد دستورالعمل‌های پیچیده زبان طبیعی را دنبال کرده و مسائل دشوار را با دقت حل کند. تاریخ قطع دانش آن آوریل 2023 است و پنجره زمینه آن 128,000 توکن است."
   },
   "openai/gpt-4.1": {
-    "description": "GPT 4.1 مدل پرچمدار OpenAI برای وظایف پیچیده است. این مدل برای حل مسائل چندرشته‌ای بسیار مناسب است."
+    "description": "سری GPT-4.1 زمینه متنی گسترده‌تر و توانایی‌های مهندسی و استدلال قوی‌تری را ارائه می‌دهد."
   },
   "openai/gpt-4.1-mini": {
-    "description": "GPT 4.1 mini تعادل بین هوشمندی، سرعت و هزینه را برقرار می‌کند و آن را به مدلی جذاب برای بسیاری از موارد استفاده تبدیل می‌کند."
+    "description": "GPT-4.1 Mini با تأخیر کمتر و صرفه‌جویی بیشتر، برای کاربردهای با زمینه متنی متوسط مناسب است."
   },
   "openai/gpt-4.1-nano": {
-    "description": "GPT-4.1 nano سریع‌ترین و مقرون‌به‌صرفه‌ترین مدل GPT 4.1 است."
+    "description": "GPT-4.1 Nano گزینه‌ای با هزینه و تأخیر بسیار پایین است که برای مکالمات کوتاه و پرتکرار یا سناریوهای طبقه‌بندی مناسب است."
   },
   "openai/gpt-4o": {
-    "description": "GPT-4o از OpenAI دانش عمومی گسترده و تخصص حوزه‌ای دارد که آن را قادر می‌سازد دستورالعمل‌های پیچیده زبان طبیعی را دنبال کرده و مسائل دشوار را با دقت حل کند. این مدل عملکرد GPT-4 Turbo را با API سریع‌تر و ارزان‌تر ارائه می‌دهد."
+    "description": "سری GPT-4o مدل Omni شرکت OpenAI است که از ورودی متن + تصویر و خروجی متنی پشتیبانی می‌کند."
   },
   "openai/gpt-4o-mini": {
-    "description": "GPT-4o mini از OpenAI کوچک‌ترین مدل پیشرفته و مقرون‌به‌صرفه آن‌ها است. این مدل چندرسانه‌ای است (ورودی متن یا تصویر را می‌پذیرد و خروجی متن ارائه می‌دهد) و هوشمندتر از gpt-3.5-turbo است، اما سرعت مشابهی دارد."
+    "description": "GPT-4o-mini نسخه کوچک و سریع GPT-4o است که برای سناریوهای ترکیبی متن و تصویر با تأخیر پایین مناسب است."
   },
   "openai/gpt-5": {
-    "description": "GPT-5 مدل زبان پرچمدار OpenAI است که در استدلال پیچیده، دانش گسترده دنیای واقعی، وظایف کدمحور و نمایندگی چندمرحله‌ای عملکرد برجسته‌ای دارد."
+    "description": "GPT-5 مدل قدرتمند OpenAI است که برای طیف گسترده‌ای از وظایف تولیدی و پژوهشی مناسب است."
+  },
+  "openai/gpt-5-chat": {
+    "description": "GPT-5 Chat زیرمدلی از GPT-5 است که برای سناریوهای گفت‌وگو بهینه‌سازی شده و با کاهش تأخیر، تجربه تعاملی بهتری ارائه می‌دهد."
+  },
+  "openai/gpt-5-codex": {
+    "description": "GPT-5-Codex نسخه‌ای از GPT-5 است که برای سناریوهای برنامه‌نویسی بهینه شده و برای جریان‌های کاری کدنویسی در مقیاس بزرگ مناسب است."
   },
   "openai/gpt-5-mini": {
-    "description": "GPT-5 mini مدلی بهینه‌شده از نظر هزینه است که در وظایف استدلال/مکالمه عملکرد خوبی دارد. این مدل تعادل بهینه‌ای بین سرعت، هزینه و توانایی ارائه می‌دهد."
+    "description": "GPT-5 Mini نسخه‌ای فشرده از خانواده GPT-5 است که برای سناریوهای با تأخیر و هزینه پایین مناسب است."
   },
   "openai/gpt-5-nano": {
-    "description": "GPT-5 nano مدلی با توان عملیاتی بالا است که در وظایف دستورالعمل ساده یا دسته‌بندی عملکرد خوبی دارد."
+    "description": "GPT-5 Nano نسخه فوق‌کوچک این خانواده است که برای کاربردهایی با نیاز بسیار بالا به کاهش هزینه و تأخیر طراحی شده است."
+  },
+  "openai/gpt-5-pro": {
+    "description": "GPT-5 Pro مدل پرچم‌دار OpenAI است که قابلیت‌های پیشرفته‌ای در استدلال، تولید کد و ویژگی‌های سطح سازمانی ارائه می‌دهد و از مسیریابی در زمان تست و سیاست‌های امنیتی دقیق‌تر پشتیبانی می‌کند."
+  },
+  "openai/gpt-5.1": {
+    "description": "GPT-5.1 جدیدترین مدل پرچم‌دار سری GPT-5 است که در استدلال عمومی، پیروی از دستورالعمل‌ها و طبیعی بودن مکالمه نسبت به GPT-5 بهبود چشمگیری دارد و برای وظایف متنوع مناسب است."
+  },
+  "openai/gpt-5.1-chat": {
+    "description": "GPT-5.1 Chat عضو سبک‌تر خانواده GPT-5.1 است که برای گفت‌وگوهای با تأخیر پایین بهینه شده و در عین حال توانایی استدلال و اجرای دستورالعمل را حفظ کرده است."
+  },
+  "openai/gpt-5.1-codex": {
+    "description": "GPT-5.1-Codex نسخه‌ای از GPT-5.1 است که برای مهندسی نرم‌افزار و جریان‌های کاری کدنویسی بهینه شده و برای بازسازی‌های بزرگ، اشکال‌زدایی پیچیده و کدنویسی خودکار طولانی‌مدت مناسب است."
+  },
+  "openai/gpt-5.1-codex-mini": {
+    "description": "GPT-5.1-Codex-Mini نسخه کوچک و سریع GPT-5.1-Codex است که برای سناریوهای کدنویسی حساس به تأخیر و هزینه مناسب‌تر است."
   },
   "openai/gpt-oss-120b": {
     "description": "مدل زبان بزرگ عمومی بسیار توانمند با توان استدلال قوی و قابل کنترل."
@@ -2736,7 +2850,7 @@
     "description": "نسخه o3-mini با سطح استدلال بالا، هوش بالایی را در همان هزینه و هدف تأخیر o1-mini ارائه می‌دهد."
   },
   "openai/o4-mini": {
-    "description": "o4-mini از OpenAI استدلال سریع و مقرون‌به‌صرفه ارائه می‌دهد و در اندازه خود عملکرد برجسته‌ای دارد، به ویژه در ریاضیات (بهترین عملکرد در آزمون AIME)، کدنویسی و وظایف بصری."
+    "description": "OpenAI o4-mini مدل استدلالی کوچک و کارآمد OpenAI است که برای سناریوهای با تأخیر پایین مناسب است."
   },
   "openai/o4-mini-high": {
     "description": "نسخه با سطح استدلال بالا o4-mini، که به‌طور خاص برای استدلال سریع و مؤثر بهینه‌سازی شده و در وظایف کدنویسی و بصری عملکرد بسیار بالایی دارد."
@@ -2940,7 +3054,7 @@
     "description": "مدل کد قدرتمند و متوسط که از طول زمینه 32K پشتیبانی می‌کند و در برنامه‌نویسی چند زبانه مهارت دارد."
   },
   "qwen/qwen3-14b": {
-    "description": "Qwen3-14B یک مدل زبان علّی با ۱۴.۸ میلیارد پارامتر در سری Qwen3 است که به طور خاص برای استدلال پیچیده و مکالمات کارآمد طراحی شده است. این مدل از جابجایی بی‌وقفه بین حالت «تفکر» برای وظایف ریاضی، برنامه‌نویسی و استدلال منطقی و حالت «غیرتفکری» برای مکالمات عمومی پشتیبانی می‌کند. این مدل به طور خاص برای پیروی از دستورات، استفاده از ابزارهای نمایندگی، نوشتن خلاق و انجام وظایف چند زبانه در بیش از ۱۰۰ زبان و گویش مختلف تنظیم شده است. این مدل به طور بومی از ۳۲K توکن زمینه پشتیبانی می‌کند و می‌تواند با استفاده از گسترش مبتنی بر YaRN به ۱۳۱K توکن گسترش یابد."
+    "description": "Qwen3-14B نسخه 14 میلیاردی از سری Qwen است که برای استدلال و گفت‌وگوهای معمولی مناسب است."
   },
   "qwen/qwen3-14b:free": {
     "description": "Qwen3-14B یک مدل زبان علّی با ۱۴.۸ میلیارد پارامتر در سری Qwen3 است که به طور خاص برای استدلال پیچیده و مکالمات کارآمد طراحی شده است. این مدل از جابجایی بی‌وقفه بین حالت «تفکر» برای وظایف ریاضی، برنامه‌نویسی و استدلال منطقی و حالت «غیرتفکری» برای مکالمات عمومی پشتیبانی می‌کند. این مدل به طور خاص برای پیروی از دستورات، استفاده از ابزارهای نمایندگی، نوشتن خلاق و انجام وظایف چند زبانه در بیش از ۱۰۰ زبان و گویش مختلف تنظیم شده است. این مدل به طور بومی از ۳۲K توکن زمینه پشتیبانی می‌کند و می‌تواند با استفاده از گسترش مبتنی بر YaRN به ۱۳۱K توکن گسترش یابد."
@@ -2948,6 +3062,12 @@
   "qwen/qwen3-235b-a22b": {
     "description": "Qwen3-235B-A22B یک مدل متخصص ترکیبی (MoE) با ۲۳۵B پارامتر است که توسط Qwen توسعه یافته و در هر بار انتقال رو به جلو ۲۲B پارامتر فعال می‌شود. این مدل از جابجایی بی‌وقفه بین حالت «تفکر» برای استدلال پیچیده، ریاضیات و وظایف کدنویسی و حالت «غیرتفکری» برای کارایی مکالمات عمومی پشتیبانی می‌کند. این مدل توانایی‌های استدلال قوی، پشتیبانی چند زبانه (بیش از ۱۰۰ زبان و گویش)، پیروی از دستورات پیشرفته و توانایی فراخوانی ابزارهای نمایندگی را نشان می‌دهد. این مدل به طور بومی از پنجره زمینه ۳۲K توکن پشتیبانی می‌کند و می‌تواند با استفاده از گسترش مبتنی بر YaRN به ۱۳۱K توکن گسترش یابد."
   },
+  "qwen/qwen3-235b-a22b-2507": {
+    "description": "Qwen3-235B-A22B-Instruct نسخه Instruct از سری Qwen3 است که برای دستورالعمل‌های چندزبانه و زمینه‌های طولانی بهینه شده است."
+  },
+  "qwen/qwen3-235b-a22b-thinking-2507": {
+    "description": "Qwen3-235B-A22B-Thinking نسخه Thinking از Qwen3 است که برای وظایف پیچیده ریاضی و استدلالی تقویت شده است."
+  },
   "qwen/qwen3-235b-a22b:free": {
     "description": "Qwen3-235B-A22B یک مدل متخصص ترکیبی (MoE) با ۲۳۵B پارامتر است که توسط Qwen توسعه یافته و در هر بار انتقال رو به جلو ۲۲B پارامتر فعال می‌شود. این مدل از جابجایی بی‌وقفه بین حالت «تفکر» برای استدلال پیچیده، ریاضیات و وظایف کدنویسی و حالت «غیرتفکری» برای کارایی مکالمات عمومی پشتیبانی می‌کند. این مدل توانایی‌های استدلال قوی، پشتیبانی چند زبانه (بیش از ۱۰۰ زبان و گویش)، پیروی از دستورات پیشرفته و توانایی فراخوانی ابزارهای نمایندگی را نشان می‌دهد. این مدل به طور بومی از پنجره زمینه ۳۲K توکن پشتیبانی می‌کند و می‌تواند با استفاده از گسترش مبتنی بر YaRN به ۱۳۱K توکن گسترش یابد."
   },
@@ -2966,6 +3086,21 @@
   "qwen/qwen3-8b:free": {
     "description": "Qwen3-8B یک مدل زبان علّی با ۸.۲ میلیارد پارامتر در سری Qwen3 است که به طور خاص برای وظایف استدلال فشرده و مکالمات کارآمد طراحی شده است. این مدل از جابجایی بی‌وقفه بین حالت «تفکر» برای ریاضیات، کدنویسی و استدلال منطقی و حالت «غیرتفکری» برای مکالمات عمومی پشتیبانی می‌کند. این مدل به طور خاص برای پیروی از دستورات، ادغام نمایندگی، نوشتن خلاق و استفاده چند زبانه در بیش از ۱۰۰ زبان و گویش مختلف تنظیم شده است. این مدل به طور بومی از پنجره زمینه ۳۲K توکن پشتیبانی می‌کند و می‌تواند از طریق YaRN به ۱۳۱K توکن گسترش یابد."
   },
+  "qwen/qwen3-coder": {
+    "description": "Qwen3-Coder خانواده تولیدکننده کد از Qwen3 است که در درک و تولید کد در اسناد طولانی تخصص دارد."
+  },
+  "qwen/qwen3-coder-plus": {
+    "description": "Qwen3-Coder-Plus مدل کدنویسی بهینه‌شده ویژه از سری Qwen است که از فراخوانی ابزارهای پیچیده و مکالمات بلندمدت پشتیبانی می‌کند."
+  },
+  "qwen/qwen3-max": {
+    "description": "Qwen3 Max مدل استدلالی سطح بالا از سری Qwen3 است که برای استدلال چندزبانه و یکپارچه‌سازی ابزارها مناسب است."
+  },
+  "qwen/qwen3-max-preview": {
+    "description": "Qwen3 Max (پیش‌نمایش) نسخه Max از سری Qwen است که برای استدلال پیشرفته و یکپارچه‌سازی ابزارها طراحی شده است."
+  },
+  "qwen/qwen3-vl-plus": {
+    "description": "Qwen3 VL-Plus نسخه تقویت‌شده بصری از Qwen3 است که توانایی استدلال چندحالته و پردازش ویدیو را بهبود داده است."
+  },
   "qwen2": {
     "description": "Qwen2 مدل زبان بزرگ نسل جدید علی‌بابا است که با عملکرد عالی از نیازهای متنوع کاربردی پشتیبانی می‌کند."
   },
@@ -3260,9 +3395,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 بیش از 20T توکن متنی و 4T توکن ترکیبی تصویر-متن را پردازش کرده و بیش از ده زبان را پوشش داده است. این مدل در بنچ‌مارک‌های متعددی از جمله ریاضیات، کدنویسی و چندمودال در میان مدل‌های متن‌باز در جایگاه پیشرو قرار گرفته است."
   },
@@ -3344,6 +3476,9 @@
   "vercel/v0-1.5-md": {
     "description": "دسترسی به مدل پشت v0 برای تولید، رفع اشکال و بهینه‌سازی برنامه‌های وب مدرن با استدلال چارچوب خاص و دانش به‌روز."
   },
+  "volcengine/doubao-seed-code": {
+    "description": "Doubao-Seed-Code مدل بزرگ بهینه‌شده برای برنامه‌نویسی عاملی (Agentic Programming) از Volcengine است که در معیارهای مختلف برنامه‌نویسی و عامل‌ها عملکرد برجسته‌ای دارد و از زمینه ۲۵۶ هزار توکن پشتیبانی می‌کند."
+  },
   "wan2.2-t2i-flash": {
     "description": "نسخه سریع Wanxiang 2.2، جدیدترین مدل فعلی. در خلاقیت، پایداری و واقع‌گرایی به طور کامل ارتقا یافته، سرعت تولید بالا و نسبت قیمت به کیفیت عالی دارد."
   },
@@ -3371,6 +3506,24 @@
   "wizardlm2:8x22b": {
     "description": "WizardLM 2 یک مدل زبانی ارائه شده توسط مایکروسافت AI است که در زمینه‌های مکالمات پیچیده، چندزبانه، استدلال و دستیارهای هوشمند عملکرد برجسته‌ای دارد."
   },
+  "x-ai/grok-4": {
+    "description": "Grok 4 مدل پرچم‌دار استدلالی xAI است که توانایی‌های قدرتمند در استدلال و چندحالته ارائه می‌دهد."
+  },
+  "x-ai/grok-4-fast": {
+    "description": "Grok 4 Fast مدل با توان عملیاتی بالا و هزینه پایین از xAI است (با پشتیبانی از پنجره زمینه ۲ میلیون توکن) که برای سناریوهای با نیاز به هم‌زمانی بالا و زمینه طولانی مناسب است."
+  },
+  "x-ai/grok-4-fast-non-reasoning": {
+    "description": "Grok 4 Fast (بدون استدلال) مدل چندحالته با توان عملیاتی بالا و هزینه پایین از xAI است (با پشتیبانی از پنجره زمینه ۲ میلیون توکن) که برای سناریوهایی مناسب است که به استدلال درون‌مدلی نیاز ندارند اما به تأخیر و هزینه حساس هستند. این مدل در کنار نسخه reasoning از Grok 4 Fast قرار دارد و می‌توان از طریق پارامتر reasoning enable در API، قابلیت استدلال را در صورت نیاز فعال کرد. ورودی‌ها و خروجی‌ها ممکن است توسط xAI یا OpenRouter برای بهبود مدل‌های آینده استفاده شوند."
+  },
+  "x-ai/grok-4.1-fast": {
+    "description": "Grok 4.1 Fast مدل با توان عملیاتی بالا و هزینه پایین از xAI است (با پشتیبانی از پنجره زمینه ۲ میلیون توکن) که برای سناریوهای با نیاز به هم‌زمانی بالا و زمینه طولانی مناسب است."
+  },
+  "x-ai/grok-4.1-fast-non-reasoning": {
+    "description": "Grok 4.1 Fast (بدون استدلال) مدل چندحالته با توان عملیاتی بالا و هزینه پایین از xAI است (با پشتیبانی از پنجره زمینه ۲ میلیون توکن) که برای سناریوهایی مناسب است که به استدلال درون‌مدلی نیاز ندارند اما به تأخیر و هزینه حساس هستند. این مدل در کنار نسخه reasoning از Grok 4.1 Fast قرار دارد و می‌توان از طریق پارامتر reasoning enable در API، قابلیت استدلال را در صورت نیاز فعال کرد. ورودی‌ها و خروجی‌ها ممکن است توسط xAI یا OpenRouter برای بهبود مدل‌های آینده استفاده شوند."
+  },
+  "x-ai/grok-code-fast-1": {
+    "description": "Grok Code Fast 1 مدل سریع کدنویسی از xAI است که خروجی‌هایی با خوانایی بالا و سازگار با مهندسی ارائه می‌دهد."
+  },
   "x1": {
     "description": "مدل Spark X1 به‌زودی ارتقا خواهد یافت و در زمینه وظایف ریاضی که در کشور پیشرو است، عملکردهای استدلال، تولید متن و درک زبان را با OpenAI o1 و DeepSeek R1 مقایسه خواهد کرد."
   },
@@ -3431,6 +3584,15 @@
   "yi-vision-v2": {
     "description": "مدل‌های پیچیده بصری که قابلیت‌های درک و تحلیل با عملکرد بالا را بر اساس چندین تصویر ارائه می‌دهند."
   },
+  "z-ai/glm-4.5": {
+    "description": "GLM 4.5 مدل پرچم‌دار Z.AI است که از حالت‌های استدلال ترکیبی پشتیبانی می‌کند و برای وظایف مهندسی و زمینه‌های طولانی بهینه شده است."
+  },
+  "z-ai/glm-4.5-air": {
+    "description": "GLM 4.5 Air نسخه سبک‌تر GLM 4.5 است که برای سناریوهای حساس به هزینه طراحی شده و همچنان توانایی استدلال قوی را حفظ کرده است."
+  },
+  "z-ai/glm-4.6": {
+    "description": "GLM 4.6 مدل پرچم‌دار Z.AI است که طول زمینه و توانایی‌های کدنویسی را گسترش داده است."
+  },
   "zai-org/GLM-4.5": {
     "description": "GLM-4.5 یک مدل پایه طراحی شده برای کاربردهای عامل هوشمند است که از معماری Mixture-of-Experts استفاده می‌کند. این مدل در زمینه‌های فراخوانی ابزار، مرور وب، مهندسی نرم‌افزار و برنامه‌نویسی فرانت‌اند بهینه‌سازی عمیق شده و از ادغام بی‌وقفه با عامل‌های کد مانند Claude Code و Roo Code پشتیبانی می‌کند. GLM-4.5 از حالت استدلال ترکیبی بهره می‌برد و می‌تواند در سناریوهای استدلال پیچیده و استفاده روزمره به خوبی عمل کند."
   },
@@ -3451,5 +3613,8 @@
   },
   "zai/glm-4.5v": {
     "description": "GLM-4.5V بر پایه مدل پایه GLM-4.5-Air ساخته شده است، فناوری اثبات شده GLM-4.1V-Thinking را به ارث برده و در عین حال با معماری قدرتمند MoE با 106 میلیارد پارامتر به طور مؤثر مقیاس‌پذیر شده است."
+  },
+  "zenmux/auto": {
+    "description": "ویژگی مسیریابی خودکار ZenMux بر اساس محتوای درخواست شما، بهترین مدل موجود از نظر عملکرد و هزینه را از میان مدل‌های پشتیبانی‌شده انتخاب می‌کند."
   }
 }

locales/fa-IR/plugin.json

@@ -1,4 +1,38 @@
 {
+  "builtins": {
+    "lobe-knowledge-base": {
+      "apiName": {
+        "readKnowledge": "خواندن محتوای پایگاه دانش",
+        "searchKnowledgeBase": "جستجو در پایگاه دانش"
+      },
+      "title": "پایگاه دانش"
+    },
+    "lobe-local-system": {
+      "apiName": {
+        "editLocalFile": "ویرایش فایل",
+        "getCommandOutput": "دریافت خروجی کد",
+        "globLocalFiles": "جستجوی فایل‌ها با الگو",
+        "grepContent": "جستجوی محتوا",
+        "killCommand": "توقف اجرای کد",
+        "listLocalFiles": "مشاهده فهرست فایل‌ها",
+        "moveLocalFiles": "انتقال فایل‌ها",
+        "readLocalFile": "خواندن محتوای فایل",
+        "renameLocalFile": "تغییر نام فایل",
+        "runCommand": "اجرای کد",
+        "searchLocalFiles": "جستجوی فایل‌ها",
+        "writeLocalFile": "نوشتن در فایل"
+      },
+      "title": "سیستم محلی"
+    },
+    "lobe-web-browsing": {
+      "apiName": {
+        "crawlMultiPages": "خواندن محتوای چندین صفحه",
+        "crawlSinglePage": "خواندن محتوای صفحه",
+        "search": "جستجوی صفحات"
+      },
+      "title": "جستجوی آنلاین"
+    }
+  },
   "confirm": "تأیید",
   "debug": {
     "arguments": "پارامترهای فراخوانی",
@@ -251,23 +285,6 @@
     "content": "در حال فراخوانی افزونه...",
     "plugin": "افزونه در حال اجرا..."
   },
-  "localSystem": {
-    "apiName": {
-      "editLocalFile": "ویرایش فایل",
-      "getCommandOutput": "دریافت خروجی کد",
-      "globLocalFiles": "جستجوی فایل‌ها با الگو",
-      "grepContent": "جستجوی محتوا",
-      "killCommand": "متوقف کردن اجرای کد",
-      "listLocalFiles": "مشاهده لیست فایل‌ها",
-      "moveLocalFiles": "جابجایی فایل‌ها",
-      "readLocalFile": "خواندن محتوای فایل",
-      "renameLocalFile": "تغییر نام",
-      "runCommand": "اجرای کد",
-      "searchLocalFiles": "جستجوی فایل‌ها",
-      "writeLocalFile": "نوشتن در فایل"
-    },
-    "title": "سیستم محلی"
-  },
   "mcpInstall": {
     "CHECKING_INSTALLATION": "در حال بررسی محیط نصب...",
     "COMPLETED": "نصب کامل شد",
@@ -375,11 +392,6 @@
     "warning": "⚠️ لطفاً اطمینان حاصل کنید که به منبع این افزونه اعتماد دارید، افزونه‌های مخرب ممکن است امنیت سیستم شما را به خطر بیندازند."
   },
   "search": {
-    "apiName": {
-      "crawlMultiPages": "خواندن محتوای چند صفحه",
-      "crawlSinglePage": "خواندن محتوای صفحه",
-      "search": "جستجوی صفحه"
-    },
     "config": {
       "addKey": "افزودن کلید",
       "close": "حذف",

locales/fa-IR/providers.json

@@ -191,6 +191,9 @@
   "xinference": {
     "description": "Xorbits Inference (Xinference) یک پلتفرم اپن‌سورس برای ساده‌سازی اجرای و ادغام انواع مدل‌های هوش مصنوعی است. با کمک Xinference، شما می‌توانید هر مدل زبانی اپن‌سورس، مدل‌های مبتنی بر بردار و مدل‌های چندمدیا را در محیط‌های ابری یا محلی اجرا کرده و برنامه‌های AI قدرتمند ایجاد کنید."
   },
+  "zenmux": {
+    "description": "ZenMux یک پلتفرم یکپارچه برای تجمیع خدمات هوش مصنوعی است که از رابط‌های خدماتی متنوعی مانند OpenAI، Anthropic، Google VertexAI و دیگر سرویس‌های هوش مصنوعی پشتیبانی می‌کند. این پلتفرم قابلیت مسیریابی انعطاف‌پذیری را ارائه می‌دهد تا بتوانید به‌راحتی بین مدل‌های مختلف هوش مصنوعی جابجا شده و آن‌ها را مدیریت کنید."
+  },
   "zeroone": {
     "description": "صفر و یک متعهد به پیشبرد انقلاب فناوری AI 2.0 با محوریت انسان است و هدف آن ایجاد ارزش اقتصادی و اجتماعی عظیم از طریق مدل‌های زبانی بزرگ و همچنین ایجاد اکوسیستم جدید هوش مصنوعی و مدل‌های تجاری است."
   },

locales/fa-IR/tool.json

@@ -14,7 +14,21 @@
     "images": "تصاویر:",
     "prompt": "کلمات کلیدی"
   },
+  "lobe-knowledge-base": {
+    "readKnowledge": {
+      "meta": {
+        "chars": "تعداد نویسه‌ها",
+        "lines": "تعداد خطوط"
+      }
+    }
+  },
   "localFiles": {
+    "editFile": {
+      "newString": "جایگزین با",
+      "oldString": "یافتن محتوا",
+      "replaceAll": "جایگزینی تمام موارد",
+      "replaceFirst": "فقط اولین مورد را جایگزین کن"
+    },
     "file": "فایل",
     "folder": "پوشه",
     "moveFiles": {
@@ -34,7 +48,12 @@
     "readFile": "خواندن فایل",
     "readFileError": "خطا در خواندن فایل، لطفاً مسیر فایل را بررسی کنید",
     "readFiles": "خواندن فایل‌ها",
-    "readFilesError": "خطا در خواندن فایل‌ها، لطفاً مسیر فایل‌ها را بررسی کنید"
+    "readFilesError": "خطا در خواندن فایل‌ها، لطفاً مسیر فایل‌ها را بررسی کنید",
+    "writeFile": {
+      "characters": "کاراکتر",
+      "preview": "پیش‌نمایش محتوا",
+      "truncated": "بریده شده"
+    }
   },
   "search": {
     "createNewSearch": "ایجاد جستجوی جدید",

locales/fr-FR/chat.json

@@ -65,6 +65,9 @@
     "thinking": {
       "title": "Interrupteur de réflexion approfondie"
     },
+    "thinkingLevel": {
+      "title": "Niveau de réflexion"
+    },
     "title": "Fonctionnalités d'extension du modèle",
     "urlContext": {
       "desc": "Une fois activé, il analysera automatiquement les liens web pour obtenir le contenu contextuel réel de la page web",
@@ -330,6 +333,11 @@
     "screenshot": "Capture d'écran",
     "settings": "Paramètres d'exportation",
     "text": "Texte",
+    "widthMode": {
+      "label": "Mode de largeur",
+      "narrow": "Mode écran étroit",
+      "wide": "Mode écran large"
+    },
     "withBackground": "Avec image de fond",
     "withFooter": "Avec pied de page",
     "withPluginInfo": "Avec informations sur le plugin",
@@ -391,6 +399,7 @@
       "rejectReasonPlaceholder": "Saisir une raison de rejet aidera l'agent à comprendre et à améliorer ses actions futures",
       "rejectTitle": "Rejeter cet appel d'outil",
       "rejectedWithReason": "Cet appel d'outil a été rejeté volontairement : {{reason}}",
+      "toolAbort": "L'appel de l'outil a été annulé par l'utilisateur",
       "toolRejected": "Cet appel d'outil a été rejeté volontairement"
     }
   },

locales/fr-FR/common.json

@@ -135,6 +135,27 @@
     }
   },
   "close": "Fermer",
+  "cmdk": {
+    "about": "À propos",
+    "communitySupport": "Support communautaire",
+    "discover": "Découvrir",
+    "knowledgeBase": "Base de connaissances",
+    "navigate": "Naviguer",
+    "newAgent": "Nouvel assistant",
+    "noResults": "Aucun résultat trouvé",
+    "openSettings": "Ouvrir les paramètres",
+    "painting": "Peinture IA",
+    "searchPlaceholder": "Entrez une commande ou recherchez...",
+    "settings": "Paramètres",
+    "starOnGitHub": "Donnez-nous une étoile sur GitHub",
+    "submitIssue": "Soumettre un problème",
+    "theme": "Thème",
+    "themeAuto": "Suivre le système",
+    "themeDark": "Mode sombre",
+    "themeLight": "Mode clair",
+    "toOpen": "Ouvrir",
+    "toSelect": "Sélectionner"
+  },
   "confirm": "Confirmer",
   "contact": "Nous contacter",
   "copy": "Copier",
@@ -283,6 +304,7 @@
     "business": "Partenariats commerciaux",
     "support": "Support par e-mail"
   },
+  "new": "Nouveau",
   "oauth": "Connexion SSO",
   "officialSite": "Site officiel",
   "ok": "OK",

locales/fr-FR/error.json

@@ -102,7 +102,7 @@
       "SPII": "Votre contenu peut contenir des informations personnelles sensibles. Pour protéger la vie privée, veuillez retirer ces informations sensibles puis réessayer.",
       "default": "Contenu bloqué : {{blockReason}}. Veuillez modifier votre demande et réessayer."
     },
-    "InsufficientQuota": "Désolé, le quota de cette clé a atteint sa limite. Veuillez vérifier si le solde de votre compte est suffisant ou augmenter le quota de la clé avant de réessayer.",
+    "InsufficientQuota": "Désolé, le quota associé à cette clé a été atteint. Veuillez vérifier si le solde de votre compte est suffisant ou augmenter le quota de la clé avant de réessayer.",
     "InvalidAccessCode": "Le mot de passe est incorrect ou vide. Veuillez saisir le mot de passe d'accès correct ou ajouter une clé API personnalisée.",
     "InvalidBedrockCredentials": "L'authentification Bedrock a échoué, veuillez vérifier AccessKeyId/SecretAccessKey et réessayer",
     "InvalidClerkUser": "Désolé, vous n'êtes pas actuellement connecté. Veuillez vous connecter ou vous inscrire avant de continuer.",
@@ -131,7 +131,7 @@
     "PluginServerError": "Erreur de réponse du serveur du plugin. Veuillez vérifier le fichier de description du plugin, la configuration du plugin ou la mise en œuvre côté serveur en fonction des informations d'erreur ci-dessous",
     "PluginSettingsInvalid": "Ce plugin doit être correctement configuré avant de pouvoir être utilisé. Veuillez vérifier votre configuration",
     "ProviderBizError": "Erreur de service {{provider}}. Veuillez vérifier les informations suivantes ou réessayer.",
-    "QuotaLimitReached": "Désolé, l'utilisation actuelle des tokens ou le nombre de requêtes a atteint la limite de quota de cette clé. Veuillez augmenter le quota de cette clé ou réessayer plus tard.",
+    "QuotaLimitReached": "Désolé, la consommation de jetons ou le nombre de requêtes a atteint la limite de quota de cette clé. Veuillez augmenter le quota de la clé ou réessayer plus tard.",
     "StreamChunkError": "Erreur de parsing du bloc de message de la requête en streaming. Veuillez vérifier si l'API actuelle respecte les normes ou contacter votre fournisseur d'API pour des conseils.",
     "SubscriptionKeyMismatch": "Nous sommes désolés, en raison d'une défaillance système occasionnelle, l'utilisation actuelle de l'abonnement est temporairement inactive. Veuillez cliquer sur le bouton ci-dessous pour rétablir votre abonnement ou nous contacter par e-mail pour obtenir de l'aide.",
     "SubscriptionPlanLimit": "Votre quota d'abonnement est épuisé, vous ne pouvez pas utiliser cette fonctionnalité. Veuillez passer à un plan supérieur ou configurer l'API du modèle personnalisé pour continuer à l'utiliser.",

locales/fr-FR/file.json

@@ -55,10 +55,10 @@
   },
   "documentList": {
     "copyContent": "Copier tout le contenu",
-    "documentCount": "{{count}} documents au total",
     "duplicate": "Créer une copie",
     "empty": "Aucun document pour le moment, cliquez sur le bouton ci-dessus pour créer votre premier document",
     "noResults": "Aucun document correspondant trouvé",
+    "pageCount": "{{count}} documents au total",
     "selectNote": "Sélectionnez un document pour commencer l’édition",
     "untitled": "Sans titre"
   },
@@ -70,7 +70,6 @@
       "uploadFile": "Télécharger un fichier",
       "uploadFolder": "Télécharger un dossier"
     },
-    "newDocumentButton": "Nouveau document",
     "newNoteDialog": {
       "cancel": "Annuler",
       "editTitle": "Modifier le document",
@@ -83,14 +82,15 @@
       "title": "Nouveau document",
       "updateSuccess": "Document mis à jour avec succès"
     },
+    "newPageButton": "Nouveau document",
     "uploadButton": "Télécharger"
   },
   "home": {
     "getStarted": "Commencer",
     "greeting": "Commencer",
     "quickActions": "Actions rapides",
-    "recentDocuments": "Documents récents",
     "recentFiles": "Fichiers récents",
+    "recentPages": "Pages récentes",
     "subtitle": "Bienvenue dans votre base de connaissances, commencez ici à gérer vos documents",
     "uploadEntries": {
       "files": {
@@ -102,7 +102,7 @@
       "knowledgeBase": {
         "title": "Créer une base de connaissances"
       },
-      "newDocument": {
+      "newPage": {
         "title": "Nouveau document"
       }
     }
@@ -116,8 +116,8 @@
     "title": "Base de connaissances"
   },
   "menu": {
-    "allDocuments": "Tous les documents",
-    "allFiles": "Tous les fichiers"
+    "allFiles": "Tous les fichiers",
+    "allPages": "Tous les documents"
   },
   "networkError": "Échec de l'accès à la base de connaissances, veuillez vérifier votre connexion réseau et réessayer",
   "notSupportGuide": {
@@ -142,8 +142,8 @@
     "downloadFile": "Télécharger le fichier",
     "unsupportedFileAndContact": "Ce format de fichier n'est pas encore pris en charge pour l'aperçu en ligne. Si vous souhaitez un aperçu, n'hésitez pas à <1>nous contacter</1>."
   },
-  "searchDocumentPlaceholder": "Rechercher un document",
   "searchFilePlaceholder": "Rechercher un fichier",
+  "searchPagePlaceholder": "Rechercher un document",
   "tab": {
     "all": "Tout",
     "audios": "Audio",
@@ -156,9 +156,7 @@
     "websites": "Sites web"
   },
   "title": "Base de connaissances",
-  "toggleLeftPanel": {
-    "title": "Afficher/Masquer le panneau de gauche"
-  },
+  "toggleLeftPanel": "Afficher/Masquer le panneau de gauche",
   "uploadDock": {
     "body": {
       "collapse": "Réduire",

locales/fr-FR/hotkey.json

@@ -7,6 +7,10 @@
     "desc": "Effacer les messages de la session actuelle et les fichiers téléchargés",
     "title": "Effacer les messages de la session"
   },
+  "commandPalette": {
+    "desc": "Ouvrez le panneau de commande global pour accéder rapidement aux fonctionnalités",
+    "title": "Panneau de commande"
+  },
   "deleteAndRegenerateMessage": {
     "desc": "Supprimer le dernier message et régénérer",
     "title": "Supprimer et régénérer"

locales/fr-FR/image.json

@@ -37,6 +37,14 @@
         "standard": "Standard"
       }
     },
+    "resolution": {
+      "label": "Résolution",
+      "options": {
+        "1K": "1K",
+        "2K": "2K",
+        "4K": "4K"
+      }
+    },
     "seed": {
       "label": "Graine",
       "random": "Graine aléatoire"