🐛 fix(desktop): persist gateway toggle state across app restarts (#13300)

🐛 fix: persist gateway toggle state across app restarts

The gateway auto-connect logic only checked if the user was logged in,
ignoring whether they had manually disabled the toggle. Added a
`gatewayEnabled` flag to the Electron store that is set on
connect/disconnect and checked before auto-connecting on startup.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.agents/skills/code-review/SKILL.md

@@ -37,6 +37,10 @@ description: 'Code review checklist for LobeHub. Use when reviewing PRs, diffs,
 - Keys added to `src/locales/default/{namespace}.ts` with `{feature}.{context}.{action|status}` naming
 - For PRs: `locales/` translations for all languages updated (`pnpm i18n`)
 
+### SPA / routing
+
+- **`desktopRouter` pair:** If the diff touches `src/spa/router/desktopRouter.config.tsx`, does it also update `src/spa/router/desktopRouter.config.desktop.tsx` with the same route paths and nesting? Single-file edits often cause drift and blank screens.
+
 ### Reuse
 
 - Newly written code duplicates existing utilities in `packages/utils` or shared modules?

.agents/skills/react/SKILL.md

@@ -32,15 +32,28 @@ Hybrid routing: Next.js App Router (static pages) + React Router DOM (main SPA).
 | Route Type         | Use Case                          | Implementation               |
 | ------------------ | --------------------------------- | ---------------------------- |
 | Next.js App Router | Auth pages (login, signup, oauth) | `src/app/[variants]/(auth)/` |
-| React Router DOM   | Main SPA (chat, settings)         | `desktopRouter.config.tsx`   |
+| React Router DOM   | Main SPA (chat, settings)         | `desktopRouter.config.tsx` + `desktopRouter.config.desktop.tsx` (must match) |
 
 ### Key Files
 
 - Entry: `src/spa/entry.web.tsx` (web), `src/spa/entry.mobile.tsx`, `src/spa/entry.desktop.tsx`
-- Desktop router: `src/spa/router/desktopRouter.config.tsx`
+- Desktop router (pair — **always edit both** when changing routes): `src/spa/router/desktopRouter.config.tsx` (dynamic imports) and `src/spa/router/desktopRouter.config.desktop.tsx` (sync imports). Drift can cause unregistered routes / blank screen.
 - Mobile router: `src/spa/router/mobileRouter.config.tsx`
 - Router utilities: `src/utils/router.tsx`
 
+### `.desktop.{ts,tsx}` File Sync Rule
+
+**CRITICAL**: Some files have a `.desktop.ts(x)` variant that Electron uses instead of the base file. When editing a base file, **always check** if a `.desktop` counterpart exists and update it in sync. Drift causes blank pages or missing features in Electron.
+
+Known pairs that must stay in sync:
+
+| Base file (web, dynamic imports) | Desktop file (Electron, sync imports) |
+| --- | --- |
+| `src/spa/router/desktopRouter.config.tsx` | `src/spa/router/desktopRouter.config.desktop.tsx` |
+| `src/routes/(main)/settings/features/componentMap.ts` | `src/routes/(main)/settings/features/componentMap.desktop.ts` |
+
+**How to check**: After editing any `.ts` / `.tsx` file, run `Glob` for `<filename>.desktop.{ts,tsx}` in the same directory. If a match exists, update it with the equivalent sync-import change.
+
 ### Router Utilities
 
 ```tsx

.agents/skills/spa-routes/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: spa-routes
-description: SPA route and feature structure. Use when adding or modifying SPA routes in src/routes, defining new route segments, or moving route logic into src/features. Covers how to keep routes thin and how to divide files between routes and features.
+description: MUST use when editing src/routes/ segments, src/spa/router/desktopRouter.config.tsx or desktopRouter.config.desktop.tsx (always change both together), mobileRouter.config.tsx, or when moving UI/logic between routes and src/features/.
 ---
 
 # SPA Routes and Features Guide
@@ -13,6 +13,8 @@ SPA structure:
 
 This project uses a **roots vs features** split: `src/routes/` only holds page segments; business logic and UI live in `src/features/` by domain.
 
+**Agent constraint — desktop router parity:** Edits to the desktop route tree must update **both** `src/spa/router/desktopRouter.config.tsx` and `src/spa/router/desktopRouter.config.desktop.tsx` in the same change (same paths, nesting, index routes, and segment registration). Updating only one causes drift; the missing tree can fail to register routes and surface as a **blank screen** or broken navigation on the affected build.
+
 ## When to Use This Skill
 
 - Adding a new SPA route or route segment
@@ -73,8 +75,21 @@ Each feature should:
    - Layout: `export { default } from '@/features/MyFeature/MyLayout'` or compose a few feature components + `<Outlet />`.
    - Page: import from `@/features/MyFeature` (or a specific subpath) and render; no business logic in the route file.
 
-5. **Register the route**
-   - Add the segment to `src/spa/router/desktopRouter.config.tsx` (or the right router config) with `dynamicElement` / `dynamicLayout` pointing at the new route paths (e.g. `@/routes/(main)/my-feature`).
+5. **Register the route (desktop — two files, always)**
+   - **`desktopRouter.config.tsx`:** Add the segment with `dynamicElement` / `dynamicLayout` pointing at route modules (e.g. `@/routes/(main)/my-feature`).
+   - **`desktopRouter.config.desktop.tsx`:** Mirror the **same** `RouteObject` shape: identical `path` / `index` / parent-child structure. Use the static imports and elements already used in that file (see neighboring routes). Do **not** register in only one of these files.
+   - **Mobile-only flows:** use `mobileRouter.config.tsx` instead (no need to duplicate into the desktop pair unless the route truly exists on both).
+
+---
+
+## 3a. Desktop router pair (`desktopRouter.config` × 2)
+
+| File | Role |
+|------|------|
+| `desktopRouter.config.tsx` | Dynamic imports via `dynamicElement` / `dynamicLayout` — code-splitting; used by `entry.web.tsx` and `entry.desktop.tsx`. |
+| `desktopRouter.config.desktop.tsx` | Same route tree with **synchronous** imports — kept for Electron / local parity and predictable bundling. |
+
+Anything that changes the tree (new segment, renamed `path`, moved layout, new child route) must be reflected in **both** files in one PR or commit. Remove routes from both when deleting.
 
 ---
 

CHANGELOG.md

@@ -2,6 +2,64 @@
 
 # Changelog
 
+### [Version 2.1.45](https://github.com/lobehub/lobe-chat/compare/v2.1.44...v2.1.45)
+
+<sup>Released on **2026-03-26**</sup>
+
+#### 👷 Build System
+
+- **misc**: add agent task system database schema.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Build System
+
+- **misc**: add agent task system database schema, closes [#13280](https://github.com/lobehub/lobe-chat/issues/13280) ([b005a9c](https://github.com/lobehub/lobe-chat/commit/b005a9c))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 2.1.44](https://github.com/lobehub/lobe-chat/compare/v2.2.0-nightly.202603200623...v2.1.44)
+
+<sup>Released on **2026-03-20**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: misc UI/UX improvements and bug fixes.
+
+#### 💄 Styles
+
+- **misc**: add image/video switch.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: misc UI/UX improvements and bug fixes, closes [#13153](https://github.com/lobehub/lobe-chat/issues/13153) ([abd152b](https://github.com/lobehub/lobe-chat/commit/abd152b))
+
+#### Styles
+
+- **misc**: add image/video switch, closes [#13152](https://github.com/lobehub/lobe-chat/issues/13152) ([2067cb2](https://github.com/lobehub/lobe-chat/commit/2067cb2))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 2.1.43](https://github.com/lobehub/lobe-chat/compare/v2.1.42...v2.1.43)
 
 <sup>Released on **2026-03-16**</sup>

apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/cli",
-  "version": "0.0.1-canary.12",
+  "version": "0.0.1-canary.14",
   "type": "module",
   "bin": {
     "lh": "./dist/index.js",

apps/cli/src/api/client.ts

@@ -5,8 +5,8 @@ import type { LambdaRouter } from '@/server/routers/lambda';
 import type { ToolsRouter } from '@/server/routers/tools';
 
 import { getValidToken } from '../auth/refresh';
-import { OFFICIAL_SERVER_URL } from '../constants/urls';
-import { loadSettings } from '../settings';
+import { CLI_API_KEY_ENV } from '../constants/auth';
+import { resolveServerUrl } from '../settings';
 import { log } from '../utils/logger';
 
 export type TrpcClient = ReturnType<typeof createTRPCClient<LambdaRouter>>;
@@ -19,31 +19,46 @@ async function getAuthAndServer() {
   // LOBEHUB_JWT + LOBEHUB_SERVER env vars (used by server-side sandbox execution)
   const envJwt = process.env.LOBEHUB_JWT;
   if (envJwt) {
-    const serverUrl = process.env.LOBEHUB_SERVER || OFFICIAL_SERVER_URL;
-    return { accessToken: envJwt, serverUrl: serverUrl.replace(/\/$/, '') };
+    const serverUrl = resolveServerUrl();
+
+    return {
+      headers: { 'Oidc-Auth': envJwt },
+      serverUrl,
+    };
+  }
+
+  const envApiKey = process.env[CLI_API_KEY_ENV];
+  if (envApiKey) {
+    const serverUrl = resolveServerUrl();
+
+    return {
+      headers: { 'X-API-Key': envApiKey },
+      serverUrl,
+    };
   }
 
   const result = await getValidToken();
   if (!result) {
-    log.error("No authentication found. Run 'lh login' first.");
+    log.error(`No authentication found. Run 'lh login' first, or set ${CLI_API_KEY_ENV}.`);
     process.exit(1);
   }
 
-  const accessToken = result.credentials.accessToken;
-  const serverUrl = loadSettings()?.serverUrl || OFFICIAL_SERVER_URL;
+  const serverUrl = resolveServerUrl();
 
-  return { accessToken, serverUrl: serverUrl.replace(/\/$/, '') };
+  return {
+    headers: { 'Oidc-Auth': result.credentials.accessToken },
+    serverUrl,
+  };
 }
 
 export async function getTrpcClient(): Promise<TrpcClient> {
   if (_client) return _client;
 
-  const { accessToken, serverUrl } = await getAuthAndServer();
-
+  const { headers, serverUrl } = await getAuthAndServer();
   _client = createTRPCClient<LambdaRouter>({
     links: [
       httpLink({
-        headers: { 'Oidc-Auth': accessToken },
+        headers,
         transformer: superjson,
         url: `${serverUrl}/trpc/lambda`,
       }),
@@ -56,12 +71,11 @@ export async function getTrpcClient(): Promise<TrpcClient> {
 export async function getToolsTrpcClient(): Promise<ToolsTrpcClient> {
   if (_toolsClient) return _toolsClient;
 
-  const { accessToken, serverUrl } = await getAuthAndServer();
-
+  const { headers, serverUrl } = await getAuthAndServer();
   _toolsClient = createTRPCClient<ToolsRouter>({
     links: [
       httpLink({
-        headers: { 'Oidc-Auth': accessToken },
+        headers,
         transformer: superjson,
         url: `${serverUrl}/trpc/tools`,
       }),

apps/cli/src/api/http.ts

@@ -1,6 +1,6 @@
 import { getValidToken } from '../auth/refresh';
-import { OFFICIAL_SERVER_URL } from '../constants/urls';
-import { loadSettings } from '../settings';
+import { CLI_API_KEY_ENV } from '../constants/auth';
+import { resolveServerUrl } from '../settings';
 import { log } from '../utils/logger';
 
 // Must match the server's SECRET_XOR_KEY (src/envs/auth.ts)
@@ -33,12 +33,19 @@ export interface AuthInfo {
 export async function getAuthInfo(): Promise<AuthInfo> {
   const result = await getValidToken();
   if (!result) {
+    if (process.env[CLI_API_KEY_ENV]) {
+      log.error(
+        `API key auth from ${CLI_API_KEY_ENV} is not supported for /webapi/* routes. Run OIDC login instead.`,
+      );
+      process.exit(1);
+    }
+
     log.error("No authentication found. Run 'lh login' first.");
     process.exit(1);
   }
 
   const accessToken = result!.credentials.accessToken;
-  const serverUrl = loadSettings()?.serverUrl || OFFICIAL_SERVER_URL;
+  const serverUrl = resolveServerUrl();
 
   return {
     accessToken,
@@ -47,6 +54,6 @@ export async function getAuthInfo(): Promise<AuthInfo> {
       'Oidc-Auth': accessToken,
       'X-lobe-chat-auth': obfuscatePayloadWithXOR({}),
     },
-    serverUrl: serverUrl.replace(/\/$/, ''),
+    serverUrl,
   };
 }

apps/cli/src/auth/apiKey.ts

@@ -0,0 +1,41 @@
+import { normalizeUrl, resolveServerUrl } from '../settings';
+
+interface CurrentUserResponse {
+  data?: {
+    id?: string;
+    userId?: string;
+  };
+  error?: string;
+  message?: string;
+  success?: boolean;
+}
+
+export async function getUserIdFromApiKey(apiKey: string, serverUrl?: string): Promise<string> {
+  const normalizedServerUrl = normalizeUrl(serverUrl) || resolveServerUrl();
+
+  const response = await fetch(`${normalizedServerUrl}/api/v1/users/me`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+  });
+
+  let body: CurrentUserResponse | undefined;
+  try {
+    body = (await response.json()) as CurrentUserResponse;
+  } catch {
+    throw new Error(`Failed to parse response from ${normalizedServerUrl}/api/v1/users/me.`);
+  }
+
+  if (!response.ok || body?.success === false) {
+    throw new Error(
+      body?.error || body?.message || `Request failed with status ${response.status}.`,
+    );
+  }
+
+  const userId = body?.data?.id || body?.data?.userId;
+  if (!userId) {
+    throw new Error('Current user response did not include a user id.');
+  }
+
+  return userId;
+}

apps/cli/src/auth/refresh.ts

@@ -1,5 +1,4 @@
-import { OFFICIAL_SERVER_URL } from '../constants/urls';
-import { loadSettings } from '../settings';
+import { resolveServerUrl } from '../settings';
 import { loadCredentials, saveCredentials, type StoredCredentials } from './credentials';
 
 const CLIENT_ID = 'lobehub-cli';
@@ -20,7 +19,7 @@ export async function getValidToken(): Promise<{ credentials: StoredCredentials
   // Token expired — try refresh
   if (!credentials.refreshToken) return null;
 
-  const serverUrl = loadSettings()?.serverUrl || OFFICIAL_SERVER_URL;
+  const serverUrl = resolveServerUrl();
   const refreshed = await refreshAccessToken(serverUrl, credentials.refreshToken);
   if (!refreshed) return null;
 

apps/cli/src/auth/resolveToken.test.ts

@@ -1,12 +1,21 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { getUserIdFromApiKey } from './apiKey';
 import { getValidToken } from './refresh';
 import { resolveToken } from './resolveToken';
 
+vi.mock('./apiKey', () => ({
+  getUserIdFromApiKey: vi.fn(),
+}));
 vi.mock('./refresh', () => ({
   getValidToken: vi.fn(),
 }));
-
+vi.mock('../settings', () => ({
+  loadSettings: vi.fn().mockReturnValue({ serverUrl: 'https://app.lobehub.com' }),
+  resolveServerUrl: vi.fn(() =>
+    (process.env.LOBEHUB_SERVER || 'https://app.lobehub.com').replace(/\/$/, ''),
+  ),
+}));
 vi.mock('../utils/logger', () => ({
   log: {
     debug: vi.fn(),
@@ -25,14 +34,23 @@ function makeJwt(sub: string): string {
 
 describe('resolveToken', () => {
   let exitSpy: ReturnType<typeof vi.spyOn>;
+  const originalApiKey = process.env.LOBEHUB_CLI_API_KEY;
+  const originalJwt = process.env.LOBEHUB_JWT;
+  const originalServer = process.env.LOBEHUB_SERVER;
 
   beforeEach(() => {
     exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
       throw new Error('process.exit');
     });
+    delete process.env.LOBEHUB_CLI_API_KEY;
+    delete process.env.LOBEHUB_JWT;
+    delete process.env.LOBEHUB_SERVER;
   });
 
   afterEach(() => {
+    process.env.LOBEHUB_CLI_API_KEY = originalApiKey;
+    process.env.LOBEHUB_JWT = originalJwt;
+    process.env.LOBEHUB_SERVER = originalServer;
     exitSpy.mockRestore();
   });
 
@@ -42,7 +60,12 @@ describe('resolveToken', () => {
 
       const result = await resolveToken({ token });
 
-      expect(result).toEqual({ token, userId: 'user-123' });
+      expect(result).toEqual({
+        serverUrl: 'https://app.lobehub.com',
+        token,
+        tokenType: 'jwt',
+        userId: 'user-123',
+      });
     });
 
     it('should exit if JWT has no sub claim', async () => {
@@ -67,7 +90,12 @@ describe('resolveToken', () => {
         userId: 'user-456',
       });
 
-      expect(result).toEqual({ token: 'svc-token', userId: 'user-456' });
+      expect(result).toEqual({
+        serverUrl: 'https://app.lobehub.com',
+        token: 'svc-token',
+        tokenType: 'serviceToken',
+        userId: 'user-456',
+      });
     });
 
     it('should exit if --user-id is not provided', async () => {
@@ -76,6 +104,37 @@ describe('resolveToken', () => {
     });
   });
 
+  describe('with environment api key', () => {
+    it('should return API key from environment', async () => {
+      process.env.LOBEHUB_CLI_API_KEY = 'sk-lh-test';
+      vi.mocked(getUserIdFromApiKey).mockResolvedValue('user-789');
+
+      const result = await resolveToken({});
+
+      expect(getUserIdFromApiKey).toHaveBeenCalledWith('sk-lh-test', 'https://app.lobehub.com');
+      expect(result).toEqual({
+        serverUrl: 'https://app.lobehub.com',
+        token: 'sk-lh-test',
+        tokenType: 'apiKey',
+        userId: 'user-789',
+      });
+    });
+
+    it('should prefer LOBEHUB_SERVER when validating the API key', async () => {
+      process.env.LOBEHUB_CLI_API_KEY = 'sk-lh-test';
+      process.env.LOBEHUB_SERVER = 'https://self-hosted.example.com/';
+      vi.mocked(getUserIdFromApiKey).mockResolvedValue('user-789');
+
+      const result = await resolveToken({});
+
+      expect(getUserIdFromApiKey).toHaveBeenCalledWith(
+        'sk-lh-test',
+        'https://self-hosted.example.com',
+      );
+      expect(result.serverUrl).toBe('https://self-hosted.example.com');
+    });
+  });
+
   describe('with stored credentials', () => {
     it('should return stored credentials token', async () => {
       const token = makeJwt('stored-user');
@@ -87,7 +146,12 @@ describe('resolveToken', () => {
 
       const result = await resolveToken({});
 
-      expect(result).toEqual({ token, userId: 'stored-user' });
+      expect(result).toEqual({
+        serverUrl: 'https://app.lobehub.com',
+        token,
+        tokenType: 'jwt',
+        userId: 'stored-user',
+      });
     });
 
     it('should exit if stored token has no sub', async () => {

apps/cli/src/auth/resolveToken.ts

@@ -1,4 +1,7 @@
+import { CLI_API_KEY_ENV } from '../constants/auth';
+import { resolveServerUrl } from '../settings';
 import { log } from '../utils/logger';
+import { getUserIdFromApiKey } from './apiKey';
 import { getValidToken } from './refresh';
 
 interface ResolveTokenOptions {
@@ -8,7 +11,9 @@ interface ResolveTokenOptions {
 }
 
 interface ResolvedAuth {
+  serverUrl: string;
   token: string;
+  tokenType: 'apiKey' | 'jwt' | 'serviceToken';
   userId: string;
 }
 
@@ -25,20 +30,21 @@ function parseJwtSub(token: string): string | undefined {
 }
 
 /**
- * Resolve an access token from explicit options or stored credentials.
+ * Resolve an access token from explicit options, environment variables, or stored credentials.
  * Exits the process if no token can be resolved.
  */
 export async function resolveToken(options: ResolveTokenOptions): Promise<ResolvedAuth> {
   // LOBEHUB_JWT env var takes highest priority (used by server-side sandbox execution)
   const envJwt = process.env.LOBEHUB_JWT;
   if (envJwt) {
+    const serverUrl = resolveServerUrl();
     const userId = parseJwtSub(envJwt);
     if (!userId) {
       log.error('Could not extract userId from LOBEHUB_JWT.');
       process.exit(1);
     }
     log.debug('Using LOBEHUB_JWT from environment');
-    return { token: envJwt, userId };
+    return { serverUrl, token: envJwt, tokenType: 'jwt', userId };
   }
 
   // Explicit token takes priority
@@ -48,7 +54,7 @@ export async function resolveToken(options: ResolveTokenOptions): Promise<Resolv
       log.error('Could not extract userId from token. Provide --user-id explicitly.');
       process.exit(1);
     }
-    return { token: options.token, userId };
+    return { serverUrl: resolveServerUrl(), token: options.token, tokenType: 'jwt', userId };
   }
 
   if (options.serviceToken) {
@@ -56,22 +62,46 @@ export async function resolveToken(options: ResolveTokenOptions): Promise<Resolv
       log.error('--user-id is required when using --service-token');
       process.exit(1);
     }
-    return { token: options.serviceToken, userId: options.userId };
+    return {
+      serverUrl: resolveServerUrl(),
+      token: options.serviceToken,
+      tokenType: 'serviceToken',
+      userId: options.userId,
+    };
+  }
+
+  const envApiKey = process.env[CLI_API_KEY_ENV];
+  if (envApiKey) {
+    try {
+      const serverUrl = resolveServerUrl();
+      const userId = await getUserIdFromApiKey(envApiKey, serverUrl);
+      log.debug(`Using ${CLI_API_KEY_ENV} from environment`);
+      return { serverUrl, token: envApiKey, tokenType: 'apiKey', userId };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log.error(`Failed to validate ${CLI_API_KEY_ENV}: ${message}`);
+      process.exit(1);
+    }
   }
 
   // Try stored credentials
   const result = await getValidToken();
   if (result) {
     log.debug('Using stored credentials');
-    const token = result.credentials.accessToken;
-    const userId = parseJwtSub(token);
+    const { credentials } = result;
+    const serverUrl = resolveServerUrl();
+
+    const userId = parseJwtSub(credentials.accessToken);
     if (!userId) {
       log.error("Stored token is invalid. Run 'lh login' again.");
       process.exit(1);
     }
-    return { token, userId };
+
+    return { serverUrl, token: credentials.accessToken, tokenType: 'jwt', userId };
   }
 
-  log.error("No authentication found. Run 'lh login' first, or provide --token.");
+  log.error(
+    `No authentication found. Run 'lh login' first, or set ${CLI_API_KEY_ENV}, or provide --token.`,
+  );
   process.exit(1);
 }

apps/cli/src/commands/brief.ts

@@ -0,0 +1,211 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../api/client';
+import { outputJson, printTable, timeAgo, truncate } from '../utils/format';
+import { log } from '../utils/logger';
+
+export function registerBriefCommand(program: Command) {
+  const brief = program.command('brief').description('Manage briefs (Agent reports)');
+
+  // ── list ──────────────────────────────────────────────
+
+  brief
+    .command('list')
+    .description('List briefs')
+    .option('--unresolved', 'Only show unresolved briefs (default)')
+    .option('--all', 'Show all briefs')
+    .option('--type <type>', 'Filter by type (decision/result/insight/error)')
+    .option('-L, --limit <n>', 'Page size', '50')
+    .option('--json [fields]', 'Output JSON')
+    .action(
+      async (options: {
+        all?: boolean;
+        json?: string | boolean;
+        limit?: string;
+        type?: string;
+        unresolved?: boolean;
+      }) => {
+        const client = await getTrpcClient();
+
+        let items: any[];
+
+        if (options.all) {
+          const input: Record<string, any> = {};
+          if (options.type) input.type = options.type;
+          if (options.limit) input.limit = Number.parseInt(options.limit, 10);
+          const result = await client.brief.list.query(input as any);
+          items = result.data;
+        } else {
+          const result = await client.brief.listUnresolved.query();
+          items = result.data;
+        }
+
+        if (options.json !== undefined) {
+          outputJson(items, typeof options.json === 'string' ? options.json : undefined);
+          return;
+        }
+
+        if (!items || items.length === 0) {
+          log.info('No briefs found.');
+          return;
+        }
+
+        const rows = items.map((b: any) => [
+          typeBadge(b.type, b.priority),
+          truncate(b.title, 40),
+          truncate(b.summary, 50),
+          b.taskId ? pc.dim(b.taskId) : b.cronJobId ? pc.dim(b.cronJobId) : '-',
+          b.resolvedAt ? pc.green('resolved') : b.readAt ? pc.dim('read') : 'new',
+          timeAgo(b.createdAt),
+        ]);
+
+        printTable(rows, ['TYPE', 'TITLE', 'SUMMARY', 'SOURCE', 'STATUS', 'CREATED']);
+      },
+    );
+
+  // ── view ──────────────────────────────────────────────
+
+  brief
+    .command('view <id>')
+    .description('View brief details (auto marks as read)')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (id: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+      const result = await client.brief.find.query({ id });
+      const b = result.data;
+
+      if (options.json !== undefined) {
+        outputJson(b, typeof options.json === 'string' ? options.json : undefined);
+        return;
+      }
+
+      if (!b) {
+        log.error('Brief not found.');
+        return;
+      }
+
+      // Auto mark as read
+      if (!b.readAt) {
+        await client.brief.markRead.mutate({ id });
+      }
+
+      const resolvedLabel = b.resolvedAt
+        ? (() => {
+            const actions = (b.actions as any[]) || [];
+            const matched = actions.find((a: any) => a.key === (b as any).resolvedAction);
+            return pc.green(` ${matched?.label || '✓ resolved'}`);
+          })()
+        : '';
+
+      console.log(`\n${typeBadge(b.type, b.priority)} ${pc.bold(b.title)}${resolvedLabel}`);
+      console.log(`${pc.dim('Type:')} ${b.type}  ${pc.dim('Created:')} ${timeAgo(b.createdAt)}`);
+      if (b.agentId) console.log(`${pc.dim('Agent:')} ${b.agentId}`);
+      if (b.taskId) console.log(`${pc.dim('Task:')} ${b.taskId}`);
+      if (b.cronJobId) console.log(`${pc.dim('CronJob:')} ${b.cronJobId}`);
+      if (b.topicId) console.log(`${pc.dim('Topic:')} ${b.topicId}`);
+      console.log(`\n${b.summary}`);
+
+      if (b.artifacts && (b.artifacts as string[]).length > 0) {
+        console.log(`\n${pc.dim('Artifacts:')}`);
+        for (const a of b.artifacts as string[]) {
+          console.log(`  📎 ${a}`);
+        }
+      }
+
+      console.log();
+      if (!b.resolvedAt) {
+        const actions = (b.actions as any[]) || [];
+        if (actions.length > 0) {
+          console.log('Actions:');
+          for (const a of actions) {
+            const cmd =
+              a.type === 'comment'
+                ? `lh brief resolve ${b.id} --action ${a.key} -m "内容"`
+                : `lh brief resolve ${b.id} --action ${a.key}`;
+            console.log(`  ${a.label}  ${pc.dim(cmd)}`);
+          }
+        } else {
+          console.log(pc.dim('Actions:'));
+          console.log(pc.dim(`  lh brief resolve ${b.id}                   # 确认通过`));
+          console.log(pc.dim(`  lh brief resolve ${b.id} --reply "修改意见"  # 反馈修改`));
+        }
+      } else if ((b as any).resolvedComment) {
+        console.log(`${pc.dim('Comment:')} ${(b as any).resolvedComment}`);
+      }
+    });
+
+  // ── resolve ──────────────────────────────────────────────
+
+  brief
+    .command('resolve <id>')
+    .description('Resolve a brief (approve, reply, or custom action)')
+    .option('--action <key>', 'Execute a specific action (e.g. approve, feedback)')
+    .option('--reply <text>', 'Reply with feedback')
+    .option('-m, --message <text>', 'Message for comment-type actions')
+    .action(async (id: string, options: { action?: string; message?: string; reply?: string }) => {
+      const client = await getTrpcClient();
+
+      const actionKey = options.action || (options.reply ? 'feedback' : 'approve');
+      const actionMessage = options.message || options.reply;
+
+      const briefResult = await client.brief.find.query({ id });
+      const b = briefResult.data;
+
+      // For comment-type actions, add comment to task
+      if (actionMessage && b?.taskId) {
+        await client.task.addComment.mutate({
+          briefId: id,
+          content: actionMessage,
+          id: b.taskId,
+        });
+      }
+
+      await client.brief.resolve.mutate({
+        action: actionKey,
+        comment: actionMessage,
+        id,
+      });
+
+      const actions = (b?.actions as any[]) || [];
+      const matchedAction = actions.find((a: any) => a.key === actionKey);
+      const label = matchedAction?.label || actionKey;
+
+      log.info(`${label} — Brief ${pc.dim(id)} resolved.`);
+    });
+
+  // ── delete ──────────────────────────────────────────────
+
+  brief
+    .command('delete <id>')
+    .description('Delete a brief')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      await client.brief.delete.mutate({ id });
+      log.info(`Brief ${pc.dim(id)} deleted.`);
+    });
+}
+
+function typeBadge(type: string, priority?: string): string {
+  if (priority === 'urgent') {
+    return pc.red('🔴');
+  }
+
+  switch (type) {
+    case 'decision': {
+      return pc.yellow('🟡');
+    }
+    case 'result': {
+      return pc.green('✅');
+    }
+    case 'insight': {
+      return '💬';
+    }
+    case 'error': {
+      return pc.red('❌');
+    }
+    default: {
+      return '·';
+    }
+  }
+}

apps/cli/src/commands/connect.test.ts

@@ -2,10 +2,16 @@ import { Command } from 'commander';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('../auth/resolveToken', () => ({
-  resolveToken: vi.fn().mockResolvedValue({ token: 'test-token', userId: 'test-user' }),
+  resolveToken: vi.fn().mockResolvedValue({
+    serverUrl: 'https://app.lobehub.com',
+    token: 'test-token',
+    tokenType: 'jwt',
+    userId: 'test-user',
+  }),
 }));
 vi.mock('../settings', () => ({
   loadSettings: vi.fn().mockReturnValue(null),
+  normalizeUrl: vi.fn((url?: string) => (url ? url.replace(/\/$/, '') : undefined)),
   saveSettings: vi.fn(),
 }));
 
@@ -161,6 +167,12 @@ describe('connect command', () => {
       serverUrl: 'https://self-hosted.example.com',
     });
   });
+  it('should pass the resolved serverUrl to GatewayClient', async () => {
+    const program = createProgram();
+    await program.parseAsync(['node', 'test', 'connect']);
+
+    expect(clientOptions.serverUrl).toBe('https://app.lobehub.com');
+  });
 
   it('should handle tool call requests', async () => {
     const program = createProgram();
@@ -208,7 +220,12 @@ describe('connect command', () => {
   });
 
   it('should handle auth_expired', async () => {
-    vi.mocked(resolveToken).mockResolvedValueOnce({ token: 'new-tok', userId: 'user' });
+    vi.mocked(resolveToken).mockResolvedValueOnce({
+      serverUrl: 'https://app.lobehub.com',
+      token: 'new-tok',
+      tokenType: 'jwt',
+      userId: 'user',
+    });
 
     const program = createProgram();
     await program.parseAsync(['node', 'test', 'connect']);
@@ -220,6 +237,24 @@ describe('connect command', () => {
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
+  it('should ignore auth_expired for api key auth', async () => {
+    vi.mocked(resolveToken).mockResolvedValueOnce({
+      serverUrl: 'https://self-hosted.example.com',
+      token: 'test-api-key',
+      tokenType: 'apiKey',
+      userId: 'user',
+    });
+
+    const program = createProgram();
+    await program.parseAsync(['node', 'test', 'connect']);
+
+    await clientEventHandlers['auth_expired']?.();
+
+    expect(log.error).not.toHaveBeenCalled();
+    expect(cleanupAllProcesses).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
   it('should handle error event', async () => {
     const program = createProgram();
     await program.parseAsync(['node', 'test', 'connect']);

apps/cli/src/commands/connect.ts

@@ -11,6 +11,7 @@ import { GatewayClient } from '@lobechat/device-gateway-client';
 import type { Command } from 'commander';
 
 import { resolveToken } from '../auth/resolveToken';
+import { CLI_API_KEY_ENV } from '../constants/auth';
 import { OFFICIAL_GATEWAY_URL } from '../constants/urls';
 import {
   appendLog,
@@ -23,7 +24,7 @@ import {
   stopDaemon,
   writeStatus,
 } from '../daemon/manager';
-import { loadSettings, saveSettings } from '../settings';
+import { loadSettings, normalizeUrl, saveSettings } from '../settings';
 import { executeToolCall } from '../tools';
 import { cleanupAllProcesses } from '../tools/shell';
 import { log, setVerbose } from '../utils/logger';
@@ -174,7 +175,7 @@ function buildDaemonArgs(options: ConnectOptions): string[] {
 async function runConnect(options: ConnectOptions, isDaemonChild: boolean) {
   const auth = await resolveToken(options);
   const settings = loadSettings();
-  const gatewayUrl = options.gateway?.replace(/\/$/, '') || settings?.gatewayUrl;
+  const gatewayUrl = normalizeUrl(options.gateway) || settings?.gatewayUrl;
 
   if (!gatewayUrl && settings?.serverUrl) {
     log.error(
@@ -194,7 +195,9 @@ async function runConnect(options: ConnectOptions, isDaemonChild: boolean) {
     deviceId: options.deviceId,
     gatewayUrl: resolvedGatewayUrl,
     logger: isDaemonChild ? createDaemonLogger() : log,
+    serverUrl: auth.serverUrl,
     token: auth.token,
+    tokenType: auth.tokenType,
     userId: auth.userId,
   });
 
@@ -214,7 +217,7 @@ async function runConnect(options: ConnectOptions, isDaemonChild: boolean) {
   info(`  Hostname  : ${os.hostname()}`);
   info(`  Platform  : ${process.platform}`);
   info(`  Gateway   : ${resolvedGatewayUrl}`);
-  info(`  Auth      : jwt`);
+  info(`  Auth      : ${auth.tokenType}`);
   info(`  Mode      : ${isDaemonChild ? 'daemon' : 'foreground'}`);
   info('───────────────────');
 
@@ -285,13 +288,19 @@ async function runConnect(options: ConnectOptions, isDaemonChild: boolean) {
   // Handle auth failed
   client.on('auth_failed', (reason) => {
     error(`Authentication failed: ${reason}`);
-    error("Run 'lh login' to re-authenticate.");
+    error(
+      `Run 'lh login', or set ${CLI_API_KEY_ENV} and run 'lh login --server <url>' to configure API key authentication.`,
+    );
     cleanup();
     process.exit(1);
   });
 
   // Handle auth expired
   client.on('auth_expired', async () => {
+    if (auth.tokenType === 'apiKey') {
+      return;
+    }
+
     error('Authentication expired. Attempting to refresh...');
     const refreshed = await resolveToken({});
     if (refreshed) {

apps/cli/src/commands/login.test.ts

@@ -3,11 +3,15 @@ import fs from 'node:fs';
 import { Command } from 'commander';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
+import { getUserIdFromApiKey } from '../auth/apiKey';
 import { saveCredentials } from '../auth/credentials';
 import { loadSettings, saveSettings } from '../settings';
 import { log } from '../utils/logger';
 import { registerLoginCommand, resolveCommandExecutable } from './login';
 
+vi.mock('../auth/apiKey', () => ({
+  getUserIdFromApiKey: vi.fn(),
+}));
 vi.mock('../auth/credentials', () => ({
   saveCredentials: vi.fn(),
 }));
@@ -37,6 +41,7 @@ vi.mock('node:child_process', () => ({
 
 describe('login command', () => {
   let exitSpy: ReturnType<typeof vi.spyOn>;
+  const originalApiKey = process.env.LOBEHUB_CLI_API_KEY;
   const originalPath = process.env.PATH;
   const originalPathext = process.env.PATHEXT;
   const originalSystemRoot = process.env.SystemRoot;
@@ -46,11 +51,13 @@ describe('login command', () => {
     vi.stubGlobal('fetch', vi.fn());
     exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
     vi.mocked(loadSettings).mockReturnValue(null);
+    delete process.env.LOBEHUB_CLI_API_KEY;
   });
 
   afterEach(() => {
     vi.useRealTimers();
     exitSpy.mockRestore();
+    process.env.LOBEHUB_CLI_API_KEY = originalApiKey;
     process.env.PATH = originalPath;
     process.env.PATHEXT = originalPathext;
     process.env.SystemRoot = originalSystemRoot;
@@ -102,8 +109,12 @@ describe('login command', () => {
     } as any;
   }
 
+  async function runLogin(program: Command, args: string[] = []) {
+    return program.parseAsync(['node', 'test', 'login', ...args]);
+  }
+
   async function runLoginAndAdvanceTimers(program: Command, args: string[] = []) {
-    const parsePromise = program.parseAsync(['node', 'test', 'login', ...args]);
+    const parsePromise = runLogin(program, args);
     // Advance timers to let sleep resolve in the polling loop
     for (let i = 0; i < 10; i++) {
       await vi.advanceTimersByTimeAsync(2000);
@@ -130,6 +141,19 @@ describe('login command', () => {
     expect(log.info).toHaveBeenCalledWith(expect.stringContaining('Login successful'));
   });
 
+  it('should use environment api key without storing credentials', async () => {
+    process.env.LOBEHUB_CLI_API_KEY = 'sk-lh-env-test';
+    vi.mocked(getUserIdFromApiKey).mockResolvedValue('user-123');
+
+    const program = createProgram();
+    await runLogin(program);
+
+    expect(getUserIdFromApiKey).toHaveBeenCalledWith('sk-lh-env-test', 'https://app.lobehub.com');
+    expect(saveCredentials).not.toHaveBeenCalled();
+    expect(saveSettings).toHaveBeenCalledWith({ serverUrl: 'https://app.lobehub.com' });
+    expect(log.info).toHaveBeenCalledWith(expect.stringContaining('Login successful'));
+  });
+
   it('should persist custom server into settings', async () => {
     vi.mocked(fetch)
       .mockResolvedValueOnce(deviceAuthResponse())
@@ -159,6 +183,23 @@ describe('login command', () => {
     });
   });
 
+  it('should preserve existing gateway for environment api key on the same server', async () => {
+    process.env.LOBEHUB_CLI_API_KEY = 'sk-lh-env-test';
+    vi.mocked(getUserIdFromApiKey).mockResolvedValue('user-123');
+    vi.mocked(loadSettings).mockReturnValueOnce({
+      gatewayUrl: 'https://gateway.example.com',
+      serverUrl: 'https://test.com',
+    });
+
+    const program = createProgram();
+    await runLogin(program, ['--server', 'https://test.com/']);
+
+    expect(saveSettings).toHaveBeenCalledWith({
+      gatewayUrl: 'https://gateway.example.com',
+      serverUrl: 'https://test.com',
+    });
+  });
+
   it('should clear existing gateway when logging into a different server', async () => {
     vi.mocked(loadSettings).mockReturnValueOnce({
       gatewayUrl: 'https://gateway.example.com',

apps/cli/src/commands/login.ts

@@ -4,9 +4,11 @@ import path from 'node:path';
 
 import type { Command } from 'commander';
 
+import { getUserIdFromApiKey } from '../auth/apiKey';
 import { saveCredentials } from '../auth/credentials';
+import { CLI_API_KEY_ENV } from '../constants/auth';
 import { OFFICIAL_SERVER_URL } from '../constants/urls';
-import { loadSettings, saveSettings } from '../settings';
+import { loadSettings, normalizeUrl, saveSettings } from '../settings';
 import { log } from '../utils/logger';
 
 const CLIENT_ID = 'lobehub-cli';
@@ -51,13 +53,43 @@ async function parseJsonResponse<T>(res: Response, endpoint: string): Promise<T>
 export function registerLoginCommand(program: Command) {
   program
     .command('login')
-    .description('Log in to LobeHub via browser (Device Code Flow)')
+    .description('Log in to LobeHub via browser (Device Code Flow) or configure API key server')
     .option('--server <url>', 'LobeHub server URL', OFFICIAL_SERVER_URL)
     .action(async (options: LoginOptions) => {
-      const serverUrl = options.server.replace(/\/$/, '');
+      const serverUrl = normalizeUrl(options.server) || OFFICIAL_SERVER_URL;
 
       log.info('Starting login...');
 
+      const apiKey = process.env[CLI_API_KEY_ENV];
+      if (apiKey) {
+        try {
+          await getUserIdFromApiKey(apiKey, serverUrl);
+
+          const existingSettings = loadSettings();
+          const shouldPreserveGateway = existingSettings?.serverUrl === serverUrl;
+
+          saveSettings(
+            shouldPreserveGateway
+              ? {
+                  gatewayUrl: existingSettings.gatewayUrl,
+                  serverUrl,
+                }
+              : {
+                  // Gateway auth is tied to the login server's token issuer/JWKS.
+                  // When server changes, clear old gateway to avoid stale cross-environment config.
+                  serverUrl,
+                },
+          );
+          log.info('Login successful! Credentials saved.');
+          return;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          log.error(`API key validation failed: ${message}`);
+          process.exit(1);
+          return;
+        }
+      }
+
       // Step 1: Request device code
       let deviceAuth: DeviceAuthResponse;
       try {
@@ -164,6 +196,7 @@ export function registerLoginCommand(program: Command) {
                 : undefined,
               refreshToken: body.refresh_token,
             });
+
             const existingSettings = loadSettings();
             const shouldPreserveGateway = existingSettings?.serverUrl === serverUrl;
 

apps/cli/src/commands/status.test.ts

@@ -3,10 +3,16 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // Mock resolveToken
 vi.mock('../auth/resolveToken', () => ({
-  resolveToken: vi.fn().mockResolvedValue({ token: 'test-token', userId: 'test-user' }),
+  resolveToken: vi.fn().mockResolvedValue({
+    serverUrl: 'https://app.lobehub.com',
+    token: 'test-token',
+    tokenType: 'jwt',
+    userId: 'test-user',
+  }),
 }));
 vi.mock('../settings', () => ({
   loadSettings: vi.fn().mockReturnValue(null),
+  normalizeUrl: vi.fn((url?: string) => (url ? url.replace(/\/$/, '') : undefined)),
   saveSettings: vi.fn(),
 }));
 
@@ -115,6 +121,16 @@ describe('status command', () => {
       serverUrl: 'https://self-hosted.example.com',
     });
   });
+  it('should pass the resolved serverUrl to GatewayClient', async () => {
+    const program = createProgram();
+    const parsePromise = program.parseAsync(['node', 'test', 'status']);
+    await vi.advanceTimersByTimeAsync(0);
+
+    clientEventHandlers['connected']?.();
+
+    await parsePromise;
+    expect(clientOptions.serverUrl).toBe('https://app.lobehub.com');
+  });
 
   it('should log CONNECTED on successful connection', async () => {
     const program = createProgram();

apps/cli/src/commands/status.ts

@@ -3,7 +3,7 @@ import type { Command } from 'commander';
 
 import { resolveToken } from '../auth/resolveToken';
 import { OFFICIAL_GATEWAY_URL } from '../constants/urls';
-import { loadSettings, saveSettings } from '../settings';
+import { loadSettings, normalizeUrl, saveSettings } from '../settings';
 import { log, setVerbose } from '../utils/logger';
 
 interface StatusOptions {
@@ -30,7 +30,7 @@ export function registerStatusCommand(program: Command) {
 
       const auth = await resolveToken(options);
       const settings = loadSettings();
-      const gatewayUrl = options.gateway?.replace(/\/$/, '') || settings?.gatewayUrl;
+      const gatewayUrl = normalizeUrl(options.gateway) || settings?.gatewayUrl;
 
       if (!gatewayUrl && settings?.serverUrl) {
         log.error(
@@ -50,7 +50,9 @@ export function registerStatusCommand(program: Command) {
         autoReconnect: false,
         gatewayUrl: gatewayUrl || OFFICIAL_GATEWAY_URL,
         logger: log,
+        serverUrl: auth.serverUrl,
         token: auth.token,
+        tokenType: auth.tokenType,
         userId: auth.userId,
       });
 

apps/cli/src/commands/task/checkpoint.ts

@@ -0,0 +1,95 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../../api/client';
+import { log } from '../../utils/logger';
+
+export function registerCheckpointCommands(task: Command) {
+  // ── checkpoint ──────────────────────────────────────────────
+
+  const cp = task.command('checkpoint').description('Manage task checkpoints');
+
+  cp.command('view <id>')
+    .description('View checkpoint config for a task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = await client.task.getCheckpoint.query({ id });
+      const c = result.data as any;
+
+      console.log(`\n${pc.bold('Checkpoint config:')}`);
+      console.log(`  onAgentRequest: ${c.onAgentRequest ?? pc.dim('not set (default: true)')}`);
+      if (c.topic) {
+        console.log(`  topic.before: ${c.topic.before ?? false}`);
+        console.log(`  topic.after: ${c.topic.after ?? false}`);
+      }
+      if (c.tasks?.beforeIds?.length > 0) {
+        console.log(`  tasks.beforeIds: ${c.tasks.beforeIds.join(', ')}`);
+      }
+      if (c.tasks?.afterIds?.length > 0) {
+        console.log(`  tasks.afterIds: ${c.tasks.afterIds.join(', ')}`);
+      }
+      if (
+        !c.topic &&
+        !c.tasks?.beforeIds?.length &&
+        !c.tasks?.afterIds?.length &&
+        c.onAgentRequest === undefined
+      ) {
+        console.log(`  ${pc.dim('(no checkpoints configured)')}`);
+      }
+      console.log();
+    });
+
+  cp.command('set <id>')
+    .description('Configure checkpoints')
+    .option('--on-agent-request <bool>', 'Allow agent to request review (true/false)')
+    .option('--topic-before <bool>', 'Pause before each topic (true/false)')
+    .option('--topic-after <bool>', 'Pause after each topic (true/false)')
+    .option('--before <ids>', 'Pause before these subtask identifiers (comma-separated)')
+    .option('--after <ids>', 'Pause after these subtask identifiers (comma-separated)')
+    .action(
+      async (
+        id: string,
+        options: {
+          after?: string;
+          before?: string;
+          onAgentRequest?: string;
+          topicAfter?: string;
+          topicBefore?: string;
+        },
+      ) => {
+        const client = await getTrpcClient();
+
+        // Get current config first
+        const current = (await client.task.getCheckpoint.query({ id })).data as any;
+        const checkpoint: any = { ...current };
+
+        if (options.onAgentRequest !== undefined) {
+          checkpoint.onAgentRequest = options.onAgentRequest === 'true';
+        }
+        if (options.topicBefore !== undefined || options.topicAfter !== undefined) {
+          checkpoint.topic = { ...checkpoint.topic };
+          if (options.topicBefore !== undefined)
+            checkpoint.topic.before = options.topicBefore === 'true';
+          if (options.topicAfter !== undefined)
+            checkpoint.topic.after = options.topicAfter === 'true';
+        }
+        if (options.before !== undefined) {
+          checkpoint.tasks = { ...checkpoint.tasks };
+          checkpoint.tasks.beforeIds = options.before
+            .split(',')
+            .map((s: string) => s.trim())
+            .filter(Boolean);
+        }
+        if (options.after !== undefined) {
+          checkpoint.tasks = { ...checkpoint.tasks };
+          checkpoint.tasks.afterIds = options.after
+            .split(',')
+            .map((s: string) => s.trim())
+            .filter(Boolean);
+        }
+
+        await client.task.updateCheckpoint.mutate({ checkpoint, id });
+        log.info('Checkpoint updated.');
+      },
+    );
+}

apps/cli/src/commands/task/dep.ts

@@ -0,0 +1,56 @@
+import type { Command } from 'commander';
+
+import { getTrpcClient } from '../../api/client';
+import { outputJson, printTable, timeAgo } from '../../utils/format';
+import { log } from '../../utils/logger';
+
+export function registerDepCommands(task: Command) {
+  // ── dep ──────────────────────────────────────────────
+
+  const dep = task.command('dep').description('Manage task dependencies');
+
+  dep
+    .command('add <taskId> <dependsOnId>')
+    .description('Add dependency (taskId blocks on dependsOnId)')
+    .option('--type <type>', 'Dependency type (blocks/relates)', 'blocks')
+    .action(async (taskId: string, dependsOnId: string, options: { type?: string }) => {
+      const client = await getTrpcClient();
+      await client.task.addDependency.mutate({
+        dependsOnId,
+        taskId,
+        type: (options.type || 'blocks') as any,
+      });
+      log.info(`Dependency added: ${taskId} ${options.type || 'blocks'} on ${dependsOnId}`);
+    });
+
+  dep
+    .command('rm <taskId> <dependsOnId>')
+    .description('Remove dependency')
+    .action(async (taskId: string, dependsOnId: string) => {
+      const client = await getTrpcClient();
+      await client.task.removeDependency.mutate({ dependsOnId, taskId });
+      log.info(`Dependency removed.`);
+    });
+
+  dep
+    .command('list <taskId>')
+    .description('List dependencies for a task')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (taskId: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+      const result = await client.task.getDependencies.query({ id: taskId });
+
+      if (options.json !== undefined) {
+        outputJson(result.data, options.json);
+        return;
+      }
+
+      if (!result.data || result.data.length === 0) {
+        log.info('No dependencies.');
+        return;
+      }
+
+      const rows = result.data.map((d: any) => [d.type, d.dependsOnId, timeAgo(d.createdAt)]);
+      printTable(rows, ['TYPE', 'DEPENDS ON', 'CREATED']);
+    });
+}

apps/cli/src/commands/task/doc.ts

@@ -0,0 +1,102 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../../api/client';
+import { log } from '../../utils/logger';
+
+export function registerDocCommands(task: Command) {
+  // ── doc ──────────────────────────────────────────────
+
+  const dc = task.command('doc').description('Manage task workspace documents');
+
+  dc.command('create <id>')
+    .description('Create a document and pin it to the task')
+    .requiredOption('-t, --title <title>', 'Document title')
+    .option('-b, --body <content>', 'Document content')
+    .option('--parent <docId>', 'Parent document/folder ID')
+    .option('--folder', 'Create as folder')
+    .action(
+      async (
+        id: string,
+        options: { body?: string; folder?: boolean; parent?: string; title: string },
+      ) => {
+        const client = await getTrpcClient();
+
+        // Create document
+        const fileType = options.folder ? 'custom/folder' : undefined;
+        const content = options.body || '';
+        const result = await client.document.createDocument.mutate({
+          content,
+          editorData: options.folder ? undefined : JSON.stringify({ content, type: 'doc' }),
+          fileType,
+          parentId: options.parent,
+          title: options.title,
+        });
+
+        // Pin to task
+        await client.task.pinDocument.mutate({
+          documentId: result.id,
+          pinnedBy: 'user',
+          taskId: id,
+        });
+
+        const icon = options.folder ? '📁' : '📄';
+        log.info(`${icon} Created & pinned: ${pc.bold(options.title)} ${pc.dim(result.id)}`);
+      },
+    );
+
+  dc.command('pin <id> <documentId>')
+    .description('Pin an existing document to a task')
+    .action(async (id: string, documentId: string) => {
+      const client = await getTrpcClient();
+      await client.task.pinDocument.mutate({ documentId, pinnedBy: 'user', taskId: id });
+      log.info(`Pinned ${pc.dim(documentId)} to ${pc.bold(id)}.`);
+    });
+
+  dc.command('unpin <id> <documentId>')
+    .description('Unpin a document from a task')
+    .action(async (id: string, documentId: string) => {
+      const client = await getTrpcClient();
+      await client.task.unpinDocument.mutate({ documentId, taskId: id });
+      log.info(`Unpinned ${pc.dim(documentId)} from ${pc.bold(id)}.`);
+    });
+
+  dc.command('mv <id> <documentId> <folder>')
+    .description('Move a document into a folder (auto-creates folder if not found)')
+    .action(async (id: string, documentId: string, folder: string) => {
+      const client = await getTrpcClient();
+
+      // Check if folder is a document ID or a folder name
+      let folderId = folder;
+      if (!folder.startsWith('docs_')) {
+        // folder is a name, find or create it
+        const detail = await client.task.detail.query({ id });
+        const folders = detail.data.workspace || [];
+
+        // Search for existing folder by name
+        const existingFolder = folders.find((f) => f.title === folder);
+
+        if (existingFolder) {
+          folderId = existingFolder.documentId;
+        } else {
+          // Create folder and pin to task
+          const result = await client.document.createDocument.mutate({
+            content: '',
+            fileType: 'custom/folder',
+            title: folder,
+          });
+          await client.task.pinDocument.mutate({
+            documentId: result.id,
+            pinnedBy: 'user',
+            taskId: id,
+          });
+          folderId = result.id;
+          log.info(`📁 Created folder: ${pc.bold(folder)} ${pc.dim(folderId)}`);
+        }
+      }
+
+      // Move document into folder
+      await client.document.updateDocument.mutate({ id: documentId, parentId: folderId });
+      log.info(`Moved ${pc.dim(documentId)} → 📁 ${pc.bold(folder)}`);
+    });
+}

apps/cli/src/commands/task/helpers.ts

@@ -0,0 +1,74 @@
+import pc from 'picocolors';
+
+export function statusBadge(status: string): string {
+  const pad = (s: string) => s.padEnd(9);
+  switch (status) {
+    case 'backlog': {
+      return pc.dim(`○ ${pad('backlog')}`);
+    }
+    case 'blocked': {
+      return pc.red(`◉ ${pad('blocked')}`);
+    }
+    case 'running': {
+      return pc.blue(`● ${pad('running')}`);
+    }
+    case 'paused': {
+      return pc.yellow(`◐ ${pad('paused')}`);
+    }
+    case 'completed': {
+      return pc.green(`✓ ${pad('completed')}`);
+    }
+    case 'failed': {
+      return pc.red(`✗ ${pad('failed')}`);
+    }
+    case 'timeout': {
+      return pc.red(`⏱ ${pad('timeout')}`);
+    }
+    case 'canceled': {
+      return pc.dim(`⊘ ${pad('canceled')}`);
+    }
+    default: {
+      return status;
+    }
+  }
+}
+
+export function briefIcon(type: string): string {
+  switch (type) {
+    case 'decision': {
+      return '📋';
+    }
+    case 'result': {
+      return '✅';
+    }
+    case 'insight': {
+      return '💡';
+    }
+    case 'error': {
+      return '❌';
+    }
+    default: {
+      return '📌';
+    }
+  }
+}
+
+export function priorityLabel(priority: number | null | undefined): string {
+  switch (priority) {
+    case 1: {
+      return pc.red('urgent');
+    }
+    case 2: {
+      return pc.yellow('high');
+    }
+    case 3: {
+      return 'normal';
+    }
+    case 4: {
+      return pc.dim('low');
+    }
+    default: {
+      return pc.dim('-');
+    }
+  }
+}

apps/cli/src/commands/task/index.ts

@@ -0,0 +1,624 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../../api/client';
+import {
+  confirm,
+  displayWidth,
+  outputJson,
+  printTable,
+  timeAgo,
+  truncate,
+} from '../../utils/format';
+import { log } from '../../utils/logger';
+import { registerCheckpointCommands } from './checkpoint';
+import { registerDepCommands } from './dep';
+import { registerDocCommands } from './doc';
+import { briefIcon, priorityLabel, statusBadge } from './helpers';
+import { registerLifecycleCommands } from './lifecycle';
+import { registerReviewCommands } from './review';
+import { registerTopicCommands } from './topic';
+
+export function registerTaskCommand(program: Command) {
+  const task = program.command('task').description('Manage agent tasks');
+
+  // ── list ──────────────────────────────────────────────
+
+  task
+    .command('list')
+    .description('List tasks')
+    .option(
+      '--status <status>',
+      'Filter by status (pending/running/paused/completed/failed/canceled)',
+    )
+    .option('--root', 'Only show root tasks (no parent)')
+    .option('--parent <id>', 'Filter by parent task ID')
+    .option('--agent <id>', 'Filter by assignee agent ID')
+    .option('-L, --limit <n>', 'Page size', '50')
+    .option('--offset <n>', 'Offset', '0')
+    .option('--tree', 'Display as tree structure')
+    .option('--json [fields]', 'Output JSON')
+    .action(
+      async (options: {
+        agent?: string;
+        json?: string | boolean;
+        limit?: string;
+        offset?: string;
+        parent?: string;
+        root?: boolean;
+        status?: string;
+        tree?: boolean;
+      }) => {
+        const client = await getTrpcClient();
+
+        const input: Record<string, any> = {};
+        if (options.status) input.status = options.status;
+        if (options.root) input.parentTaskId = null;
+        if (options.parent) input.parentTaskId = options.parent;
+        if (options.agent) input.assigneeAgentId = options.agent;
+        if (options.limit) input.limit = Number.parseInt(options.limit, 10);
+        if (options.offset) input.offset = Number.parseInt(options.offset, 10);
+
+        // For tree mode, fetch all tasks (no pagination limit)
+        if (options.tree) {
+          input.limit = 100;
+          delete input.offset;
+        }
+
+        const result = await client.task.list.query(input as any);
+
+        if (options.json !== undefined) {
+          outputJson(result.data, options.json);
+          return;
+        }
+
+        if (!result.data || result.data.length === 0) {
+          log.info('No tasks found.');
+          return;
+        }
+
+        if (options.tree) {
+          // Build tree display
+          const taskMap = new Map<string, any>();
+          for (const t of result.data) taskMap.set(t.id, t);
+
+          const roots = result.data.filter((t: any) => !t.parentTaskId);
+          const children = new Map<string, any[]>();
+          for (const t of result.data) {
+            if (t.parentTaskId) {
+              const list = children.get(t.parentTaskId) || [];
+              list.push(t);
+              children.set(t.parentTaskId, list);
+            }
+          }
+
+          // Sort children by sortOrder first, then seq
+          for (const [, list] of children) {
+            list.sort(
+              (a: any, b: any) =>
+                (a.sortOrder ?? 0) - (b.sortOrder ?? 0) || (a.seq ?? 0) - (b.seq ?? 0),
+            );
+          }
+
+          const printNode = (t: any, prefix: string, isLast: boolean, isRoot: boolean) => {
+            const connector = isRoot ? '' : isLast ? '└── ' : '├── ';
+            const name = truncate(t.name || t.instruction, 40);
+            console.log(
+              `${prefix}${connector}${pc.dim(t.identifier)} ${statusBadge(t.status)} ${name}`,
+            );
+            const childList = children.get(t.id) || [];
+            const newPrefix = isRoot ? '' : prefix + (isLast ? '    ' : '│   ');
+            childList.forEach((child: any, i: number) => {
+              printNode(child, newPrefix, i === childList.length - 1, false);
+            });
+          };
+
+          for (const root of roots) {
+            printNode(root, '', true, true);
+          }
+          log.info(`Total: ${result.total}`);
+          return;
+        }
+
+        const rows = result.data.map((t: any) => [
+          pc.dim(t.identifier),
+          truncate(t.name || t.instruction, 40),
+          statusBadge(t.status),
+          priorityLabel(t.priority),
+          t.assigneeAgentId ? pc.dim(t.assigneeAgentId) : '-',
+          t.parentTaskId ? pc.dim('↳ subtask') : '',
+          timeAgo(t.createdAt),
+        ]);
+
+        printTable(rows, ['ID', 'NAME', 'STATUS', 'PRI', 'AGENT', 'TYPE', 'CREATED']);
+        log.info(`Total: ${result.total}`);
+      },
+    );
+
+  // ── view ──────────────────────────────────────────────
+
+  task
+    .command('view <id>')
+    .description('View task details (by ID or identifier like T-1)')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (id: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+
+      // ── Auto-detect by id prefix ──
+
+      // docs_ → show document content
+      if (id.startsWith('docs_')) {
+        const doc = await client.document.getDocumentDetail.query({ id });
+
+        if (options.json !== undefined) {
+          outputJson(doc, options.json);
+          return;
+        }
+
+        if (!doc) {
+          log.error('Document not found.');
+          return;
+        }
+
+        console.log(`\n📄 ${pc.bold(doc.title || 'Untitled')} ${pc.dim(doc.id)}`);
+        if (doc.fileType) console.log(`${pc.dim('Type:')} ${doc.fileType}`);
+        if (doc.totalCharCount) console.log(`${pc.dim('Size:')} ${doc.totalCharCount} chars`);
+        console.log(`${pc.dim('Updated:')} ${timeAgo(doc.updatedAt)}`);
+        console.log();
+        if (doc.content) {
+          console.log(doc.content);
+        }
+        return;
+      }
+
+      // tpc_ → show topic messages
+      if (id.startsWith('tpc_')) {
+        const messages = await client.message.getMessages.query({ topicId: id });
+        const items = Array.isArray(messages) ? messages : [];
+
+        if (options.json !== undefined) {
+          outputJson(items, options.json);
+          return;
+        }
+
+        if (items.length === 0) {
+          log.info('No messages in this topic.');
+          return;
+        }
+
+        console.log();
+        for (const msg of items) {
+          const role =
+            msg.role === 'assistant'
+              ? pc.green('Assistant')
+              : msg.role === 'user'
+                ? pc.blue('User')
+                : pc.dim(msg.role);
+
+          console.log(`${pc.bold(role)} ${pc.dim(timeAgo(msg.createdAt))}`);
+          if (msg.content) {
+            console.log(msg.content);
+          }
+          console.log();
+        }
+        return;
+      }
+
+      // Default: task detail
+      const result = await client.task.detail.query({ id });
+
+      if (options.json !== undefined) {
+        outputJson(result.data, options.json);
+        return;
+      }
+
+      const t = result.data;
+
+      // ── Header ──
+      console.log(`\n${pc.bold(t.identifier)} ${t.name || ''}`);
+      console.log(
+        `${pc.dim('Status:')} ${statusBadge(t.status)}  ${pc.dim('Priority:')} ${priorityLabel(t.priority)}`,
+      );
+      console.log(`${pc.dim('Instruction:')} ${t.instruction}`);
+      if (t.description) console.log(`${pc.dim('Description:')} ${t.description}`);
+      if (t.agentId) console.log(`${pc.dim('Agent:')} ${t.agentId}`);
+      if (t.userId) console.log(`${pc.dim('User:')} ${t.userId}`);
+      if (t.parent) {
+        console.log(`${pc.dim('Parent:')} ${t.parent.identifier} ${t.parent.name || ''}`);
+      }
+      const topicInfo = t.topicCount ? `${t.topicCount}` : '0';
+      const createdInfo = t.createdAt ? timeAgo(t.createdAt) : '-';
+      console.log(`${pc.dim('Topics:')} ${topicInfo}  ${pc.dim('Created:')} ${createdInfo}`);
+      if (t.heartbeat?.timeout && t.heartbeat.lastAt) {
+        const hb = timeAgo(t.heartbeat.lastAt);
+        const interval = t.heartbeat.interval ? `${t.heartbeat.interval}s` : '-';
+        const elapsed = (Date.now() - new Date(t.heartbeat.lastAt).getTime()) / 1000;
+        const isStuck = t.status === 'running' && elapsed > t.heartbeat.timeout;
+        console.log(
+          `${pc.dim('Heartbeat:')} ${isStuck ? pc.red(hb) : hb}  ${pc.dim('interval:')} ${interval}  ${pc.dim('timeout:')} ${t.heartbeat.timeout}s${isStuck ? pc.red('  ⚠ TIMEOUT') : ''}`,
+        );
+      }
+      if (t.error) console.log(`${pc.red('Error:')} ${t.error}`);
+
+      // ── Subtasks ──
+      if (t.subtasks && t.subtasks.length > 0) {
+        // Build lookup: which subtasks are completed
+        const completedIdentifiers = new Set(
+          t.subtasks.filter((s) => s.status === 'completed').map((s) => s.identifier),
+        );
+
+        console.log(`\n${pc.bold('Subtasks:')}`);
+        for (const s of t.subtasks) {
+          const depInfo = s.blockedBy ? pc.dim(` ← blocks: ${s.blockedBy}`) : '';
+          // Show 'blocked' instead of 'backlog' if task has unresolved dependencies
+          const isBlocked = s.blockedBy && !completedIdentifiers.has(s.blockedBy);
+          const displayStatus = s.status === 'backlog' && isBlocked ? 'blocked' : s.status;
+          console.log(
+            `  ${pc.dim(s.identifier)} ${statusBadge(displayStatus)} ${s.name || '(unnamed)'}${depInfo}`,
+          );
+        }
+      }
+
+      // ── Dependencies ──
+      if (t.dependencies && t.dependencies.length > 0) {
+        console.log(`\n${pc.bold('Dependencies:')}`);
+        for (const d of t.dependencies) {
+          const depName = d.name ? ` ${d.name}` : '';
+          console.log(`  ${pc.dim(d.type || 'blocks')}: ${d.dependsOn}${depName}`);
+        }
+      }
+
+      // ── Checkpoint ──
+      {
+        const cp = t.checkpoint || {};
+        console.log(`\n${pc.bold('Checkpoint:')}`);
+        const hasConfig =
+          cp.onAgentRequest !== undefined ||
+          cp.topic?.before ||
+          cp.topic?.after ||
+          cp.tasks?.beforeIds?.length ||
+          cp.tasks?.afterIds?.length;
+
+        if (hasConfig) {
+          if (cp.onAgentRequest !== undefined)
+            console.log(`  onAgentRequest: ${cp.onAgentRequest}`);
+          if (cp.topic?.before) console.log(`  topic.before: ${cp.topic.before}`);
+          if (cp.topic?.after) console.log(`  topic.after: ${cp.topic.after}`);
+          if (cp.tasks?.beforeIds?.length)
+            console.log(`  tasks.before: ${cp.tasks.beforeIds.join(', ')}`);
+          if (cp.tasks?.afterIds?.length)
+            console.log(`  tasks.after: ${cp.tasks.afterIds.join(', ')}`);
+        } else {
+          console.log(`  ${pc.dim('(not configured, default: onAgentRequest=true)')}`);
+        }
+      }
+
+      // ── Review ──
+      {
+        const rv = t.review as any;
+        console.log(`\n${pc.bold('Review:')}`);
+        if (rv && rv.enabled) {
+          console.log(
+            `  judge: ${rv.judge?.model || 'default'}${rv.judge?.provider ? ` (${rv.judge.provider})` : ''}`,
+          );
+          console.log(`  maxIterations: ${rv.maxIterations}  autoRetry: ${rv.autoRetry}`);
+          if (rv.rubrics?.length > 0) {
+            for (let i = 0; i < rv.rubrics.length; i++) {
+              const rb = rv.rubrics[i];
+              const threshold = rb.threshold ? ` ≥ ${Math.round(rb.threshold * 100)}%` : '';
+              const typeTag = pc.dim(`[${rb.type}]`);
+              let configInfo = '';
+              if (rb.type === 'llm-rubric') configInfo = rb.config?.criteria || '';
+              else if (rb.type === 'contains' || rb.type === 'equals')
+                configInfo = `value="${rb.config?.value}"`;
+              else if (rb.type === 'regex') configInfo = `pattern="${rb.config?.pattern}"`;
+              console.log(`  ${i + 1}. ${rb.name} ${typeTag}${threshold} ${pc.dim(configInfo)}`);
+            }
+          }
+        } else {
+          console.log(`  ${pc.dim('(not configured)')}`);
+        }
+      }
+
+      // ── Workspace ──
+      {
+        const nodes = t.workspace || [];
+        if (nodes.length === 0) {
+          console.log(`\n${pc.bold('Workspace:')}`);
+          console.log(`  ${pc.dim('No documents yet.')}`);
+        } else {
+          const countNodes = (list: typeof nodes): number =>
+            list.reduce((sum, n) => sum + 1 + (n.children ? countNodes(n.children) : 0), 0);
+          console.log(`\n${pc.bold(`Workspace (${countNodes(nodes)}):`)}`);
+
+          const formatSize = (chars: number | null | undefined) => {
+            if (!chars) return '';
+            if (chars >= 10_000) return `${(chars / 1000).toFixed(1)}k`;
+            return `${chars}`;
+          };
+
+          const LEFT_COL = 56;
+          const FROM_WIDTH = 10;
+
+          const renderNodes = (list: typeof nodes, indent: string, isChild: boolean) => {
+            for (let i = 0; i < list.length; i++) {
+              const node = list[i];
+              const isFolder = node.fileType === 'custom/folder';
+              const isLast = i === list.length - 1;
+              const icon = isFolder ? '📁' : '📄';
+              const connector = isChild ? (isLast ? '└── ' : '├── ') : '';
+              const prefix = `${indent}${connector}${icon} `;
+              const titleStr = truncate(node.title || 'Untitled', LEFT_COL - displayWidth(prefix));
+              const titlePad = ' '.repeat(
+                Math.max(1, LEFT_COL - displayWidth(prefix) - displayWidth(titleStr)),
+              );
+
+              const fromStr = node.sourceTaskIdentifier ? `← ${node.sourceTaskIdentifier}` : '';
+              const fromPad = ' '.repeat(Math.max(1, FROM_WIDTH - fromStr.length + 1));
+              const size =
+                !isFolder && node.size
+                  ? formatSize(node.size).padStart(6) + ' chars'
+                  : ''.padStart(12);
+
+              const ago = node.createdAt ? `  ${timeAgo(node.createdAt)}` : '';
+
+              console.log(
+                `${prefix}${titleStr}${titlePad}${pc.dim(`(${node.documentId})`)}  ${fromStr}${fromPad}${pc.dim(size)}${pc.dim(ago)}`,
+              );
+
+              if (node.children && node.children.length > 0) {
+                const childIndent = isChild ? indent + (isLast ? '    ' : '│   ') : indent;
+                renderNodes(node.children, childIndent, true);
+              }
+            }
+          };
+          renderNodes(nodes, '  ', false);
+        }
+      }
+
+      // ── Activities (already sorted desc by service) ──
+      {
+        console.log(`\n${pc.bold('Activities:')}`);
+        const acts = t.activities || [];
+        if (acts.length === 0) {
+          console.log(`  ${pc.dim('No activities yet.')}`);
+        } else {
+          for (const act of acts) {
+            const ago = act.time ? timeAgo(act.time) : '';
+            const idSuffix = act.id ? `  ${pc.dim(act.id)}` : '';
+            if (act.type === 'topic') {
+              const sBadge = statusBadge(act.status || 'running');
+              console.log(
+                `  💬 ${pc.dim(ago.padStart(7))} Topic #${act.seq || '?'} ${act.title || 'Untitled'} ${sBadge}${idSuffix}`,
+              );
+            } else if (act.type === 'brief') {
+              const icon = briefIcon(act.briefType || '');
+              const pri =
+                act.priority === 'urgent'
+                  ? pc.red(' [urgent]')
+                  : act.priority === 'normal'
+                    ? pc.yellow(' [normal]')
+                    : '';
+              const resolved = act.resolvedAction ? pc.green(` ✏️ ${act.resolvedAction}`) : '';
+              const typeLabel = pc.dim(`[${act.briefType}]`);
+              console.log(
+                `  ${icon} ${pc.dim(ago.padStart(7))} Brief ${typeLabel} ${act.title}${pri}${resolved}${idSuffix}`,
+              );
+            } else if (act.type === 'comment') {
+              const author = act.agentId ? `🤖 ${act.agentId}` : '👤 user';
+              console.log(`  💭 ${pc.dim(ago.padStart(7))} ${pc.cyan(author)} ${act.content}`);
+            }
+          }
+        }
+      }
+
+      console.log();
+    });
+
+  // ── create ──────────────────────────────────────────────
+
+  task
+    .command('create')
+    .description('Create a new task')
+    .requiredOption('-i, --instruction <text>', 'Task instruction')
+    .option('-n, --name <name>', 'Task name')
+    .option('--agent <id>', 'Assign to agent')
+    .option('--parent <id>', 'Parent task ID')
+    .option('--priority <n>', 'Priority (0=none, 1=urgent, 2=high, 3=normal, 4=low)', '0')
+    .option('--prefix <prefix>', 'Identifier prefix', 'T')
+    .option('--json [fields]', 'Output JSON')
+    .action(
+      async (options: {
+        agent?: string;
+        instruction: string;
+        json?: string | boolean;
+        name?: string;
+        parent?: string;
+        prefix?: string;
+        priority?: string;
+      }) => {
+        const client = await getTrpcClient();
+
+        const input: Record<string, any> = {
+          instruction: options.instruction,
+        };
+        if (options.name) input.name = options.name;
+        if (options.agent) input.assigneeAgentId = options.agent;
+        if (options.parent) input.parentTaskId = options.parent;
+        if (options.priority) input.priority = Number.parseInt(options.priority, 10);
+        if (options.prefix) input.identifierPrefix = options.prefix;
+
+        const result = await client.task.create.mutate(input as any);
+
+        if (options.json !== undefined) {
+          outputJson(result.data, options.json);
+          return;
+        }
+
+        log.info(`Task created: ${pc.bold(result.data.identifier)} ${result.data.name || ''}`);
+      },
+    );
+
+  // ── edit ──────────────────────────────────────────────
+
+  task
+    .command('edit <id>')
+    .description('Update a task')
+    .option('-n, --name <name>', 'Task name')
+    .option('-i, --instruction <text>', 'Task instruction')
+    .option('--agent <id>', 'Assign to agent')
+    .option('--priority <n>', 'Priority (0-4)')
+    .option('--heartbeat-interval <n>', 'Heartbeat interval in seconds')
+    .option('--heartbeat-timeout <n>', 'Heartbeat timeout in seconds (0 to disable)')
+    .option('--description <text>', 'Task description')
+    .option(
+      '--status <status>',
+      'Set status (backlog, running, paused, completed, failed, canceled)',
+    )
+    .option('--json [fields]', 'Output JSON')
+    .action(
+      async (
+        id: string,
+        options: {
+          agent?: string;
+          description?: string;
+          heartbeatInterval?: string;
+          heartbeatTimeout?: string;
+          instruction?: string;
+          json?: string | boolean;
+          name?: string;
+          priority?: string;
+          status?: string;
+        },
+      ) => {
+        const client = await getTrpcClient();
+
+        // Handle --status separately (uses updateStatus API)
+        if (options.status) {
+          const valid = ['backlog', 'running', 'paused', 'completed', 'failed', 'canceled'];
+          if (!valid.includes(options.status)) {
+            log.error(`Invalid status "${options.status}". Must be one of: ${valid.join(', ')}`);
+            return;
+          }
+          const result = await client.task.updateStatus.mutate({ id, status: options.status });
+          log.info(`${pc.bold(result.data.identifier)} → ${options.status}`);
+          return;
+        }
+
+        const input: Record<string, any> = { id };
+        if (options.name) input.name = options.name;
+        if (options.instruction) input.instruction = options.instruction;
+        if (options.description) input.description = options.description;
+        if (options.agent) input.assigneeAgentId = options.agent;
+        if (options.priority) input.priority = Number.parseInt(options.priority, 10);
+        if (options.heartbeatInterval)
+          input.heartbeatInterval = Number.parseInt(options.heartbeatInterval, 10);
+        if (options.heartbeatTimeout !== undefined) {
+          const val = Number.parseInt(options.heartbeatTimeout, 10);
+          input.heartbeatTimeout = val === 0 ? null : val;
+        }
+
+        const result = await client.task.update.mutate(input as any);
+
+        if (options.json !== undefined) {
+          outputJson(result.data, typeof options.json === 'string' ? options.json : undefined);
+          return;
+        }
+
+        log.info(`Task updated: ${pc.bold(result.data.identifier)}`);
+      },
+    );
+
+  // ── delete ──────────────────────────────────────────────
+
+  task
+    .command('delete <id>')
+    .description('Delete a task')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (id: string, options: { yes?: boolean }) => {
+      if (!options.yes) {
+        const ok = await confirm(`Delete task ${pc.bold(id)}?`);
+        if (!ok) return;
+      }
+
+      const client = await getTrpcClient();
+      await client.task.delete.mutate({ id });
+      log.info(`Task ${pc.bold(id)} deleted.`);
+    });
+
+  // ── clear ──────────────────────────────────────────────
+
+  task
+    .command('clear')
+    .description('Delete all tasks')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options: { yes?: boolean }) => {
+      if (!options.yes) {
+        const ok = await confirm(`Delete ${pc.red('ALL')} tasks? This cannot be undone.`);
+        if (!ok) return;
+      }
+
+      const client = await getTrpcClient();
+      const result = (await client.task.clearAll.mutate()) as any;
+      log.info(`${result.count} task(s) deleted.`);
+    });
+
+  // ── tree ──────────────────────────────────────────────
+
+  task
+    .command('tree <id>')
+    .description('Show task tree (subtasks + dependencies)')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (id: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+      const result = await client.task.getTaskTree.query({ id });
+
+      if (options.json !== undefined) {
+        outputJson(result.data, options.json);
+        return;
+      }
+
+      if (!result.data || result.data.length === 0) {
+        log.info('No tasks found.');
+        return;
+      }
+
+      // Build tree display (raw SQL returns snake_case)
+      const taskMap = new Map<string, any>();
+      for (const t of result.data) taskMap.set(t.id, t);
+
+      const printNode = (taskId: string, indent: number) => {
+        const t = taskMap.get(taskId);
+        if (!t) return;
+
+        const prefix = indent === 0 ? '' : '  '.repeat(indent) + '├── ';
+        const name = t.name || t.identifier || '';
+        const status = t.status || 'pending';
+        const identifier = t.identifier || t.id;
+        console.log(`${prefix}${pc.dim(identifier)} ${statusBadge(status)} ${name}`);
+
+        // Print children (handle both camelCase and snake_case)
+        for (const child of result.data) {
+          const childParent = child.parentTaskId || child.parent_task_id;
+          if (childParent === taskId) {
+            printNode(child.id, indent + 1);
+          }
+        }
+      };
+
+      // Find root - resolve identifier first
+      const resolved = await client.task.find.query({ id });
+      const rootId = resolved.data.id;
+      const root = result.data.find((t: any) => t.id === rootId);
+      if (root) printNode(root.id, 0);
+      else log.info('Root task not found in tree.');
+    });
+
+  // Register subcommand groups
+  registerLifecycleCommands(task);
+  registerCheckpointCommands(task);
+  registerReviewCommands(task);
+  registerDepCommands(task);
+  registerTopicCommands(task);
+  registerDocCommands(task);
+}

apps/cli/src/commands/task/lifecycle.ts

@@ -0,0 +1,303 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../../api/client';
+import { getAuthInfo } from '../../api/http';
+import { streamAgentEvents } from '../../utils/agentStream';
+import { log } from '../../utils/logger';
+
+export function registerLifecycleCommands(task: Command) {
+  // ── start ──────────────────────────────────────────────
+
+  task
+    .command('start <id>')
+    .description('Start a task (pending → running)')
+    .option('--no-run', 'Only update status, do not trigger agent execution')
+    .option('-p, --prompt <text>', 'Additional context for the agent')
+    .option('-f, --follow', 'Follow agent output in real-time (default: run in background)')
+    .option('--json', 'Output full JSON event stream')
+    .option('-v, --verbose', 'Show detailed tool call info')
+    .action(
+      async (
+        id: string,
+        options: {
+          follow?: boolean;
+          json?: boolean;
+          prompt?: string;
+          run?: boolean;
+          verbose?: boolean;
+        },
+      ) => {
+        const client = await getTrpcClient();
+
+        // Check if already running
+        const taskDetail = await client.task.find.query({ id });
+
+        if (taskDetail.data.status === 'running') {
+          log.info(`Task ${pc.bold(taskDetail.data.identifier)} is already running.`);
+          return;
+        }
+
+        const statusResult = await client.task.updateStatus.mutate({ id, status: 'running' });
+        log.info(`Task ${pc.bold(statusResult.data.identifier)} started.`);
+
+        // Auto-run unless --no-run
+        if (options.run === false) return;
+
+        // Default agent to inbox if not assigned
+        if (!taskDetail.data.assigneeAgentId) {
+          await client.task.update.mutate({ assigneeAgentId: 'inbox', id });
+          log.info(`Assigned default agent: ${pc.dim('inbox')}`);
+        }
+
+        const result = (await client.task.run.mutate({
+          id,
+          ...(options.prompt && { prompt: options.prompt }),
+        })) as any;
+
+        if (!result.success) {
+          log.error(`Failed to run task: ${result.error || result.message || 'Unknown error'}`);
+          process.exit(1);
+        }
+
+        log.info(
+          `Operation: ${pc.dim(result.operationId)} · Topic: ${pc.dim(result.topicId || 'n/a')}`,
+        );
+
+        if (!options.follow) {
+          log.info(
+            `Agent running in background. Use ${pc.dim(`lh task view ${id}`)} to check status.`,
+          );
+          return;
+        }
+
+        const { serverUrl, headers } = await getAuthInfo();
+        const streamUrl = `${serverUrl}/api/agent/stream?operationId=${encodeURIComponent(result.operationId)}`;
+
+        await streamAgentEvents(streamUrl, headers, {
+          json: options.json,
+          verbose: options.verbose,
+        });
+
+        // Send heartbeat after completion
+        try {
+          await client.task.heartbeat.mutate({ id });
+        } catch {
+          // ignore heartbeat errors
+        }
+      },
+    );
+
+  // ── run ──────────────────────────────────────────────
+
+  task
+    .command('run <id>')
+    .description('Run a task — trigger agent execution')
+    .option('-p, --prompt <text>', 'Additional context for the agent')
+    .option('-c, --continue <topicId>', 'Continue running on an existing topic')
+    .option('-f, --follow', 'Follow agent output in real-time (default: run in background)')
+    .option('--topics <n>', 'Run N topics in sequence (default: 1, implies --follow)', '1')
+    .option('--delay <s>', 'Delay between topics in seconds', '0')
+    .option('--json', 'Output full JSON event stream')
+    .option('-v, --verbose', 'Show detailed tool call info')
+    .action(
+      async (
+        id: string,
+        options: {
+          continue?: string;
+          delay?: string;
+          follow?: boolean;
+          json?: boolean;
+          prompt?: string;
+          topics?: string;
+          verbose?: boolean;
+        },
+      ) => {
+        const topicCount = Number.parseInt(options.topics || '1', 10);
+        const delaySec = Number.parseInt(options.delay || '0', 10);
+
+        // --topics > 1 implies --follow
+        const shouldFollow = options.follow || topicCount > 1;
+
+        for (let i = 0; i < topicCount; i++) {
+          if (i > 0) {
+            log.info(`\n${'─'.repeat(60)}`);
+            log.info(`Topic ${i + 1}/${topicCount}`);
+            if (delaySec > 0) {
+              log.info(`Waiting ${delaySec}s before next topic...`);
+              await new Promise((r) => setTimeout(r, delaySec * 1000));
+            }
+          }
+
+          const client = await getTrpcClient();
+
+          // Auto-assign inbox agent on first topic if not assigned
+          if (i === 0) {
+            const taskDetail = await client.task.find.query({ id });
+            if (!taskDetail.data.assigneeAgentId) {
+              await client.task.update.mutate({ assigneeAgentId: 'inbox', id });
+              log.info(`Assigned default agent: ${pc.dim('inbox')}`);
+            }
+          }
+
+          // Only pass extra prompt and continue on first topic
+          const result = (await client.task.run.mutate({
+            id,
+            ...(i === 0 && options.prompt && { prompt: options.prompt }),
+            ...(i === 0 && options.continue && { continueTopicId: options.continue }),
+          })) as any;
+
+          if (!result.success) {
+            log.error(`Failed to run task: ${result.error || result.message || 'Unknown error'}`);
+            process.exit(1);
+          }
+
+          const operationId = result.operationId;
+          if (i === 0) {
+            log.info(`Task ${pc.bold(result.taskIdentifier)} running`);
+          }
+          log.info(`Operation: ${pc.dim(operationId)} · Topic: ${pc.dim(result.topicId || 'n/a')}`);
+
+          if (!shouldFollow) {
+            log.info(
+              `Agent running in background. Use ${pc.dim(`lh task view ${id}`)} to check status.`,
+            );
+            return;
+          }
+
+          // Connect to SSE stream and wait for completion
+          const { serverUrl, headers } = await getAuthInfo();
+          const streamUrl = `${serverUrl}/api/agent/stream?operationId=${encodeURIComponent(operationId)}`;
+
+          await streamAgentEvents(streamUrl, headers, {
+            json: options.json,
+            verbose: options.verbose,
+          });
+
+          // Update heartbeat after each topic
+          try {
+            await client.task.heartbeat.mutate({ id });
+          } catch {
+            // ignore heartbeat errors
+          }
+        }
+      },
+    );
+
+  // ── comment ──────────────────────────────────────────────
+
+  task
+    .command('comment <id>')
+    .description('Add a comment to a task')
+    .requiredOption('-m, --message <text>', 'Comment content')
+    .action(async (id: string, options: { message: string }) => {
+      const client = await getTrpcClient();
+      await client.task.addComment.mutate({ content: options.message, id });
+      log.info('Comment added.');
+    });
+
+  // ── pause ──────────────────────────────────────────────
+
+  task
+    .command('pause <id>')
+    .description('Pause a running task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = await client.task.updateStatus.mutate({ id, status: 'paused' });
+      log.info(`Task ${pc.bold(result.data.identifier)} paused.`);
+    });
+
+  // ── resume ──────────────────────────────────────────────
+
+  task
+    .command('resume <id>')
+    .description('Resume a paused task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = await client.task.updateStatus.mutate({ id, status: 'running' });
+      log.info(`Task ${pc.bold(result.data.identifier)} resumed.`);
+    });
+
+  // ── complete ──────────────────────────────────────────────
+
+  task
+    .command('complete <id>')
+    .description('Mark a task as completed')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = (await client.task.updateStatus.mutate({ id, status: 'completed' })) as any;
+      log.info(`Task ${pc.bold(result.data.identifier)} completed.`);
+      if (result.unlocked?.length > 0) {
+        log.info(`Unlocked: ${result.unlocked.map((id: string) => pc.bold(id)).join(', ')}`);
+      }
+      if (result.paused?.length > 0) {
+        log.info(
+          `Paused (checkpoint): ${result.paused.map((id: string) => pc.yellow(id)).join(', ')}`,
+        );
+      }
+      if (result.checkpointTriggered) {
+        log.info(`${pc.yellow('Checkpoint triggered')} — parent task paused for review.`);
+      }
+      if (result.allSubtasksDone) {
+        log.info(`All subtasks of parent task completed.`);
+      }
+    });
+
+  // ── cancel ──────────────────────────────────────────────
+
+  task
+    .command('cancel <id>')
+    .description('Cancel a task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = await client.task.updateStatus.mutate({ id, status: 'canceled' });
+      log.info(`Task ${pc.bold(result.data.identifier)} canceled.`);
+    });
+
+  // ── sort ──────────────────────────────────────────────
+
+  task
+    .command('sort <id> <identifiers...>')
+    .description('Reorder subtasks (e.g. lh task sort T-1 T-2 T-4 T-3)')
+    .action(async (id: string, identifiers: string[]) => {
+      const client = await getTrpcClient();
+      const result = (await client.task.reorderSubtasks.mutate({
+        id,
+        order: identifiers,
+      })) as any;
+
+      log.info('Subtasks reordered:');
+      for (const item of result.data) {
+        console.log(`  ${pc.dim(`#${item.sortOrder}`)} ${item.identifier}`);
+      }
+    });
+
+  // ── heartbeat ──────────────────────────────────────────────
+
+  task
+    .command('heartbeat <id>')
+    .description('Manually send heartbeat for a running task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      await client.task.heartbeat.mutate({ id });
+      log.info(`Heartbeat sent for ${pc.bold(id)}.`);
+    });
+
+  // ── watchdog ──────────────────────────────────────────────
+
+  task
+    .command('watchdog')
+    .description('Run watchdog check — detect and fail stuck tasks')
+    .action(async () => {
+      const client = await getTrpcClient();
+      const result = (await client.task.watchdog.mutate()) as any;
+
+      if (result.failed?.length > 0) {
+        log.info(
+          `${pc.red('Stuck tasks failed:')} ${result.failed.map((id: string) => pc.bold(id)).join(', ')}`,
+        );
+      } else {
+        log.info('No stuck tasks found.');
+      }
+    });
+}

apps/cli/src/commands/task/review.ts

@@ -0,0 +1,306 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../../api/client';
+import { printTable, truncate } from '../../utils/format';
+import { log } from '../../utils/logger';
+
+export function registerReviewCommands(task: Command) {
+  // ── review ──────────────────────────────────────────────
+
+  const rv = task.command('review').description('Manage task review (LLM-as-Judge)');
+
+  rv.command('view <id>')
+    .description('View review config for a task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = await client.task.getReview.query({ id });
+      const r = result.data as any;
+
+      if (!r || !r.enabled) {
+        log.info('Review not configured for this task.');
+        return;
+      }
+
+      console.log(`\n${pc.bold('Review config:')}`);
+      console.log(`  enabled: ${r.enabled}`);
+      if (r.judge?.model)
+        console.log(`  judge: ${r.judge.model}${r.judge.provider ? ` (${r.judge.provider})` : ''}`);
+      console.log(`  maxIterations: ${r.maxIterations}`);
+      console.log(`  autoRetry: ${r.autoRetry}`);
+      if (r.rubrics?.length > 0) {
+        console.log(`  rubrics:`);
+        for (let i = 0; i < r.rubrics.length; i++) {
+          const rb = r.rubrics[i];
+          const threshold = rb.threshold ? ` ≥ ${Math.round(rb.threshold * 100)}%` : '';
+          const typeTag = pc.dim(`[${rb.type}]`);
+          let configInfo = '';
+          if (rb.type === 'llm-rubric') configInfo = rb.config?.criteria || '';
+          else if (rb.type === 'contains' || rb.type === 'equals')
+            configInfo = `value="${rb.config?.value}"`;
+          else if (rb.type === 'regex') configInfo = `pattern="${rb.config?.pattern}"`;
+          console.log(`    ${i + 1}. ${rb.name} ${typeTag}${threshold} ${pc.dim(configInfo)}`);
+        }
+      } else {
+        console.log(`  rubrics: ${pc.dim('(none)')}`);
+      }
+      console.log();
+    });
+
+  rv.command('set <id>')
+    .description('Enable review and configure judge settings')
+    .option('--model <model>', 'Judge model')
+    .option('--provider <provider>', 'Judge provider')
+    .option('--max-iterations <n>', 'Max review iterations', '3')
+    .option('--no-auto-retry', 'Disable auto retry on failure')
+    .option('--recursive', 'Apply to all subtasks as well')
+    .action(
+      async (
+        id: string,
+        options: {
+          autoRetry?: boolean;
+          maxIterations?: string;
+          model?: string;
+          provider?: string;
+          recursive?: boolean;
+        },
+      ) => {
+        const client = await getTrpcClient();
+
+        // Read current review config to preserve rubrics
+        const current = (await client.task.getReview.query({ id })).data as any;
+        const existingRubrics = current?.rubrics || [];
+
+        const review = {
+          autoRetry: options.autoRetry !== false,
+          enabled: true,
+          judge: {
+            ...(options.model && { model: options.model }),
+            ...(options.provider && { provider: options.provider }),
+          },
+          maxIterations: Number.parseInt(options.maxIterations || '3', 10),
+          rubrics: existingRubrics,
+        };
+
+        await client.task.updateReview.mutate({ id, review });
+
+        if (options.recursive) {
+          const subtasks = await client.task.getSubtasks.query({ id });
+          for (const s of subtasks.data || []) {
+            const subCurrent = (await client.task.getReview.query({ id: s.id })).data as any;
+            await client.task.updateReview.mutate({
+              id: s.id,
+              review: { ...review, rubrics: subCurrent?.rubrics || existingRubrics },
+            });
+          }
+          log.info(
+            `Review enabled for ${pc.bold(id)} + ${(subtasks.data || []).length} subtask(s).`,
+          );
+        } else {
+          log.info('Review enabled.');
+        }
+      },
+    );
+
+  // ── review criteria ──────────────────────────────────────
+
+  const rc = rv.command('criteria').description('Manage review rubrics');
+
+  rc.command('list <id>')
+    .description('List review rubrics for a task')
+    .action(async (id: string) => {
+      const client = await getTrpcClient();
+      const result = await client.task.getReview.query({ id });
+      const r = result.data as any;
+      const rubrics = r?.rubrics || [];
+
+      if (rubrics.length === 0) {
+        log.info('No rubrics configured.');
+        return;
+      }
+
+      const rows = rubrics.map((r: any, i: number) => {
+        const config = r.config || {};
+        const configStr =
+          r.type === 'llm-rubric'
+            ? config.criteria || ''
+            : r.type === 'contains' || r.type === 'equals'
+              ? `value: "${config.value}"`
+              : r.type === 'regex'
+                ? `pattern: "${config.pattern}"`
+                : JSON.stringify(config);
+
+        return [
+          String(i + 1),
+          r.name,
+          r.type,
+          r.threshold ? `≥ ${Math.round(r.threshold * 100)}%` : '-',
+          String(r.weight ?? 1),
+          truncate(configStr, 40),
+        ];
+      });
+
+      printTable(rows, ['#', 'NAME', 'TYPE', 'THRESHOLD', 'WEIGHT', 'CONFIG']);
+    });
+
+  rc.command('add <id>')
+    .description('Add a review rubric')
+    .requiredOption('-n, --name <name>', 'Rubric name (e.g. "内容准确性")')
+    .option('--type <type>', 'Rubric type (default: llm-rubric)', 'llm-rubric')
+    .option('-t, --threshold <n>', 'Pass threshold 0-100 (converted to 0-1)')
+    .option('-d, --description <text>', 'Criteria description (for llm-rubric type)')
+    .option('--value <value>', 'Expected value (for contains/equals type)')
+    .option('--pattern <pattern>', 'Regex pattern (for regex type)')
+    .option('-w, --weight <n>', 'Weight for scoring (default: 1)')
+    .option('--recursive', 'Add to all subtasks as well')
+    .action(
+      async (
+        id: string,
+        options: {
+          description?: string;
+          name: string;
+          pattern?: string;
+          recursive?: boolean;
+          threshold?: string;
+          type: string;
+          value?: string;
+          weight?: string;
+        },
+      ) => {
+        const client = await getTrpcClient();
+
+        // Build rubric config based on type
+        const buildConfig = (): Record<string, any> | null => {
+          switch (options.type) {
+            case 'llm-rubric': {
+              return { criteria: options.description || options.name };
+            }
+            case 'contains':
+            case 'equals':
+            case 'starts-with':
+            case 'ends-with': {
+              if (!options.value) {
+                log.error(`--value is required for type "${options.type}"`);
+                return null;
+              }
+              return { value: options.value };
+            }
+            case 'regex': {
+              if (!options.pattern) {
+                log.error('--pattern is required for type "regex"');
+                return null;
+              }
+              return { pattern: options.pattern };
+            }
+            default: {
+              return { criteria: options.description || options.name };
+            }
+          }
+        };
+
+        const config = buildConfig();
+        if (!config) return;
+
+        const rubric: Record<string, any> = {
+          config,
+          id: `rubric-${Date.now()}`,
+          name: options.name,
+          type: options.type,
+          weight: options.weight ? Number.parseFloat(options.weight) : 1,
+        };
+        if (options.threshold) {
+          rubric.threshold = Number.parseInt(options.threshold, 10) / 100;
+        }
+
+        const addToTask = async (taskId: string) => {
+          const current = (await client.task.getReview.query({ id: taskId })).data as any;
+          const rubrics = current?.rubrics || [];
+
+          // Replace if same name exists, otherwise append
+          const filtered = rubrics.filter((r: any) => r.name !== options.name);
+          filtered.push(rubric);
+
+          await client.task.updateReview.mutate({
+            id: taskId,
+            review: {
+              autoRetry: current?.autoRetry ?? true,
+              enabled: current?.enabled ?? true,
+              judge: current?.judge ?? {},
+              maxIterations: current?.maxIterations ?? 3,
+              rubrics: filtered,
+            },
+          });
+        };
+
+        await addToTask(id);
+
+        if (options.recursive) {
+          const subtasks = await client.task.getSubtasks.query({ id });
+          for (const s of subtasks.data || []) {
+            await addToTask(s.id);
+          }
+          log.info(
+            `Rubric "${options.name}" [${options.type}] added to ${pc.bold(id)} + ${(subtasks.data || []).length} subtask(s).`,
+          );
+        } else {
+          log.info(`Rubric "${options.name}" [${options.type}] added.`);
+        }
+      },
+    );
+
+  rc.command('rm <id>')
+    .description('Remove a review rubric')
+    .requiredOption('-n, --name <name>', 'Rubric name to remove')
+    .option('--recursive', 'Remove from all subtasks as well')
+    .action(async (id: string, options: { name: string; recursive?: boolean }) => {
+      const client = await getTrpcClient();
+
+      const removeFromTask = async (taskId: string) => {
+        const current = (await client.task.getReview.query({ id: taskId })).data as any;
+        if (!current) return;
+
+        const rubrics = (current.rubrics || []).filter((r: any) => r.name !== options.name);
+
+        await client.task.updateReview.mutate({
+          id: taskId,
+          review: { ...current, rubrics },
+        });
+      };
+
+      await removeFromTask(id);
+
+      if (options.recursive) {
+        const subtasks = await client.task.getSubtasks.query({ id });
+        for (const s of subtasks.data || []) {
+          await removeFromTask(s.id);
+        }
+        log.info(
+          `Rubric "${options.name}" removed from ${pc.bold(id)} + ${(subtasks.data || []).length} subtask(s).`,
+        );
+      } else {
+        log.info(`Rubric "${options.name}" removed.`);
+      }
+    });
+
+  rv.command('run <id>')
+    .description('Manually run review on content')
+    .requiredOption('--content <text>', 'Content to review')
+    .action(async (id: string, options: { content: string }) => {
+      const client = await getTrpcClient();
+      const result = (await client.task.runReview.mutate({
+        content: options.content,
+        id,
+      })) as any;
+      const r = result.data;
+
+      console.log(
+        `\n${r.passed ? pc.green('✓ Review passed') : pc.red('✗ Review failed')} (${r.overallScore}%)`,
+      );
+      for (const s of r.rubricResults || []) {
+        const icon = s.passed ? pc.green('✓') : pc.red('✗');
+        const pct = Math.round(s.score * 100);
+        console.log(`  ${icon} ${s.rubricId}: ${pct}%${s.reason ? ` — ${s.reason}` : ''}`);
+      }
+      console.log();
+    });
+}

apps/cli/src/commands/task/topic.ts

@@ -0,0 +1,117 @@
+import type { Command } from 'commander';
+import pc from 'picocolors';
+
+import { getTrpcClient } from '../../api/client';
+import { confirm, outputJson, printTable, timeAgo, truncate } from '../../utils/format';
+import { log } from '../../utils/logger';
+import { statusBadge } from './helpers';
+
+export function registerTopicCommands(task: Command) {
+  // ── topic ──────────────────────────────────────────────
+
+  const tp = task.command('topic').description('Manage task topics');
+
+  tp.command('list <id>')
+    .description('List topics for a task')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (id: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+      const result = await client.task.getTopics.query({ id });
+
+      if (options.json !== undefined) {
+        outputJson(result.data, options.json);
+        return;
+      }
+
+      if (!result.data || result.data.length === 0) {
+        log.info('No topics found for this task.');
+        return;
+      }
+
+      const rows = result.data.map((t: any) => [
+        `#${t.seq}`,
+        t.id,
+        statusBadge(t.status || 'running'),
+        truncate(t.title || 'Untitled', 40),
+        t.operationId ? pc.dim(truncate(t.operationId, 20)) : '-',
+        timeAgo(t.createdAt),
+      ]);
+
+      printTable(rows, ['SEQ', 'TOPIC ID', 'STATUS', 'TITLE', 'OPERATION', 'CREATED']);
+    });
+
+  tp.command('view <id> <topicId>')
+    .description('View messages of a topic (topicId can be a seq number like "1")')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (id: string, topicId: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+
+      let resolvedTopicId = topicId;
+
+      // If it's a number, treat as seq index
+      const seqNum = Number.parseInt(topicId, 10);
+      if (!Number.isNaN(seqNum) && String(seqNum) === topicId) {
+        const topicsResult = await client.task.getTopics.query({ id });
+        const match = (topicsResult.data || []).find((t: any) => t.seq === seqNum);
+        if (!match) {
+          log.error(`Topic #${seqNum} not found for this task.`);
+          return;
+        }
+        resolvedTopicId = match.id;
+        log.info(
+          `Topic #${seqNum}: ${pc.bold(match.title || 'Untitled')} ${pc.dim(resolvedTopicId)}`,
+        );
+      }
+
+      const messages = await client.message.getMessages.query({ topicId: resolvedTopicId });
+      const items = Array.isArray(messages) ? messages : [];
+
+      if (options.json !== undefined) {
+        outputJson(items, options.json);
+        return;
+      }
+
+      if (items.length === 0) {
+        log.info('No messages in this topic.');
+        return;
+      }
+
+      console.log();
+      for (const msg of items) {
+        const role =
+          msg.role === 'assistant'
+            ? pc.green('Assistant')
+            : msg.role === 'user'
+              ? pc.blue('User')
+              : pc.dim(msg.role);
+
+        console.log(`${pc.bold(role)} ${pc.dim(timeAgo(msg.createdAt))}`);
+        if (msg.content) {
+          console.log(msg.content);
+        }
+        console.log();
+      }
+    });
+
+  tp.command('cancel <topicId>')
+    .description('Cancel a running topic and pause the task')
+    .action(async (topicId: string) => {
+      const client = await getTrpcClient();
+      await client.task.cancelTopic.mutate({ topicId });
+      log.info(`Topic ${pc.bold(topicId)} canceled. Task paused.`);
+    });
+
+  tp.command('delete <topicId>')
+    .description('Delete a topic and its messages')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (topicId: string, options: { yes?: boolean }) => {
+      if (!options.yes) {
+        const ok = await confirm(`Delete topic ${pc.bold(topicId)} and all its messages?`);
+        if (!ok) return;
+      }
+
+      const client = await getTrpcClient();
+      await client.task.deleteTopic.mutate({ topicId });
+      log.info(`Topic ${pc.bold(topicId)} deleted.`);
+    });
+}

apps/cli/src/constants/auth.ts

@@ -0,0 +1 @@
+export const CLI_API_KEY_ENV = 'LOBEHUB_CLI_API_KEY';

apps/cli/src/settings/index.test.ts

@@ -5,18 +5,19 @@ import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { log } from '../utils/logger';
-import { loadSettings, saveSettings } from './index';
+import { loadSettings, normalizeUrl, resolveServerUrl, saveSettings } from './index';
 
 const tmpDir = path.join(os.tmpdir(), 'lobehub-cli-test-settings');
 const settingsDir = path.join(tmpDir, '.lobehub');
 const settingsFile = path.join(settingsDir, 'settings.json');
+const originalServer = process.env.LOBEHUB_SERVER;
 
 vi.mock('node:os', async (importOriginal) => {
   const actual = await importOriginal<Record<string, any>>();
   return {
     ...actual,
     default: {
-      ...actual['default'],
+      ...actual.default,
       homedir: () => path.join(os.tmpdir(), 'lobehub-cli-test-settings'),
     },
   };
@@ -31,10 +32,12 @@ vi.mock('../utils/logger', () => ({
 describe('settings', () => {
   beforeEach(() => {
     fs.mkdirSync(tmpDir, { recursive: true });
+    delete process.env.LOBEHUB_SERVER;
   });
 
   afterEach(() => {
     fs.rmSync(tmpDir, { force: true, recursive: true });
+    process.env.LOBEHUB_SERVER = originalServer;
     vi.clearAllMocks();
   });
 
@@ -64,4 +67,28 @@ describe('settings', () => {
     expect(loadSettings()).toBeNull();
     expect(log.warn).toHaveBeenCalledWith(expect.stringContaining('Please delete this file'));
   });
+
+  it('should normalize trailing slashes', () => {
+    expect(normalizeUrl('https://self-hosted.example.com/')).toBe(
+      'https://self-hosted.example.com',
+    );
+    expect(normalizeUrl(undefined)).toBeUndefined();
+  });
+
+  it('should prefer LOBEHUB_SERVER over settings', () => {
+    saveSettings({ serverUrl: 'https://settings.example.com/' });
+    process.env.LOBEHUB_SERVER = 'https://env.example.com/';
+
+    expect(resolveServerUrl()).toBe('https://env.example.com');
+  });
+
+  it('should fall back to settings then official server', () => {
+    saveSettings({ serverUrl: 'https://settings.example.com/' });
+
+    expect(resolveServerUrl()).toBe('https://settings.example.com');
+
+    fs.unlinkSync(settingsFile);
+
+    expect(resolveServerUrl()).toBe('https://app.lobehub.com');
+  });
 });

apps/cli/src/settings/index.ts

@@ -14,10 +14,17 @@ const LOBEHUB_DIR_NAME = process.env.LOBEHUB_CLI_HOME || '.lobehub';
 const SETTINGS_DIR = path.join(os.homedir(), LOBEHUB_DIR_NAME);
 const SETTINGS_FILE = path.join(SETTINGS_DIR, 'settings.json');
 
-function normalizeUrl(url: string | undefined): string | undefined {
+export function normalizeUrl(url: string | undefined): string | undefined {
   return url ? url.replace(/\/$/, '') : undefined;
 }
 
+export function resolveServerUrl(): string {
+  const envServerUrl = normalizeUrl(process.env.LOBEHUB_SERVER);
+  const settingsServerUrl = normalizeUrl(loadSettings()?.serverUrl);
+
+  return envServerUrl || settingsServerUrl || OFFICIAL_SERVER_URL;
+}
+
 export function saveSettings(settings: StoredSettings): void {
   const serverUrl = normalizeUrl(settings.serverUrl);
   const gatewayUrl = normalizeUrl(settings.gatewayUrl);

apps/cli/src/utils/format.ts

@@ -87,7 +87,7 @@ function stripAnsi(s: string): string {
  * Calculate the display width of a string in the terminal.
  * CJK characters and fullwidth symbols occupy 2 columns.
  */
-function displayWidth(s: string): number {
+export function displayWidth(s: string): number {
   const plain = stripAnsi(s);
   let width = 0;
   for (const char of plain) {

apps/desktop/src/main/const/store.ts

@@ -28,7 +28,10 @@ export const defaultProxySettings: NetworkProxySettings = {
 export const STORE_DEFAULTS: ElectronMainStore = {
   dataSyncConfig: { storageMode: 'cloud' },
   encryptedTokens: {},
+  gatewayDeviceDescription: '',
   gatewayDeviceId: '',
+  gatewayDeviceName: '',
+  gatewayEnabled: true,
   gatewayUrl: 'https://device-gateway.lobehub.com',
   locale: 'auto',
   networkProxy: defaultProxySettings,

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

@@ -55,11 +55,13 @@ export default class GatewayConnectionCtr extends ControllerModule {
 
   @IpcMethod()
   async connect(): Promise<{ error?: string; success: boolean }> {
+    this.app.storeManager.set('gatewayEnabled', true);
     return this.service.connect();
   }
 
   @IpcMethod()
   async disconnect(): Promise<{ success: boolean }> {
+    this.app.storeManager.set('gatewayEnabled', false);
     return this.service.disconnect();
   }
 
@@ -70,16 +72,33 @@ export default class GatewayConnectionCtr extends ControllerModule {
 
   @IpcMethod()
   async getDeviceInfo(): Promise<{
+    description: string;
     deviceId: string;
     hostname: string;
+    name: string;
     platform: string;
   }> {
     return this.service.getDeviceInfo();
   }
 
+  @IpcMethod()
+  async setDeviceName(params: { name: string }): Promise<{ success: boolean }> {
+    this.service.setDeviceName(params.name);
+    return { success: true };
+  }
+
+  @IpcMethod()
+  async setDeviceDescription(params: { description: string }): Promise<{ success: boolean }> {
+    this.service.setDeviceDescription(params.description);
+    return { success: true };
+  }
+
   // ─── Auto Connect ───
 
   private async tryAutoConnect() {
+    const gatewayEnabled = this.app.storeManager.get('gatewayEnabled');
+    if (!gatewayEnabled) return;
+
     const isConfigured = await this.remoteServerConfigCtr.isRemoteServerConfigured();
     if (!isConfigured) return;
 

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

@@ -1,8 +1,10 @@
 import { constants } from 'node:fs';
-import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 
 import {
+  type AuditSafePathsParams,
+  type AuditSafePathsResult,
   type EditLocalFileParams,
   type EditLocalFileResult,
   type GlobFilesParams,
@@ -52,6 +54,72 @@ import { ControllerModule, IpcMethod } from './index';
 // Create logger
 const logger = createLogger('controllers:LocalFileCtr');
 
+const SAFE_PATH_PREFIXES = ['/tmp', '/var/tmp'] as const;
+
+const normalizeAbsolutePath = (inputPath: string): string =>
+  path.normalize(path.isAbsolute(inputPath) ? inputPath : `/${inputPath}`);
+
+const resolvePathWithScope = (inputPath: string, scope: string): string =>
+  path.isAbsolute(inputPath) ? inputPath : path.join(scope, inputPath);
+
+const isWithinSafePathPrefixes = (targetPath: string, prefixes: readonly string[]): boolean =>
+  prefixes.some((prefix) => targetPath === prefix || targetPath.startsWith(`${prefix}${path.sep}`));
+
+const resolveNearestExistingRealPath = async (targetPath: string): Promise<string | undefined> => {
+  let currentPath = targetPath;
+
+  while (true) {
+    try {
+      await access(currentPath, constants.F_OK);
+      return normalizeAbsolutePath(await realpath(currentPath));
+    } catch {
+      const parentPath = path.dirname(currentPath);
+      if (parentPath === currentPath) return undefined;
+      currentPath = parentPath;
+    }
+  }
+};
+
+const resolveSafePathRealPrefixes = async (): Promise<string[]> => {
+  const prefixes = new Set<string>(SAFE_PATH_PREFIXES);
+
+  for (const safePrefix of SAFE_PATH_PREFIXES) {
+    try {
+      prefixes.add(normalizeAbsolutePath(await realpath(safePrefix)));
+    } catch {
+      // Keep the lexical prefix if the platform does not expose this directory.
+    }
+  }
+
+  return [...prefixes];
+};
+
+const areAllPathsSafeOnDisk = async (
+  paths: string[],
+  resolveAgainstScope: string,
+): Promise<boolean> => {
+  if (paths.length === 0) return false;
+
+  const safeRealPrefixes = await resolveSafePathRealPrefixes();
+
+  for (const currentPath of paths) {
+    const normalizedPath = normalizeAbsolutePath(
+      resolvePathWithScope(currentPath, resolveAgainstScope),
+    );
+
+    if (!isWithinSafePathPrefixes(normalizedPath, SAFE_PATH_PREFIXES)) {
+      return false;
+    }
+
+    const realPath = await resolveNearestExistingRealPath(normalizedPath);
+    if (!realPath || !isWithinSafePathPrefixes(realPath, safeRealPrefixes)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
 export default class LocalFileCtr extends ControllerModule {
   static override readonly groupName = 'localSystem';
   private get searchService() {
@@ -240,6 +308,18 @@ export default class LocalFileCtr extends ControllerModule {
     return writeLocalFile({ content, path: filePath });
   }
 
+  @IpcMethod()
+  async auditSafePaths({
+    paths,
+    resolveAgainstScope,
+  }: AuditSafePathsParams): Promise<AuditSafePathsResult> {
+    logger.debug('Auditing safe paths', { count: paths.length, resolveAgainstScope });
+
+    return {
+      allSafe: await areAllPathsSafeOnDisk(paths, resolveAgainstScope),
+    };
+  }
+
   @IpcMethod()
   async handlePrepareSkillDirectory({
     forceRefresh,

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

@@ -196,7 +196,10 @@ describe('GatewayConnectionCtr', () => {
     vi.useFakeTimers();
     MockGatewayClient.lastInstance = null;
     MockGatewayClient.lastOptions = null;
-    mockStoreGet.mockReturnValue(undefined);
+    mockStoreGet.mockImplementation((key: string) => {
+      if (key === 'gatewayEnabled') return true;
+      return undefined;
+    });
 
     mockGatewayConnectionSrv = new GatewayConnectionService(mockApp);
     ctr = new GatewayConnectionCtr(mockApp);
@@ -212,6 +215,7 @@ describe('GatewayConnectionCtr', () => {
   describe('connect', () => {
     it('should create GatewayClient with correct options', async () => {
       mockStoreGet.mockImplementation((key: string) => {
+        if (key === 'gatewayEnabled') return true;
         if (key === 'gatewayDeviceId') return 'stored-device-id';
         if (key === 'gatewayUrl') return undefined;
         return undefined;
@@ -231,6 +235,7 @@ describe('GatewayConnectionCtr', () => {
 
     it('should use custom gateway URL from store when set', async () => {
       mockStoreGet.mockImplementation((key: string) => {
+        if (key === 'gatewayEnabled') return true;
         if (key === 'gatewayUrl') return 'http://localhost:8787';
         return undefined;
       });
@@ -255,6 +260,16 @@ describe('GatewayConnectionCtr', () => {
       expect(MockGatewayClient.lastInstance).toBeNull();
     });
 
+    it('should persist gatewayEnabled=true on connect', async () => {
+      vi.mocked(mockRemoteServerConfigCtr.isRemoteServerConfigured).mockResolvedValueOnce(false);
+      ctr.afterAppReady();
+      await vi.advanceTimersByTimeAsync(0);
+      mockStoreSet.mockClear();
+
+      await ctr.connect();
+      expect(mockStoreSet).toHaveBeenCalledWith('gatewayEnabled', true);
+    });
+
     it('should no-op when already connected', async () => {
       ctr.afterAppReady();
       await vi.advanceTimersByTimeAsync(0);
@@ -299,6 +314,16 @@ describe('GatewayConnectionCtr', () => {
       });
     });
 
+    it('should persist gatewayEnabled=false on disconnect', async () => {
+      ctr.afterAppReady();
+      await vi.advanceTimersByTimeAsync(0);
+      MockGatewayClient.lastInstance!.simulateConnected();
+      mockStoreSet.mockClear();
+
+      await ctr.disconnect();
+      expect(mockStoreSet).toHaveBeenCalledWith('gatewayEnabled', false);
+    });
+
     it('should not trigger reconnect after intentional disconnect', async () => {
       ctr.afterAppReady();
       await vi.advanceTimersByTimeAsync(0);
@@ -327,6 +352,19 @@ describe('GatewayConnectionCtr', () => {
       expect(MockGatewayClient.lastInstance!.connect).toHaveBeenCalled();
     });
 
+    it('should skip auto-connect when gatewayEnabled is false', async () => {
+      mockStoreGet.mockImplementation((key: string) => {
+        if (key === 'gatewayEnabled') return false;
+        return undefined;
+      });
+
+      ctr = new GatewayConnectionCtr(mockApp);
+      ctr.afterAppReady();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(MockGatewayClient.lastInstance).toBeNull();
+    });
+
     it('should skip auto-connect when remote server not configured', async () => {
       vi.mocked(mockRemoteServerConfigCtr.isRemoteServerConfigured).mockResolvedValueOnce(false);
 
@@ -353,9 +391,11 @@ describe('GatewayConnectionCtr', () => {
     });
 
     it('should reuse persisted device ID', () => {
-      mockStoreGet.mockImplementation((key: string) =>
-        key === 'gatewayDeviceId' ? 'existing-id' : undefined,
-      );
+      mockStoreGet.mockImplementation((key: string) => {
+        if (key === 'gatewayEnabled') return true;
+        if (key === 'gatewayDeviceId') return 'existing-id';
+        return undefined;
+      });
       ctr = new GatewayConnectionCtr(mockApp);
       ctr.afterAppReady();
 
@@ -545,16 +585,20 @@ describe('GatewayConnectionCtr', () => {
 
   describe('getDeviceInfo', () => {
     it('should return device information', async () => {
-      mockStoreGet.mockImplementation((key: string) =>
-        key === 'gatewayDeviceId' ? 'my-device' : undefined,
-      );
+      mockStoreGet.mockImplementation((key: string) => {
+        if (key === 'gatewayEnabled') return true;
+        if (key === 'gatewayDeviceId') return 'my-device';
+        return undefined;
+      });
       ctr = new GatewayConnectionCtr(mockApp);
       ctr.afterAppReady();
 
       const info = await ctr.getDeviceInfo();
       expect(info).toEqual({
+        description: '',
         deviceId: 'my-device',
         hostname: 'mock-hostname',
+        name: 'mock-hostname',
         platform: process.platform,
       });
     });

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

@@ -45,6 +45,7 @@ vi.mock('node:fs/promises', () => ({
   mkdir: vi.fn(),
   readFile: vi.fn(),
   readdir: vi.fn(),
+  realpath: vi.fn(),
   rename: vi.fn(),
   rm: vi.fn(),
   stat: vi.fn(),
@@ -301,6 +302,46 @@ describe('LocalFileCtr', () => {
     });
   });
 
+  describe('auditSafePaths', () => {
+    it('should treat real temporary paths as safe', async () => {
+      vi.mocked(mockFsPromises.access).mockResolvedValue(undefined);
+      vi.mocked(mockFsPromises.realpath).mockImplementation(async (targetPath: string) => {
+        if (targetPath === '/tmp') return '/private/tmp';
+        if (targetPath === '/var/tmp') return '/private/var/tmp';
+        if (targetPath === '/tmp/out') return '/private/tmp/out';
+        return targetPath;
+      });
+
+      const result = await localFileCtr.auditSafePaths({
+        paths: ['/tmp/out'],
+        resolveAgainstScope: '/Users/me/project',
+      });
+
+      expect(result).toEqual({ allSafe: true });
+    });
+
+    it('should reject safe-path candidates whose real target escapes the temporary roots', async () => {
+      vi.mocked(mockFsPromises.access).mockImplementation(async (targetPath: string) => {
+        if (targetPath === '/tmp/out/config') {
+          throw new Error('ENOENT');
+        }
+      });
+      vi.mocked(mockFsPromises.realpath).mockImplementation(async (targetPath: string) => {
+        if (targetPath === '/tmp') return '/private/tmp';
+        if (targetPath === '/var/tmp') return '/private/var/tmp';
+        if (targetPath === '/tmp/out') return '/Users/me/.ssh';
+        return targetPath;
+      });
+
+      const result = await localFileCtr.auditSafePaths({
+        paths: ['/tmp/out/config'],
+        resolveAgainstScope: '/Users/me/project',
+      });
+
+      expect(result).toEqual({ allSafe: false });
+    });
+  });
+
   describe('handlePrepareSkillDirectory', () => {
     it('should download and extract a skill zip into a local cache directory', async () => {
       const zipped = zipSync({

apps/desktop/src/main/services/gatewayConnectionSrv.ts

@@ -84,12 +84,32 @@ export default class GatewayConnectionService extends ServiceModule {
 
   getDeviceInfo() {
     return {
+      description: this.getDeviceDescription(),
       deviceId: this.getDeviceId(),
       hostname: os.hostname(),
+      name: this.getDeviceName(),
       platform: process.platform,
     };
   }
 
+  // ─── Device Name & Description ───
+
+  getDeviceName(): string {
+    return (this.app.storeManager.get('gatewayDeviceName') as string) || os.hostname();
+  }
+
+  setDeviceName(name: string) {
+    this.app.storeManager.set('gatewayDeviceName', name);
+  }
+
+  getDeviceDescription(): string {
+    return (this.app.storeManager.get('gatewayDeviceDescription') as string) || '';
+  }
+
+  setDeviceDescription(description: string) {
+    this.app.storeManager.set('gatewayDeviceDescription', description);
+  }
+
   // ─── Connection Logic ───
 
   async connect(): Promise<{ error?: string; success: boolean }> {

apps/desktop/src/main/types/store.ts

@@ -12,7 +12,10 @@ export interface ElectronMainStore {
     lastRefreshAt?: number;
     refreshToken?: string;
   };
+  gatewayDeviceDescription: string;
   gatewayDeviceId: string;
+  gatewayDeviceName: string;
+  gatewayEnabled: boolean;
   gatewayUrl: string;
   locale: string;
   networkProxy: NetworkProxySettings;

apps/device-gateway/src/DeviceGatewayDO.ts

@@ -1,7 +1,7 @@
 import { DurableObject } from 'cloudflare:workers';
 import { Hono } from 'hono';
 
-import { verifyDesktopToken } from './auth';
+import { resolveSocketAuth, verifyApiKeyToken, verifyDesktopToken } from './auth';
 import type { DeviceAttachment, Env } from './types';
 
 const AUTH_TIMEOUT = 10_000; // 10s to authenticate after connect
@@ -58,24 +58,25 @@ export class DeviceGatewayDO extends DurableObject<Env> {
       if (att.authenticated) return; // Already authenticated, ignore
 
       try {
-        const token = data.token as string;
-        if (!token) throw new Error('Missing token');
+        const token = data.token as string | undefined;
+        const tokenType = data.tokenType as 'apiKey' | 'jwt' | 'serviceToken' | undefined;
+        const serverUrl = data.serverUrl as string | undefined;
+        const storedUserId = await this.ctx.storage.get<string>('_userId');
 
-        let verifiedUserId: string;
-
-        if (token === this.env.SERVICE_TOKEN) {
-          // Service token auth (for CLI debugging)
-          const storedUserId = await this.ctx.storage.get<string>('_userId');
-          if (!storedUserId) throw new Error('Missing userId');
-          verifiedUserId = storedUserId;
-        } else {
-          // JWT auth (normal desktop flow)
-          const result = await verifyDesktopToken(this.env, token);
-          verifiedUserId = result.userId;
-        }
+        const verifiedUserId = await resolveSocketAuth({
+          serverUrl,
+          serviceToken: this.env.SERVICE_TOKEN,
+          storedUserId,
+          token,
+          tokenType,
+          verifyApiKey: verifyApiKeyToken,
+          verifyJwt: async (jwt) => {
+            const result = await verifyDesktopToken(this.env, jwt);
+            return { userId: result.userId };
+          },
+        });
 
         // Verify userId matches the DO routing
-        const storedUserId = await this.ctx.storage.get<string>('_userId');
         if (storedUserId && verifiedUserId !== storedUserId) {
           throw new Error('userId mismatch');
         }

apps/device-gateway/src/auth.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { resolveSocketAuth } from './auth';
+
+describe('resolveSocketAuth', () => {
+  it('rejects missing token', async () => {
+    const verifyApiKey = vi.fn();
+    const verifyJwt = vi.fn();
+
+    await expect(
+      resolveSocketAuth({
+        serviceToken: 'service-secret',
+        storedUserId: 'user-123',
+        verifyApiKey,
+        verifyJwt,
+      }),
+    ).rejects.toThrow('Missing token');
+
+    expect(verifyApiKey).not.toHaveBeenCalled();
+    expect(verifyJwt).not.toHaveBeenCalled();
+  });
+
+  it('rejects the real service token when storedUserId is missing', async () => {
+    const verifyApiKey = vi.fn();
+    const verifyJwt = vi.fn();
+
+    await expect(
+      resolveSocketAuth({
+        serviceToken: 'service-secret',
+        token: 'service-secret',
+        tokenType: 'serviceToken',
+        verifyApiKey,
+        verifyJwt,
+      }),
+    ).rejects.toThrow('Missing userId');
+
+    expect(verifyApiKey).not.toHaveBeenCalled();
+    expect(verifyJwt).not.toHaveBeenCalled();
+  });
+  it('rejects clients that only self-declare serviceToken mode', async () => {
+    const verifyApiKey = vi.fn();
+    const verifyJwt = vi.fn().mockRejectedValue(new Error('invalid jwt'));
+
+    await expect(
+      resolveSocketAuth({
+        serviceToken: 'service-secret',
+        storedUserId: 'user-123',
+        token: 'attacker-token',
+        tokenType: 'serviceToken',
+        verifyApiKey,
+        verifyJwt,
+      }),
+    ).rejects.toThrow('invalid jwt');
+
+    expect(verifyApiKey).not.toHaveBeenCalled();
+    expect(verifyJwt).toHaveBeenCalledWith('attacker-token');
+  });
+
+  it('treats a forged serviceToken claim with a valid JWT as JWT auth', async () => {
+    const verifyApiKey = vi.fn();
+    const verifyJwt = vi.fn().mockResolvedValue({ userId: 'user-123' });
+
+    await expect(
+      resolveSocketAuth({
+        serviceToken: 'service-secret',
+        storedUserId: 'user-123',
+        token: 'valid-jwt',
+        tokenType: 'serviceToken',
+        verifyApiKey,
+        verifyJwt,
+      }),
+    ).resolves.toBe('user-123');
+
+    expect(verifyApiKey).not.toHaveBeenCalled();
+    expect(verifyJwt).toHaveBeenCalledWith('valid-jwt');
+  });
+
+  it('accepts the real service token', async () => {
+    const verifyApiKey = vi.fn();
+    const verifyJwt = vi.fn();
+
+    await expect(
+      resolveSocketAuth({
+        serviceToken: 'service-secret',
+        storedUserId: 'user-123',
+        token: 'service-secret',
+        tokenType: 'serviceToken',
+        verifyApiKey,
+        verifyJwt,
+      }),
+    ).resolves.toBe('user-123');
+
+    expect(verifyApiKey).not.toHaveBeenCalled();
+    expect(verifyJwt).not.toHaveBeenCalled();
+  });
+});

apps/device-gateway/src/auth.ts

@@ -4,6 +4,26 @@ import type { Env } from './types';
 
 let cachedKey: CryptoKey | null = null;
 
+interface CurrentUserResponse {
+  data?: {
+    id?: string;
+    userId?: string;
+  };
+  error?: string;
+  message?: string;
+  success?: boolean;
+}
+
+export interface ResolveSocketAuthOptions {
+  serverUrl?: string;
+  serviceToken: string;
+  storedUserId?: string;
+  token?: string;
+  tokenType?: 'apiKey' | 'jwt' | 'serviceToken';
+  verifyApiKey: (serverUrl: string, token: string) => Promise<{ userId: string }>;
+  verifyJwt: (token: string) => Promise<{ userId: string }>;
+}
+
 async function getPublicKey(env: Env): Promise<CryptoKey> {
   if (cachedKey) return cachedKey;
 
@@ -34,3 +54,57 @@ export async function verifyDesktopToken(
     userId: payload.sub,
   };
 }
+
+export async function verifyApiKeyToken(
+  serverUrl: string,
+  token: string,
+): Promise<{ userId: string }> {
+  const normalizedServerUrl = new URL(serverUrl).toString().replace(/\/$/, '');
+
+  const response = await fetch(`${normalizedServerUrl}/api/v1/users/me`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  let body: CurrentUserResponse | undefined;
+  try {
+    body = (await response.json()) as CurrentUserResponse;
+  } catch {
+    throw new Error(`Failed to parse response from ${normalizedServerUrl}/api/v1/users/me.`);
+  }
+
+  if (!response.ok || body?.success === false) {
+    throw new Error(
+      body?.error || body?.message || `Request failed with status ${response.status}.`,
+    );
+  }
+
+  const userId = body?.data?.id || body?.data?.userId;
+  if (!userId) {
+    throw new Error('Current user response did not include a user id.');
+  }
+
+  return { userId };
+}
+
+export async function resolveSocketAuth(options: ResolveSocketAuthOptions): Promise<string> {
+  const { serverUrl, serviceToken, storedUserId, token, tokenType, verifyApiKey, verifyJwt } =
+    options;
+
+  if (!token) throw new Error('Missing token');
+
+  if (tokenType === 'apiKey') {
+    if (!serverUrl) throw new Error('Missing serverUrl');
+    const result = await verifyApiKey(serverUrl, token);
+    return result.userId;
+  }
+
+  if (token === serviceToken) {
+    if (!storedUserId) throw new Error('Missing userId');
+    return storedUserId;
+  }
+
+  const result = await verifyJwt(token);
+  return result.userId;
+}

apps/device-gateway/src/types.ts

@@ -20,7 +20,9 @@ export interface DeviceAttachment {
 
 // Desktop → CF
 export interface AuthMessage {
+  serverUrl?: string;
   token: string;
+  tokenType?: 'apiKey' | 'jwt' | 'serviceToken';
   type: 'auth';
 }
 

changelog/v2.json

@@ -1,4 +1,19 @@
 [
+  {
+    "children": {
+      "improvements": ["add agent task system database schema."]
+    },
+    "date": "2026-03-26",
+    "version": "2.1.45"
+  },
+  {
+    "children": {
+      "fixes": ["misc UI/UX improvements and bug fixes."],
+      "improvements": ["add image/video switch."]
+    },
+    "date": "2026-03-20",
+    "version": "2.1.44"
+  },
   {
     "children": {
       "improvements": [

docs/development/database-schema.dbml

@@ -907,6 +907,46 @@ table nextauth_verificationtokens {
   }
 }
 
+table notification_deliveries {
+  id uuid [pk, not null, default: `gen_random_uuid()`]
+  notification_id uuid [not null]
+  channel text [not null]
+  status text [not null]
+  provider_message_id text
+  failed_reason text
+  sent_at "timestamp with time zone"
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    notification_id [name: 'idx_deliveries_notification']
+    channel [name: 'idx_deliveries_channel']
+    status [name: 'idx_deliveries_status']
+  }
+}
+
+table notifications {
+  id uuid [pk, not null, default: `gen_random_uuid()`]
+  user_id text [not null]
+  category text [not null]
+  type text [not null]
+  title text [not null]
+  content text [not null]
+  dedupe_key text
+  action_url text
+  is_read boolean [not null, default: false]
+  is_archived boolean [not null, default: false]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+  updated_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    user_id [name: 'idx_notifications_user']
+    (user_id, created_at) [name: 'idx_notifications_user_active']
+    user_id [name: 'idx_notifications_user_unread']
+    (user_id, dedupe_key) [name: 'idx_notifications_dedupe', unique]
+    (updated_at, created_at, id) [name: 'idx_notifications_archived_cleanup']
+  }
+}
+
 table oauth_handoffs {
   id text [pk, not null]
   client varchar(50) [not null]
@@ -1340,6 +1380,166 @@ table sessions {
   }
 }
 
+table briefs {
+  id text [pk, not null]
+  user_id text [not null]
+  task_id text
+  cron_job_id text
+  topic_id text
+  agent_id text
+  type text [not null]
+  priority text [default: 'info']
+  title text [not null]
+  summary text [not null]
+  artifacts jsonb
+  actions jsonb
+  resolved_action text
+  resolved_comment text
+  read_at "timestamp with time zone"
+  resolved_at "timestamp with time zone"
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    user_id [name: 'briefs_user_id_idx']
+    task_id [name: 'briefs_task_id_idx']
+    cron_job_id [name: 'briefs_cron_job_id_idx']
+    agent_id [name: 'briefs_agent_id_idx']
+    type [name: 'briefs_type_idx']
+    priority [name: 'briefs_priority_idx']
+    (user_id, resolved_at) [name: 'briefs_unresolved_idx']
+  }
+}
+
+table task_comments {
+  id text [pk, not null]
+  task_id text [not null]
+  user_id text [not null]
+  author_user_id text
+  author_agent_id text
+  content text [not null]
+  editor_data jsonb
+  brief_id text
+  topic_id text
+  accessed_at "timestamp with time zone" [not null, default: `now()`]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+  updated_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    task_id [name: 'task_comments_task_id_idx']
+    user_id [name: 'task_comments_user_id_idx']
+    author_user_id [name: 'task_comments_author_user_id_idx']
+    author_agent_id [name: 'task_comments_agent_id_idx']
+    brief_id [name: 'task_comments_brief_id_idx']
+    topic_id [name: 'task_comments_topic_id_idx']
+  }
+}
+
+table task_dependencies {
+  id uuid [pk, not null, default: `gen_random_uuid()`]
+  task_id text [not null]
+  depends_on_id text [not null]
+  user_id text [not null]
+  type text [not null, default: 'blocks']
+  condition jsonb
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    (task_id, depends_on_id) [name: 'task_deps_unique_idx', unique]
+    task_id [name: 'task_deps_task_id_idx']
+    depends_on_id [name: 'task_deps_depends_on_id_idx']
+    user_id [name: 'task_deps_user_id_idx']
+  }
+}
+
+table task_documents {
+  id uuid [pk, not null, default: `gen_random_uuid()`]
+  task_id text [not null]
+  document_id text [not null]
+  user_id text [not null]
+  pinned_by text [not null, default: 'agent']
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    (task_id, document_id) [name: 'task_docs_unique_idx', unique]
+    task_id [name: 'task_docs_task_id_idx']
+    document_id [name: 'task_docs_document_id_idx']
+    user_id [name: 'task_docs_user_id_idx']
+  }
+}
+
+table task_topics {
+  id uuid [pk, not null, default: `gen_random_uuid()`]
+  task_id text [not null]
+  topic_id text
+  user_id text [not null]
+  seq integer [not null]
+  operation_id text
+  status text [not null, default: 'running']
+  handoff jsonb
+  review_passed integer
+  review_score integer
+  review_scores jsonb
+  review_iteration integer
+  reviewed_at "timestamp with time zone"
+  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 {
+    (task_id, topic_id) [name: 'task_topics_unique_idx', unique]
+    task_id [name: 'task_topics_task_id_idx']
+    topic_id [name: 'task_topics_topic_id_idx']
+    user_id [name: 'task_topics_user_id_idx']
+    (task_id, status) [name: 'task_topics_status_idx']
+  }
+}
+
+table tasks {
+  id text [pk, not null]
+  identifier text [not null]
+  seq integer [not null]
+  created_by_user_id text [not null]
+  created_by_agent_id text
+  assignee_user_id text
+  assignee_agent_id text
+  parent_task_id text
+  name text
+  description varchar(255)
+  instruction text [not null]
+  status text [not null, default: 'backlog']
+  priority integer [default: 0]
+  sort_order integer [default: 0]
+  heartbeat_interval integer [default: 300]
+  heartbeat_timeout integer
+  last_heartbeat_at "timestamp with time zone"
+  schedule_pattern text
+  schedule_timezone text [default: 'UTC']
+  total_topics integer [default: 0]
+  max_topics integer
+  current_topic_id text
+  context jsonb [default: `{}`]
+  config jsonb [default: `{}`]
+  error text
+  started_at "timestamp with time zone"
+  completed_at "timestamp with time zone"
+  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 {
+    
+    (identifier, created_by_user_id) [name: 'tasks_identifier_idx', unique]
+    created_by_user_id [name: 'tasks_created_by_user_id_idx']
+    created_by_agent_id [name: 'tasks_created_by_agent_id_idx']
+    assignee_user_id [name: 'tasks_assignee_user_id_idx']
+    assignee_agent_id [name: 'tasks_assignee_agent_id_idx']
+    parent_task_id [name: 'tasks_parent_task_id_idx']
+    status [name: 'tasks_status_idx']
+    priority [name: 'tasks_priority_idx']
+    (status, last_heartbeat_at) [name: 'tasks_heartbeat_idx']
+  }
+}
+
 table threads {
   id text [pk, not null]
   title text
@@ -1463,6 +1663,7 @@ table user_settings {
   memory jsonb
   tool jsonb
   image jsonb
+  notification jsonb
 }
 
 table users {
@@ -1828,4 +2029,4 @@ ref: topic_documents.document_id > documents.id
 
 ref: topic_documents.topic_id > topics.id
 
-ref: topics.session_id - sessions.id
+ref: topics.session_id - sessions.id

e2e/src/steps/page/page-crud.steps.ts

@@ -166,7 +166,7 @@ async function clickNewPageButton(world: CustomWorld): Promise<void> {
 // Given Steps
 // ============================================
 
-Given('用户在 Page 页面', async function (this: CustomWorld) {
+Given('用户在 Page 页面', { timeout: 30_000 }, async function (this: CustomWorld) {
   console.log('   📍 Step: 导航到 Page 页面...');
   await this.page.goto('/page');
   await this.page.waitForLoadState('networkidle', { timeout: 15_000 });

locales/ar/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "فشل الاتصال",
   "sync.title": "حالة المزامنة",
   "sync.unconnected.tip": "فشل الاتصال بخادم الإشارة، ولا يمكن إنشاء قناة اتصال من نظير إلى نظير. يرجى التحقق من الشبكة والمحاولة مرة أخرى.",
-  "tab.aiImage": "الرسومات",
   "tab.audio": "الصوت",
   "tab.chat": "الدردشة",
   "tab.community": "المجتمع",
@@ -405,6 +404,7 @@
   "tab.eval": "مختبر التقييم",
   "tab.files": "الملفات",
   "tab.home": "الرئيسية",
+  "tab.image": "صورة",
   "tab.knowledgeBase": "المكتبة",
   "tab.marketplace": "السوق",
   "tab.me": "أنا",

locales/ar/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "لنماذج توليد الصور من Gemini 3؛ يتحكم في دقة الصور المُولدة.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "لـ نماذج الصور Gemini 3.1 Flash؛ يتحكم في دقة الصور المُنشأة (يدعم 512 بكسل).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "لنماذج Claude وQwen3 وما شابهها؛ يتحكم في ميزانية الرموز المخصصة للاستدلال.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "لـ GLM-5 و GLM-4.7؛ يتحكم في ميزانية الرموز للتفكير (الحد الأقصى 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "لسلسلة Qwen3؛ يتحكم في ميزانية الرموز للتفكير (الحد الأقصى 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "لنماذج OpenAI وغيرها من النماذج القادرة على الاستدلال؛ يتحكم في جهد الاستدلال.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "لسلسلة GPT-5+؛ يتحكم في تفصيل النص الناتج.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "لبعض نماذج Doubao؛ يسمح للنموذج بتحديد ما إذا كان يجب التفكير بعمق.",

locales/ar/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev هو نموذج توليد وتحرير صور متعدد الوسائط من Black Forest Labs، مبني على بنية Rectified Flow Transformer ويحتوي على 12 مليار معامل. يركز على توليد الصور، إعادة بنائها، تحسينها أو تحريرها ضمن شروط سياقية محددة. يجمع بين قدرات التوليد القابلة للتحكم لنماذج الانتشار ونمذجة السياق باستخدام Transformer، ويدعم مخرجات عالية الجودة لمهام مثل inpainting، outpainting، وإعادة بناء المشاهد البصرية.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev هو نموذج لغة متعدد الوسائط مفتوح المصدر من Black Forest Labs، محسن لمهام النص والصورة، ويجمع بين فهم وتوليد النصوص/الصور. مبني على نماذج LLM متقدمة (مثل Mistral-7B)، ويستخدم مشفر رؤية مصمم بعناية وضبط تعليمات متعدد المراحل لتمكين التنسيق متعدد الوسائط والاستدلال المعقد.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: إصدار خفيف الوزن للاستجابات السريعة.",
+  "GLM-4.5.description": "GLM-4.5: نموذج عالي الأداء للمنطق، البرمجة، ومهام الوكلاء.",
+  "GLM-4.6.description": "GLM-4.6: نموذج الجيل السابق.",
+  "GLM-4.7.description": "GLM-4.7 هو النموذج الرائد الأحدث من Zhipu، معزز لسيناريوهات البرمجة الوكيلية مع تحسين قدرات البرمجة، تخطيط المهام طويلة الأمد، والتعاون مع الأدوات.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: إصدار محسن من GLM-5 مع استدلال أسرع لمهام البرمجة.",
+  "GLM-5.description": "GLM-5 هو نموذج الأساس الرائد من الجيل التالي لـ Zhipu، مصمم خصيصًا للهندسة الوكيلية. يوفر إنتاجية موثوقة في هندسة الأنظمة المعقدة ومهام الوكلاء طويلة الأمد. في قدرات البرمجة والوكلاء، يحقق GLM-5 أداءً رائدًا بين النماذج مفتوحة المصدر.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) هو نموذج مبتكر لمجالات متنوعة ومهام معقدة.",
   "HY-Image-V3.0.description": "قدرات قوية لاستخراج الميزات من الصور الأصلية والحفاظ على التفاصيل، مما يوفر نسيجًا بصريًا أكثر ثراءً وينتج صورًا عالية الدقة ومتقنة ومناسبة للإنتاج.",
   "HelloMeme.description": "HelloMeme هي أداة ذكاء اصطناعي لإنشاء الميمات، الصور المتحركة (GIFs)، أو مقاطع الفيديو القصيرة من الصور أو الحركات التي تقدمها. لا تتطلب مهارات رسم أو برمجة—فقط صورة مرجعية—لإنتاج محتوى ممتع وجذاب ومتناسق من حيث الأسلوب.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "نموذج استدلال داخلي جديد بسلسلة تفكير تصل إلى 80K ومدخلات حتى 1M، يقدم أداءً مماثلاً لأفضل النماذج العالمية.",
   "MiniMax-M2-Stable.description": "مصمم لتدفقات العمل البرمجية والوكلاء بكفاءة عالية، مع قدرة تزامن أعلى للاستخدام التجاري.",
   "MiniMax-M2.1-Lightning.description": "قدرات برمجة متعددة اللغات قوية وتجربة برمجة مطورة بالكامل. أسرع وأكثر كفاءة.",
+  "MiniMax-M2.1-highspeed.description": "قدرات برمجة متعددة اللغات قوية مع استدلال أسرع وأكثر كفاءة.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 هو نموذج مفتوح المصدر رائد من MiniMax، يركز على حل المهام الواقعية المعقدة. يتميز بقدرات برمجة متعددة اللغات والقدرة على أداء المهام المعقدة كوكلاء ذكي.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: نفس الأداء، أسرع وأكثر رشاقة (تقريباً 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: نفس أداء M2.5 مع استدلال أسرع.",
   "MiniMax-M2.5.description": "أداء من الدرجة الأولى وفعالية تكلفة قصوى، يتعامل بسهولة مع المهام المعقدة (تقريباً 60 tps).",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: نفس أداء M2.7 مع استدلال أسرع بشكل ملحوظ.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: بداية رحلة التحسين الذاتي التكراري، قدرات هندسية واقعية رائدة.",
+  "MiniMax-M2.description": "MiniMax M2: نموذج الجيل السابق.",
   "MiniMax-Text-01.description": "MiniMax-01 يقدم انتباهًا خطيًا واسع النطاق يتجاوز Transformers التقليدية، مع 456 مليار معامل و45.9 مليار مفعّلة في كل تمرير. يحقق أداءً من الدرجة الأولى ويدعم حتى 4 ملايين رمز سياقي (32× GPT-4o، 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 هو نموذج استدلال كبير مفتوح الأوزان مع 456 مليار معلمة إجمالية وحوالي 45.9 مليار نشطة لكل رمز. يدعم سياق 1 مليون بشكل طبيعي ويستخدم Flash Attention لتقليل FLOPs بنسبة 75% على توليد 100 ألف رمز مقارنة بـ DeepSeek R1. مع بنية MoE بالإضافة إلى CISPO وتدريب RL الهجين، يحقق أداءً رائدًا في الاستدلال طويل المدخلات ومهام الهندسة البرمجية الواقعية.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 يعيد تعريف كفاءة الوكلاء. إنه نموذج MoE مضغوط وسريع وفعال من حيث التكلفة مع 230 مليار معلمة إجمالية و10 مليارات معلمة نشطة، مصمم لمهام البرمجة والوكلاء من الدرجة الأولى مع الحفاظ على ذكاء عام قوي. مع 10 مليارات معلمة نشطة فقط، ينافس النماذج الأكبر بكثير، مما يجعله مثاليًا للتطبيقات عالية الكفاءة.",
   "Moonshot-Kimi-K2-Instruct.description": "يحتوي على 1 تريليون معامل إجماليًا و32 مليار مفعّلة. من بين النماذج غير المفكرة، يتصدر في المعرفة المتقدمة، الرياضيات، والبرمجة، وأقوى في مهام الوكلاء العامة. محسن لأعباء عمل الوكلاء، يمكنه اتخاذ إجراءات وليس فقط الإجابة على الأسئلة. الأفضل للمحادثات العامة الارتجالية وتجارب الوكلاء كنموذج يعمل بردود فعل دون تفكير طويل.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46.7B) هو نموذج تعليمات عالي الدقة للحسابات المعقدة.",
   "OmniConsistency.description": "تحسّن OmniConsistency التناسق الأسلوبي والتعميم في مهام تحويل الصور إلى صور من خلال إدخال محولات الانتشار واسعة النطاق (DiTs) وبيانات مزدوجة النمط، مما يمنع تدهور الأسلوب.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "إصدار محدث من نموذج Phi-3-mini.",
   "Phi-3.5-vision-instrust.description": "إصدار محدث من نموذج Phi-3-vision.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 هو نموذج لغوي مفتوح المصدر ومتقدم، مُحسَّن لقدرات الوكلاء، ويتفوق في البرمجة، واستخدام الأدوات، واتباع التعليمات، والتخطيط طويل الأمد. يدعم النموذج تطوير البرمجيات متعددة اللغات وتنفيذ سير العمل المعقد متعدد الخطوات، وحقق نتيجة 74.0 على SWE-bench Verified، متفوقًا على Claude Sonnet 4.5 في السيناريوهات متعددة اللغات.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 هو أحدث نموذج لغة كبير تم تطويره بواسطة MiniMax، تم تدريبه من خلال التعلم المعزز واسع النطاق عبر مئات الآلاف من البيئات الواقعية المعقدة. يتميز ببنية MoE مع 229 مليار معلمة، ويحقق أداءً رائدًا في الصناعة في مهام مثل البرمجة، استدعاء أدوات الوكلاء، البحث، وسيناريوهات المكتب.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct هو نموذج لغوي كبير (LLM) موجه للتعليمات ضمن سلسلة Qwen2. يستخدم بنية Transformer مع SwiGLU، وانحياز QKV في الانتباه، وانتباه الاستعلامات المجمعة، ويعالج مدخلات كبيرة. يتميز بأداء قوي في فهم اللغة، التوليد، المهام متعددة اللغات، البرمجة، الرياضيات، والاستدلال، متفوقًا على معظم النماذج المفتوحة ومنافسًا للنماذج التجارية. يتفوق على Qwen1.5-7B-Chat في العديد من المعايير.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct هو جزء من أحدث سلسلة نماذج لغوية كبيرة من Alibaba Cloud. يقدم هذا النموذج ذو 7 مليارات معلمة تحسينات ملحوظة في البرمجة والرياضيات، ويدعم أكثر من 29 لغة، ويعزز اتباع التعليمات، وفهم البيانات المنظمة، وإنتاج المخرجات المنظمة (خصوصًا JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct هو أحدث نموذج لغوي كبير من Alibaba Cloud يركز على البرمجة. مبني على Qwen2.5 ومدرب على 5.5 تريليون رمز، يعزز بشكل كبير توليد الشيفرة، الاستدلال، والإصلاح، مع الحفاظ على القوة في الرياضيات والقدرات العامة، مما يوفر أساسًا قويًا لوكلاء البرمجة.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL هو نموذج رؤية-لغة جديد من Qwen يتمتع بفهم بصري قوي. يحلل النصوص، الرسوم البيانية، والتخطيطات في الصور، ويفهم مقاطع الفيديو الطويلة والأحداث، ويدعم الاستدلال واستخدام الأدوات، وتحديد الكائنات عبر تنسيقات متعددة، وإنتاج مخرجات منظمة. يعزز فهم الفيديو من خلال تحسينات في الدقة الديناميكية ومعدل الإطارات، ويزيد من كفاءة مشفر الرؤية.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking هو نموذج رؤية-لغة مفتوح المصدر من Zhipu AI ومختبر KEG في جامعة تسينغهوا، مصمم للإدراك متعدد الوسائط المعقد. مبني على GLM-4-9B-0414، ويضيف استدلال سلسلة الأفكار والتعلم المعزز (RL) لتحسين الاستدلال عبر الوسائط والاستقرار بشكل كبير.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat هو النموذج المفتوح المصدر من سلسلة GLM-4 من Zhipu AI. يتميز بأداء قوي في الدلالات، الرياضيات، الاستدلال، البرمجة، والمعرفة. بالإضافة إلى المحادثة متعددة الأدوار، يدعم تصفح الويب، تنفيذ الشيفرة، استدعاء الأدوات المخصصة، والاستدلال على النصوص الطويلة. يدعم 26 لغة (بما في ذلك الصينية، الإنجليزية، اليابانية، الكورية، والألمانية). يحقق نتائج جيدة في AlignBench-v2، MT-Bench، MMLU، وC-Eval، ويدعم سياقًا يصل إلى 128 ألف رمز للاستخدام الأكاديمي والتجاري.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B مستخلص من Qwen2.5-Math-7B ومُحسن على 800 ألف عينة مختارة من DeepSeek-R1. يقدم أداءً قويًا، بنسبة 92.8% على MATH-500، و55.5% على AIME 2024، وتصنيف 1189 على CodeForces لنموذج 7B.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 هو نموذج استدلال مدفوع بالتعلم المعزز يقلل التكرار ويحسن قابلية القراءة. يستخدم بيانات بداية باردة قبل التعلم المعزز لتعزيز الاستدلال، ويضاهي OpenAI-o1 في مهام الرياضيات، البرمجة، والاستدلال، ويحقق نتائج أفضل من خلال تدريب دقيق.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus هو إصدار محدث من نموذج V3.1، مصمم كنموذج وكيل هجين. يعالج المشكلات التي أبلغ عنها المستخدمون، ويحسن الاستقرار، وتناسق اللغة، ويقلل من الخلط بين الصينية/الإنجليزية والرموز غير الطبيعية. يدمج أوضاع التفكير وغير التفكير مع قوالب محادثة للتبديل المرن. كما يعزز أداء وكلاء الشيفرة والبحث لاستخدام أدوات أكثر موثوقية ومهام متعددة الخطوات.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 هو نموذج يجمع بين الكفاءة الحسابية العالية وأداء التفكير والوكيل الممتاز. يعتمد نهجه على ثلاثة اختراقات تكنولوجية رئيسية: DeepSeek Sparse Attention (DSA)، وهي آلية انتباه فعالة تقلل بشكل كبير من التعقيد الحسابي مع الحفاظ على أداء النموذج، ومُحسنة خصيصًا للسيناريوهات ذات السياق الطويل؛ إطار عمل للتعلم المعزز القابل للتوسع يمكن من خلاله أن ينافس أداء النموذج GPT-5، مع نسخته عالية الحوسبة التي تضاهي Gemini-3.0-Pro في قدرات التفكير؛ وخط أنابيب واسع النطاق لتوليف مهام الوكيل يهدف إلى دمج قدرات التفكير في سيناريوهات استخدام الأدوات، مما يحسن اتباع التعليمات والتعميم في البيئات التفاعلية المعقدة. حقق النموذج أداءً متميزًا في الأولمبياد الدولي للرياضيات (IMO) وأولمبياد المعلوماتية الدولي (IOI) لعام 2025.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 هو أحدث وأقوى إصدار من Kimi K2. إنه نموذج MoE من الدرجة الأولى يحتوي على إجمالي 1 تريليون و32 مليار معلمة نشطة. من أبرز ميزاته الذكاء البرمجي القوي مع تحسينات كبيرة في المعايير ومهام الوكلاء الواقعية، بالإضافة إلى تحسينات في جمالية واجهة الشيفرة وسهولة الاستخدام.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo هو إصدار Turbo محسّن لسرعة الاستدلال والإنتاجية مع الحفاظ على قدرات التفكير متعدد الخطوات واستخدام الأدوات في K2 Thinking. إنه نموذج MoE يحتوي على حوالي 1 تريليون معلمة إجمالية، ويدعم سياقًا أصليًا بطول 256 ألف رمز، واستدعاء أدوات واسع النطاق ومستقر لسيناريوهات الإنتاج التي تتطلب زمن استجابة وتزامنًا صارمين.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 هو نموذج وكيل متعدد الوسائط مفتوح المصدر، مبني على Kimi-K2-Base، ومدرب على حوالي 1.5 تريليون رمز من النصوص والرؤية. يستخدم بنية MoE بعدد إجمالي 1 تريليون مع 32 مليار معلمات نشطة، ويدعم نافذة سياق تصل إلى 256 ألف، مما يدمج الفهم البصري واللغوي بسلاسة.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 هو النموذج الرائد الجديد من Zhipu مع 355 مليار معلمة إجمالية و32 مليار معلمة نشطة، تم ترقيته بالكامل في الحوار العام، المنطق، وقدرات الوكلاء. يعزز GLM-4.7 التفكير المتداخل ويقدم التفكير المحفوظ والتفكير على مستوى الدور.",
   "Pro/zai-org/glm-5.description": "GLM-5 هو نموذج اللغة الكبير من الجيل التالي من Zhipu، يركز على هندسة الأنظمة المعقدة ومهام الوكيل طويلة المدة. تم توسيع معلمات النموذج إلى 744 مليار (40 مليار نشطة) وتدمج DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ هو نموذج بحث تجريبي يركز على تحسين الاستدلال.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview هو نموذج بحثي من Qwen يركز على الاستدلال البصري، مع قوة في فهم المشاهد المعقدة ومسائل الرياضيات البصرية.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ هو نموذج بحث تجريبي يركز على تحسين استدلال الذكاء الاصطناعي.",
   "Qwen/QwQ-32B.description": "QwQ هو نموذج استدلال ضمن عائلة Qwen. مقارنة بالنماذج التقليدية الموجهة للتعليمات، يضيف QwQ قدرات تفكير واستدلال تعزز الأداء بشكل كبير في المهام الصعبة. QwQ-32B هو نموذج استدلال متوسط الحجم ينافس نماذج استدلال رائدة مثل DeepSeek-R1 وo1-mini. يستخدم RoPE، SwiGLU، RMSNorm، وانحياز QKV في الانتباه، مع 64 طبقة و40 رأس انتباه (8 KV في GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 هو أحدث إصدار لتحرير الصور من فريق Qwen. مبني على نموذج Qwen-Image بحجم 20 مليار معلمة، ويمتد من قدرات عرض النصوص القوية إلى تحرير الصور بدقة. يستخدم بنية تحكم مزدوجة، حيث تُرسل المدخلات إلى Qwen2.5-VL للتحكم الدلالي وإلى مشفر VAE للتحكم في المظهر، مما يتيح تحريرًا على مستوى الدلالة والمظهر. يدعم التعديلات المحلية (إضافة/إزالة/تعديل) والتعديلات الدلالية المتقدمة مثل إنشاء الملكية الفكرية ونقل الأسلوب مع الحفاظ على المعنى. يحقق نتائج رائدة في العديد من المعايير.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "الجيل الثاني من نموذج Skylark. يوفر Skylark2-pro-turbo-8k استدلالًا أسرع بتكلفة أقل مع نافذة سياق تصل إلى 8 آلاف رمز.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 هو نموذج GLM من الجيل التالي يحتوي على 32 مليار معامل، ويقارن في الأداء مع نماذج OpenAI GPT وسلسلة DeepSeek V3/R1.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 هو نموذج GLM يحتوي على 9 مليارات معامل، ويعتمد على تقنيات GLM-4-32B مع إمكانية نشر أخف. يتميز في توليد الشيفرات، وتصميم الويب، وتوليد SVG، والكتابة المعتمدة على البحث.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking هو نموذج مفتوح المصدر من Zhipu AI ومختبر Tsinghua KEG، مصمم للإدراك متعدد الوسائط المعقد. يعتمد على GLM-4-9B-0414، ويضيف التفكير المتسلسل والتعلم المعزز لتحسين الاستدلال عبر الوسائط والثبات بشكل كبير.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 هو نموذج استدلال عميق مبني على GLM-4-32B-0414 باستخدام بيانات بدء باردة وتوسيع التعلم المعزز، وتم تدريبه بشكل إضافي على الرياضيات والبرمجة والمنطق. يُظهر تحسنًا كبيرًا في القدرة على حل المسائل الرياضية والمهام المعقدة مقارنة بالنموذج الأساسي.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 هو نموذج GLM صغير يحتوي على 9 مليارات معامل، يحتفظ بقوة المصدر المفتوح ويقدم أداءً مميزًا. يتميز في الاستدلال الرياضي والمهام العامة، ويتفوق على النماذج المفتوحة من نفس الفئة الحجمية.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat هو النموذج مفتوح المصدر من Zhipu AI ضمن سلسلة GLM-4. يتميز بقوة في الفهم الدلالي، والرياضيات، والاستدلال، والبرمجة، والمعرفة. بالإضافة إلى الدردشة متعددة الأدوار، يدعم تصفح الويب، وتنفيذ الشيفرات، واستدعاء الأدوات المخصصة، والاستدلال على النصوص الطويلة. يدعم 26 لغة (بما في ذلك الصينية، والإنجليزية، واليابانية، والكورية، والألمانية). يحقق أداءً جيدًا في AlignBench-v2 وMT-Bench وMMLU وC-Eval، ويدعم نافذة سياق تصل إلى 128 ألف رمز للاستخدام الأكاديمي والتجاري.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B هو أول نموذج استدلال طويل السياق (LRM) تم تدريبه باستخدام التعلم المعزز، مُحسن للاستدلال النصي الطويل. يتيح التوسع التدريجي للسياق عبر التعلم المعزز انتقالًا مستقرًا من السياق القصير إلى الطويل. يتفوق على OpenAI-o3-mini وQwen3-235B-A22B في سبعة معايير استدلال وثائق طويلة السياق، منافسًا Claude-3.7-Sonnet-Thinking. يتميز بقوة خاصة في الرياضيات، المنطق، والاستدلال متعدد الخطوات.",
   "Yi-34B-Chat.description": "Yi-1.5-34B يحتفظ بقدرات اللغة العامة القوية للسلسلة، ويستخدم تدريبًا تدريجيًا على 500 مليار رمز عالي الجودة لتحسين كبير في المنطق الرياضي والبرمجة.",
   "abab5.5-chat.description": "مصمم لسيناريوهات الإنتاجية، مع قدرة على التعامل مع المهام المعقدة وتوليد نصوص فعالة للاستخدام المهني.",
   "abab5.5s-chat.description": "مصمم للدردشة بشخصيات صينية، ويقدم حوارات صينية عالية الجودة لمجموعة متنوعة من التطبيقات.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "يتميز Claude 3.5 Sonnet بقدرات عالية في البرمجة والكتابة والتفكير المعقد.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet مزود بقدرات تفكير موسعة للمهام التي تتطلب استدلالًا معقدًا.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet هو إصدار مطور يتمتع بسياق موسع وقدرات محسّنة.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 هو النموذج الأسرع والأكثر ذكاءً من Anthropic، مع سرعة فائقة وتفكير ممتد.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 نموذج سريع وفعّال لمجموعة متنوعة من المهام.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking هو إصدار متقدم يمكنه عرض عملية تفكيره.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 هو أحدث وأقوى نموذج من Anthropic للمهام المعقدة للغاية، يتميز بالأداء، الذكاء، الطلاقة، والفهم.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 هو النموذج الأكثر قوة من Anthropic للمهام المعقدة للغاية، يتميز بالأداء، الذكاء، الطلاقة، والفهم.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 هو النموذج الرائد من Anthropic، يجمع بين الذكاء الاستثنائي والأداء القابل للتوسع، مثالي للمهام المعقدة التي تتطلب استجابات عالية الجودة وتفكير متقدم.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 هو النموذج الأكثر ذكاءً من Anthropic لبناء الوكلاء والبرمجة.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking يمكنه تقديم استجابات شبه فورية أو تفكير متسلسل مرئي.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 هو النموذج الأكثر ذكاءً من Anthropic حتى الآن، يقدم استجابات شبه فورية أو تفكيرًا ممتدًا خطوة بخطوة مع تحكم دقيق لمستخدمي API.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 هو النموذج الأكثر ذكاءً من Anthropic حتى الآن.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 هو أفضل مزيج من السرعة والذكاء من Anthropic.",
   "claude-sonnet-4.description": "Claude Sonnet 4 هو الجيل الأحدث مع أداء محسّن في جميع المهام.",
   "codegeex-4.description": "CodeGeeX-4 هو مساعد برمجة ذكي يدعم الأسئلة والأجوبة متعددة اللغات وإكمال الشيفرة لزيادة إنتاجية المطورين.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B هو نموذج توليد شيفرة متعدد اللغات يدعم الإكمال والتوليد، تفسير الشيفرة، البحث عبر الإنترنت، استدعاء الوظائف، وأسئلة وأجوبة على مستوى المستودع، ويغطي مجموعة واسعة من سيناريوهات تطوير البرمجيات. يُعد من أفضل نماذج الشيفرة تحت 10B.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "تستخدم نماذج DeepSeek-R1 المستخلصة التعلم المعزز وبيانات البداية الباردة لتحسين التفكير وتحديد معايير جديدة للنماذج المفتوحة متعددة المهام.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "تستخدم نماذج DeepSeek-R1 المستخلصة التعلم المعزز وبيانات البداية الباردة لتحسين التفكير وتحديد معايير جديدة للنماذج المفتوحة متعددة المهام.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "تم استخلاص DeepSeek-R1-Distill-Qwen-32B من Qwen2.5-32B وتم تحسينه باستخدام 800 ألف عينة مختارة من DeepSeek-R1. يتميز في الرياضيات، والبرمجة، والتفكير، ويحقق نتائج قوية في AIME 2024، وMATH-500 (بدقة 94.3٪)، وGPQA Diamond.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B مستخلص من Qwen2.5-Math-7B ومُحسن على 800 ألف عينة مختارة من DeepSeek-R1. يقدم أداءً قويًا، بنسبة 92.8% على MATH-500، و55.5% على AIME 2024، وتصنيف 1189 على CodeForces لنموذج 7B.",
   "deepseek-ai/DeepSeek-R1.description": "يعزز DeepSeek-R1 قدرات التفكير باستخدام التعلم المعزز وبيانات البداية الباردة، ويحدد معايير جديدة للنماذج المفتوحة متعددة المهام متفوقًا على OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "يعمل DeepSeek-V2.5 على ترقية DeepSeek-V2-Chat وDeepSeek-Coder-V2-Instruct، ويمزج بين القدرات العامة والبرمجية. يحسن الكتابة واتباع التعليمات لمواءمة التفضيلات بشكل أفضل، ويظهر تحسنًا ملحوظًا في AlpacaEval 2.0 وArenaHard وAlignBench وMT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus هو إصدار محدث من V3.1 كنموذج وكيل هجين. يعالج المشكلات التي أبلغ عنها المستخدمون ويحسن الاستقرار واتساق اللغة ويقلل من الخلط بين الصينية/الإنجليزية والرموز غير الطبيعية. يدمج أوضاع التفكير وغير التفكير مع قوالب المحادثة للتبديل المرن. كما يعزز أداء وكلاء الكود والبحث لاستخدام الأدوات بشكل أكثر موثوقية وتنفيذ المهام متعددة الخطوات.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 هو نموذج تفكير من الجيل التالي يتمتع بقدرات أقوى في التفكير المعقد وسلسلة التفكير لمهام التحليل العميق.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 هو نموذج استدلال من الجيل التالي يتميز بقدرات استدلال معقدة وسلسلة التفكير.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 هو نموذج رؤية-لغة MoE يعتمد على DeepSeekMoE-27B مع تنشيط متفرق، ويحقق أداءً قويًا باستخدام 4.5 مليار معلمة نشطة فقط. يتميز في الأسئلة البصرية، وOCR، وفهم المستندات/الجداول/المخططات، والتأريض البصري.",
+  "deepseek-chat.description": "DeepSeek V3.2 يوازن بين التفكير وطول المخرجات لمهام الأسئلة اليومية والوكلاء. تصل المعايير العامة إلى مستويات GPT-5، وهو الأول الذي يدمج التفكير في استخدام الأدوات، مما يؤدي إلى تقييمات الوكلاء مفتوحة المصدر.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B هو نموذج لغة برمجية تم تدريبه على 2 تريليون رمز (87٪ كود، 13٪ نص صيني/إنجليزي). يقدم نافذة سياق 16K ومهام الإكمال في المنتصف، ويوفر إكمال كود على مستوى المشاريع وملء مقاطع الكود.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 هو نموذج كود MoE مفتوح المصدر يتميز بأداء قوي في مهام البرمجة، ويضاهي GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 هو نموذج كود MoE مفتوح المصدر يتميز بأداء قوي في مهام البرمجة، ويضاهي GPT-4 Turbo.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "الإصدار الكامل السريع من DeepSeek R1 مع بحث ويب في الوقت الحقيقي، يجمع بين قدرات بحجم 671B واستجابة أسرع.",
   "deepseek-r1-online.description": "الإصدار الكامل من DeepSeek R1 مع 671 مليار معلمة وبحث ويب في الوقت الحقيقي، يوفر فهمًا وتوليدًا أقوى.",
   "deepseek-r1.description": "يستخدم DeepSeek-R1 بيانات البداية الباردة قبل التعلم المعزز ويؤدي أداءً مماثلًا لـ OpenAI-o1 في الرياضيات، والبرمجة، والتفكير.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking هو نموذج استدلال عميق يولد سلسلة من الأفكار قبل المخرجات لتحقيق دقة أعلى، مع نتائج تنافسية رائدة واستدلال قابل للمقارنة مع Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 هو نموذج MoE فعال لمعالجة منخفضة التكلفة.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B هو نموذج DeepSeek الموجه للبرمجة مع قدرات قوية في توليد الكود.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 هو نموذج MoE يحتوي على 671 مليار معلمة يتميز بقوة في البرمجة، والقدرات التقنية، وفهم السياق، والتعامل مع النصوص الطويلة.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp يقدم انتباهاً متفرقاً لتحسين كفاءة التدريب والاستدلال على النصوص الطويلة، بسعر أقل من deepseek-v3.1.",
   "deepseek-v3.2-speciale.description": "في المهام شديدة التعقيد، يتفوق نموذج Speciale بشكل كبير على النسخة القياسية، ولكنه يستهلك عددًا كبيرًا من الرموز ويتكبد تكاليف أعلى. حاليًا، يتم استخدام DeepSeek-V3.2-Speciale للأبحاث فقط، ولا يدعم استدعاء الأدوات، ولم يتم تحسينه بشكل خاص للمحادثات اليومية أو مهام الكتابة.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think هو نموذج تفكير عميق كامل يتميز باستدلال طويل السلسلة أقوى.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 هو أحدث نموذج برمجة من DeepSeek مع قدرات استدلال قوية.",
   "deepseek-v3.description": "DeepSeek-V3 هو نموذج MoE قوي بإجمالي 671 مليار معلمة و37 مليار معلمة نشطة لكل رمز.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small هو إصدار متعدد الوسائط خفيف الوزن للاستخدام في البيئات ذات الموارد المحدودة أو التزامن العالي.",
   "deepseek-vl2.description": "DeepSeek VL2 هو نموذج متعدد الوسائط لفهم النصوص والصور والإجابة البصرية الدقيقة.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K هو نموذج تفكير سريع بسياق 32K للاستدلال المعقد والدردشة متعددة الأدوار.",
   "ernie-x1.1-preview.description": "معاينة ERNIE X1.1 هو نموذج تفكير مخصص للتقييم والاختبار.",
   "ernie-x1.1.description": "ERNIE X1.1 هو نموذج تفكير تجريبي للتقييم والاختبار.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5، تم تطويره بواسطة فريق ByteDance Seed، يدعم تحرير وتكوين الصور المتعددة. يتميز باتساق الموضوع المعزز، اتباع التعليمات بدقة، فهم المنطق المكاني، التعبير الجمالي، تخطيط الملصقات وتصميم الشعارات مع تقديم نصوص وصور عالية الدقة.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0، تم تطويره بواسطة ByteDance Seed، يدعم إدخال النصوص والصور لتوليد صور عالية الجودة وقابلة للتحكم من المطالبات.",
   "fal-ai/flux-kontext/dev.description": "نموذج FLUX.1 يركز على تحرير الصور، ويدعم إدخال النصوص والصور.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] يقبل النصوص وصور مرجعية كمدخلات، مما يتيح تعديلات محلية مستهدفة وتحولات معقدة في المشهد العام.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] هو نموذج لتوليد الصور يتميز بميول جمالية نحو صور أكثر واقعية وطبيعية.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "نموذج قوي لتوليد الصور متعدد الوسائط أصلي.",
   "fal-ai/imagen4/preview.description": "نموذج عالي الجودة لتوليد الصور من Google.",
   "fal-ai/nano-banana.description": "Nano Banana هو أحدث وأسرع وأكثر نماذج Google كفاءةً لتوليد وتحرير الصور من خلال المحادثة.",
+  "fal-ai/qwen-image-edit.description": "نموذج تحرير الصور الاحترافي من فريق Qwen، يدعم التعديلات الدلالية والمظهرية، تحرير النصوص الدقيقة باللغتين الصينية والإنجليزية، نقل الأنماط، التدوير، والمزيد.",
+  "fal-ai/qwen-image.description": "نموذج توليد الصور القوي من فريق Qwen مع تقديم نصوص صينية قوية وأنماط بصرية متنوعة.",
   "flux-1-schnell.description": "نموذج تحويل النص إلى صورة يحتوي على 12 مليار معلمة من Black Forest Labs يستخدم تقنيات تقطير الانتشار العدائي الكامن لتوليد صور عالية الجودة في 1-4 خطوات. ينافس البدائل المغلقة ومتاح بموجب ترخيص Apache-2.0 للاستخدام الشخصي والبحثي والتجاري.",
   "flux-dev.description": "FLUX.1 [dev] هو نموذج مفتوح الأوزان ومقطر للاستخدام غير التجاري. يحافظ على جودة صور قريبة من المستوى الاحترافي واتباع التعليمات مع كفاءة تشغيل أعلى مقارنة بالنماذج القياسية من نفس الحجم.",
   "flux-kontext-max.description": "توليد وتحرير صور سياقية متقدمة، تجمع بين النصوص والصور لتحقيق نتائج دقيقة ومتسقة.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro هو النموذج الرائد من Google في مجال الاستدلال، يدعم السياق الطويل للمهام المعقدة.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash هو أذكى نموذج تم تصميمه للسرعة، يجمع بين الذكاء المتقدم وأساس بحث ممتاز.",
   "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-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) يقدم جودة صور احترافية بسرعة فائقة مع دعم الدردشة متعددة الوسائط.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) يقدم جودة صور بمستوى Pro بسرعة Flash مع دعم الدردشة متعددة الوسائط.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview هو النموذج الأكثر كفاءة من حيث التكلفة من Google، مُحسّن للمهام الوكيلة ذات الحجم الكبير، الترجمة، ومعالجة البيانات.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview يحسن من Gemini 3 Pro مع قدرات استدلال محسّنة ويضيف دعم مستوى التفكير المتوسط.",
   "gemini-flash-latest.description": "أحدث إصدار من Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "إصدار K2 عالي السرعة للتفكير الطويل مع نافذة سياق 256k، استدلال عميق قوي، وإخراج 60–100 رمز/ثانية.",
   "kimi-k2-thinking.description": "kimi-k2-thinking هو نموذج تفكير من Moonshot AI يتمتع بقدرات عامة في الوكالة والاستدلال. يتفوق في الاستدلال العميق ويمكنه حل المشكلات الصعبة باستخدام أدوات متعددة الخطوات.",
   "kimi-k2-turbo-preview.description": "kimi-k2 هو نموذج MoE أساسي يتمتع بقدرات قوية في البرمجة والوكالة (1 تريليون معلمة إجمالية، 32 مليار نشطة)، ويتفوق على النماذج المفتوحة السائدة في اختبارات الاستدلال، البرمجة، الرياضيات، والوكالة.",
+  "kimi-k2.5.description": "Kimi K2.5 هو النموذج الأكثر تنوعًا من Kimi حتى الآن، يتميز ببنية متعددة الوسائط تدعم المدخلات البصرية والنصية، أوضاع \"التفكير\" و\"غير التفكير\"، ومهام المحادثة والوكلاء.",
   "kimi-k2.description": "Kimi-K2 هو نموذج MoE أساسي من Moonshot AI يتمتع بقدرات قوية في البرمجة والوكالة، بإجمالي 1 تريليون معلمة و32 مليار نشطة. يتفوق على النماذج المفتوحة السائدة في اختبارات الاستدلال العام، البرمجة، الرياضيات، ومهام الوكالة.",
   "kimi-k2:1t.description": "Kimi K2 هو نموذج LLM كبير من نوع MoE من Moonshot AI بإجمالي 1 تريليون معلمة و32 مليار نشطة لكل تمرير أمامي. مُحسّن لقدرات الوكالة بما في ذلك استخدام الأدوات المتقدمة، الاستدلال، وتوليد الشيفرة.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (مجاني لفترة محدودة) يركز على فهم الشيفرة والأتمتة لوكلاء البرمجة الفعالة.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K يدعم 32,768 رمزًا لسياق متوسط الطول، وهو مثالي للوثائق الطويلة والحوارات المعقدة في إنشاء المحتوى، والتقارير، وأنظمة الدردشة.",
   "moonshot-v1-8k-vision-preview.description": "نماذج Kimi للرؤية (بما في ذلك moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) قادرة على فهم محتوى الصور مثل النصوص، الألوان، وأشكال الكائنات.",
   "moonshot-v1-8k.description": "Moonshot V1 8K مُحسّن لتوليد النصوص القصيرة بكفاءة عالية، حيث يتعامل مع 8,192 رمزًا للمحادثات القصيرة، والملاحظات، والمحتوى السريع.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B هو نموذج برمجة مفتوح المصدر مُحسن باستخدام التعلم المعزز واسع النطاق لإنتاج تصحيحات قوية وجاهزة للإنتاج. يسجل 60.4% على SWE-bench Verified، محققًا رقمًا قياسيًا جديدًا للنماذج المفتوحة في مهام هندسة البرمجيات الآلية مثل إصلاح الأخطاء ومراجعة الكود.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 هو أحدث وأقوى إصدار من Kimi K2. إنه نموذج MoE من الدرجة الأولى يحتوي على تريليون معلمة إجمالية و32 مليار معلمة نشطة. من أبرز ميزاته الذكاء البرمجي القوي، وتحسينات كبيرة في اختبارات الأداء والمهام الواقعية، بالإضافة إلى تحسينات في جمالية واجهات الاستخدام وسهولة البرمجة الأمامية.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking هو أحدث وأقوى نموذج تفكير مفتوح المصدر. يوسع بشكل كبير عمق التفكير متعدد الخطوات ويحافظ على استخدام الأدوات المستقر عبر 200-300 استدعاء متتالي، محققًا أرقامًا قياسية جديدة في Humanity's Last Exam (HLE)، BrowseComp، ومعايير أخرى. يتفوق في البرمجة، الرياضيات، المنطق، وسيناريوهات الوكيل. يعتمد على بنية MoE مع ~1 تريليون معلمة إجمالية، ويدعم نافذة سياق 256K واستدعاء الأدوات.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 هو إصدار موجه من سلسلة Kimi، مناسب للبرمجة عالية الجودة واستخدام الأدوات.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "الجيل التالي من Qwen coder محسن لتوليد الأكواد المعقدة متعددة الملفات، وتصحيح الأخطاء، وسير العمل عالي الإنتاجية للوكلاء. مصمم لتكامل الأدوات القوي وتحسين أداء الاستدلال.",
   "qwen3-coder-plus.description": "نموذج Qwen للبرمجة. سلسلة Qwen3-Coder الأحدث مبنية على Qwen3 وتوفر قدرات قوية كوكلاء برمجة، واستخدام الأدوات، والتفاعل مع البيئة للبرمجة الذاتية، مع أداء ممتاز في البرمجة وقدرات عامة قوية.",
   "qwen3-coder:480b.description": "نموذج عالي الأداء من Alibaba لمعالجة المهام المتعلقة بالوكلاء والبرمجة مع دعم لسياقات طويلة.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: النموذج الأفضل أداءً من Qwen للمهام البرمجية المعقدة متعددة الخطوات مع دعم التفكير.",
   "qwen3-max-preview.description": "أفضل نموذج Qwen للأداء في المهام المعقدة متعددة الخطوات. المعاينة تدعم التفكير.",
   "qwen3-max.description": "نماذج Qwen3 Max تقدم تحسينات كبيرة مقارنة بسلسلة 2.5 في القدرات العامة، وفهم اللغة الصينية/الإنجليزية، واتباع التعليمات المعقدة، والمهام المفتوحة الذاتية، والقدرات متعددة اللغات، واستخدام الأدوات، مع تقليل الهلوسة. الإصدار الأحدث qwen3-max يعزز البرمجة الوكيلة واستخدام الأدوات مقارنة بـ qwen3-max-preview. هذا الإصدار يحقق أداءً رائداً في المجال ويستهدف احتياجات الوكلاء المعقدة.",
   "qwen3-next-80b-a3b-instruct.description": "نموذج Qwen3 من الجيل التالي مفتوح المصدر غير مخصص للتفكير. مقارنة بالإصدار السابق (Qwen3-235B-A22B-Instruct-2507)، يتميز بفهم أفضل للغة الصينية، واستدلال منطقي أقوى، وتحسين في توليد النصوص.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ هو نموذج استدلال من عائلة Qwen. مقارنة بالنماذج المضبوطة على التعليمات، يقدم قدرات تفكير واستدلال تعزز الأداء بشكل كبير، خاصة في المشكلات الصعبة. QwQ-32B هو نموذج متوسط الحجم ينافس أفضل نماذج الاستدلال مثل DeepSeek-R1 و o1-mini.",
   "qwq_32b.description": "نموذج استدلال متوسط الحجم من عائلة Qwen. مقارنة بالنماذج المضبوطة على التعليمات، تعزز قدرات التفكير والاستدلال في QwQ الأداء بشكل كبير، خاصة في المشكلات الصعبة.",
   "r1-1776.description": "R1-1776 هو إصدار ما بعد التدريب من DeepSeek R1 مصمم لتقديم معلومات واقعية غير خاضعة للرقابة أو التحيز.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro من ByteDance يدعم تحويل النص إلى فيديو، الصورة إلى فيديو (الإطار الأول، الإطار الأول + الأخير)، وتوليد الصوت المتزامن مع المرئيات.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite من BytePlus يتميز بتوليد معزز بالمعلومات المسترجعة من الويب للحصول على معلومات في الوقت الفعلي، تفسير المطالبات المعقدة بشكل محسن، وتحسين اتساق المراجع لإنشاء مرئيات احترافية.",
   "solar-mini-ja.description": "Solar Mini (Ja) يوسع Solar Mini مع تركيز على اللغة اليابانية مع الحفاظ على الأداء القوي والكفاءة في الإنجليزية والكورية.",
   "solar-mini.description": "Solar Mini هو نموذج لغة مدمج يتفوق على GPT-3.5، يتميز بقدرات متعددة اللغات قوية تدعم الإنجليزية والكورية، ويقدم حلاً فعالاً بصمة صغيرة.",
   "solar-pro.description": "Solar Pro هو نموذج لغة عالي الذكاء من Upstage، يركز على اتباع التعليمات باستخدام وحدة معالجة رسومات واحدة، مع درجات IFEval تتجاوز 80. حالياً يدعم اللغة الإنجليزية؛ وكان من المقرر إصدار النسخة الكاملة في نوفمبر 2024 مع دعم لغات موسع وسياق أطول.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "نموذج التفكير اللغوي الرائد من Stepfun. يتميز بقدرات تفكير من الدرجة الأولى وقدرات تنفيذ سريعة وموثوقة. قادر على تحليل وتخطيط المهام المعقدة، واستدعاء الأدوات بسرعة وموثوقية لأداء المهام، والتعامل مع مختلف المهام المعقدة مثل التفكير المنطقي، الرياضيات، هندسة البرمجيات، والبحث المتعمق.",
   "step-3.description": "يتمتع هذا النموذج بإدراك بصري قوي واستدلال معقد، ويتعامل بدقة مع فهم المعرفة عبر المجالات، وتحليل الرياضيات والرؤية، ومجموعة واسعة من مهام التحليل البصري اليومية.",
   "step-r1-v-mini.description": "نموذج استدلال يتمتع بفهم قوي للصور، يمكنه معالجة الصور والنصوص، ثم توليد نص بعد استدلال عميق. يتفوق في الاستدلال البصري ويقدم أداءً رائدًا في الرياضيات والبرمجة والاستدلال النصي، مع نافذة سياق تصل إلى 100 ألف.",
+  "stepfun-ai/step3.description": "Step3 هو نموذج استدلال متعدد الوسائط متقدم من StepFun، يعتمد على بنية MoE مع 321 مليار معلمة إجمالية و38 مليار معلمة نشطة. تصميمه الشامل يقلل من تكلفة فك التشفير مع تقديم استدلال رؤية-لغة من الدرجة الأولى. مع تصميم MFA وAFD، يظل فعالًا على كل من المسرعات الرائدة والمنخفضة. يستخدم التدريب المسبق أكثر من 20 تريليون رمز نصي و4 تريليون رمز نصي-صوري عبر العديد من اللغات. يحقق أداءً رائدًا للنماذج المفتوحة في الرياضيات، البرمجة، ومعايير متعددة الوسائط.",
   "taichu4_vl_2b_nothinking.description": "الإصدار بدون التفكير من نموذج Taichu4.0-VL 2B يتميز باستخدام ذاكرة أقل، تصميم خفيف الوزن، سرعة استجابة سريعة، وقدرات فهم متعددة الوسائط قوية.",
   "taichu4_vl_32b.description": "الإصدار التفكير من نموذج Taichu4.0-VL 32B مناسب لمهام الفهم والاستدلال متعددة الوسائط المعقدة، ويظهر أداءً رائعًا في الاستدلال الرياضي متعدد الوسائط، قدرات الوكيل متعدد الوسائط، والفهم العام للصور والبصريات.",
   "taichu4_vl_32b_nothinking.description": "الإصدار بدون التفكير من نموذج Taichu4.0-VL 32B مصمم لفهم النصوص والصور المعقدة وسيناريوهات الإجابة على الأسئلة المعرفية البصرية، ويتفوق في وصف الصور، الإجابة على الأسئلة البصرية، فهم الفيديو، ومهام تحديد المواقع البصرية.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air هو نموذج أساسي لتطبيقات الوكلاء يستخدم بنية Mixture-of-Experts. مُحسّن لاستخدام الأدوات، وتصفح الويب، والهندسة البرمجية، وبرمجة الواجهات، ويتكامل مع وكلاء البرمجة مثل Claude Code وRoo Code. يستخدم استدلالًا هجينًا للتعامل مع السيناريوهات المعقدة واليومية.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V هو أحدث نموذج رؤية من Zhipu AI، مبني على نموذج النص الرائد GLM-4.5-Air (إجمالي 106 مليار، 12 مليار نشط) باستخدام بنية MoE لأداء قوي بتكلفة أقل. يتبع مسار GLM-4.1V-Thinking ويضيف 3D-RoPE لتحسين الاستدلال المكاني ثلاثي الأبعاد. مُحسّن من خلال التدريب المسبق، والتعلم الخاضع للإشراف، والتعلم المعزز، ويتعامل مع الصور، والفيديو، والمستندات الطويلة، ويتصدر النماذج المفتوحة في 41 معيارًا متعدد الوسائط. يتيح وضع التفكير للمستخدمين التوازن بين السرعة والعمق.",
   "zai-org/GLM-4.6.description": "مقارنة بـ GLM-4.5، يوسّع GLM-4.6 السياق من 128 ألف إلى 200 ألف لمهام الوكلاء المعقدة. يحقق نتائج أعلى في اختبارات البرمجة ويُظهر أداءً أقوى في التطبيقات الواقعية مثل Claude Code وCline وRoo Code وKilo Code، بما في ذلك توليد صفحات الواجهة الأمامية بشكل أفضل. تم تحسين الاستدلال ودعم استخدام الأدوات أثناء التفكير، مما يعزز القدرات العامة. يتكامل بشكل أفضل مع أطر الوكلاء، ويحسّن وكلاء الأدوات/البحث، ويتميز بأسلوب كتابة مفضل بشريًا وطبيعية في تقمص الأدوار.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V يحقق دقة فهم بصري رائدة بالنسبة لحجم معلماته وهو الأول الذي يدمج قدرات استدعاء الوظائف بشكل طبيعي في بنية نموذج الرؤية، مما يجسر الفجوة بين \"الإدراك البصري\" و\"الإجراءات القابلة للتنفيذ\" ويوفر أساسًا تقنيًا موحدًا للوكلاء متعدد الوسائط في سيناريوهات الأعمال الواقعية. يتم تمديد نافذة السياق البصري إلى 128 ألف، مما يدعم معالجة تدفقات الفيديو الطويلة وتحليل الصور المتعددة عالية الدقة.",
   "zai/glm-4.5-air.description": "GLM-4.5 وGLM-4.5-Air هما أحدث النماذج الرائدة لدينا لتطبيقات الوكلاء، وكلاهما يستخدم بنية MoE. يحتوي GLM-4.5 على 355 مليار إجمالي و32 مليار نشط لكل تمرير؛ بينما GLM-4.5-Air أنحف بإجمالي 106 مليار و12 مليار نشط.",
   "zai/glm-4.5.description": "سلسلة GLM-4.5 مصممة للوكلاء. النموذج الرائد GLM-4.5 يجمع بين الاستدلال، والبرمجة، ومهارات الوكلاء مع 355 مليار معلمة إجمالية (32 مليار نشطة) ويقدّم أوضاع تشغيل مزدوجة كنظام استدلال هجين.",
   "zai/glm-4.5v.description": "GLM-4.5V مبني على GLM-4.5-Air، ويَرِث تقنيات GLM-4.1V-Thinking المثبتة، ويتوسع ببنية MoE قوية بسعة 106 مليار.",

locales/ar/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "تقدم Azure نماذج ذكاء اصطناعي متقدمة، بما في ذلك سلسلة GPT-3.5 وGPT-4، لمعالجة أنواع بيانات متنوعة ومهام معقدة مع التركيز على الأمان والموثوقية والاستدامة.",
   "azureai.description": "توفر Azure نماذج ذكاء اصطناعي متقدمة، بما في ذلك سلسلة GPT-3.5 وGPT-4، لمعالجة أنواع بيانات متنوعة ومهام معقدة مع التركيز على الأمان والموثوقية والاستدامة.",
   "baichuan.description": "تركز Baichuan AI على النماذج الأساسية ذات الأداء القوي في المعرفة الصينية، ومعالجة السياقات الطويلة، والتوليد الإبداعي. تم تحسين نماذجها (Baichuan 4 وBaichuan 3 Turbo وBaichuan 3 Turbo 128k) لسيناريوهات مختلفة وتقدم قيمة عالية.",
+  "bailiancodingplan.description": "خطة الترميز علي بابليون هي خدمة ذكاء اصطناعي متخصصة توفر الوصول إلى نماذج محسّنة للترميز من Qwen وGLM وKimi وMiniMax عبر نقطة نهاية مخصصة.",
   "bedrock.description": "توفر Amazon Bedrock للمؤسسات نماذج لغوية وبصرية متقدمة، بما في ذلك Anthropic Claude وMeta Llama 3.1، بدءًا من الخيارات الخفيفة إلى عالية الأداء لمهام النصوص والدردشة والصور.",
   "bfl.description": "مختبر أبحاث رائد في مجال الذكاء الاصطناعي المتقدم، يعمل على بناء البنية التحتية البصرية للمستقبل.",
   "cerebras.description": "Cerebras هي منصة استدلال تعتمد على نظام CS-3، تركز على تقديم خدمات نماذج لغوية كبيرة بزمن استجابة منخفض جدًا وسرعة عالية لمهام الوقت الحقيقي مثل توليد الأكواد والمهام التفاعلية.",
@@ -21,6 +22,7 @@
   "giteeai.description": "توفر Gitee AI واجهات برمجة تطبيقات بدون خوادم لخدمات استدلال النماذج اللغوية الكبيرة، جاهزة للاستخدام من قبل المطورين.",
   "github.description": "مع نماذج GitHub، يمكن للمطورين العمل كمهندسي ذكاء اصطناعي باستخدام نماذج رائدة في الصناعة.",
   "githubcopilot.description": "يمكنك الوصول إلى نماذج Claude وGPT وGemini من خلال اشتراكك في GitHub Copilot.",
+  "glmcodingplan.description": "خطة الترميز GLM توفر الوصول إلى نماذج الذكاء الاصطناعي Zhipu بما في ذلك GLM-5 وGLM-4.7 لأداء مهام الترميز عبر اشتراك ثابت الرسوم.",
   "google.description": "عائلة Gemini من Google هي أكثر نماذج الذكاء الاصطناعي تطورًا للأغراض العامة، تم تطويرها بواسطة Google DeepMind للاستخدام متعدد الوسائط عبر النصوص والرموز والصور والصوت والفيديو. يمكن تشغيلها من مراكز البيانات إلى الأجهزة المحمولة بكفاءة عالية وانتشار واسع.",
   "groq.description": "توفر محركات الاستدلال LPU من Groq أداءً متميزًا في المعايير مع سرعة وكفاءة استثنائية، مما يضع معيارًا عاليًا للاستدلال منخفض الكمون في السحابة.",
   "higress.description": "Higress هو بوابة API سحابية أصلية تم تطويرها داخل Alibaba لمعالجة تأثير إعادة تحميل Tengine على الاتصالات طويلة الأمد وسد الفجوات في موازنة تحميل gRPC/Dubbo.",
@@ -29,9 +31,12 @@
   "infiniai.description": "توفر خدمات نماذج لغوية كبيرة عالية الأداء وسهلة الاستخدام وآمنة لمطوري التطبيقات، تغطي كامل دورة العمل من تطوير النموذج إلى نشره في الإنتاج.",
   "internlm.description": "منظمة مفتوحة المصدر تركز على أبحاث النماذج الكبيرة والأدوات، وتوفر منصة فعالة وسهلة الاستخدام تتيح الوصول إلى أحدث النماذج والخوارزميات.",
   "jina.description": "تأسست Jina AI في عام 2020، وهي شركة رائدة في مجال البحث الذكي. تشمل تقنياتها نماذج المتجهات، ومعيدو الترتيب، ونماذج لغوية صغيرة لبناء تطبيقات بحث توليدية ومتعددة الوسائط عالية الجودة.",
+  "kimicodingplan.description": "كود Kimi من Moonshot AI يوفر الوصول إلى نماذج Kimi بما في ذلك K2.5 لأداء مهام الترميز.",
   "lmstudio.description": "LM Studio هو تطبيق سطح مكتب لتطوير وتجربة النماذج اللغوية الكبيرة على جهازك.",
+  "lobehub.description": "LobeHub Cloud يستخدم واجهات برمجية رسمية للوصول إلى نماذج الذكاء الاصطناعي ويقيس الاستخدام عبر أرصدة مرتبطة برموز النماذج.",
   "longcat.description": "LongCat هو سلسلة من نماذج الذكاء الاصطناعي التوليدية الكبيرة التي تم تطويرها بشكل مستقل بواسطة Meituan. تم تصميمه لتعزيز إنتاجية المؤسسة الداخلية وتمكين التطبيقات المبتكرة من خلال بنية حسابية فعالة وقدرات متعددة الوسائط قوية.",
   "minimax.description": "تأسست MiniMax في عام 2021، وتبني نماذج ذكاء اصطناعي متعددة الوسائط للأغراض العامة، بما في ذلك نماذج نصية بمليارات المعلمات، ونماذج صوتية وبصرية، بالإضافة إلى تطبيقات مثل Hailuo AI.",
+  "minimaxcodingplan.description": "خطة الرموز MiniMax توفر الوصول إلى نماذج MiniMax بما في ذلك M2.7 لأداء مهام الترميز عبر اشتراك ثابت الرسوم.",
   "mistral.description": "تقدم Mistral نماذج متقدمة عامة ومتخصصة وبحثية للتفكير المعقد، والمهام متعددة اللغات، وتوليد الأكواد، مع دعم استدعاء الوظائف للتكامل المخصص.",
   "modelscope.description": "ModelScope هي منصة نماذج كخدمة من Alibaba Cloud، تقدم مجموعة واسعة من النماذج وخدمات الاستدلال.",
   "moonshot.description": "تقدم Moonshot، من Moonshot AI (شركة Beijing Moonshot Technology)، نماذج معالجة لغة طبيعية متعددة لحالات استخدام مثل إنشاء المحتوى، والبحث، والتوصيات، والتحليل الطبي، مع دعم قوي للسياقات الطويلة والتوليد المعقد.",
@@ -64,6 +69,7 @@
   "vertexai.description": "عائلة Gemini من Google هي أكثر نماذج الذكاء الاصطناعي تطورًا للأغراض العامة، تم تطويرها بواسطة Google DeepMind للاستخدام متعدد الوسائط عبر النصوص والرموز والصور والصوت والفيديو. يمكن تشغيلها من مراكز البيانات إلى الأجهزة المحمولة، مما يعزز الكفاءة ومرونة النشر.",
   "vllm.description": "vLLM مكتبة سريعة وسهلة الاستخدام لاستدلال وخدمة النماذج اللغوية الكبيرة.",
   "volcengine.description": "توفر منصة نماذج ByteDance وصولًا آمنًا وغنيًا بالميزات وفعالًا من حيث التكلفة إلى النماذج، بالإضافة إلى أدوات شاملة للبيانات، والتخصيص، والاستدلال، والتقييم.",
+  "volcenginecodingplan.description": "خطة الترميز Volcengine من ByteDance توفر الوصول إلى نماذج ترميز متعددة بما في ذلك Doubao-Seed-Code وGLM-4.7 وDeepSeek-V3.2 وKimi-K2.5 عبر اشتراك ثابت الرسوم.",
   "wenxin.description": "منصة متكاملة للمؤسسات لتطوير النماذج الأساسية والتطبيقات الذكية، تقدم أدوات شاملة لسير عمل النماذج التوليدية وتطبيقاتها.",
   "xai.description": "تقوم xAI ببناء ذكاء اصطناعي لتسريع الاكتشاف العلمي، بهدف تعميق فهم البشرية للكون.",
   "xiaomimimo.description": "تقدم Xiaomi MiMo خدمة نموذج محادثة متوافقة مع واجهة برمجة تطبيقات OpenAI. يدعم نموذج mimo-v2-flash التفكير العميق، الإخراج المتدفق، استدعاء الوظائف، نافذة سياق بسعة 256 ألف، وإخراجًا أقصى يصل إلى 128 ألف.",

locales/ar/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "يدعم بطاقات الائتمان / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "يدعم بطاقات الائتمان",
   "plans.btn.soon": "قريبًا",
+  "plans.cancelDowngrade": "إلغاء التخفيض المجدول",
+  "plans.cancelDowngradeSuccess": "تم إلغاء التخفيض المجدول",
   "plans.changePlan": "اختر خطة",
   "plans.cloud.history": "سجل محادثات غير محدود",
   "plans.cloud.sync": "مزامنة سحابية عالمية",
@@ -215,6 +217,7 @@
   "plans.current": "الخطة الحالية",
   "plans.downgradePlan": "خطة التخفيض المستهدفة",
   "plans.downgradeTip": "لقد قمت بالفعل بتغيير الاشتراك. لا يمكنك تنفيذ عمليات أخرى حتى يكتمل التبديل",
+  "plans.downgradeWillCancel": "سيؤدي هذا الإجراء إلى إلغاء تخفيض الخطة المجدول",
   "plans.embeddingStorage.embeddings": "مدخلات",
   "plans.embeddingStorage.title": "تخزين المتجهات",
   "plans.embeddingStorage.tooltip": "تنتج صفحة مستند واحدة (1000-1500 حرف) حوالي إدخال متجه واحد. (تقدير باستخدام OpenAI Embeddings، وقد يختلف حسب النموذج)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "تأكيد الاختيار",
   "plans.payonce.popconfirm": "بعد الدفع لمرة واحدة، يجب الانتظار حتى انتهاء الاشتراك لتغيير الخطة أو دورة الفوترة. يرجى تأكيد اختيارك.",
   "plans.payonce.tooltip": "يتطلب الدفع لمرة واحدة الانتظار حتى انتهاء الاشتراك لتغيير الخطة أو دورة الفوترة",
+  "plans.pendingDowngrade": "تخفيض قيد الانتظار",
   "plans.plan.enterprise.contactSales": "اتصل بالمبيعات",
   "plans.plan.enterprise.title": "الشركات",
   "plans.plan.free.desc": "للمستخدمين الجدد",
@@ -366,6 +370,7 @@
   "summary.title": "ملخص الفوترة",
   "summary.usageThisMonth": "عرض استخدامك هذا الشهر.",
   "summary.viewBillingHistory": "عرض سجل المدفوعات",
+  "switchDowngradeTarget": "تغيير هدف التخفيض",
   "switchPlan": "تبديل الخطة",
   "switchToMonthly.desc": "بعد التبديل، ستبدأ الفوترة الشهرية بعد انتهاء الخطة السنوية الحالية.",
   "switchToMonthly.title": "التبديل إلى الفوترة الشهرية",

locales/bg-BG/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Неуспешна връзка",
   "sync.title": "Статус на синхронизация",
   "sync.unconnected.tip": "Неуспешна връзка със сървъра за сигнализация, не може да се установи P2P комуникация. Моля, проверете мрежата и опитайте отново.",
-  "tab.aiImage": "Изкуство",
   "tab.audio": "Аудио",
   "tab.chat": "Чат",
   "tab.community": "Общност",
@@ -405,6 +404,7 @@
   "tab.eval": "Оценителна лаборатория",
   "tab.files": "Файлове",
   "tab.home": "Начало",
+  "tab.image": "Изображение",
   "tab.knowledgeBase": "Библиотека",
   "tab.marketplace": "Пазар",
   "tab.me": "Аз",

locales/bg-BG/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "За моделите Gemini 3 за генериране на изображения; контролира резолюцията на генерираните изображения.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "За модели Gemini 3.1 Flash Image; контролира резолюцията на генерираните изображения (поддържа 512px).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "За Claude, Qwen3 и подобни; контролира бюджета от токени за разсъждение.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "За GLM-5 и GLM-4.7; контролира бюджета за токени за разсъждение (максимум 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "За серията Qwen3; контролира бюджета за токени за разсъждение (максимум 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "За OpenAI и други модели с логическо мислене; контролира усилието за разсъждение.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "За серията GPT-5+; контролира обемността на изходния текст.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "За някои модели Doubao; позволява на модела да реши дали да мисли задълбочено.",

locales/bg-BG/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev е мултимодален модел за генериране и редактиране на изображения от Black Forest Labs, базиран на архитектура Rectified Flow Transformer с 12B параметъра. Фокусира се върху генериране, реконструкция, подобрение и редакция на изображения според зададен контекст. Комбинира контролираната генерация на дифузионни модели с контекстното моделиране на Transformer, поддържайки висококачествени резултати за задачи като inpainting, outpainting и реконструкция на визуални сцени.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev е мултимодален езиков модел с отворен код (MLLM) от Black Forest Labs, оптимизиран за задачи с изображения и текст, комбиниращ разбиране и генериране на изображения/текст. Изграден върху напреднали LLM модели (като Mistral-7B), използва внимателно проектиран визуален енкодер и многоетапна настройка с инструкции за постигане на мултимодална координация и логическо мислене при сложни задачи.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: Олекотена версия за бързи отговори.",
+  "GLM-4.5.description": "GLM-4.5: Високопроизводителен модел за разсъждения, програмиране и задачи с агенти.",
+  "GLM-4.6.description": "GLM-4.6: Модел от предишно поколение.",
+  "GLM-4.7.description": "GLM-4.7 е най-новият водещ модел на Zhipu, подобрен за сценарии на агентно програмиране с усъвършенствани възможности за кодиране, дългосрочно планиране на задачи и сътрудничество с инструменти.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: Оптимизирана версия на GLM-5 с по-бързо извеждане за задачи по програмиране.",
+  "GLM-5.description": "GLM-5 е водещ модел от следващо поколение на Zhipu, създаден за агентно инженерство. Той осигурява надеждна продуктивност в сложни системни инженерни задачи и дългосрочни агентни задачи. В областта на програмирането и агентните способности GLM-5 постига най-добри резултати сред моделите с отворен код.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) е иновативен модел за разнообразни области и сложни задачи.",
   "HY-Image-V3.0.description": "Мощни възможности за извличане на характеристики от оригиналното изображение и запазване на детайлите, предоставящи по-богата визуална текстура и създаващи високоточни, добре композирани, продукционни визуализации.",
   "HelloMeme.description": "HelloMeme е AI инструмент, който генерира мемета, GIF-ове или кратки видеа от предоставени изображения или движения. Не изисква умения за рисуване или програмиране — само референтно изображение — за създаване на забавно, атрактивно и стилово консистентно съдържание.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "Нов вътрешен модел за разсъждение с 80K верига на мисълта и 1M вход, предлагащ производителност, сравнима с водещите глобални модели.",
   "MiniMax-M2-Stable.description": "Създаден за ефективно програмиране и агентски работни потоци, с по-висока едновременност за търговска употреба.",
   "MiniMax-M2.1-Lightning.description": "Мощни многоезични възможности за програмиране и цялостно подобрено програмистко изживяване. По-бързо и по-ефективно.",
+  "MiniMax-M2.1-highspeed.description": "Мощни многоезични програмни възможности с по-бързо и ефективно извеждане.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 е водеща отворена голяма езикова система от MiniMax, фокусирана върху решаването на сложни реални задачи. Основните ѝ предимства са възможностите за програмиране на множество езици и способността да действа като агент за решаване на сложни задачи.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: Същата производителност, по-бърз и по-агилен (приблизително 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: Същата производителност като M2.5, но с по-бързо извеждане.",
   "MiniMax-M2.5.description": "MiniMax-M2.5 е водещ модел с отворен код от MiniMax, фокусиран върху решаването на сложни реални задачи. Основните му предимства са мултиезиковите програмни възможности и способността да решава сложни задачи като агент.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: Същата производителност като M2.7, но със значително по-бързо извеждане.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: Начало на пътя към рекурсивно самоусъвършенстване, водещи инженерни способности в реалния свят.",
+  "MiniMax-M2.description": "MiniMax M2: Модел от предишно поколение.",
   "MiniMax-Text-01.description": "MiniMax-01 въвежда мащабно линейно внимание отвъд класическите трансформери, с 456B параметри и 45.9B активирани на преминаване. Постига водеща производителност и поддържа до 4M токена контекст (32× GPT-4o, 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 е модел за хибридно внимание с отворени тегла, съдържащ 456 милиарда общи параметри и ~45.9 милиарда активни на токен. Той поддържа контекст от 1 милион токена и използва Flash Attention за намаляване на FLOPs с 75% при генериране на 100K токена спрямо DeepSeek R1. С архитектура MoE плюс CISPO и обучение с хибридно внимание RL, той постига водещи резултати в задачи за дългосрочно разсъждение и реално софтуерно инженерство.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 преосмисля ефективността на агентите. Това е компактен, бърз и икономичен модел MoE с 230 милиарда общи и 10 милиарда активни параметри, създаден за водещи задачи по програмиране и агенти, като същевременно запазва силен общ интелект. Със само 10 милиарда активни параметри, той съперничи на много по-големи модели, което го прави идеален за приложения с висока ефективност.",
   "Moonshot-Kimi-K2-Instruct.description": "1T общи параметри с 32B активни. Сред немислещите модели е водещ в гранични знания, математика и програмиране, и по-силен в общи агентски задачи. Оптимизиран за агентски натоварвания, може да предприема действия, а не само да отговаря на въпроси. Най-подходящ за импровизационен, общ чат и агентски преживявания като модел на рефлексно ниво без дълго мислене.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46.7B) е високоточен модел с инструкции за сложни изчисления.",
   "OmniConsistency.description": "OmniConsistency подобрява стиловата последователност и обобщението при задачи от изображение към изображение чрез въвеждане на мащабни дифузионни трансформери (DiTs) и сдвоени стилизирани данни, избягвайки влошаване на стила.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Актуализирана версия на модела Phi-3-mini.",
   "Phi-3.5-vision-instrust.description": "Актуализирана версия на модела Phi-3-vision.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 е отворен модел с голям езиков капацитет, оптимизиран за агентни способности, с изключителни резултати в програмиране, използване на инструменти, следване на инструкции и дългосрочно планиране. Моделът поддържа многоезична разработка на софтуер и изпълнение на сложни многoетапни работни потоци, постигайки резултат от 74.0 в SWE-bench Verified и надминава Claude Sonnet 4.5 в многоезични сценарии.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 е най-новият голям езиков модел, разработен от MiniMax, обучен чрез мащабно обучение с подсилване в стотици хиляди сложни, реални среди. С архитектура MoE и 229 милиарда параметри, той постига водещи резултати в задачи като програмиране, използване на инструменти от агенти, търсене и офис сценарии.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct е 7B модел с инструкции от серията Qwen2. Използва трансформерна архитектура със SwiGLU, QKV bias и групирано внимание, и обработва големи входове. Постига отлични резултати в езиково разбиране, генериране, многоезични задачи, програмиране, математика и разсъждение, надминавайки повечето отворени модели и конкурирайки се със затворени.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct е част от най-новата серия LLM на Alibaba Cloud. Моделът с 7B параметри носи значителни подобрения в програмирането и математиката, поддържа над 29 езика и подобрява следването на инструкции, разбирането на структурирани данни и генерирането на структурирани изходи (особено JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct е най-новият LLM на Alibaba Cloud, фокусиран върху програмиране. Изграден върху Qwen2.5 и обучен с 5.5T токена, значително подобрява генерирането на код, разсъждението и поправката, като същевременно запазва силни математически и общи способности, осигурявайки стабилна основа за кодови агенти.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL е нов модел за визия и език от серията Qwen с мощно визуално разбиране. Анализира текст, графики и оформления в изображения, разбира дълги видеа и събития, поддържа разсъждение и използване на инструменти, обвързване на обекти във формати, и структурирани изходи. Подобрява динамичната резолюция и обучението с честота на кадрите за видео разбиране и повишава ефективността на визуалния енкодер.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking е отворен VLM модел, разработен от Zhipu AI и лабораторията KEG на университета Цинхуа, създаден за сложна мултимодална когниция. Базиран на GLM-4-9B-0414, той добавя верижно разсъждение (chain-of-thought) и обучение чрез подсилване (RL), което значително подобрява между-модалното разсъждение и стабилността.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat е отворен GLM-4 модел от Zhipu AI. Демонстрира високи резултати в семантика, математика, логическо мислене, програмиране и знания. Освен многозавойни разговори, поддържа уеб сърфиране, изпълнение на код, извикване на персонализирани инструменти и разсъждение върху дълги текстове. Поддържа 26 езика (включително китайски, английски, японски, корейски, немски). Представя се отлично в AlignBench-v2, MT-Bench, MMLU и C-Eval и поддържа до 128K контекст за академични и бизнес приложения.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B е дистилиран от Qwen2.5-Math-7B и фино настроен върху 800K подбрани проби от DeepSeek-R1. Той показва силни резултати: 92.8% на MATH-500, 55.5% на AIME 2024 и рейтинг 1189 на CodeForces за модел с 7 милиарда параметри.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 е модел за разсъждение, базиран на обучение чрез подсилване (RL), който намалява повторенията и подобрява четимостта. Използва cold-start данни преди RL, за да засили разсъждението, съпоставя се с OpenAI-o1 при задачи по математика, код и логика и подобрява общите резултати чрез внимателно обучение.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus е обновен модел от серията V3.1, позициониран като хибриден агентен LLM. Отстранява докладвани от потребители проблеми и подобрява стабилността, езиковата последователност и намалява смесването на китайски/английски и аномални символи. Интегрира режими с и без разсъждение с шаблони за чат за гъвкаво превключване. Подобрява и производителността на Code Agent и Search Agent за по-надеждно използване на инструменти и многoетапни задачи.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 е модел, който съчетава висока изчислителна ефективност с отлично разсъждение и производителност като агент. Подходът му се основава на три ключови технологични пробива: DeepSeek Sparse Attention (DSA), ефективен механизъм за внимание, който значително намалява изчислителната сложност, като същевременно поддържа производителността на модела и е специално оптимизиран за сценарии с дълъг контекст; мащабируема рамка за подсилващо обучение, чрез която производителността на модела може да съперничи на GPT-5, а версията с висока изчислителна мощност съответства на Gemini-3.0-Pro по способности за разсъждение; и мащабна тръбопроводна система за синтез на задачи за агенти, насочена към интегриране на способности за разсъждение в сценарии за използване на инструменти, като по този начин подобрява следването на инструкции и обобщаването в сложни интерактивни среди. Моделът постигна златен медал на Международната математическа олимпиада (IMO) и Международната олимпиада по информатика (IOI) през 2025 г.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 е най-новият и най-мощен модел от серията Kimi K2. Това е MoE модел от най-висок клас с 1T общо и 32B активни параметъра. Основните му предимства включват по-силна агентна интелигентност при програмиране с значителни подобрения в бенчмаркове и реални задачи, както и подобрена естетика и използваемост на фронтенд кода.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo е ускорен вариант, оптимизиран за скорост на разсъждение и пропускателна способност, като запазва многoетапното разсъждение и използване на инструменти от K2 Thinking. Това е MoE модел с ~1T общи параметри, роден 256K контекст и стабилно мащабируемо извикване на инструменти за производствени сценарии с по-строги изисквания за латентност и едновременност.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 е отворен мултимодален агентен модел, базиран на Kimi-K2-Base, обучен върху приблизително 1.5 трилиона смесени визуални и текстови токени. Моделът използва MoE архитектура с общо 1T параметри и 32B активни параметри, поддържа контекстен прозорец от 256K и безпроблемно интегрира визуално и езиково разбиране.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 е новото поколение водещ модел на Zhipu с 355 милиарда общи параметри и 32 милиарда активни параметри, напълно обновен за общ диалог, разсъждения и агентни способности. GLM-4.7 подобрява преплетеното мислене и въвежда запазено мислене и мислене на ниво завой.",
   "Pro/zai-org/glm-5.description": "GLM-5 е следващото поколение голям езиков модел на Zhipu, фокусиран върху сложното системно инженерство и задачи на агенти с дълга продължителност. Параметрите на модела са разширени до 744 милиарда (40 милиарда активни) и интегрират DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ е експериментален изследователски модел, фокусиран върху подобряване на разсъждението.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview е изследователски модел от Qwen, фокусиран върху визуално разсъждение, със силни страни в разбирането на сложни сцени и визуални математически задачи.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ е експериментален изследователски модел, фокусиран върху подобрено AI разсъждение.",
   "Qwen/QwQ-32B.description": "QwQ е модел за разсъждение от семейството Qwen. В сравнение със стандартните модели, настроени по инструкции, той добавя мисловни и логически способности, които значително подобряват представянето при трудни задачи. QwQ-32B е среден по размер модел, съпоставим с водещи модели за разсъждение като DeepSeek-R1 и o1-mini. Използва RoPE, SwiGLU, RMSNorm и QKV bias в вниманието, с 64 слоя и 40 Q глави (8 KV в GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 е най-новата версия за редактиране на изображения от екипа на Qwen. Базиран на 20B модела Qwen-Image, той разширява силното текстово рендиране към редактиране на изображения за прецизни текстови промени. Използва двуканална архитектура – входовете се подават към Qwen2.5-VL за семантичен контрол и към VAE енкодер за контрол на външния вид, което позволява редакции както на семантично, така и на визуално ниво. Поддържа локални редакции (добавяне/премахване/промяна) и по-високо ниво на семантични промени като създаване на IP и трансфер на стил, като същевременно запазва смисъла. Постига SOTA резултати в множество бенчмаркове.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Модел от второ поколение Skylark. Skylark2-pro-turbo-8k предлага по-бърза инференция на по-ниска цена с контекстен прозорец от 8K.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 е следващо поколение отворен GLM модел с 32 милиарда параметъра, сравним по производителност с OpenAI GPT и сериите DeepSeek V3/R1.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 е 9-милиарден GLM модел, който наследява технологиите на GLM-4-32B, като същевременно предлага по-леко внедряване. Представя се добре в генериране на код, уеб дизайн, създаване на SVG и писане, базирано на търсене.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking е модел с отворен код от Zhipu AI и лабораторията KEG на университета Цинхуа, създаден за сложна мултимодална когниция. Построен върху GLM-4-9B-0414, той добавя разсъждения чрез верига от мисли и RL за значително подобряване на кръстомодалното разсъждение и стабилност.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 е модел за дълбоко разсъждение, изграден от GLM-4-32B-0414 с данни за студен старт и разширено подсилено обучение, допълнително обучен върху математика, код и логика. Значително подобрява способността за решаване на сложни задачи спрямо базовия модел.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 е компактен GLM модел с 9 милиарда параметъра, който запазва силните страни на отворения код, като същевременно предлага впечатляващи възможности. Представя се отлично в математическо разсъждение и общи задачи, водещ в своя клас сред отворените модели.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat е отвореният GLM-4 модел от Zhipu AI. Представя се силно в семантика, математика, разсъждение, код и знания. Освен многозавойни чатове, поддържа уеб браузване, изпълнение на код, извикване на персонализирани инструменти и разсъждение върху дълги текстове. Поддържа 26 езика (включително китайски, английски, японски, корейски, немски). Представя се добре в AlignBench-v2, MT-Bench, MMLU и C-Eval и поддържа до 128K контекст за академична и бизнес употреба.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B е първият модел за разсъждение с дълъг контекст (LRM), обучен с RL, оптимизиран за разсъждение върху дълги текстове. Неговото прогресивно разширяване на контекста чрез RL позволява стабилен преход от кратък към дълъг контекст. Той надминава OpenAI-o3-mini и Qwen3-235B-A22B на седем бенчмарка за QA върху документи с дълъг контекст, съперничейки на Claude-3.7-Sonnet-Thinking. Особено силен е в математика, логика и многократни разсъждения.",
   "Yi-34B-Chat.description": "Yi-1.5-34B запазва силните езикови способности на серията, като използва инкрементално обучение върху 500 милиарда висококачествени токена, за да подобри значително логиката в математиката и програмирането.",
   "abab5.5-chat.description": "Създаден за продуктивни сценарии с обработка на сложни задачи и ефективно генериране на текст за професионална употреба.",
   "abab5.5s-chat.description": "Проектиран за чат с китайски персонажи, осигуряващ висококачествен диалог на китайски език за различни приложения.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet се отличава в програмиране, писане и сложни разсъждения.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet с разширено мислене за задачи, изискващи сложни разсъждения.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet е надградена версия с разширен контекст и възможности.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 е най-бързият и интелигентен модел Haiku на Anthropic, с мълниеносна скорост и разширено мислене.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 е бърз и ефективен модел за различни задачи.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking е усъвършенстван вариант, който може да разкрие процеса си на разсъждение.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 е най-новият и най-способен модел на Anthropic за силно сложни задачи, отличаващ се с производителност, интелигентност, плавност и разбиране.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 е най-мощният модел на Anthropic за силно сложни задачи, отличаващ се с производителност, интелигентност, плавност и разбиране.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 е флагманският модел на Anthropic, комбиниращ изключителна интелигентност с мащабируема производителност, идеален за сложни задачи, изискващи най-висококачествени отговори и разсъждение.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 е най-интелигентният модел на Anthropic за изграждане на агенти и програмиране.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking може да генерира почти мигновени отговори или разширено стъпково мислене с видим процес.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 е най-интелигентният модел на Anthropic досега, предлагащ почти мигновени отговори или разширено мислене стъпка по стъпка с фино управление за API потребители.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic досега.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 е най-добрата комбинация от скорост и интелигентност на Anthropic.",
   "claude-sonnet-4.description": "Claude Sonnet 4 е най-новото поколение с подобрена производителност във всички задачи.",
   "codegeex-4.description": "CodeGeeX-4 е мощен AI асистент за програмиране, който поддържа многоезични въпроси и допълване на код, повишавайки продуктивността на разработчиците.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B е многоезичен модел за генериране на код, който поддържа допълване и създаване на код, интерпретиране, уеб търсене, извикване на функции и въпроси на ниво хранилище. Подходящ е за широк спектър от софтуерни сценарии и е водещ модел под 10 милиарда параметри.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "Дестилираните модели DeepSeek-R1 използват RL и cold-start данни за подобряване на разсъждението и поставят нови бенчмарк стандарти за отворени модели с много задачи.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "Дестилираните модели DeepSeek-R1 използват RL и cold-start данни за подобряване на разсъждението и поставят нови бенчмарк стандарти за отворени модели с много задачи.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B е дестилиран от Qwen2.5-32B и фино настроен върху 800K подбрани проби от DeepSeek-R1. Отличава се в математика, програмиране и разсъждение, постигайки силни резултати на AIME 2024, MATH-500 (94.3% точност) и GPQA Diamond.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B е дистилиран от Qwen2.5-Math-7B и фино настроен върху 800K подбрани проби от DeepSeek-R1. Той показва силни резултати: 92.8% на MATH-500, 55.5% на AIME 2024 и рейтинг 1189 на CodeForces за модел с 7 милиарда параметри.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 подобрява разсъждението с RL и cold-start данни, поставяйки нови бенчмарк стандарти за отворени модели с много задачи и надминава OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 надгражда DeepSeek-V2-Chat и DeepSeek-Coder-V2-Instruct, комбинирайки общи и кодови способности. Подобрява писането и следването на инструкции за по-добро съответствие с предпочитанията и показва значителни подобрения в AlpacaEval 2.0, ArenaHard, AlignBench и MT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus е обновен модел V3.1, позициониран като хибриден агентен LLM. Отстранява докладвани от потребители проблеми и подобрява стабилността, езиковата последователност и намалява смесените китайски/английски и аномални символи. Интегрира режими на мислене и немислене с шаблони за чат за гъвкаво превключване. Подобрява и производителността на Code Agent и Search Agent за по-надеждно използване на инструменти и многоетапни задачи.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 е модел за разсъждение от ново поколение с по-силни способности за сложни разсъждения и верига от мисли за задълбочени аналитични задачи.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 е модел за разсъждение от следващо поколение с по-силни способности за сложни разсъждения и верига на мисълта.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 е MoE модел за визия и език, базиран на DeepSeekMoE-27B със слаба активация, постигайки висока производителност с едва 4.5 милиарда активни параметъра. Отличава се в визуални въпроси и отговори, OCR, разбиране на документи/таблици/графики и визуално привързване.",
+  "deepseek-chat.description": "DeepSeek V3.2 балансира разсъжденията и дължината на изхода за ежедневни QA и задачи с агенти. Публичните бенчмаркове достигат нивата на GPT-5, и той е първият, който интегрира мислене в използването на инструменти, водещ в оценките на агенти с отворен код.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B е езиков модел за програмиране, обучен върху 2 трилиона токени (87% код, 13% китайски/английски текст). Въвежда 16K контекстен прозорец и задачи за попълване в средата, осигурявайки допълване на код на ниво проект и попълване на фрагменти.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 е отворен MoE модел за програмиране, който се представя на ниво GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 е отворен MoE модел за програмиране, който се представя на ниво GPT-4 Turbo.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "Пълна бърза версия на DeepSeek R1 с търсене в реално време в уеб, комбинираща възможности от мащаб 671B и по-бърз отговор.",
   "deepseek-r1-online.description": "Пълна версия на DeepSeek R1 с 671 милиарда параметъра и търсене в реално време в уеб, предлагаща по-силно разбиране и генериране.",
   "deepseek-r1.description": "DeepSeek-R1 използва данни от студен старт преди подсиленото обучение и се представя наравно с OpenAI-o1 в математика, програмиране и разсъждение.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking е модел за дълбоко разсъждение, който генерира верига от мисли преди изходите за по-висока точност, с водещи резултати в състезания и разсъждения, сравними с Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 е ефективен MoE модел за икономична обработка.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B е модел на DeepSeek, фокусиран върху програмиране, с висока производителност при генериране на код.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 е MoE модел с 671 милиарда параметъра, с изключителни способности в програмиране, технически задачи, разбиране на контекст и обработка на дълги текстове.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp въвежда разредено внимание за подобряване на ефективността при обучение и извеждане върху дълги текстове, на по-ниска цена от deepseek-v3.1.",
   "deepseek-v3.2-speciale.description": "При силно сложни задачи, моделът Speciale значително превъзхожда стандартната версия, но консумира значително повече токени и води до по-високи разходи. В момента DeepSeek-V3.2-Speciale е предназначен само за изследователска употреба, не поддържа използване на инструменти и не е специално оптимизиран за ежедневни разговори или задачи за писане.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think е пълен модел за дълбоко мислене с по-силно дълговерижно разсъждение.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 е най-новият модел за програмиране на DeepSeek със силни способности за разсъждение.",
   "deepseek-v3.description": "DeepSeek-V3 е мощен MoE модел с общо 671 милиарда параметъра и 37 милиарда активни на токен.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small е лек мултимодален вариант за среди с ограничени ресурси и висока едновременност.",
   "deepseek-vl2.description": "DeepSeek VL2 е мултимодален модел за разбиране на изображения и текст и прецизни визуални въпроси и отговори.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K е бърз мислещ модел с 32K контекст за сложни разсъждения и многозавойни разговори.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview е предварителен модел за мислене, предназначен за оценка и тестване.",
   "ernie-x1.1.description": "ERNIE X1.1 е мисловен модел за предварителен преглед за оценка и тестване.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5, създаден от екипа Seed на ByteDance, поддържа редактиране и композиция на множество изображения. Характеризира се с подобрена консистентност на обектите, прецизно следване на инструкции, разбиране на пространствена логика, естетично изразяване, оформление на плакати и дизайн на лого с високопрецизно текстово-изображение рендиране.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0, създаден от ByteDance Seed, поддържа текстови и визуални входове за силно контролируемо, висококачествено генериране на изображения от подсказки.",
   "fal-ai/flux-kontext/dev.description": "FLUX.1 модел, фокусиран върху редактиране на изображения, поддържащ вход от текст и изображения.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] приема текст и референтни изображения като вход, позволявайки целенасочени локални редакции и сложни глобални трансформации на сцени.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] е модел за генериране на изображения с естетично предпочитание към по-реалистични и естествени изображения.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "Мощен роден мултимодален модел за генериране на изображения.",
   "fal-ai/imagen4/preview.description": "Модел за висококачествено генериране на изображения от Google.",
   "fal-ai/nano-banana.description": "Nano Banana е най-новият, най-бърз и най-ефективен роден мултимодален модел на Google, позволяващ генериране и редактиране на изображения чрез разговор.",
+  "fal-ai/qwen-image-edit.description": "Професионален модел за редактиране на изображения от екипа Qwen, поддържащ семантични и визуални редакции, прецизно редактиране на текст на китайски/английски, трансфер на стил, ротация и други.",
+  "fal-ai/qwen-image.description": "Мощен модел за генериране на изображения от екипа Qwen със силно рендиране на китайски текст и разнообразни визуални стилове.",
   "flux-1-schnell.description": "Модел за преобразуване на текст в изображение с 12 милиарда параметъра от Black Forest Labs, използващ латентна дифузионна дестилация за генериране на висококачествени изображения в 1–4 стъпки. Съперничи на затворени алтернативи и е пуснат под лиценз Apache-2.0 за лична, изследователска и търговска употреба.",
   "flux-dev.description": "FLUX.1 [dev] е дестилиран модел с отворени тегла за нетърговска употреба. Запазва почти професионално качество на изображенията и следване на инструкции, като същевременно работи по-ефективно и използва ресурсите по-добре от стандартни модели със същия размер.",
   "flux-kontext-max.description": "Съвременно генериране и редактиране на изображения с контекст, комбиниращо текст и изображения за прецизни и последователни резултати.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro е най-усъвършенстваният модел за разсъждение на Google, способен да разсъждава върху код, математика и STEM проблеми и да анализира големи набори от данни, кодови бази и документи с дълъг контекст.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash е най-интелигентният модел, създаден за скорост, съчетаващ авангардна интелигентност с отлично търсене и обоснованост.",
   "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 е най-мощният агентен и „vibe-coding“ модел на Google, който предлага по-богати визуализации и по-дълбоко взаимодействие, базирано на съвременно логическо мислене.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) е най-бързият модел на Google за генериране на изображения с поддръжка на мислене, разговорно генериране и редактиране на изображения.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) предлага качество на изображения от ниво Pro с Flash скорост и поддръжка на мултимодален чат.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview е най-икономичният мултимодален модел на Google, оптимизиран за задачи с голям обем, превод и обработка на данни.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview подобрява Gemini 3 Pro с усъвършенствани способности за разсъждение и добавя поддръжка за средно ниво на мислене.",
   "gemini-flash-latest.description": "Най-новата версия на Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "Високоскоростен вариант на K2 с дълбоко мислене, 256k контекст, силно дълбоко разсъждение и скорост на изход от 60–100 токена/сек.",
   "kimi-k2-thinking.description": "kimi-k2-thinking е мисловен модел на Moonshot AI с общи агентни и разсъждателни способности. Отличава се с дълбоко разсъждение и може да решава трудни задачи чрез многостъпкова употреба на инструменти.",
   "kimi-k2-turbo-preview.description": "kimi-k2 е MoE базов модел с мощни способности за програмиране и агентни задачи (1T общи параметри, 32B активни), надминаващ други водещи отворени модели в области като разсъждение, програмиране, математика и агентни бенчмаркове.",
+  "kimi-k2.5.description": "Kimi K2.5 е най-универсалният модел на Kimi досега, с родна мултимодална архитектура, която поддържа както визуални, така и текстови входове, режими 'мислене' и 'немислене', както и задачи за разговори и агенти.",
   "kimi-k2.description": "Kimi-K2 е MoE базов модел от Moonshot AI с мощни способности за програмиране и агентни задачи, с общо 1T параметри и 32B активни. В бенчмаркове за общо разсъждение, програмиране, математика и агентни задачи надминава други водещи отворени модели.",
   "kimi-k2:1t.description": "Kimi K2 е голям MoE LLM от Moonshot AI с 1T общи параметри и 32B активни на всяко преминаване. Оптимизиран е за агентни способности, включително напреднало използване на инструменти, разсъждение и синтез на код.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (ограничено безплатен) се фокусира върху разбиране на код и автоматизация за ефективни кодиращи агенти.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K поддържа 32 768 токена за средно дълъг контекст, идеален за дълги документи и сложни диалози в създаване на съдържание, отчети и чат системи.",
   "moonshot-v1-8k-vision-preview.description": "Моделите Kimi vision (включително moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) разбират съдържание на изображения като текст, цветове и форми на обекти.",
   "moonshot-v1-8k.description": "Moonshot V1 8K е оптимизиран за генериране на кратки текстове с висока ефективност, обработвайки 8 192 токена за кратки чатове, бележки и бързо съдържание.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B е модел за програмиране с отворен код, оптимизиран с мащабно RL за създаване на надеждни, готови за производство корекции. Той постига 60.4% на SWE-bench Verified, поставяйки нов рекорд за модели с отворен код в автоматизирани задачи като поправка на грешки и преглед на код.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 е най-новият и най-мощен модел от серията Kimi K2. Това е MoE модел от най-висок клас с 1T общо и 32B активни параметъра. Основни характеристики включват по-силна агентна интелигентност при програмиране, значителни подобрения в бенчмаркове и реални задачи, както и подобрена естетика и използваемост на фронтенд кода.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking е най-новият и най-мощен модел за мислене с отворен код. Той значително разширява дълбочината на многократното разсъждение и поддържа стабилно използване на инструменти в 200–300 последователни извиквания, поставяйки нови рекорди на Humanity's Last Exam (HLE), BrowseComp и други бенчмаркове. Превъзхожда в кодиране, математика, логика и сценарии с агенти. Изграден на архитектура MoE с ~1 трилион общи параметри, поддържа 256K контекстен прозорец и извикване на инструменти.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 е instruct вариант от серията Kimi, подходящ за висококачествен код и използване на инструменти.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "Следващо поколение Qwen кодер, оптимизиран за сложна многокодова генерация, дебъгване и високопроизводителни работни потоци на агенти. Създаден за силна интеграция на инструменти и подобрена производителност на разсъждения.",
   "qwen3-coder-plus.description": "Модел за програмиране Qwen. Най-новата серия Qwen3-Coder е базирана на Qwen3 и предлага силни способности за програмиране чрез агенти, използване на инструменти и взаимодействие със среди за автономно програмиране, с отлично представяне при код и стабилни общи възможности.",
   "qwen3-coder:480b.description": "Високопроизводителен модел на Alibaba с дълъг контекст за задачи с агенти и програмиране.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: Най-добре представящият се модел Qwen за сложни, многократни задачи по програмиране с поддръжка на мислене.",
   "qwen3-max-preview.description": "Най-добре представящият се модел Qwen за сложни, многоетапни задачи. Прегледната версия поддържа разсъждение.",
   "qwen3-max.description": "Моделите Qwen3 Max предлагат значителни подобрения спрямо серията 2.5 в общите способности, разбиране на китайски/английски, следване на сложни инструкции, субективни отворени задачи, многоезичност и използване на инструменти, с по-малко халюцинации. Най-новият qwen3-max подобрява програмирането чрез агенти и използването на инструменти спрямо qwen3-max-preview. Тази версия достига водещи резултати в индустрията и е насочена към по-сложни нужди на агентите.",
   "qwen3-next-80b-a3b-instruct.description": "Следващо поколение отворен модел Qwen3 без мисловни способности. В сравнение с предишната версия (Qwen3-235B-A22B-Instruct-2507), предлага по-добро разбиране на китайски, по-силна логическа аргументация и подобрено генериране на текст.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ е модел за аргументация от семейството на Qwen. В сравнение със стандартните модели, обучени с инструкции, предлага мисловни и логически способности, които значително подобряват ефективността при трудни задачи. QwQ-32B е среден по размер модел, който се конкурира с водещи модели като DeepSeek-R1 и o1-mini.",
   "qwq_32b.description": "Среден по размер модел за аргументация от семейството на Qwen. В сравнение със стандартните модели, обучени с инструкции, мисловните и логическите способности на QwQ значително подобряват ефективността при трудни задачи.",
   "r1-1776.description": "R1-1776 е дообучен вариант на DeepSeek R1, създаден да предоставя неконфронтирана, обективна и фактическа информация.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro от ByteDance поддържа текст към видео, изображение към видео (първа рамка, първа+последна рамка) и генериране на аудио, синхронизирано с визуализации.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite от BytePlus предлага генериране, обогатено с уеб търсене за реална информация, подобрена интерпретация на сложни подсказки и подобрена консистентност на препратките за професионално визуално създаване.",
   "solar-mini-ja.description": "Solar Mini (Ja) разширява Solar Mini с фокус върху японски език, като запазва ефективността и силната производителност на английски и корейски.",
   "solar-mini.description": "Solar Mini е компактен LLM, който превъзхожда GPT-3.5, с мощни многоезични възможности, поддържащ английски и корейски, и предлага ефективно решение с малък отпечатък.",
   "solar-pro.description": "Solar Pro е интелигентен LLM от Upstage, фокусиран върху следване на инструкции на един GPU, с IFEval резултати над 80. Понастоящем поддържа английски; пълното издание е планирано за ноември 2024 с разширена езикова поддръжка и по-дълъг контекст.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "Флагманският модел за езиково разсъждение на Stepfun. Този модел има първокласни способности за разсъждение и бързи и надеждни изпълнителни възможности. Може да разлага и планира сложни задачи, бързо и надеждно да извиква инструменти за изпълнение на задачи и да бъде компетентен в различни сложни задачи като логическо разсъждение, математика, софтуерно инженерство и задълбочени изследвания.",
   "step-3.description": "Този модел притежава силно визуално възприятие и сложна логика, точно обработва междудомейново знание, анализ между математика и визия и широк спектър от ежедневни визуални задачи.",
   "step-r1-v-mini.description": "Модел за логическо разсъждение със силно визуално разбиране, който може да обработва изображения и текст, след което да генерира текст след дълбоко разсъждение. Отличава се във визуално разсъждение и предоставя водещи резултати в математика, програмиране и текстово разсъждение, с контекстен прозорец от 100K.",
+  "stepfun-ai/step3.description": "Step3 е авангарден модел за мултимодално разсъждение от StepFun, построен върху архитектура MoE с 321 милиарда общи и 38 милиарда активни параметри. Неговият дизайн от край до край минимизира разходите за декодиране, като същевременно осигурява водещо разсъждение за визия и език. С дизайна MFA и AFD, той остава ефективен както на водещи, така и на нискобюджетни ускорители. Предварителното обучение използва над 20 трилиона текстови токени и 4 трилиона токени за изображения-текстове на много езици. Той достига водещи резултати сред модели с отворен код в математика, код и мултимодални бенчмаркове.",
   "taichu4_vl_2b_nothinking.description": "Версията без мислене на модела Taichu4.0-VL 2B се отличава с по-ниска употреба на памет, лек дизайн, бърза скорост на отговор и силни способности за мултимодално разбиране.",
   "taichu4_vl_32b.description": "Версията с мислене на модела Taichu4.0-VL 32B е подходяща за сложни задачи за мултимодално разбиране и разсъждение, демонстрирайки изключителна производителност в мултимодално математическо разсъждение, мултимодални способности на агенти и общо разбиране на изображения и визуализации.",
   "taichu4_vl_32b_nothinking.description": "Версията без мислене на модела Taichu4.0-VL 32B е предназначена за сложни сценарии за разбиране на изображения и текст и визуални въпроси и отговори, превъзхождайки в описания на изображения, визуални въпроси и отговори, разбиране на видео и задачи за визуална локализация.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air е базов модел за агентни приложения с архитектура Mixture-of-Experts. Оптимизиран е за използване на инструменти, уеб браузване, софтуерно инженерство и фронтенд програмиране, и се интегрира с кодови агенти като Claude Code и Roo Code. Използва хибридно разсъждение за справяне както със сложни, така и с ежедневни задачи.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V е най-новият визуален езиков модел (VLM) на Zhipu AI, изграден върху флагманския текстов модел GLM-4.5-Air (106B общо, 12B активни) с MoE архитектура за висока производителност при по-ниска цена. Следва пътя на GLM-4.1V-Thinking и добавя 3D-RoPE за подобрено пространствено разсъждение в 3D. Оптимизиран чрез предварително обучение, SFT и RL, обработва изображения, видео и дълги документи и е сред водещите отворени модели в 41 публични мултимодални бенчмарка. Режимът Thinking позволява на потребителите да балансират между скорост и дълбочина.",
   "zai-org/GLM-4.6.description": "В сравнение с GLM-4.5, GLM-4.6 разширява контекста от 128K до 200K за по-сложни агентни задачи. Постига по-високи резултати в кодови бенчмаркове и показва по-добра реална производителност в приложения като Claude Code, Cline, Roo Code и Kilo Code, включително по-добро генериране на фронтенд страници. Разсъждението е подобрено и се поддържа използване на инструменти по време на разсъждение, което засилва цялостните възможности. По-добре се интегрира в агентни рамки, подобрява инструментите/търсещите агенти и има по-предпочитан от хора стил на писане и естественост в ролевите сценарии.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V постига водеща точност във визуалното разбиране за своя мащаб на параметрите и е първият, който нативно интегрира възможности за извикване на функции в архитектурата на визуалния модел, преодолявайки разликата между \"визуално възприятие\" и \"изпълними действия\" и предоставяйки унифицирана техническа основа за мултимодални агенти в реални бизнес сценарии. Визуалният контекстен прозорец е разширен до 128 хиляди, поддържайки обработка на дълги видео потоци и анализ на изображения с висока резолюция.",
   "zai/glm-4.5-air.description": "GLM-4.5 и GLM-4.5-Air са най-новите ни флагмани за агентни приложения, и двата използват MoE. GLM-4.5 има 355B общо и 32B активни параметри на стъпка; GLM-4.5-Air е по-лек с 106B общо и 12B активни.",
   "zai/glm-4.5.description": "Серията GLM-4.5 е проектирана за агенти. Флагманският GLM-4.5 комбинира разсъждение, програмиране и агентни умения с 355B общи параметри (32B активни) и предлага два режима на работа като хибридна система за разсъждение.",
   "zai/glm-4.5v.description": "GLM-4.5V надгражда GLM-4.5-Air, наследявайки доказани техники от GLM-4.1V-Thinking и мащабира с мощна MoE архитектура с 106 милиарда параметъра.",

locales/bg-BG/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure предлага усъвършенствани AI модели, включително сериите GPT-3.5 и GPT-4, за разнообразни типове данни и сложни задачи с фокус върху безопасен, надежден и устойчив AI.",
   "azureai.description": "Azure предоставя усъвършенствани AI модели, включително сериите GPT-3.5 и GPT-4, за разнообразни типове данни и сложни задачи с акцент върху безопасен, надежден и устойчив AI.",
   "baichuan.description": "Baichuan AI се фокусира върху базови модели с висока ефективност при китайски знания, обработка на дълъг контекст и креативно генериране. Моделите му (Baichuan 4, Baichuan 3 Turbo, Baichuan 3 Turbo 128k) са оптимизирани за различни сценарии и предлагат висока стойност.",
+  "bailiancodingplan.description": "Aliyun Bailian Coding Plan е специализирана AI услуга за програмиране, предоставяща достъп до модели, оптимизирани за програмиране, като Qwen, GLM, Kimi и MiniMax чрез специален крайна точка.",
   "bedrock.description": "Amazon Bedrock предоставя на предприятията усъвършенствани езикови и визуални модели, включително Anthropic Claude и Meta Llama 3.1, обхващащи от леки до високопроизводителни опции за текст, чат и изображения.",
   "bfl.description": "Водеща изследователска лаборатория в областта на frontier AI, изграждаща визуалната инфраструктура на бъдещето.",
   "cerebras.description": "Cerebras е платформа за инференция, изградена върху системата CS-3, фокусирана върху ултраниска латентност и висок капацитет за LLM услуги в реално време като генериране на код и агентни задачи.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Gitee AI Serverless API предоставят готови за използване услуги за LLM инференция за разработчици.",
   "github.description": "С GitHub Models разработчиците могат да работят като AI инженери, използвайки водещи в индустрията модели.",
   "githubcopilot.description": "Достъпвайте моделите Claude, GPT и Gemini чрез вашия абонамент за GitHub Copilot.",
+  "glmcodingplan.description": "GLM Coding Plan предоставя достъп до модели на Zhipu AI, включително GLM-5 и GLM-4.7, за задачи, свързани с програмиране, чрез абонамент с фиксирана такса.",
   "google.description": "Семейството Gemini на Google е най-усъвършенстваният му универсален AI, създаден от Google DeepMind за мултимодална употреба с текст, код, изображения, аудио и видео. Работи както в центрове за данни, така и на мобилни устройства с висока ефективност и обхват.",
   "groq.description": "Инференционният енджин LPU на Groq осигурява изключителна производителност с висока скорост и ефективност, поставяйки нов стандарт за нисколатентна облачна LLM инференция.",
   "higress.description": "Higress е облачно-нативен API gateway, създаден в Alibaba за справяне с проблемите при презареждане на Tengine и липсите в балансирането на натоварването при gRPC/Dubbo.",
@@ -29,9 +31,12 @@
   "infiniai.description": "Предоставя на разработчиците на приложения високоефективни, лесни за използване и сигурни LLM услуги за целия работен процес — от разработка на модел до внедряване в продукция.",
   "internlm.description": "Open-source организация, фокусирана върху изследвания и инструменти за големи модели, предоставяща ефективна и лесна за използване платформа за достъп до водещи модели и алгоритми.",
   "jina.description": "Основана през 2020 г., Jina AI е водеща компания в областта на търсещия AI. Технологичният ѝ стек включва векторни модели, преоценители и малки езикови модели за създаване на надеждни генеративни и мултимодални търсещи приложения.",
+  "kimicodingplan.description": "Kimi Code от Moonshot AI предоставя достъп до модели Kimi, включително K2.5, за задачи, свързани с програмиране.",
   "lmstudio.description": "LM Studio е десктоп приложение за разработка и експериментиране с LLM на вашия компютър.",
+  "lobehub.description": "LobeHub Cloud използва официални API за достъп до AI модели и измерва използването чрез кредити, свързани с токените на модела.",
   "longcat.description": "LongCat е серия от големи модели за генеративен AI, независимо разработени от Meituan. Той е създаден да подобри вътрешната продуктивност на предприятието и да позволи иновативни приложения чрез ефективна изчислителна архитектура и силни мултимодални възможности.",
   "minimax.description": "Основана през 2021 г., MiniMax създава универсален AI с мултимодални базови модели, включително текстови модели с трилиони параметри, речеви и визуални модели, както и приложения като Hailuo AI.",
+  "minimaxcodingplan.description": "MiniMax Token Plan предоставя достъп до модели MiniMax, включително M2.7, за задачи, свързани с програмиране, чрез абонамент с фиксирана такса.",
   "mistral.description": "Mistral предлага усъвършенствани универсални, специализирани и изследователски модели за сложни разсъждения, многоезични задачи и генериране на код, с извикване на функции за персонализирани интеграции.",
   "modelscope.description": "ModelScope е платформа на Alibaba Cloud за модели като услуга, предлагаща широка гама от AI модели и услуги за инференция.",
   "moonshot.description": "Moonshot, от Moonshot AI (Beijing Moonshot Technology), предлага множество NLP модели за създаване на съдържание, изследвания, препоръки и медицински анализи, с поддръжка на дълъг контекст и сложни генерации.",
@@ -64,6 +69,7 @@
   "vertexai.description": "Семейството Gemini на Google е най-усъвършенстваният му универсален AI, създаден от Google DeepMind за мултимодална употреба с текст, код, изображения, аудио и видео. Работи както в центрове за данни, така и на мобилни устройства, подобрявайки ефективността и гъвкавостта на внедряване.",
   "vllm.description": "vLLM е бърза и лесна за използване библиотека за инференция и обслужване на LLM.",
   "volcengine.description": "Платформата за модели на ByteDance предлага сигурен, богат на функции и икономичен достъп до модели, както и цялостни инструменти за данни, фино настройване, инференция и оценка.",
+  "volcenginecodingplan.description": "Volcengine Coding Plan от ByteDance предоставя достъп до множество модели за програмиране, включително Doubao-Seed-Code, GLM-4.7, DeepSeek-V3.2 и Kimi-K2.5, чрез абонамент с фиксирана такса.",
   "wenxin.description": "Платформа за предприятия за базови модели и разработка на AI-приложения, предлагаща цялостни инструменти за работни потоци с генеративен AI.",
   "xai.description": "xAI създава AI за ускоряване на научните открития с мисията да задълбочи разбирането на човечеството за Вселената.",
   "xiaomimimo.description": "Xiaomi MiMo предоставя услуга за разговорен модел с API, съвместим с OpenAI. Моделът mimo-v2-flash поддържа задълбочено разсъждение, поточно извеждане, извикване на функции, контекстен прозорец от 256K и максимален изход от 128K.",

locales/bg-BG/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "Поддържа кредитна карта / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "Поддържа кредитна карта",
   "plans.btn.soon": "Очаквайте скоро",
+  "plans.cancelDowngrade": "Отмяна на планираното понижение",
+  "plans.cancelDowngradeSuccess": "Планираното понижение е отменено",
   "plans.changePlan": "Избери план",
   "plans.cloud.history": "Неограничена история на разговорите",
   "plans.cloud.sync": "Синхронизация в облака по целия свят",
@@ -215,6 +217,7 @@
   "plans.current": "Текущ план",
   "plans.downgradePlan": "Целеви понижен план",
   "plans.downgradeTip": "Вече си сменил абонамента. Не можеш да извършваш други действия, докато смяната не приключи",
+  "plans.downgradeWillCancel": "Това действие ще отмени планираното понижение на плана ви",
   "plans.embeddingStorage.embeddings": "записа",
   "plans.embeddingStorage.title": "Векторно съхранение",
   "plans.embeddingStorage.tooltip": "Една страница документ (1000-1500 знака) генерира приблизително 1 векторен запис. (Оценено с OpenAI Embeddings, може да варира според модела)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "Потвърди избора",
   "plans.payonce.popconfirm": "След еднократно плащане трябва да изчакаш изтичането на абонамента, за да смениш план или цикъл на плащане. Потвърди избора си.",
   "plans.payonce.tooltip": "При еднократно плащане трябва да изчакаш изтичането на абонамента, за да смениш план или цикъл на плащане",
+  "plans.pendingDowngrade": "Очакващо понижение",
   "plans.plan.enterprise.contactSales": "Свържи се с търговски представител",
   "plans.plan.enterprise.title": "Бизнес",
   "plans.plan.free.desc": "За нови потребители",
@@ -366,6 +370,7 @@
   "summary.title": "Обобщение на таксуването",
   "summary.usageThisMonth": "Вижте използването си за този месец.",
   "summary.viewBillingHistory": "Виж история на плащанията",
+  "switchDowngradeTarget": "Смяна на целта за понижение",
   "switchPlan": "Смени план",
   "switchToMonthly.desc": "След смяната, месечното таксуване ще влезе в сила след изтичане на текущия годишен план.",
   "switchToMonthly.title": "Превключване към месечно таксуване",

locales/de-DE/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Verbindung fehlgeschlagen",
   "sync.title": "Synchronisationsstatus",
   "sync.unconnected.tip": "Verbindung zum Signalisierungsserver fehlgeschlagen, Peer-to-Peer-Kommunikationskanal kann nicht aufgebaut werden. Bitte überprüfen Sie Ihre Netzwerkverbindung und versuchen Sie es erneut.",
-  "tab.aiImage": "Kunstwerk",
   "tab.audio": "Audio",
   "tab.chat": "Chat",
   "tab.community": "Community",
@@ -405,6 +404,7 @@
   "tab.eval": "Bewertungslabor",
   "tab.files": "Dateien",
   "tab.home": "Startseite",
+  "tab.image": "Bild",
   "tab.knowledgeBase": "Bibliothek",
   "tab.marketplace": "Marktplatz",
   "tab.me": "Ich",

locales/de-DE/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "Für Gemini 3 Bildgenerierungsmodelle; steuert die Auflösung der generierten Bilder.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "Für Gemini 3.1 Flash Image-Modelle; steuert die Auflösung der generierten Bilder (unterstützt 512px).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "Für Claude, Qwen3 und ähnliche Modelle; steuert das Token-Budget für logisches Denken.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "Für GLM-5 und GLM-4.7; steuert das Token-Budget für das logische Denken (max. 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "Für die Qwen3-Serie; steuert das Token-Budget für das logische Denken (max. 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "Für OpenAI und andere Modelle mit Denkfähigkeit; steuert den Denkaufwand.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "Für die GPT-5+-Serie; steuert die Ausführlichkeit der Ausgabe.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "Für einige Doubao-Modelle; erlaubt dem Modell zu entscheiden, ob es tiefgründig denken soll.",

locales/de-DE/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev ist ein multimodales Modell zur Bildgenerierung und -bearbeitung von Black Forest Labs, basierend auf einer Rectified Flow Transformer-Architektur mit 12 Milliarden Parametern. Es konzentriert sich auf die Erzeugung, Rekonstruktion, Verbesserung oder Bearbeitung von Bildern unter gegebenen Kontextbedingungen. Es kombiniert die kontrollierbare Generierung von Diffusionsmodellen mit der Kontextmodellierung von Transformern und unterstützt hochwertige Ergebnisse für Aufgaben wie Inpainting, Outpainting und visuelle Szenenrekonstruktion.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev ist ein Open-Source-multimodales Sprachmodell (MLLM) von Black Forest Labs, optimiert für Bild-Text-Aufgaben. Es kombiniert Bild-/Textverständnis und -generierung. Basierend auf fortschrittlichen LLMs (z. B. Mistral-7B) nutzt es einen sorgfältig entwickelten Vision-Encoder und mehrstufiges Instruction-Tuning für multimodale Koordination und komplexes logisches Denken.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: Leichtgewichtige Version für schnelle Antworten.",
+  "GLM-4.5.description": "GLM-4.5: Hochleistungsmodell für logisches Denken, Programmierung und Agentenaufgaben.",
+  "GLM-4.6.description": "GLM-4.6: Modell der vorherigen Generation.",
+  "GLM-4.7.description": "GLM-4.7 ist Zhipus neuestes Flaggschiffmodell, optimiert für agentenbasierte Codierungsszenarien mit verbesserten Programmierfähigkeiten, langfristiger Aufgabenplanung und Werkzeugzusammenarbeit.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: Optimierte Version von GLM-5 mit schnellerer Inferenz für Programmieraufgaben.",
+  "GLM-5.description": "GLM-5 ist Zhipus Flaggschiffmodell der nächsten Generation, speziell entwickelt für agentenbasierte Ingenieursaufgaben. Es bietet zuverlässige Produktivität in komplexen Systemingenieurprojekten und langfristigen agentenbasierten Aufgaben. In den Bereichen Programmierung und Agentenfähigkeiten erreicht GLM-5 Spitzenleistungen unter Open-Source-Modellen.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) ist ein innovatives Modell für vielfältige Anwendungsbereiche und komplexe Aufgaben.",
   "HY-Image-V3.0.description": "Leistungsstarke Funktionen zur Extraktion von Originalbildern und zur Detailerhaltung, die eine reichere visuelle Textur liefern und hochpräzise, gut komponierte, produktionsreife Bilder erzeugen.",
   "HelloMeme.description": "HelloMeme ist ein KI-Tool zur Erstellung von Memes, GIFs oder Kurzvideos aus bereitgestellten Bildern oder Bewegungen. Es erfordert keine Zeichen- oder Programmierkenntnisse – ein Referenzbild genügt, um unterhaltsame, ansprechende und stilistisch konsistente Inhalte zu erzeugen.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "Ein neues Inhouse-Argumentationsmodell mit 80K Chain-of-Thought und 1M Eingabe, vergleichbar mit führenden globalen Modellen.",
   "MiniMax-M2-Stable.description": "Entwickelt für effizientes Coden und Agenten-Workflows mit höherer Parallelität für den kommerziellen Einsatz.",
   "MiniMax-M2.1-Lightning.description": "Leistungsstarke mehrsprachige Programmierfunktionen, umfassend verbesserte Programmiererfahrung. Schneller und effizienter.",
+  "MiniMax-M2.1-highspeed.description": "Leistungsstarke mehrsprachige Programmierfähigkeiten mit schnellerer und effizienterer Inferenz.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 ist das Flaggschiff unter den Open-Source-Großmodellen von MiniMax und konzentriert sich auf die Lösung komplexer Aufgaben aus der realen Welt. Seine zentralen Stärken liegen in der mehrsprachigen Programmierfähigkeit und der Fähigkeit, als Agent komplexe Aufgaben zu bewältigen.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: Gleiche Leistung, schneller und agiler (ca. 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: Gleiche Leistung wie M2.5 mit schnellerer Inferenz.",
   "MiniMax-M2.5.description": "MiniMax-M2.5 ist ein Flaggschiff-Open-Source-Großmodell von MiniMax, das sich auf die Lösung komplexer realer Aufgaben konzentriert. Seine Kernstärken sind mehrsprachige Programmierfähigkeiten und die Fähigkeit, komplexe Aufgaben als Agent zu lösen.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: Gleiche Leistung wie M2.7 mit deutlich schnellerer Inferenz.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: Beginn der Reise zur rekursiven Selbstverbesserung, erstklassige reale Ingenieursfähigkeiten.",
+  "MiniMax-M2.description": "MiniMax M2: Modell der vorherigen Generation.",
   "MiniMax-Text-01.description": "MiniMax-01 führt großskalige lineare Aufmerksamkeit über klassische Transformer hinaus ein. Mit 456B Parametern und 45,9B aktiv pro Durchlauf erreicht es Spitzenleistung und unterstützt bis zu 4M Token Kontext (32× GPT-4o, 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 ist ein großskaliges Hybrid-Attention-Reasoning-Modell mit offenen Gewichten, 456 Milliarden Gesamtparametern und ~45,9 Milliarden aktiven Parametern pro Token. Es unterstützt nativ 1 Million Kontext und verwendet Flash Attention, um FLOPs bei der Generierung von 100.000 Tokens im Vergleich zu DeepSeek R1 um 75 % zu reduzieren. Mit einer MoE-Architektur sowie CISPO und Hybrid-Attention-RL-Training erreicht es führende Leistungen bei langem Input-Reasoning und realen Software-Engineering-Aufgaben.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 definiert die Effizienz von Agenten neu. Es ist ein kompaktes, schnelles und kosteneffizientes MoE-Modell mit 230 Milliarden Gesamt- und 10 Milliarden aktiven Parametern, entwickelt für erstklassige Programmier- und Agentenaufgaben bei gleichzeitig starker allgemeiner Intelligenz. Mit nur 10 Milliarden aktiven Parametern konkurriert es mit deutlich größeren Modellen und ist ideal für hocheffiziente Anwendungen.",
   "Moonshot-Kimi-K2-Instruct.description": "1 Billion Gesamtparameter mit 32 Milliarden aktiven. Unter den nicht-denkenden Modellen gehört es zur Spitzenklasse in den Bereichen aktuelles Wissen, Mathematik und Programmierung und ist besonders stark bei allgemeinen Agentenaufgaben. Optimiert für Agenten-Workloads kann es nicht nur Fragen beantworten, sondern auch Handlungen ausführen. Ideal für improvisierte, allgemeine Chats und Agentenerlebnisse als reflexartiges Modell ohne langes Nachdenken.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46,7B) ist ein hochpräzises Anweisungsmodell für komplexe Berechnungen.",
   "OmniConsistency.description": "OmniConsistency verbessert die Stil-Konsistenz und Generalisierung bei Bild-zu-Bild-Aufgaben durch den Einsatz großskaliger Diffusion Transformers (DiTs) und gepaarter stilisierter Daten, wodurch Stilverluste vermieden werden.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Eine aktualisierte Version des Phi-3-mini-Modells.",
   "Phi-3.5-vision-instrust.description": "Eine aktualisierte Version des Phi-3-vision-Modells.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 ist ein Open-Source-Sprachmodell der nächsten Generation, das für agentenbasierte Fähigkeiten optimiert wurde. Es überzeugt in den Bereichen Programmierung, Werkzeugnutzung, Befolgen von Anweisungen und langfristige Planung. Das Modell unterstützt mehrsprachige Softwareentwicklung und die Ausführung komplexer, mehrstufiger Arbeitsabläufe. Es erreichte 74,0 Punkte im SWE-bench Verified und übertrifft Claude Sonnet 4.5 in mehrsprachigen Szenarien.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 ist das neueste große Sprachmodell von MiniMax, trainiert durch großskaliges Reinforcement Learning in Hunderttausenden komplexer, realer Umgebungen. Mit einer MoE-Architektur und 229 Milliarden Parametern erreicht es branchenführende Leistungen bei Aufgaben wie Programmierung, Agenten-Tool-Nutzung, Suche und Büroszenarien.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct ist ein 7B-Instruktionsmodell der Qwen2-Serie. Es verwendet eine Transformer-Architektur mit SwiGLU, Attention-QKV-Bias und Grouped-Query-Attention und verarbeitet große Eingaben. Es zeigt starke Leistungen in Sprachverständnis, Textgenerierung, Mehrsprachigkeit, Programmierung, Mathematik und logischem Denken, übertrifft die meisten Open-Source-Modelle und konkurriert mit proprietären Modellen. Es übertrifft Qwen1.5-7B-Chat in mehreren Benchmarks.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct ist Teil der neuesten LLM-Serie von Alibaba Cloud. Das 7B-Modell bietet deutliche Verbesserungen in den Bereichen Programmierung und Mathematik, unterstützt über 29 Sprachen und verbessert das Befolgen von Anweisungen, das Verständnis strukturierter Daten und strukturierte Ausgaben (insbesondere JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct ist das neueste codefokussierte LLM von Alibaba Cloud. Basierend auf Qwen2.5 und trainiert mit 5,5 Billionen Tokens verbessert es die Codegenerierung, das logische Denken und die Fehlerbehebung erheblich, während es mathematische und allgemeine Stärken beibehält – eine solide Grundlage für Coding-Agenten.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL ist ein neues Vision-Language-Modell der Qwen-Serie mit starker visueller Verständnisfähigkeit. Es analysiert Text, Diagramme und Layouts in Bildern, versteht lange Videos und Ereignisse, unterstützt logisches Denken und Werkzeugnutzung, Objektverankerung in mehreren Formaten und strukturierte Ausgaben. Es verbessert die dynamische Auflösung und das Frame-Rate-Training für Videoverständnis und steigert die Effizienz des Vision-Encoders.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking ist ein Open-Source-VLM von Zhipu AI und dem Tsinghua KEG Lab, entwickelt für komplexe multimodale Kognition. Basierend auf GLM-4-9B-0414 erweitert es das Chain-of-Thought-Denken und RL, um das multimodale Schlussfolgern und die Stabilität deutlich zu verbessern.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat ist das Open-Source-Modell GLM-4 von Zhipu AI. Es zeigt starke Leistungen in Semantik, Mathematik, logischem Denken, Programmierung und Wissen. Neben mehrstufigem Chat unterstützt es Web-Browsing, Codeausführung, benutzerdefinierte Tool-Aufrufe und langes Textverständnis. Es unterstützt 26 Sprachen (darunter Chinesisch, Englisch, Japanisch, Koreanisch, Deutsch) und bietet bis zu 128K Kontext für akademische und geschäftliche Anwendungen.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B wurde aus Qwen2.5-Math-7B destilliert und auf 800.000 kuratierten DeepSeek-R1-Proben feinabgestimmt. Es erzielt starke Leistungen mit 92,8 % bei MATH-500, 55,5 % bei AIME 2024 und einer CodeForces-Bewertung von 1189 für ein 7B-Modell.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 ist ein durch RL optimiertes Schlussfolgerungsmodell, das Wiederholungen reduziert und die Lesbarkeit verbessert. Es verwendet Cold-Start-Daten vor dem RL, um das logische Denken weiter zu verbessern, erreicht vergleichbare Leistungen wie OpenAI-o1 bei Mathematik-, Code- und Denkaufgaben und verbessert die Gesamtergebnisse durch sorgfältiges Training.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus ist eine aktualisierte Version des V3.1-Modells, das als hybrides Agenten-LLM positioniert ist. Es behebt von Nutzern gemeldete Probleme, verbessert die Stabilität und Sprachkonsistenz und reduziert gemischte chinesisch/englische Ausgaben und fehlerhafte Zeichen. Es integriert Denk- und Nicht-Denk-Modi mit Chat-Vorlagen für flexibles Umschalten. Außerdem verbessert es die Leistung von Code- und Suchagenten für zuverlässigere Werkzeugnutzung und mehrstufige Aufgaben.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 ist ein Modell, das hohe Rechenleistungseffizienz mit exzellenter Argumentation und Agentenleistung kombiniert. Sein Ansatz basiert auf drei technologischen Durchbrüchen: DeepSeek Sparse Attention (DSA), einem effizienten Aufmerksamkeitsmechanismus, der die Rechenkomplexität erheblich reduziert und gleichzeitig die Modellleistung beibehält, speziell optimiert für Langkontext-Szenarien; einem skalierbaren Reinforcement-Learning-Framework, durch das die Modellleistung mit GPT-5 konkurrieren kann, wobei die Hochleistungsvariante mit Gemini-3.0-Pro in Argumentationsfähigkeiten vergleichbar ist; und einer groß angelegten Agenten-Aufgabensynthese-Pipeline, die darauf abzielt, Argumentationsfähigkeiten in Werkzeugszenarien zu integrieren, um die Befolgung von Anweisungen und die Generalisierung in komplexen interaktiven Umgebungen zu verbessern. Das Modell erreichte Goldmedaillenleistungen bei der Internationalen Mathematik-Olympiade (IMO) und der Internationalen Informatik-Olympiade (IOI) 2025.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 ist das neueste und leistungsstärkste Modell der Kimi K2-Reihe. Es handelt sich um ein MoE-Spitzenmodell mit insgesamt 1 Billion und 32 Milliarden aktiven Parametern. Zu den Hauptmerkmalen zählen eine verbesserte agentenbasierte Programmierintelligenz mit deutlichen Leistungssteigerungen bei Benchmarks und realen Agentenaufgaben sowie eine optimierte Ästhetik und Benutzerfreundlichkeit im Frontend-Coding.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo ist die Turbo-Variante, die für hohe Geschwindigkeit und Durchsatz beim logischen Denken optimiert wurde, während die Fähigkeit zu mehrstufigem Denken und Werkzeugnutzung von K2 Thinking erhalten bleibt. Es handelt sich um ein MoE-Modell mit etwa 1 Billion Parametern, nativem 256K-Kontext und stabiler großskaliger Tool-Nutzung für Produktionsszenarien mit strengen Anforderungen an Latenz und Parallelität.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 ist ein Open-Source-natives multimodales Agentenmodell, basierend auf Kimi-K2-Base, trainiert mit etwa 1,5 Billionen gemischten Bild- und Text-Tokens. Das Modell verwendet eine MoE-Architektur mit insgesamt 1 Billion Parametern und 32 Milliarden aktiven Parametern, unterstützt ein Kontextfenster von 256K und integriert nahtlos visuelle und sprachliche Verständnisfähigkeiten.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 ist Zhipus neues Flaggschiffmodell der Generation mit 355 Milliarden Gesamt- und 32 Milliarden aktiven Parametern, vollständig aktualisiert in allgemeinem Dialog, logischem Denken und Agentenfähigkeiten. GLM-4.7 verbessert Interleaved Thinking und führt Preserved Thinking sowie Turn-level Thinking ein.",
   "Pro/zai-org/glm-5.description": "GLM-5 ist Zhipus nächste Generation eines großen Sprachmodells, das sich auf komplexe Systementwicklung und lang andauernde Agentenaufgaben konzentriert. Die Modellparameter wurden auf 744 Milliarden (40 Milliarden aktiv) erweitert und integrieren DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ ist ein experimentelles Forschungsmodell mit Fokus auf die Verbesserung logischer Schlussfolgerungen.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview ist ein Forschungsmodell von Qwen, das sich auf visuelles Denken konzentriert und Stärken in der komplexen Szenenverständnis und visuellen Mathematikproblemen aufweist.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ ist ein experimentelles Forschungsmodell zur Verbesserung der KI-Logik und des Denkvermögens.",
   "Qwen/QwQ-32B.description": "QwQ ist ein Modell für logisches Denken aus der Qwen-Familie. Im Vergleich zu standardmäßig instruktionstunierten Modellen bietet es erweitertes Denkvermögen, das die Leistung bei anspruchsvollen Aufgaben deutlich steigert. QwQ-32B ist ein mittelgroßes Modell, das mit führenden Denkmodellen wie DeepSeek-R1 und o1-mini konkurriert. Es verwendet RoPE, SwiGLU, RMSNorm und Attention QKV Bias, mit 64 Schichten und 40 Q-Attention-Köpfen (8 KV in GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 ist die neueste Bearbeitungsversion von Qwen-Image aus dem Qwen-Team. Basierend auf dem 20B Qwen-Image-Modell erweitert es die präzise Textdarstellung um Bildbearbeitungsfunktionen. Es nutzt eine Dual-Control-Architektur, bei der Eingaben an Qwen2.5-VL zur semantischen Steuerung und an einen VAE-Encoder zur visuellen Steuerung gesendet werden. Dadurch sind sowohl semantische als auch visuelle Bearbeitungen möglich. Es unterstützt lokale Änderungen (Hinzufügen/Entfernen/Modifizieren) sowie semantische Bearbeitungen wie IP-Erstellung und Stilübertragungen bei gleichzeitiger Wahrung der Bedeutung. Es erzielt SOTA-Ergebnisse in mehreren Benchmarks.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Skylark Modell der 2. Generation. Skylark2-pro-turbo-8k bietet schnellere Inferenz bei geringeren Kosten mit einem 8K-Kontextfenster.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 ist ein Open-Source-GLM-Modell der nächsten Generation mit 32 Milliarden Parametern, das in seiner Leistung mit OpenAI GPT und der DeepSeek V3/R1-Serie vergleichbar ist.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 ist ein 9-Milliarden-Parameter-Modell, das auf den Techniken von GLM-4-32B basiert und eine leichtere Bereitstellung ermöglicht. Es überzeugt bei der Codegenerierung, Webdesign, SVG-Erstellung und suchbasiertem Schreiben.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking ist ein Open-Source-VLM von Zhipu AI und dem Tsinghua KEG Lab, entwickelt für komplexe multimodale Kognition. Basierend auf GLM-4-9B-0414 fügt es Chain-of-Thought-Reasoning und RL hinzu, um die cross-modale Argumentation und Stabilität erheblich zu verbessern.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 ist ein Modell für tiefgehende Argumentation, das auf GLM-4-32B-0414 basiert und mit Cold-Start-Daten sowie erweitertem Reinforcement Learning weitertrainiert wurde. Es wurde zusätzlich auf Mathematik, Code und Logik trainiert und verbessert die Fähigkeiten zur Lösung komplexer Aufgaben erheblich.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 ist ein kompaktes GLM-Modell mit 9 Milliarden Parametern, das die Stärken von Open-Source-Modellen beibehält und gleichzeitig eine beeindruckende Leistung bietet. Es überzeugt besonders bei mathematischer Argumentation und allgemeinen Aufgaben und ist führend in seiner Größenklasse unter offenen Modellen.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat ist das quelloffene GLM-4-Modell von Zhipu AI. Es zeigt starke Leistungen in Semantik, Mathematik, Argumentation, Code und Wissen. Neben mehrstufigem Dialog unterstützt es Web-Browsing, Codeausführung, benutzerdefinierte Tool-Aufrufe und Langtext-Argumentation. Es unterstützt 26 Sprachen (darunter Chinesisch, Englisch, Japanisch, Koreanisch, Deutsch) und erzielt gute Ergebnisse bei AlignBench-v2, MT-Bench, MMLU und C-Eval. Es unterstützt Kontexte bis zu 128.000 Tokens für akademische und geschäftliche Anwendungen.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B ist das erste Modell für langes Kontextdenken (LRM), das mit RL trainiert wurde und für langes Textdenken optimiert ist. Sein progressives Kontext-Erweiterungs-RL ermöglicht eine stabile Übertragung von kurzen zu langen Kontexten. Es übertrifft OpenAI-o3-mini und Qwen3-235B-A22B in sieben Benchmarks für langes Kontext-Dokument-QA und konkurriert mit Claude-3.7-Sonnet-Thinking. Besonders stark ist es in Mathematik, Logik und mehrstufigem Denken.",
   "Yi-34B-Chat.description": "Yi-1.5-34B bewahrt die starken allgemeinen Sprachfähigkeiten der Serie und verbessert durch inkrementelles Training mit 500 Milliarden hochwertigen Tokens die Leistungen in Mathematik, Logik und Programmierung deutlich.",
   "abab5.5-chat.description": "Entwickelt für produktive Szenarien mit komplexer Aufgabenverarbeitung und effizienter Textgenerierung für den professionellen Einsatz.",
   "abab5.5s-chat.description": "Optimiert für chinesische Persona-Chats und liefert hochwertige chinesische Dialoge für vielfältige Anwendungen.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet überzeugt durch herausragende Leistungen in den Bereichen Programmierung, Schreiben und komplexes Denken.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet mit erweitertem Denkvermögen für anspruchsvolle Aufgaben im Bereich komplexes Schlussfolgern.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet ist eine verbesserte Version mit erweitertem Kontext und erweiterten Fähigkeiten.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 ist das schnellste und intelligenteste Haiku-Modell von Anthropic, mit blitzschneller Geschwindigkeit und erweitertem Denken.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 ist ein schnelles und effizientes Modell für vielfältige Aufgaben.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking ist eine erweiterte Variante, die ihren Denkprozess offenlegen kann.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 ist das neueste und leistungsfähigste Modell von Anthropic für hochkomplexe Aufgaben, das in Leistung, Intelligenz, Sprachgewandtheit und Verständnis herausragt.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 ist das leistungsstärkste Modell von Anthropic für hochkomplexe Aufgaben, das in Leistung, Intelligenz, Sprachgewandtheit und Verständnis herausragt.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 ist das Flaggschiffmodell von Anthropic. Es kombiniert herausragende Intelligenz mit skalierbarer Leistung und ist ideal für komplexe Aufgaben, die höchste Qualität bei Antworten und logischem Denken erfordern.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 ist das intelligenteste Modell von Anthropic für die Entwicklung von Agenten und Programmierung.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking kann nahezu sofortige Antworten oder schrittweises Denken mit sichtbarem Prozess erzeugen.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 ist das bisher intelligenteste Modell von Anthropic, das nahezu sofortige Antworten oder erweitertes schrittweises Denken mit fein abgestimmter Kontrolle für API-Nutzer bietet.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 ist das bisher intelligenteste Modell von Anthropic.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 ist die beste Kombination aus Geschwindigkeit und Intelligenz von Anthropic.",
   "claude-sonnet-4.description": "Claude Sonnet 4 ist die neueste Generation mit verbesserter Leistung in allen Aufgabenbereichen.",
   "codegeex-4.description": "CodeGeeX-4 ist ein leistungsstarker KI-Coding-Assistent, der mehrsprachige Q&A und Codevervollständigung unterstützt, um die Produktivität von Entwicklern zu steigern.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B ist ein mehrsprachiges Codegenerierungsmodell, das Codevervollständigung, Codeinterpretation, Websuche, Funktionsaufrufe und Q&A auf Repositoriumsebene unterstützt. Es deckt eine Vielzahl von Softwareentwicklungsszenarien ab und ist eines der besten Code-Modelle unter 10 Milliarden Parametern.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "Die destillierten Modelle von DeepSeek-R1 nutzen RL und Cold-Start-Daten zur Verbesserung des Denkvermögens und setzen neue Maßstäbe für offene Multi-Task-Modelle.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "Die destillierten Modelle von DeepSeek-R1 nutzen RL und Cold-Start-Daten zur Verbesserung des Denkvermögens und setzen neue Maßstäbe für offene Multi-Task-Modelle.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B ist aus Qwen2.5-32B destilliert und auf 800.000 kuratierten DeepSeek-R1-Beispielen feinabgestimmt. Es überzeugt in Mathematik, Programmierung und logischem Denken mit starken Ergebnissen bei AIME 2024, MATH-500 (94,3 % Genauigkeit) und GPQA Diamond.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B wurde aus Qwen2.5-Math-7B destilliert und auf 800.000 kuratierten DeepSeek-R1-Proben feinabgestimmt. Es erzielt starke Leistungen mit 92,8 % bei MATH-500, 55,5 % bei AIME 2024 und einer CodeForces-Bewertung von 1189 für ein 7B-Modell.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 verbessert das Denkvermögen durch RL und Cold-Start-Daten, setzt neue Maßstäbe für offene Multi-Task-Modelle und übertrifft OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 ist ein Upgrade von DeepSeek-V2-Chat und DeepSeek-Coder-V2-Instruct und kombiniert allgemeine und Programmierfähigkeiten. Es verbessert das Schreiben und das Befolgen von Anweisungen für eine bessere Präferenzanpassung und zeigt deutliche Fortschritte bei AlpacaEval 2.0, ArenaHard, AlignBench und MT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus ist ein aktualisiertes V3.1-Modell, das als hybrides Agenten-LLM positioniert ist. Es behebt gemeldete Probleme, verbessert die Stabilität und Sprachkonsistenz und reduziert gemischte chinesisch/englische Ausgaben sowie fehlerhafte Zeichen. Es integriert Denk- und Nicht-Denk-Modi mit Chat-Vorlagen für flexibles Umschalten. Zudem verbessert es die Leistung von Code- und Suchagenten für zuverlässigere Toolnutzung und mehrstufige Aufgaben.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 ist ein Next-Gen-Denkmodell mit stärkerem komplexem Denken und Chain-of-Thought für tiefgreifende Analyseaufgaben.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 ist ein Next-Gen-Modell für logisches Denken mit stärkeren Fähigkeiten für komplexes Denken und Kettenlogik.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 ist ein MoE Vision-Language-Modell auf Basis von DeepSeekMoE-27B mit sparsamer Aktivierung. Es erreicht starke Leistung mit nur 4,5B aktiven Parametern und überzeugt bei visuellen QA-Aufgaben, OCR, Dokument-/Tabellen-/Diagrammverständnis und visueller Verankerung.",
+  "deepseek-chat.description": "DeepSeek V3.2 balanciert logisches Denken und Ausgabelänge für tägliche QA- und Agentenaufgaben. Öffentliche Benchmarks erreichen GPT-5-Niveau, und es ist das erste Modell, das Denken in die Werkzeugnutzung integriert und führende Open-Source-Agentenbewertungen erzielt.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B ist ein Code-Sprachmodell, trainiert auf 2 B Tokens (87 % Code, 13 % chinesisch/englischer Text). Es bietet ein 16K-Kontextfenster und Fill-in-the-Middle-Aufgaben für projektweite Codevervollständigung und Snippet-Ergänzung.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 ist ein Open-Source-MoE-Code-Modell mit starker Leistung bei Programmieraufgaben, vergleichbar mit GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 ist ein Open-Source-MoE-Code-Modell mit starker Leistung bei Programmieraufgaben, vergleichbar mit GPT-4 Turbo.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "DeepSeek R1 Schnellversion mit Echtzeit-Websuche – kombiniert 671B-Fähigkeiten mit schneller Reaktion.",
   "deepseek-r1-online.description": "DeepSeek R1 Vollversion mit 671B Parametern und Echtzeit-Websuche – bietet stärkeres Verständnis und bessere Generierung.",
   "deepseek-r1.description": "DeepSeek-R1 nutzt Cold-Start-Daten vor dem RL und erreicht vergleichbare Leistungen wie OpenAI-o1 bei Mathematik, Programmierung und logischem Denken.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking ist ein tiefes Argumentationsmodell, das vor der Ausgabe eine Gedankenkette generiert, um höhere Genauigkeit zu erzielen, mit Spitzenwettbewerbsergebnissen und Argumentationsfähigkeiten vergleichbar mit Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 ist ein effizientes MoE-Modell für kostengünstige Verarbeitung.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B ist das codefokussierte Modell von DeepSeek mit starker Codegenerierung.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 ist ein MoE-Modell mit 671B Parametern und herausragenden Stärken in Programmierung, technischer Kompetenz, Kontextverständnis und Langtextverarbeitung.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp führt Sparse Attention ein, um die Effizienz beim Training und bei der Inferenz bei langen Texten zu verbessern – zu einem günstigeren Preis als deepseek-v3.1.",
   "deepseek-v3.2-speciale.description": "Bei hochkomplexen Aufgaben übertrifft das Speciale-Modell die Standardversion deutlich, verbraucht jedoch erheblich mehr Tokens und verursacht höhere Kosten. Derzeit ist DeepSeek-V3.2-Speciale nur für Forschungszwecke vorgesehen, unterstützt keine Werkzeugaufrufe und wurde nicht speziell für alltägliche Konversations- oder Schreibaufgaben optimiert.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think ist ein vollwertiges Denkmodell mit stärkerer langkettiger Argumentation.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 ist DeepSeeks neuestes Programmiermodell mit starken Argumentationsfähigkeiten.",
   "deepseek-v3.description": "DeepSeek-V3 ist ein leistungsstarkes MoE-Modell mit insgesamt 671 Milliarden Parametern und 37 Milliarden aktiven Parametern pro Token.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small ist eine leichtgewichtige multimodale Version für ressourcenbeschränkte und hochparallele Anwendungen.",
   "deepseek-vl2.description": "DeepSeek VL2 ist ein multimodales Modell für Bild-Text-Verständnis und fein abgestimmte visuelle Fragebeantwortung.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K ist ein schnelles Denkmodell mit 32K Kontext für komplexe Schlussfolgerungen und mehrstufige Gespräche.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview ist ein Vorschau-Modell mit Denkfähigkeit zur Bewertung und zum Testen.",
   "ernie-x1.1.description": "ERNIE X1.1 ist ein Vorschau-Denkmodell für Evaluierung und Tests.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5, entwickelt vom ByteDance Seed-Team, unterstützt die Bearbeitung und Komposition mehrerer Bilder. Es bietet verbesserte Konsistenz des Motivs, präzise Befolgung von Anweisungen, räumliches Logikverständnis, ästhetischen Ausdruck, Posterlayout und Logodesign mit hochpräziser Text-Bild-Wiedergabe.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0, entwickelt von ByteDance Seed, unterstützt Text- und Bildeingaben für hochkontrollierbare, qualitativ hochwertige Bildgenerierung aus Eingabeaufforderungen.",
   "fal-ai/flux-kontext/dev.description": "FLUX.1-Modell mit Fokus auf Bildbearbeitung, unterstützt Text- und Bildeingaben.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] akzeptiert Texte und Referenzbilder als Eingabe und ermöglicht gezielte lokale Bearbeitungen sowie komplexe globale Szenentransformationen.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] ist ein Bildgenerierungsmodell mit ästhetischer Ausrichtung auf realistischere, natürliche Bilder.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "Ein leistungsstarkes natives multimodales Bildgenerierungsmodell.",
   "fal-ai/imagen4/preview.description": "Hochwertiges Bildgenerierungsmodell von Google.",
   "fal-ai/nano-banana.description": "Nano Banana ist das neueste, schnellste und effizienteste native multimodale Modell von Google. Es ermöglicht Bildgenerierung und -bearbeitung im Dialog.",
+  "fal-ai/qwen-image-edit.description": "Ein professionelles Bildbearbeitungsmodell des Qwen-Teams, das semantische und Erscheinungsbearbeitungen, präzise chinesische/englische Textbearbeitung, Stiltransfer, Rotation und mehr unterstützt.",
+  "fal-ai/qwen-image.description": "Ein leistungsstarkes Bildgenerierungsmodell des Qwen-Teams mit starker chinesischer Textrendering-Fähigkeit und vielfältigen visuellen Stilen.",
   "flux-1-schnell.description": "Ein Text-zu-Bild-Modell mit 12 Milliarden Parametern von Black Forest Labs, das latente adversariale Diffusionsdistillation nutzt, um hochwertige Bilder in 1–4 Schritten zu erzeugen. Es konkurriert mit geschlossenen Alternativen und ist unter Apache-2.0 für persönliche, Forschungs- und kommerzielle Nutzung verfügbar.",
   "flux-dev.description": "FLUX.1 [dev] ist ein Modell mit offenen Gewichten für nicht-kommerzielle Nutzung. Es bietet nahezu professionelle Bildqualität und Befolgung von Anweisungen bei effizienterer Nutzung von Ressourcen im Vergleich zu Standardmodellen gleicher Größe.",
   "flux-kontext-max.description": "Modernste kontextuelle Bildgenerierung und -bearbeitung, kombiniert Text und Bilder für präzise, kohärente Ergebnisse.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro ist Googles fortschrittlichstes Reasoning-Modell, das über Code, Mathematik und MINT-Probleme nachdenken und große Datensätze, Codebasen und Dokumente mit langem Kontext analysieren kann.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash ist das intelligenteste Modell, das auf Geschwindigkeit ausgelegt ist – es vereint modernste Intelligenz mit exzellenter Suchverankerung.",
   "gemini-3-pro-image-preview.description": "Gemini 3 Pro Image (Nano Banana Pro) ist Googles Bildgenerierungsmodell, das auch multimodale Dialoge unterstützt.",
+  "gemini-3-pro-image-preview:image.description": "Gemini 3 Pro Image (Nano Banana Pro) ist Googles Bildgenerierungsmodell und unterstützt auch multimodale Chats.",
   "gemini-3-pro-preview.description": "Gemini 3 Pro ist Googles leistungsstärkstes Agenten- und Vibe-Coding-Modell. Es bietet reichhaltigere visuelle Inhalte und tiefere Interaktionen auf Basis modernster logischer Fähigkeiten.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) ist Googles schnellstes natives Bildgenerierungsmodell mit Denkunterstützung, konversationaler Bildgenerierung und -bearbeitung.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) liefert Pro-Level-Bildqualität mit Flash-Geschwindigkeit und unterstützt multimodale Chats.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview ist Googles kosteneffizientestes multimodales Modell, optimiert für hochvolumige agentische Aufgaben, Übersetzung und Datenverarbeitung.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview verbessert Gemini 3 Pro mit erweiterten Fähigkeiten für logisches Denken und unterstützt mittleres Denklevel.",
   "gemini-flash-latest.description": "Neueste Version von Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "Hochgeschwindigkeitsvariante von K2 mit erweitertem Denkvermögen, 256k Kontext, starkem logischen Denken und einer Ausgabe von 60–100 Token/Sekunde.",
   "kimi-k2-thinking.description": "kimi-k2-thinking ist ein Denkmodell von Moonshot AI mit allgemeinen Agenten- und Denkfähigkeiten. Es glänzt durch tiefes logisches Denken und kann komplexe Probleme durch mehrstufige Werkzeugnutzung lösen.",
   "kimi-k2-turbo-preview.description": "kimi-k2 ist ein MoE-Grundlagenmodell mit starken Fähigkeiten in den Bereichen Programmierung und Agentenfunktionen (1T Gesamtparameter, 32B aktiv) und übertrifft andere gängige Open-Source-Modelle in den Bereichen logisches Denken, Programmierung, Mathematik und Agenten-Benchmarks.",
+  "kimi-k2.5.description": "Kimi K2.5 ist Kimi's vielseitigstes Modell bisher, mit einer nativen multimodalen Architektur, die sowohl visuelle als auch Texteingaben unterstützt, 'Denk'- und 'Nicht-Denk'-Modi sowie Konversations- und Agentenaufgaben.",
   "kimi-k2.description": "Kimi-K2 ist ein MoE-Basismodell von Moonshot AI mit starken Fähigkeiten in den Bereichen Programmierung und Agentenfunktionen, insgesamt 1T Parameter mit 32B aktiven. In Benchmarks zu allgemeinem logischen Denken, Programmierung, Mathematik und Agentenaufgaben übertrifft es andere gängige Open-Source-Modelle.",
   "kimi-k2:1t.description": "Kimi K2 ist ein großes MoE-LLM von Moonshot AI mit insgesamt 1T Parametern und 32B aktiven pro Durchlauf. Es ist für Agentenfunktionen wie fortgeschrittene Werkzeugnutzung, logisches Denken und Codegenerierung optimiert.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (zeitlich begrenzt kostenlos) konzentriert sich auf Codeverständnis und Automatisierung für effiziente Programmieragenten.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K unterstützt 32.768 Tokens für mittellange Kontexte – ideal für lange Dokumente und komplexe Dialoge in der Inhaltserstellung, Berichterstattung und Chat-Systemen.",
   "moonshot-v1-8k-vision-preview.description": "Kimi Vision-Modelle (einschließlich moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) können Bildinhalte wie Text, Farben und Objektformen verstehen.",
   "moonshot-v1-8k.description": "Moonshot V1 8K ist für die Generierung kurzer Texte mit effizienter Leistung optimiert und verarbeitet 8.192 Tokens – ideal für kurze Chats, Notizen und schnelle Inhalte.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B ist ein Open-Source-Code-LLM, optimiert durch großskaliges RL, um robuste, produktionsreife Patches zu erstellen. Es erzielt 60,4 % auf SWE-bench Verified und setzt einen neuen Rekord für automatisierte Software-Engineering-Aufgaben wie Fehlerbehebung und Code-Review.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 ist das neueste und leistungsstärkste Modell der Kimi K2-Reihe. Es handelt sich um ein MoE-Spitzenmodell mit insgesamt 1T und 32B aktiven Parametern. Zu den Hauptmerkmalen gehören eine stärkere agentenbasierte Codierungsintelligenz mit deutlichen Verbesserungen bei Benchmarks und realen Agentenaufgaben sowie eine verbesserte Ästhetik und Benutzerfreundlichkeit im Frontend-Code.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking ist das neueste und leistungsstärkste Open-Source-Denkmodell. Es erweitert die Tiefe des mehrstufigen Denkens erheblich und gewährleistet stabile Werkzeugnutzung über 200–300 aufeinanderfolgende Aufrufe, wobei neue Rekorde bei Humanity's Last Exam (HLE), BrowseComp und anderen Benchmarks aufgestellt werden. Es zeichnet sich in den Bereichen Programmierung, Mathematik, Logik und Agentenszenarien aus. Basierend auf einer MoE-Architektur mit ~1 Billion Gesamtparametern unterstützt es ein 256K-Kontextfenster und Werkzeugaufrufe.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 ist die Instruct-Variante der Kimi-Serie, geeignet für hochwertigen Code und Werkzeugnutzung.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "Next-Gen Qwen-Coder optimiert für komplexe Multi-Datei-Codegenerierung, Debugging und hochdurchsatzfähige Agenten-Workflows. Entwickelt für starke Werkzeugintegration und verbesserte Leistung im logischen Denken.",
   "qwen3-coder-plus.description": "Qwen-Code-Modell. Die neueste Qwen3-Coder-Serie basiert auf Qwen3 und bietet starke Fähigkeiten für Coding-Agenten, Werkzeugnutzung und Interaktion mit Umgebungen für autonomes Programmieren, mit exzellenter Codeleistung und solider Allgemeinkompetenz.",
   "qwen3-coder:480b.description": "Alibabas leistungsstarkes Langkontextmodell für Agenten- und Programmieraufgaben.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: Bestleistendes Qwen-Modell für komplexe, mehrstufige Programmieraufgaben mit Unterstützung für logisches Denken.",
   "qwen3-max-preview.description": "Leistungsstärkstes Qwen-Modell für komplexe, mehrstufige Aufgaben. Die Vorschau unterstützt Denkprozesse.",
   "qwen3-max.description": "Qwen3 Max-Modelle bieten große Fortschritte gegenüber der 2.5-Serie in allgemeiner Fähigkeit, chinesisch/englischem Verständnis, komplexer Anweisungsbefolgung, offenen subjektiven Aufgaben, Mehrsprachigkeit und Werkzeugnutzung bei weniger Halluzinationen. Das neueste qwen3-max verbessert agentisches Programmieren und Werkzeugnutzung gegenüber qwen3-max-preview. Diese Version erreicht SOTA-Niveau und zielt auf komplexere Agentenanforderungen.",
   "qwen3-next-80b-a3b-instruct.description": "Nächste Generation des Qwen3 Open-Source-Modells ohne Denkfunktion. Im Vergleich zur vorherigen Version (Qwen3-235B-A22B-Instruct-2507) bietet es besseres chinesisches Verständnis, stärkere logische Schlussfolgerung und verbesserte Textgenerierung.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ ist ein Schlussfolgerungsmodell aus der Qwen-Familie. Im Vergleich zu standardmäßig instruktionstunierten Modellen bietet es überlegene Denk- und Schlussfolgerungsfähigkeiten, die die Leistung bei nachgelagerten Aufgaben deutlich verbessern – insbesondere bei schwierigen Problemen. QwQ-32B ist ein mittelgroßes Modell, das mit führenden Schlussfolgerungsmodellen wie DeepSeek-R1 und o1-mini mithalten kann.",
   "qwq_32b.description": "Mittelgroßes Schlussfolgerungsmodell aus der Qwen-Familie. Im Vergleich zu standardmäßig instruktionstunierten Modellen steigern QwQs Denk- und Schlussfolgerungsfähigkeiten die Leistung bei nachgelagerten Aufgaben deutlich – insbesondere bei schwierigen Problemen.",
   "r1-1776.description": "R1-1776 ist eine nachtrainierte Variante von DeepSeek R1, die darauf ausgelegt ist, unzensierte, objektive und faktenbasierte Informationen bereitzustellen.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro von ByteDance unterstützt Text-zu-Video, Bild-zu-Video (erstes Bild, erstes+letztes Bild) und Audiogenerierung synchronisiert mit visuellen Elementen.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite von BytePlus bietet webabfrage-unterstützte Generierung für Echtzeitinformationen, verbesserte Interpretation komplexer Eingabeaufforderungen und verbesserte Konsistenz von Referenzen für professionelle visuelle Kreationen.",
   "solar-mini-ja.description": "Solar Mini (Ja) erweitert Solar Mini mit einem Fokus auf Japanisch und behält dabei eine effiziente und starke Leistung in Englisch und Koreanisch bei.",
   "solar-mini.description": "Solar Mini ist ein kompaktes LLM, das GPT-3.5 übertrifft. Es bietet starke mehrsprachige Fähigkeiten in Englisch und Koreanisch und ist eine effiziente Lösung mit kleinem Ressourcenbedarf.",
   "solar-pro.description": "Solar Pro ist ein hochintelligentes LLM von Upstage, das auf Befolgen von Anweisungen auf einer einzelnen GPU ausgelegt ist und IFEval-Werte über 80 erreicht. Derzeit wird Englisch unterstützt; die vollständige Veröffentlichung mit erweitertem Sprachsupport und längeren Kontexten war für November 2024 geplant.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "Stepfuns Flaggschiff-Sprachargumentationsmodell. Dieses Modell verfügt über erstklassige Argumentationsfähigkeiten und schnelle sowie zuverlässige Ausführungskapazitäten. Es kann komplexe Aufgaben wie logisches Denken, Mathematik, Softwareentwicklung und tiefgehende Forschung zerlegen und planen, Werkzeuge schnell und zuverlässig aufrufen, um Aufgaben auszuführen, und ist in verschiedenen komplexen Aufgaben kompetent.",
   "step-3.description": "Dieses Modell verfügt über starke visuelle Wahrnehmung und komplexe Schlussfolgerungsfähigkeiten. Es verarbeitet domänenübergreifendes Wissen, analysiert Mathematik und visuelle Inhalte gemeinsam und bewältigt eine Vielzahl alltäglicher visueller Analyseaufgaben.",
   "step-r1-v-mini.description": "Ein Schlussfolgerungsmodell mit starkem Bildverständnis, das Bilder und Texte verarbeiten und anschließend durch tiefes Denken Text generieren kann. Es glänzt im visuellen Denken und liefert Spitzenleistungen in Mathematik, Programmierung und Textverständnis – mit einem Kontextfenster von 100K.",
+  "stepfun-ai/step3.description": "Step3 ist ein hochmodernes multimodales Argumentationsmodell von StepFun, basierend auf einer MoE-Architektur mit 321 Milliarden Gesamt- und 38 Milliarden aktiven Parametern. Sein End-to-End-Design minimiert Dekodierungskosten und liefert erstklassige Vision-Language-Argumentation. Mit MFA- und AFD-Design bleibt es effizient auf sowohl Flaggschiff- als auch Low-End-Beschleunigern. Das Pretraining verwendet über 20 Billionen Text-Tokens und 4 Billionen Bild-Text-Tokens in vielen Sprachen. Es erreicht führende Open-Model-Leistungen bei Mathematik-, Code- und multimodalen Benchmarks.",
   "taichu4_vl_2b_nothinking.description": "Die No-Thinking-Version des Taichu4.0-VL 2B-Modells bietet geringeren Speicherverbrauch, ein leichtes Design, schnelle Reaktionsgeschwindigkeit und starke multimodale Verständnisfähigkeiten.",
   "taichu4_vl_32b.description": "Die Thinking-Version des Taichu4.0-VL 32B-Modells eignet sich für komplexe multimodale Verständnis- und Denkaufgaben und zeigt herausragende Leistung in multimodaler mathematischer Logik, multimodalen Agentenfähigkeiten und allgemeinem Bild- und visuellen Verständnis.",
   "taichu4_vl_32b_nothinking.description": "Die No-Thinking-Version des Taichu4.0-VL 32B-Modells ist für komplexe Bild- und Textverständnis- sowie visuelle Wissens-QA-Szenarien konzipiert und zeichnet sich durch Bildunterschriftenerstellung, visuelle Fragenbeantwortung, Videoverständnis und visuelle Lokalisierungsaufgaben aus.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air ist ein Basismodell für Agentenanwendungen mit Mixture-of-Experts-Architektur. Es ist optimiert für Toolnutzung, Web-Browsing, Softwareentwicklung und Frontend-Codierung und integriert sich mit Code-Agenten wie Claude Code und Roo Code. Es nutzt hybrides Reasoning für komplexe und alltägliche Szenarien.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V ist Zhipu AIs neuestes VLM, basierend auf dem GLM-4.5-Air-Textmodell (106B gesamt, 12B aktiv) mit MoE-Architektur für starke Leistung bei geringeren Kosten. Es folgt dem GLM-4.1V-Thinking-Ansatz und fügt 3D-RoPE zur Verbesserung des 3D-Räumlichkeitsdenkens hinzu. Optimiert durch Pretraining, SFT und RL, verarbeitet es Bilder, Videos und lange Dokumente und belegt Spitzenplätze unter offenen Modellen in 41 öffentlichen multimodalen Benchmarks. Ein Thinking-Modus-Schalter ermöglicht die Balance zwischen Geschwindigkeit und Tiefe.",
   "zai-org/GLM-4.6.description": "Im Vergleich zu GLM-4.5 erweitert GLM-4.6 den Kontext von 128K auf 200K für komplexere Agentenaufgaben. Es erzielt höhere Werte in Code-Benchmarks und zeigt stärkere reale Leistung in Apps wie Claude Code, Cline, Roo Code und Kilo Code – einschließlich besserer Frontend-Seitengenerierung. Reasoning wurde verbessert und Toolnutzung während des Denkens unterstützt, was die Gesamtleistung stärkt. Es integriert sich besser in Agentenframeworks, verbessert Tool-/Suchagenten und bietet einen menschenfreundlicheren Schreibstil und natürlichere Rollenspiele.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V erreicht SOTA-Genauigkeit bei visueller Wahrnehmung für seine Parametergröße und ist das erste Modell, das Funktion-Call-Fähigkeiten nativ in die Architektur des Vision-Modells integriert, wodurch die Lücke zwischen 'visueller Wahrnehmung' und 'ausführbaren Aktionen' geschlossen wird. Es bietet eine einheitliche technische Grundlage für multimodale Agenten in realen Geschäftsszenarien. Das visuelle Kontextfenster wird auf 128k erweitert und unterstützt die Verarbeitung langer Videostreams sowie die Analyse hochauflösender Multi-Bilder.",
   "zai/glm-4.5-air.description": "GLM-4.5 und GLM-4.5-Air sind unsere neuesten Flaggschiffe für Agentenanwendungen, beide mit MoE. GLM-4.5 hat 355B gesamt und 32B aktiv pro Forward-Pass; GLM-4.5-Air ist schlanker mit 106B gesamt und 12B aktiv.",
   "zai/glm-4.5.description": "Die GLM-4.5-Serie ist für Agenten konzipiert. Das Flaggschiff GLM-4.5 kombiniert Reasoning-, Coding- und Agentenfähigkeiten mit 355B Gesamtparametern (32B aktiv) und bietet zwei Betriebsmodi als hybrides Reasoning-System.",
   "zai/glm-4.5v.description": "GLM-4.5V baut auf GLM-4.5-Air auf, übernimmt bewährte GLM-4.1V-Thinking-Techniken und skaliert mit einer starken 106B-Parameter-MoE-Architektur.",

locales/de-DE/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure bietet fortschrittliche KI-Modelle, darunter die GPT-3.5- und GPT-4-Serien, für vielfältige Datentypen und komplexe Aufgaben mit Fokus auf sichere, zuverlässige und nachhaltige KI.",
   "azureai.description": "Azure stellt fortschrittliche KI-Modelle wie GPT-3.5 und GPT-4 für verschiedenste Datentypen und komplexe Aufgaben bereit – mit Fokus auf Sicherheit, Zuverlässigkeit und Nachhaltigkeit.",
   "baichuan.description": "Baichuan AI konzentriert sich auf Foundation-Modelle mit starker Leistung im chinesischen Sprachverständnis, Langkontextverarbeitung und kreativer Generierung. Die Modelle (Baichuan 4, Baichuan 3 Turbo, Baichuan 3 Turbo 128k) sind für verschiedene Szenarien optimiert und bieten hohen Mehrwert.",
+  "bailiancodingplan.description": "Der Aliyun Bailian Coding Plan ist ein spezialisierter KI-Coding-Dienst, der über einen dedizierten Endpunkt Zugriff auf coding-optimierte Modelle wie Qwen, GLM, Kimi und MiniMax bietet.",
   "bedrock.description": "Amazon Bedrock stellt Unternehmen fortschrittliche Sprach- und Bildmodelle zur Verfügung, darunter Anthropic Claude und Meta Llama 3.1 – von leichten bis leistungsstarken Optionen für Text-, Chat- und Bildaufgaben.",
   "bfl.description": "Ein führendes KI-Forschungslabor an der Spitze der visuellen Infrastruktur von morgen.",
   "cerebras.description": "Cerebras ist eine Inferenzplattform auf Basis des CS-3-Systems, die auf extrem niedrige Latenz und hohen Durchsatz für Echtzeitanwendungen wie Codegenerierung und Agentenaufgaben ausgelegt ist.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Gitee AI Serverless APIs bieten sofort einsatzbereite LLM-Inferenzdienste für Entwickler.",
   "github.description": "Mit GitHub Models können Entwickler als KI-Ingenieure mit branchenführenden Modellen arbeiten.",
   "githubcopilot.description": "Greifen Sie mit Ihrem GitHub Copilot-Abonnement auf die Modelle Claude, GPT und Gemini zu.",
+  "glmcodingplan.description": "Der GLM Coding Plan bietet Zugriff auf Zhipu AI-Modelle, darunter GLM-5 und GLM-4.7, für Coding-Aufgaben im Rahmen eines Festpreis-Abonnements.",
   "google.description": "Die Gemini-Familie von Google ist die fortschrittlichste Allzweck-KI von Google DeepMind für multimodale Anwendungen in Text, Code, Bildern, Audio und Video. Sie skaliert effizient von Rechenzentren bis zu Mobilgeräten.",
   "groq.description": "Groqs LPU-Inferenz-Engine liefert herausragende Benchmark-Leistung mit außergewöhnlicher Geschwindigkeit und Effizienz – ideal für latenzarme, cloudbasierte LLM-Inferenz.",
   "higress.description": "Higress ist ein cloud-natives API-Gateway, das bei Alibaba entwickelt wurde, um Tengine-Neuladeprobleme bei langlebigen Verbindungen und Lücken im gRPC/Dubbo-Load-Balancing zu beheben.",
@@ -29,9 +31,12 @@
   "infiniai.description": "Bietet App-Entwicklern leistungsstarke, benutzerfreundliche und sichere LLM-Dienste über den gesamten Workflow – von der Modellentwicklung bis zur produktiven Bereitstellung.",
   "internlm.description": "Eine Open-Source-Organisation für Forschung und Tools rund um große Modelle – mit einer effizienten, benutzerfreundlichen Plattform für den Zugang zu modernsten Modellen und Algorithmen.",
   "jina.description": "Jina AI wurde 2020 gegründet und ist ein führendes Unternehmen im Bereich Such-KI. Der Such-Stack umfasst Vektormodelle, Reranker und kleine Sprachmodelle für zuverlässige, hochwertige generative und multimodale Suchanwendungen.",
+  "kimicodingplan.description": "Kimi Code von Moonshot AI bietet Zugriff auf Kimi-Modelle, darunter K2.5, für Coding-Aufgaben.",
   "lmstudio.description": "LM Studio ist eine Desktop-App zur Entwicklung und zum Experimentieren mit LLMs auf dem eigenen Computer.",
+  "lobehub.description": "LobeHub Cloud verwendet offizielle APIs, um auf KI-Modelle zuzugreifen, und misst die Nutzung mit Credits, die an Modell-Tokens gebunden sind.",
   "longcat.description": "LongCat ist eine Reihe von generativen KI-Großmodellen, die unabhängig von Meituan entwickelt wurden. Sie sind darauf ausgelegt, die Produktivität innerhalb des Unternehmens zu steigern und innovative Anwendungen durch eine effiziente Rechenarchitektur und starke multimodale Fähigkeiten zu ermöglichen.",
   "minimax.description": "MiniMax wurde 2021 gegründet und entwickelt allgemeine KI mit multimodalen Foundation-Modellen, darunter Textmodelle mit Billionen Parametern, Sprach- und Bildmodelle sowie Apps wie Hailuo AI.",
+  "minimaxcodingplan.description": "Der MiniMax Token Plan bietet Zugriff auf MiniMax-Modelle, darunter M2.7, für Coding-Aufgaben im Rahmen eines Festpreis-Abonnements.",
   "mistral.description": "Mistral bietet fortschrittliche allgemeine, spezialisierte und Forschungsmodelle für komplexes Denken, mehrsprachige Aufgaben und Codegenerierung – inklusive Funktionsaufrufen für individuelle Integrationen.",
   "modelscope.description": "ModelScope ist die Model-as-a-Service-Plattform von Alibaba Cloud mit einer breiten Auswahl an KI-Modellen und Inferenzdiensten.",
   "moonshot.description": "Moonshot von Moonshot AI (Beijing Moonshot Technology) bietet mehrere NLP-Modelle für Anwendungsfälle wie Content-Erstellung, Forschung, Empfehlungen und medizinische Analysen – mit starker Langkontext- und komplexer Generierungsunterstützung.",
@@ -64,6 +69,7 @@
   "vertexai.description": "Die Gemini-Familie von Google ist die fortschrittlichste Allzweck-KI von Google DeepMind für multimodale Anwendungen in Text, Code, Bildern, Audio und Video – skalierbar von Rechenzentren bis zu Mobilgeräten.",
   "vllm.description": "vLLM ist eine schnelle, benutzerfreundliche Bibliothek für LLM-Inferenz und -Bereitstellung.",
   "volcengine.description": "Die Modellserviceplattform von ByteDance bietet sicheren, funktionsreichen und kostengünstigen Modellzugang sowie End-to-End-Tools für Daten, Feintuning, Inferenz und Bewertung.",
+  "volcenginecodingplan.description": "Der Volcengine Coding Plan von ByteDance bietet Zugriff auf mehrere Coding-Modelle, darunter Doubao-Seed-Code, GLM-4.7, DeepSeek-V3.2 und Kimi-K2.5, im Rahmen eines Festpreis-Abonnements.",
   "wenxin.description": "Eine All-in-One-Plattform für Unternehmen zur Entwicklung von Foundation-Modellen und KI-nativen Anwendungen – mit End-to-End-Tools für generative KI-Workflows.",
   "xai.description": "xAI entwickelt KI zur Beschleunigung wissenschaftlicher Entdeckungen – mit dem Ziel, das Verständnis des Universums durch die Menschheit zu vertiefen.",
   "xiaomimimo.description": "Xiaomi MiMo bietet einen Konversationsmodell-Service mit einer OpenAI-kompatiblen API. Das Modell mimo-v2-flash unterstützt tiefgreifendes Schlussfolgern, Streaming-Ausgaben, Funktionsaufrufe, ein Kontextfenster von 256K sowie eine maximale Ausgabe von 128K.",

locales/de-DE/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "Unterstützt Kreditkarte / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "Unterstützt Kreditkarte",
   "plans.btn.soon": "Demnächst verfügbar",
+  "plans.cancelDowngrade": "Geplante Herabstufung abbrechen",
+  "plans.cancelDowngradeSuccess": "Geplante Herabstufung wurde abgebrochen",
   "plans.changePlan": "Plan auswählen",
   "plans.cloud.history": "Unbegrenzter Gesprächsverlauf",
   "plans.cloud.sync": "Globale Cloud-Synchronisierung",
@@ -215,6 +217,7 @@
   "plans.current": "Aktueller Plan",
   "plans.downgradePlan": "Ziel-Down-Grade-Plan",
   "plans.downgradeTip": "Sie haben bereits einen Planwechsel vorgenommen. Weitere Änderungen sind erst nach Abschluss möglich",
+  "plans.downgradeWillCancel": "Diese Aktion wird Ihre geplante Tarifherabstufung abbrechen",
   "plans.embeddingStorage.embeddings": "Einträge",
   "plans.embeddingStorage.title": "Vektorspeicher",
   "plans.embeddingStorage.tooltip": "Eine Dokumentenseite (1000–1500 Zeichen) erzeugt ca. 1 Vektoreintrag. (Schätzung basierend auf OpenAI Embeddings, modellabhängig)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "Auswahl bestätigen",
   "plans.payonce.popconfirm": "Nach einer Einmalzahlung können Sie den Plan oder Abrechnungszeitraum erst nach Ablauf ändern. Bitte bestätigen Sie Ihre Auswahl.",
   "plans.payonce.tooltip": "Bei Einmalzahlung ist ein Wechsel erst nach Ablauf des Abonnements möglich",
+  "plans.pendingDowngrade": "Ausstehende Herabstufung",
   "plans.plan.enterprise.contactSales": "Vertrieb kontaktieren",
   "plans.plan.enterprise.title": "Enterprise",
   "plans.plan.free.desc": "Für Erstnutzer",
@@ -366,6 +370,7 @@
   "summary.title": "Abrechnungsübersicht",
   "summary.usageThisMonth": "Nutzung in diesem Monat anzeigen.",
   "summary.viewBillingHistory": "Zahlungsverlauf anzeigen",
+  "switchDowngradeTarget": "Ziel der Herabstufung ändern",
   "switchPlan": "Plan wechseln",
   "switchToMonthly.desc": "Nach dem Wechsel wird die monatliche Abrechnung nach Ablauf des aktuellen Jahresplans aktiv.",
   "switchToMonthly.title": "Zu monatlicher Abrechnung wechseln",

locales/en-US/agent.json

@@ -86,5 +86,7 @@
   "channel.wechatQrScaned": "QR code scanned. Please confirm the login in WeChat.",
   "channel.wechatQrWait": "Open WeChat and scan the QR code to connect.",
   "channel.wechatScanTitle": "Connect WeChat Bot",
-  "channel.wechatScanToConnect": "Scan QR Code to Connect"
+  "channel.wechatScanToConnect": "Scan QR Code to Connect",
+  "channel.wechatTip1": "Please update WeChat to the latest version, and it is recommended to restart WeChat.",
+  "channel.wechatTip2": "The WeChat ClawBot plugin is currently in gradual rollout. You can check Settings => Plugins to confirm whether you have access."
 }

locales/en-US/auth.json

@@ -230,7 +230,7 @@
   "tab.profile": "My Account",
   "tab.security": "Security",
   "tab.stats": "Statistics",
-  "tab.usage": "Usage Statistics",
+  "tab.usage": "Usage",
   "usage.activeModels.modelTable": "Model List",
   "usage.activeModels.models": "Active Models",
   "usage.activeModels.providerTable": "Provider List",

locales/en-US/common.json

@@ -97,7 +97,7 @@
   "cmdk.aiModeEmptyState": "Type your question above to start chatting with AI",
   "cmdk.aiModeHint": "Press Enter to ask",
   "cmdk.aiModePlaceholder": "Ask AI anything...",
-  "cmdk.aiPainting": "AI Art",
+  "cmdk.aiPainting": "AI Image",
   "cmdk.askAI": "Ask Agent",
   "cmdk.askAIHeading": "Use the following features for {{query}}",
   "cmdk.askAIHeadingEmpty": "Choose an AI feature",
@@ -113,7 +113,7 @@
   "cmdk.context.group": "Group",
   "cmdk.context.memory": "Memory",
   "cmdk.context.page": "Page",
-  "cmdk.context.painting": "Painting",
+  "cmdk.context.painting": "Image",
   "cmdk.context.resource": "Resource",
   "cmdk.context.settings": "Settings",
   "cmdk.discover": "Discover",
@@ -156,7 +156,7 @@
   "cmdk.noResults": "No Results found",
   "cmdk.openSettings": "Open Settings",
   "cmdk.pages": "Pages",
-  "cmdk.painting": "Painting",
+  "cmdk.painting": "Image",
   "cmdk.resource": "Resources",
   "cmdk.search.agent": "Agent",
   "cmdk.search.agents": "Agents",
@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Connection Failed",
   "sync.title": "Sync Status",
   "sync.unconnected.tip": "Signaling server connection failed, and peer-to-peer communication channel cannot be established. Please check the network and try again.",
-  "tab.aiImage": "Artwork",
   "tab.audio": "Audio",
   "tab.chat": "Chat",
   "tab.community": "Community",
@@ -405,6 +404,7 @@
   "tab.eval": "Eval Lab",
   "tab.files": "Files",
   "tab.home": "Home",
+  "tab.image": "Image",
   "tab.knowledgeBase": "Library",
   "tab.marketplace": "Marketplace",
   "tab.me": "Me",
@@ -429,10 +429,10 @@
   "upgradeVersion.newVersion": "Update available: {{version}}",
   "upgradeVersion.serverVersion": "Server: {{version}}",
   "userPanel.anonymousNickName": "Anonymous User",
-  "userPanel.billing": "Billing Management",
+  "userPanel.billing": "Billing",
   "userPanel.cloud": "Launch {{name}}",
   "userPanel.community": "Community",
-  "userPanel.credits": "Credits Management",
+  "userPanel.credits": "Credits",
   "userPanel.data": "Data Storage",
   "userPanel.defaultNickname": "Community User",
   "userPanel.discord": "Discord",
@@ -445,6 +445,6 @@
   "userPanel.profile": "Account",
   "userPanel.setting": "Settings",
   "userPanel.upgradePlan": "Upgrade Plan",
-  "userPanel.usages": "Usage Statistics",
+  "userPanel.usages": "Usage",
   "version": "Version"
 }

locales/en-US/electron.json

@@ -1,4 +1,13 @@
 {
+  "gateway.description": "Description",
+  "gateway.descriptionPlaceholder": "Optional",
+  "gateway.deviceName": "Device Name",
+  "gateway.deviceNamePlaceholder": "Enter device name",
+  "gateway.enableConnection": "Connect to Gateway",
+  "gateway.statusConnected": "Connected to Gateway",
+  "gateway.statusConnecting": "Connecting to Gateway...",
+  "gateway.statusDisconnected": "Not connected to Gateway",
+  "gateway.title": "Device Gateway",
   "navigation.chat": "Chat",
   "navigation.discover": "Discover",
   "navigation.discoverAssistants": "Discover Assistants",

locales/en-US/image.json

@@ -4,7 +4,7 @@
   "config.aspectRatio.unlock": "Unlock Aspect Ratio",
   "config.cfg.label": "Guidance Intensity",
   "config.header.desc": "Brief description, create instantly",
-  "config.header.title": "Painting",
+  "config.header.title": "Image",
   "config.height.label": "Height",
   "config.imageNum.label": "Number of Images",
   "config.imageUrl.label": "Reference Image",
@@ -58,6 +58,6 @@
   "topic.deleteConfirm": "Delete Generation Topic",
   "topic.deleteConfirmDesc": "You are about to delete this generation topic. This action cannot be undone, please proceed with caution.",
   "topic.empty": "No generation topics",
-  "topic.title": "Painting Theme",
+  "topic.title": "Image Topic",
   "topic.untitled": "Default Topic"
 }

locales/en-US/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "For Gemini 3 image generation models; controls resolution of generated images.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "For Gemini 3.1 Flash Image models; controls resolution of generated images (supports 512px).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "For Claude, Qwen3 and similar; controls token budget for reasoning.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "For GLM-5 and GLM-4.7; controls token budget for reasoning (max 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "For Qwen3 series; controls token budget for reasoning (max 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "For OpenAI and other reasoning-capable models; controls reasoning effort.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "For GPT-5+ series; controls output verbosity.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "For some Doubao models; allow model to decide whether to think deeply.",

locales/en-US/models.json

@@ -88,6 +88,7 @@
   "MiniMax-M1.description": "A new in-house reasoning model with 80K chain-of-thought and 1M input, delivering performance comparable to top global models.",
   "MiniMax-M2-Stable.description": "Built for efficient coding and agent workflows, with higher concurrency for commercial use.",
   "MiniMax-M2.1-Lightning.description": "Powerful multilingual programming capabilities, comprehensively upgraded programming experience. Faster and more efficient.",
+  "MiniMax-M2.1-highspeed.description": "Powerful multilingual programming capabilities with faster and more efficient inference.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 is a flagship open-source large model from MiniMax, focusing on solving complex real-world tasks. Its core strengths are multi-language programming capabilities and the ability to solve complex tasks as an Agent.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: Same performance, faster and more agile (approx. 100 tps).",
   "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: Same performance as M2.5 with faster inference.",
@@ -96,6 +97,8 @@
   "MiniMax-M2.7.description": "MiniMax M2.7: Beginning the journey of recursive self-improvement, top real-world engineering capabilities.",
   "MiniMax-M2.description": "MiniMax M2: Previous generation model.",
   "MiniMax-Text-01.description": "MiniMax-01 introduces large-scale linear attention beyond classic Transformers, with 456B parameters and 45.9B activated per pass. It achieves top-tier performance and supports up to 4M tokens of context (32× GPT-4o, 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 is an open-weights large-scale hybrid-attention reasoning model with 456B total parameters and ~45.9B active per token. It natively supports 1M context and uses Flash Attention to cut FLOPs by 75% on 100K-token generation vs DeepSeek R1. With an MoE architecture plus CISPO and hybrid-attention RL training, it achieves leading performance on long-input reasoning and real software engineering tasks.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 redefines agent efficiency. It is a compact, fast, cost-effective MoE model with 230B total and 10B active parameters, built for top-tier coding and agent tasks while retaining strong general intelligence. With only 10B active parameters, it rivals much larger models, making it ideal for high-efficiency applications.",
   "Moonshot-Kimi-K2-Instruct.description": "1T total parameters with 32B active. Among non-thinking models, it is top-tier in frontier knowledge, math, and coding, and stronger at general agent tasks. Optimized for agent workloads, it can take actions, not just answer questions. Best for improvisational, general chat, and agent experiences as a reflex-level model without long thinking.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46.7B) is a high-precision instruction model for complex computation.",
   "OmniConsistency.description": "OmniConsistency improves style consistency and generalization in image-to-image tasks by introducing large-scale Diffusion Transformers (DiTs) and paired stylized data, avoiding style degradation.",
@@ -109,13 +112,14 @@
   "Phi-3.5-mini-instruct.description": "An updated version of the Phi-3-mini model.",
   "Phi-3.5-vision-instrust.description": "An updated version of the Phi-3-vision model.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 is an open-source large language model optimized for agent capabilities, excelling in programming, tool usage, instruction following, and long-term planning. The model supports multilingual software development and complex multi-step workflow execution, achieving a score of 74.0 on SWE-bench Verified and surpassing Claude Sonnet 4.5 in multilingual scenarios.",
-  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 is the latest large language model from MiniMax, featuring a Mixture-of-Experts (MoE) architecture with 229 billion total parameters. It achieves industry-leading performance in programming, agent tool calling, search tasks, and office scenarios, with a SWE-Bench Verified score of 80.2% and 37% faster inference speed compared to M2.1.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 is the latest large language model developed by MiniMax, trained through large-scale reinforcement learning across hundreds of thousands of complex, real-world environments. Featuring an MoE architecture with 229 billion parameters, it achieves industry-leading performance in tasks such as programming, agent tool-calling, search, and office scenarios.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct is a 7B instruction-tuned LLM in the Qwen2 series. It uses Transformer architecture with SwiGLU, attention QKV bias, and grouped-query attention, and handles large inputs. It performs strongly across language understanding, generation, multilingual tasks, coding, math, and reasoning, outperforming most open models and competing with proprietary ones. It surpasses Qwen1.5-7B-Chat on multiple benchmarks.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct is part of Alibaba Cloud’s latest LLM series. The 7B model brings notable gains in coding and math, supports 29+ languages, and improves instruction following, structured data understanding, and structured output (especially JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct is the latest Alibaba Cloud code-focused LLM. Built on Qwen2.5 and trained on 5.5T tokens, it significantly improves code generation, reasoning, and repair while retaining math and general strengths, providing a solid base for coding agents.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL is a new Qwen vision-language model with strong visual understanding. It analyzes text, charts, and layouts in images, understands long videos and events, supports reasoning and tool use, multi-format object grounding, and structured outputs. It improves dynamic resolution and frame-rate training for video understanding and boosts vision encoder efficiency.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking is an open-source VLM from Zhipu AI and Tsinghua KEG Lab, designed for complex multimodal cognition. Built on GLM-4-9B-0414, it adds chain-of-thought reasoning and RL to significantly improve cross-modal reasoning and stability.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat is the open-source GLM-4 model from Zhipu AI. It performs strongly across semantics, math, reasoning, code, and knowledge. Beyond multi-turn chat, it supports web browsing, code execution, custom tool calls, and long-text reasoning. It supports 26 languages (including Chinese, English, Japanese, Korean, German). It performs well on AlignBench-v2, MT-Bench, MMLU, and C-Eval, and supports up to 128K context for academic and business use.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B is distilled from Qwen2.5-Math-7B and fine-tuned on 800K curated DeepSeek-R1 samples. It performs strongly, with 92.8% on MATH-500, 55.5% on AIME 2024, and a 1189 CodeForces rating for a 7B model.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 is an RL-driven reasoning model that reduces repetition and improves readability. It uses cold-start data before RL to further boost reasoning, matches OpenAI-o1 on math, code, and reasoning tasks, and improves overall results through careful training.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus is an updated V3.1 model positioned as a hybrid agent LLM. It fixes user-reported issues and improves stability, language consistency, and reduces mixed Chinese/English and abnormal characters. It integrates Thinking and Non-thinking modes with chat templates for flexible switching. It also improves Code Agent and Search Agent performance for more reliable tool use and multi-step tasks.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 is a model that combines high computational efficiency with excellent reasoning and Agent performance. Its approach is built on three key technological breakthroughs: DeepSeek Sparse Attention (DSA), an efficient attention mechanism that significantly reduces computational complexity while maintaining model performance, and is specifically optimized for long-context scenarios; a scalable reinforcement learning framework through which model performance can rival GPT-5, with its high-compute version matching Gemini-3.0-Pro in reasoning capabilities; and a large-scale Agent task synthesis pipeline aimed at integrating reasoning capabilities into tool use scenarios, thereby improving instruction following and generalization in complex interactive environments. The model achieved gold medal performance in the 2025 International Mathematical Olympiad (IMO) and International Olympiad in Informatics (IOI).",
@@ -123,9 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 is the newest and most powerful Kimi K2. It is a top-tier MoE model with 1T total and 32B active parameters. Key features include stronger agentic coding intelligence with significant gains on benchmarks and real-world agent tasks, plus improved frontend coding aesthetics and usability.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo is the Turbo variant optimized for reasoning speed and throughput while retaining K2 Thinking’s multi-step reasoning and tool use. It is an MoE model with ~1T total parameters, native 256K context, and stable large-scale tool calling for production scenarios with stricter latency and concurrency needs.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 is an open-source native multimodal agent model, built on Kimi-K2-Base, trained on approximately 1.5 trillion mixed vision and text tokens. The model adopts an MoE architecture with 1T total parameters and 32B active parameters, supporting a 256K context window, seamlessly integrating vision and language understanding capabilities.",
-  "Pro/zai-org/GLM-4.7.description": "GLM-4.7 is Zhipu's new generation flagship model with 355B total parameters and 32B active parameters, fully upgraded in general dialogue, reasoning, and agent capabilities. GLM-4.7 enhances Interleaved Thinking and introduces Preserved Thinking and Turn-level Thinking.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 is Zhipu's new generation flagship model with 355B total parameters and 32B active parameters, fully upgraded in general dialogue, reasoning, and agent capabilities. GLM-4.7 enhances Interleaved Thinking and introduces Preserved Thinking and Turn-level Thinking.",
   "Pro/zai-org/glm-5.description": "GLM-5 is Zhipu's next-generation large language model, focusing on complex system engineering and long-duration Agent tasks. The model parameters have been expanded to 744B (40B active) and integrate DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ is an experimental research model focused on improving reasoning.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview is a research model from Qwen focused on visual reasoning, with strengths in complex scene understanding and visual math problems.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ is an experimental research model focused on improved AI reasoning.",
   "Qwen/QwQ-32B.description": "QwQ is a reasoning model in the Qwen family. Compared with standard instruction-tuned models, it adds thinking and reasoning that significantly boost downstream performance, especially on hard problems. QwQ-32B is a mid-size reasoning model competitive with top reasoning models like DeepSeek-R1 and o1-mini. It uses RoPE, SwiGLU, RMSNorm, and attention QKV bias, with 64 layers and 40 Q attention heads (8 KV in GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 is the latest editing version of Qwen-Image from the Qwen team. Built on the 20B Qwen-Image model, it extends strong text rendering into image editing for precise text edits. It uses a dual-control architecture, sending inputs to Qwen2.5-VL for semantic control and a VAE encoder for appearance control, enabling both semantic- and appearance-level editing. It supports local edits (add/remove/modify) and higher-level semantic edits like IP creation and style transfer while preserving semantics. It achieves SOTA results on multiple benchmarks.",
@@ -209,10 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Skylark 2nd-gen model. Skylark2-pro-turbo-8k offers faster inference at lower cost with an 8K context window.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 is a next-gen open GLM model with 32B parameters, comparable to OpenAI GPT and DeepSeek V3/R1 series in performance.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 is a 9B GLM model that inherits GLM-4-32B techniques while offering a lighter deployment. It performs well in code generation, web design, SVG generation, and search-based writing.",
-  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking is an open-source vision language model (VLM) jointly released by Zhipu AI and Tsinghua University KEG Lab. Based on GLM-4-9B-0414, it introduces Chain-of-Thought reasoning mechanism and uses reinforcement learning strategy, significantly improving its cross-modal reasoning ability and stability. As a lightweight 9B model, it achieves a balance between deployment efficiency and performance.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking is an open-source VLM from Zhipu AI and Tsinghua KEG Lab, designed for complex multimodal cognition. Built on GLM-4-9B-0414, it adds chain-of-thought reasoning and RL to significantly improve cross-modal reasoning and stability.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 is a deep-thinking reasoning model built from GLM-4-32B-0414 with cold-start data and expanded RL, further trained on math, code, and logic. It significantly improves math ability and complex task solving over the base model.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 is a small 9B-parameter GLM model that retains open-source strengths while delivering impressive capability. It performs strongly on math reasoning and general tasks, leading its size class among open models.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat is the open-source GLM-4 model from Zhipu AI. It performs strongly across semantics, math, reasoning, code, and knowledge. Beyond multi-turn chat, it supports web browsing, code execution, custom tool calls, and long-text reasoning. It supports 26 languages (including Chinese, English, Japanese, Korean, German). It performs well on AlignBench-v2, MT-Bench, MMLU, and C-Eval, and supports up to 128K context for academic and business use.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B is the first long-context reasoning model (LRM) trained with RL, optimized for long-text reasoning. Its progressive context expansion RL enables stable transfer from short to long context. It surpasses OpenAI-o3-mini and Qwen3-235B-A22B on seven long-context document QA benchmarks, rivaling Claude-3.7-Sonnet-Thinking. It is especially strong at math, logic, and multi-hop reasoning.",
   "Yi-34B-Chat.description": "Yi-1.5-34B retains the series’ strong general language abilities while using incremental training on 500B high-quality tokens to significantly improve math logic and coding.",
   "abab5.5-chat.description": "Built for productivity scenarios with complex task handling and efficient text generation for professional use.",
   "abab5.5s-chat.description": "Designed for Chinese persona chat, delivering high-quality Chinese dialogue for various applications.",
@@ -304,17 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet excels at coding, writing, and complex reasoning.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet with extended thinking for complex reasoning tasks.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet is an upgraded version with extended context and capabilities.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 is Anthropic’s fastest and smartest Haiku model, with lightning speed and extended reasoning.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 is Anthropic's fastest and most intelligent Haiku model, with lightning speed and extended thinking.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 is a fast and efficient model for various tasks.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking is an advanced variant that can reveal its reasoning process.",
-  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 is Anthropic’s latest and most capable model for highly complex tasks, excelling in performance, intelligence, fluency, and understanding.",
-  "claude-opus-4-20250514.description": "Claude Opus 4 is Anthropic’s most powerful model for highly complex tasks, excelling in performance, intelligence, fluency, and comprehension.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 is Anthropic's latest and most capable model for highly complex tasks, excelling in performance, intelligence, fluency, and understanding.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 is Anthropic's most powerful model for highly complex tasks, excelling in performance, intelligence, fluency, and understanding.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 is Anthropic’s flagship model, combining outstanding intelligence with scalable performance, ideal for complex tasks requiring the highest-quality responses and reasoning.",
-  "claude-opus-4-6.description": "Claude Opus 4.6 is Anthropic’s most intelligent model for building agents and coding.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 is Anthropic's most intelligent model for building agents and coding.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking can produce near-instant responses or extended step-by-step thinking with visible process.",
-  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 can produce near-instant responses or extended step-by-step thinking with visible process.",
-  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 is Anthropic’s most intelligent model to date.",
-  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 is Anthropic’s best combination of speed and intelligence.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 is Anthropic's most intelligent model to date, offering near-instant responses or extended step-by-step thinking with fine-grained control for API users.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 is Anthropic's most intelligent model to date.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 is Anthropic's best combination of speed and intelligence.",
   "claude-sonnet-4.description": "Claude Sonnet 4 is the latest generation with improved performance across all tasks.",
   "codegeex-4.description": "CodeGeeX-4 is a powerful AI coding assistant that supports multilingual Q&A and code completion to boost developer productivity.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B is a multilingual code generation model supporting code completion and generation, code interpreter, web search, function calling, and repo-level code Q&A, covering a wide range of software development scenarios. It is a top-tier code model under 10B parameters.",
@@ -371,7 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "DeepSeek-R1 distilled models use RL and cold-start data to improve reasoning and set new open-model multi-task benchmarks.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "DeepSeek-R1 distilled models use RL and cold-start data to improve reasoning and set new open-model multi-task benchmarks.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B is distilled from Qwen2.5-32B and fine-tuned on 800K curated DeepSeek-R1 samples. It excels in math, programming, and reasoning, achieving strong results on AIME 2024, MATH-500 (94.3% accuracy), and GPQA Diamond.",
-  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B is distilled from Qwen2.5-Math-7B and fine-tuned on 800K curated DeepSeek-R1 samples. It excels in math, programming, and reasoning, achieving 92.8% on MATH-500, 55.5% on AIME 2024, and 1189 on CodeForces.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B is distilled from Qwen2.5-Math-7B and fine-tuned on 800K curated DeepSeek-R1 samples. It performs strongly, with 92.8% on MATH-500, 55.5% on AIME 2024, and a 1189 CodeForces rating for a 7B model.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 improves reasoning with RL and cold-start data, setting new open-model multi-task benchmarks and surpassing OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 upgrades DeepSeek-V2-Chat and DeepSeek-Coder-V2-Instruct, combining general and coding abilities. It improves writing and instruction following for better preference alignment, and shows significant gains on AlpacaEval 2.0, ArenaHard, AlignBench, and MT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus is an updated V3.1 model positioned as a hybrid agent LLM. It fixes user-reported issues and improves stability, language consistency, and reduces mixed Chinese/English and abnormal characters. It integrates Thinking and Non-thinking modes with chat templates for flexible switching. It also improves Code Agent and Search Agent performance for more reliable tool use and multi-step tasks.",
@@ -384,7 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 is a next-gen reasoning model with stronger complex reasoning and chain-of-thought for deep analysis tasks.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 is a next-gen reasoning model with stronger complex reasoning and chain-of-thought capabilities.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 is a MoE vision-language model based on DeepSeekMoE-27B with sparse activation, achieving strong performance with only 4.5B active parameters. It excels at visual QA, OCR, document/table/chart understanding, and visual grounding.",
-  "deepseek-chat.description": "A new open-source model combining general and code abilities. It preserves the chat model’s general dialogue and the coder model’s strong coding, with better preference alignment. DeepSeek-V2.5 also improves writing and instruction following.",
+  "deepseek-chat.description": "DeepSeek V3.2 balances reasoning and output length for daily QA and agent tasks. Public benchmarks reach GPT-5 levels, and it is the first to integrate thinking into tool use, leading open-source agent evaluations.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B is a code language model trained on 2T tokens (87% code, 13% Chinese/English text). It introduces a 16K context window and fill-in-the-middle tasks, providing project-level code completion and snippet infilling.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 is an open-source MoE code model that performs strongly on coding tasks, comparable to GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 is an open-source MoE code model that performs strongly on coding tasks, comparable to GPT-4 Turbo.",
@@ -407,7 +413,7 @@
   "deepseek-r1-fast-online.description": "DeepSeek R1 fast full version with real-time web search, combining 671B-scale capability and faster response.",
   "deepseek-r1-online.description": "DeepSeek R1 full version with 671B parameters and real-time web search, offering stronger understanding and generation.",
   "deepseek-r1.description": "DeepSeek-R1 uses cold-start data before RL and performs comparably to OpenAI-o1 on math, coding, and reasoning.",
-  "deepseek-reasoner.description": "DeepSeek V3.2 thinking mode outputs a chain-of-thought before the final answer to improve accuracy.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking is a deep reasoning model that generates chain-of-thought before outputs for higher accuracy, with top competition results and reasoning comparable to Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 is an efficient MoE model for cost-effective processing.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B is DeepSeek’s code-focused model with strong code generation.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 is a 671B-parameter MoE model with standout strengths in programming and technical capability, context understanding, and long-text handling.",
@@ -467,7 +473,6 @@
   "doubao-seed-2.0-lite.description": "Doubao-Seed-2.0-lite is a new multimodal deep-reasoning model that delivers better value and a strong choice for common tasks, with a context window up to 256k.",
   "doubao-seed-2.0-mini.description": "Doubao-Seed-2.0-mini is a lightweight model with fast response and high performance, suitable for small tasks and high-concurrency scenarios.",
   "doubao-seed-2.0-pro.description": "Doubao-Seed-2.0-pro is ByteDance's flagship Agent general model, with all-around leaps in complex task planning and execution capabilities.",
-  "doubao-seed-code-2.0.description": "Doubao-Seed-Code-2.0 is ByteDance's next generation coding model with enhanced agentic capabilities and multimodal understanding.",
   "doubao-seed-code.description": "Doubao-Seed-Code is deeply optimized for agentic coding, supports multimodal inputs (text/image/video) and a 256k context window, is compatible with the Anthropic API, and fits coding, vision understanding, and agent workflows.",
   "doubao-seedance-1-0-lite-i2v-250428.description": "Stable generation quality with high cost-effectiveness, capable of generating videos from a first frame, first-and-last frames, or reference images.",
   "doubao-seedance-1-0-lite-t2v-250428.description": "Stable generation quality with high cost-effectiveness, capable of generating videos based on text instructions.",
@@ -508,7 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K is a fast thinking model with 32K context for complex reasoning and multi-turn chat.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview is a thinking-model preview for evaluation and testing.",
   "ernie-x1.1.description": "ERNIE X1.1 is a thinking-model preview for evaluation and testing.",
-  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0 is an image generation model from ByteDance Seed, supporting text and image inputs with highly controllable, high-quality image generation. It generates images from text prompts.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5, built by ByteDance Seed team, supports multi-image editing and composition. Features enhanced subject consistency, precise instruction following, spatial logic understanding, aesthetic expression, poster layout and logo design with high-precision text-image rendering.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0, built by ByteDance Seed, supports text and image inputs for highly controllable, high-quality image generation from prompts.",
   "fal-ai/flux-kontext/dev.description": "FLUX.1 model focused on image editing, supporting text and image inputs.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] accepts text and reference images as input, enabling targeted local edits and complex global scene transformations.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] is an image generation model with an aesthetic bias toward more realistic, natural images.",
@@ -516,8 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "A powerful native multimodal image generation model.",
   "fal-ai/imagen4/preview.description": "High-quality image generation model from Google.",
   "fal-ai/nano-banana.description": "Nano Banana is Google’s newest, fastest, and most efficient native multimodal model, enabling image generation and editing through conversation.",
-  "fal-ai/qwen-image-edit.description": "A professional image editing model from the Qwen team that supports semantic and appearance edits, precisely edits Chinese and English text, and enables high-quality edits such as style transfer and object rotation.",
-  "fal-ai/qwen-image.description": "A powerful image generation model from the Qwen team with impressive Chinese text rendering and diverse visual styles.",
+  "fal-ai/qwen-image-edit.description": "A professional image editing model from the Qwen team, supporting semantic and appearance edits, precise Chinese/English text editing, style transfer, rotation, and more.",
+  "fal-ai/qwen-image.description": "A powerful image generation model from the Qwen team with strong Chinese text rendering and diverse visual styles.",
   "flux-1-schnell.description": "A 12B-parameter text-to-image model from Black Forest Labs using latent adversarial diffusion distillation to generate high-quality images in 1-4 steps. It rivals closed alternatives and is released under Apache-2.0 for personal, research, and commercial use.",
   "flux-dev.description": "FLUX.1 [dev] is an open-weights distilled model for non-commercial use. It keeps near-pro image quality and instruction following while running more efficiently, using resources better than same-size standard models.",
   "flux-kontext-max.description": "State-of-the-art contextual image generation and editing, combining text and images for precise, coherent results.",
@@ -561,10 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro is Google’s most advanced reasoning model, able to reason over code, math, and STEM problems and analyze large datasets, codebases, and documents with long context.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash is the smartest model built for speed, combining cutting-edge intelligence with excellent search grounding.",
   "gemini-3-pro-image-preview.description": "Gemini 3 Pro Image (Nano Banana Pro) is Google's image generation model that also supports multimodal dialogue.",
-  "gemini-3-pro-image-preview:image.description": "Gemini 3 Pro Image (Nano Banana Pro) is Google’s image generation model and also supports multimodal chat.",
+  "gemini-3-pro-image-preview:image.description": "Gemini 3 Pro Image (Nano Banana Pro) is Google's image generation model and also supports multimodal chat.",
   "gemini-3-pro-preview.description": "Gemini 3 Pro is Google’s most powerful agent and vibe-coding model, delivering richer visuals and deeper interaction on top of state-of-the-art reasoning.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) is Google's fastest native image generation model with thinking support, conversational image generation and editing.",
-  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) is Google's fastest native image generation model with thinking support, conversational image generation and editing.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) delivers Pro-level image quality at Flash speed with multimodal chat support.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview is Google's most cost-efficient multimodal model, optimized for high-volume agentic tasks, translation, and data processing.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview improves on Gemini 3 Pro with enhanced reasoning capabilities and adds medium thinking level support.",
   "gemini-flash-latest.description": "Latest release of Gemini Flash",
@@ -961,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K supports 32,768 tokens for medium-length context, ideal for long documents and complex dialogues in content creation, reports, and chat systems.",
   "moonshot-v1-8k-vision-preview.description": "Kimi vision models (including moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) can understand image content such as text, colors, and object shapes.",
   "moonshot-v1-8k.description": "Moonshot V1 8K is optimized for short text generation with efficient performance, handling 8,192 tokens for short chats, notes, and quick content.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B is an open-source code LLM optimized with large-scale RL to produce robust, production-ready patches. It scores 60.4% on SWE-bench Verified, setting a new open-model record for automated software engineering tasks like bug fixing and code review.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 is the newest and most powerful Kimi K2. It is a top-tier MoE model with 1T total and 32B active parameters. Key features include stronger agentic coding intelligence with significant gains on benchmarks and real-world agent tasks, plus improved frontend coding aesthetics and usability.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking is the latest and most powerful open-source thinking model. It greatly extends multi-step reasoning depth and sustains stable tool use across 200–300 consecutive calls, setting new records on Humanity's Last Exam (HLE), BrowseComp, and other benchmarks. 'It excels in coding, math, logic, and agent scenarios. Built on an MoE architecture with ~1T total parameters, it supports a 256K context window and tool calling.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 is the instruct variant in the Kimi series, suited for high-quality code and tool use.",
@@ -1193,6 +1200,8 @@
   "qwq.description": "QwQ is a reasoning model in the Qwen family. Compared with standard instruction-tuned models, it brings thinking and reasoning abilities that significantly improve downstream performance, especially on hard problems. QwQ-32B is a mid-sized reasoning model that competes well with top reasoning models like DeepSeek-R1 and o1-mini.",
   "qwq_32b.description": "Mid-sized reasoning model in the Qwen family. Compared with standard instruction-tuned models, QwQ’s thinking and reasoning abilities significantly boost downstream performance, especially on hard problems.",
   "r1-1776.description": "R1-1776 is a post-trained variant of DeepSeek R1 designed to provide uncensored, unbiased factual information.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro by ByteDance supports text-to-video, image-to-video (first frame, first+last frame), and audio generation synchronized with visuals.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite by BytePlus features web-retrieval-augmented generation for real-time information, enhanced complex prompt interpretation, and improved reference consistency for professional visual creation.",
   "solar-mini-ja.description": "Solar Mini (Ja) extends Solar Mini with a focus on Japanese while maintaining efficient, strong performance in English and Korean.",
   "solar-mini.description": "Solar Mini is a compact LLM that outperforms GPT-3.5, with strong multilingual capability supporting English and Korean, offering an efficient small-footprint solution.",
   "solar-pro.description": "Solar Pro is a high-intelligence LLM from Upstage, focused on instruction following on a single GPU, with IFEval scores above 80. It currently supports English; the full release was planned for November 2024 with expanded language support and longer context.",
@@ -1228,7 +1237,7 @@
   "step-3.5-flash.description": "Stepfun’s flagship language reasoning model.This model has top-notch reasoning capabilities and fast and reliable execution capabilities.Able to decompose and plan complex tasks, call tools quickly and reliably to perform tasks, and be competent in various complex tasks such as logical reasoning, mathematics, software engineering, and in-depth research.",
   "step-3.description": "This model has strong visual perception and complex reasoning, accurately handling cross-domain knowledge understanding, math-vision cross analysis, and a wide range of everyday visual analysis tasks.",
   "step-r1-v-mini.description": "A reasoning model with strong image understanding that can process images and text, then generate text after deep reasoning. It excels at visual reasoning and delivers top-tier math, coding, and text reasoning, with a 100K context window.",
-  "stepfun-ai/Step-3.5-Flash.description": "Step 3.5 Flash is the most powerful open-source foundation model from StepFun, using sparse Mixture of Experts (MoE) architecture with 196B total parameters, only 11B active parameters per token. Model supports 256K context window, achieving 100-300 tok/s generation throughput through 3-way Multi-Token Prediction (MTP-3). Excellent performance on programming and Agent tasks, SWE-bench Verified reaches 74.4%.",
+  "stepfun-ai/step3.description": "Step3 is a cutting-edge multimodal reasoning model from StepFun, built on an MoE architecture with 321B total and 38B active parameters. Its end-to-end design minimizes decoding cost while delivering top-tier vision-language reasoning. With MFA and AFD design, it stays efficient on both flagship and low-end accelerators. Pretraining uses 20T+ text tokens and 4T image-text tokens across many languages. It reaches leading open-model performance on math, code, and multimodal benchmarks.",
   "taichu4_vl_2b_nothinking.description": "The No-Thinking version of the Taichu4.0-VL 2B model features lower memory usage, a lightweight design, fast response speed, and strong multimodal understanding capabilities.",
   "taichu4_vl_32b.description": "The Thinking version of the Taichu4.0-VL 32B model is suited for complex multimodal understanding and reasoning tasks, demonstrating outstanding performance in multimodal mathematical reasoning, multimodal agent capabilities, and general image and visual comprehension.",
   "taichu4_vl_32b_nothinking.description": "The No-Thinking version of the Taichu4.0-VL 32B model is designed for complex image-and-text understanding and visual knowledge QA scenarios, excelling in image captioning, visual question answering, video comprehension, and visual localization tasks.",
@@ -1315,7 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air is a base model for agent applications using a Mixture-of-Experts architecture. It is optimized for tool use, web browsing, software engineering, and frontend coding, and integrates with code agents like Claude Code and Roo Code. It uses hybrid reasoning to handle both complex reasoning and everyday scenarios.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V is Zhipu AI’s latest VLM, built on the GLM-4.5-Air flagship text model (106B total, 12B active) with an MoE architecture for strong performance at lower cost. It follows the GLM-4.1V-Thinking path and adds 3D-RoPE to improve 3D spatial reasoning. Optimized through pretraining, SFT, and RL, it handles images, video, and long documents and ranks top among open models on 41 public multimodal benchmarks. A Thinking mode toggle lets users balance speed and depth.",
   "zai-org/GLM-4.6.description": "Compared to GLM-4.5, GLM-4.6 expands context from 128K to 200K for more complex agent tasks. It scores higher on code benchmarks and shows stronger real-world performance in apps like Claude Code, Cline, Roo Code, and Kilo Code, including better frontend page generation. Reasoning is improved and tool use is supported during reasoning, strengthening overall capability. It integrates better into agent frameworks, improves tool/search agents, and has more human-preferred writing style and roleplay naturalness.",
-  "zai-org/GLM-4.6V.description": "GLM-4.6V achieves SOTA visual understanding accuracy at the same parameter scale, and is the first to natively integrate Function Call capability into vision models in the model architecture, connecting the chain from visual perception to executable action (Action), providing a unified technical foundation for multimodal Agents in real business scenarios. Visual context window expanded to 128K, supporting long video stream processing and high-resolution multi-image analysis.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V achieves SOTA visual understanding accuracy for its parameter scale and is the first to natively integrate Function Call capabilities into the vision model architecture, bridging the gap from \"visual perception\" to \"executable actions\" and providing a unified technical foundation for multimodal agents in real business scenarios. The visual context window is extended to 128k, supporting long video stream processing and high-resolution multi-image analysis.",
   "zai/glm-4.5-air.description": "GLM-4.5 and GLM-4.5-Air are our latest flagships for agent applications, both using MoE. GLM-4.5 has 355B total and 32B active per forward pass; GLM-4.5-Air is slimmer with 106B total and 12B active.",
   "zai/glm-4.5.description": "The GLM-4.5 series is designed for agents. The flagship GLM-4.5 combines reasoning, coding, and agent skills with 355B total params (32B active) and offers dual operation modes as a hybrid reasoning system.",
   "zai/glm-4.5v.description": "GLM-4.5V builds on GLM-4.5-Air, inheriting proven GLM-4.1V-Thinking techniques and scaling with a strong 106B-parameter MoE architecture.",

locales/en-US/providers.json

@@ -33,6 +33,7 @@
   "jina.description": "Founded in 2020, Jina AI is a leading search AI company. Its search stack includes vector models, rerankers, and small language models to build reliable, high-quality generative and multimodal search apps.",
   "kimicodingplan.description": "Kimi Code from Moonshot AI provides access to Kimi models including K2.5 for coding tasks.",
   "lmstudio.description": "LM Studio is a desktop app for developing and experimenting with LLMs on your computer.",
+  "lobehub.description": "LobeHub Cloud uses official APIs to access AI models and measures usage with Credits tied to model tokens.",
   "longcat.description": "LongCat is a series of generative AI large models independently developed by Meituan. It is designed to enhance internal enterprise productivity and enable innovative applications through an efficient computational architecture and strong multimodal capabilities.",
   "minimax.description": "Founded in 2021, MiniMax builds general-purpose AI with multimodal foundation models, including trillion-parameter MoE text models, speech models, and vision models, along with apps like Hailuo AI.",
   "minimaxcodingplan.description": "MiniMax Token Plan provides access to MiniMax models including M2.7 for coding tasks via a fixed-fee subscription.",

locales/en-US/setting.json

@@ -164,9 +164,9 @@
   "agentSkillModal.contentPlaceholder": "Enter skill content in Markdown format...",
   "agentSkillModal.description": "Description",
   "agentSkillModal.descriptionPlaceholder": "Briefly describe this skill",
-  "agentSkillModal.github.desc": "Import skills directly from a public GitHub repository.",
+  "agentSkillModal.github.desc": "Paste the URL of a skill directory from a public GitHub repository. The directory must contain a SKILL.md file.",
   "agentSkillModal.github.title": "Import from GitHub",
-  "agentSkillModal.github.urlPlaceholder": "https://github.com/username/repo",
+  "agentSkillModal.github.urlPlaceholder": "https://github.com/username/repo/tree/main/skills/my-skill",
   "agentSkillModal.importError": "Import failed: {{error}}",
   "agentSkillModal.importSuccess": "Agent Skill imported successfully",
   "agentSkillModal.upload.desc": "Upload a local .zip or .skill file to install.",
@@ -601,12 +601,7 @@
   "settingGroupMembers.you": "You",
   "settingImage.defaultCount.desc": "Set the default number of images generated when creating a new task in the image generation panel.",
   "settingImage.defaultCount.label": "Default Image Count",
-  "settingImage.defaultCount.title": "AI Art",
-  "settingModel.contextCompressionMode.desc": "Economy: compress early to save tokens on long conversations. Full: use more context for better quality.",
-  "settingModel.contextCompressionMode.disabled": "Disabled",
-  "settingModel.contextCompressionMode.economy": "Economy",
-  "settingModel.contextCompressionMode.full": "Full",
-  "settingModel.contextCompressionMode.title": "Context Compression",
+  "settingImage.defaultCount.title": "AI Image",
   "settingModel.enableContextCompression.desc": "Automatically compress historical messages into summaries when conversation exceeds 64,000 tokens, saving 60-80% token usage",
   "settingModel.enableContextCompression.title": "Enable Auto Context Compression",
   "settingModel.enableMaxTokens.title": "Enable Max Tokens Limit",
@@ -761,8 +756,8 @@
   "systemAgent.customPrompt.placeholder": "Please enter custom prompt",
   "systemAgent.customPrompt.title": "Custom Prompt",
   "systemAgent.generationTopic.label": "Model",
-  "systemAgent.generationTopic.modelDesc": "Model designated for automatic naming of AI art topics",
-  "systemAgent.generationTopic.title": "AI Art Topic Naming Agent",
+  "systemAgent.generationTopic.modelDesc": "Model designated for automatic naming of AI image topics",
+  "systemAgent.generationTopic.title": "AI Image Topic Naming Agent",
   "systemAgent.helpInfo": "When creating a new agent, the default agent settings will be used as preset values.",
   "systemAgent.historyCompress.label": "Model",
   "systemAgent.historyCompress.modelDesc": "Specify the model used to compress conversation history",

locales/en-US/subscription.json

@@ -183,8 +183,8 @@
   "payment.success.actions.viewBill": "View Billing History",
   "payment.success.desc": "Your subscription plan has been activated successfully",
   "payment.success.title": "Subscription Successful",
-  "payment.switchSuccess.desc": "Your subscription plan will automatically switch on {{switchAt}}",
-  "payment.switchSuccess.title": "Switch Successful",
+  "payment.switchSuccess.desc": "Your subscription will automatically downgrade from <bold>{{from}}</bold> to <bold>{{to}}</bold> on {{switchAt}}",
+  "payment.switchSuccess.title": "Downgrade Scheduled",
   "payment.upgradeFailed.alert.reason.bank3DS": "Your bank requires 3DS verification, please confirm again",
   "payment.upgradeFailed.alert.reason.inefficient": "Insufficient card balance",
   "payment.upgradeFailed.alert.reason.security": "Stripe system risk control",
@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "Supports credit card / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "Supports credit card",
   "plans.btn.soon": "Coming Soon",
+  "plans.cancelDowngrade": "Cancel Scheduled Downgrade",
+  "plans.cancelDowngradeSuccess": "Scheduled downgrade has been cancelled",
   "plans.changePlan": "Choose Plan",
   "plans.cloud.history": "Unlimited conversation history",
   "plans.cloud.sync": "Global cloud sync",
@@ -214,7 +216,8 @@
   "plans.credit.tooltip": "Monthly model message computing credits",
   "plans.current": "Current Plan",
   "plans.downgradePlan": "Target Downgrade Plan",
-  "plans.downgradeTip": "You have already switched subscription. You cannot perform other operations until the switch is complete",
+  "plans.downgradeTip": "Your subscription has been canceled. You cannot perform other operations until the cancellation is complete",
+  "plans.downgradeWillCancel": "This action will cancel your scheduled plan downgrade",
   "plans.embeddingStorage.embeddings": "entries",
   "plans.embeddingStorage.title": "Vector Storage",
   "plans.embeddingStorage.tooltip": "One document page (1000-1500 characters) generates approximately 1 vector entry. (Estimated using OpenAI Embeddings, may vary by model)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "Confirm Selection",
   "plans.payonce.popconfirm": "After one-time payment, you must wait until subscription expires to switch plans or change billing cycle. Please confirm your selection.",
   "plans.payonce.tooltip": "One-time payment requires waiting until subscription expires to switch plans or change billing cycle",
+  "plans.pendingDowngrade": "Pending Downgrade",
   "plans.plan.enterprise.contactSales": "Contact Sales",
   "plans.plan.enterprise.title": "Enterprise",
   "plans.plan.free.desc": "For first-time users",
@@ -366,17 +370,18 @@
   "summary.title": "Billing Summary",
   "summary.usageThisMonth": "View your usage this month.",
   "summary.viewBillingHistory": "View Payment History",
-  "switchPlan": "Switch Plan",
+  "switchDowngradeTarget": "Switch Downgrade Target",
+  "switchPlan": "Downgrade",
   "switchToMonthly.desc": "After switching, monthly billing will take effect after the current yearly plan expires.",
   "switchToMonthly.title": "Switch to Monthly Billing",
   "switchToYearly.desc": "After switching, yearly billing will take effect immediately after paying the difference. Start date inherits from previous plan.",
   "switchToYearly.title": "Switch to Yearly Billing",
-  "tab.billing": "Billing Management",
-  "tab.credits": "Credits Management",
+  "tab.billing": "Billing",
+  "tab.credits": "Credits",
   "tab.plans": "Plans",
   "tab.referral": "Referral Rewards",
   "tab.spend": "Credits Details",
-  "tab.usage": "Usage Statistics",
+  "tab.usage": "Usage",
   "upgrade": "Upgrade",
   "upgradeNow": "Upgrade Now",
   "upgradePlan": "Upgrade Plan",

locales/es-ES/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Fallo de conexión",
   "sync.title": "Estado de sincronización",
   "sync.unconnected.tip": "Fallo en la conexión con el servidor de señalización, no se puede establecer el canal de comunicación entre pares. Verifica tu red e inténtalo de nuevo.",
-  "tab.aiImage": "Arte",
   "tab.audio": "Audio",
   "tab.chat": "Chat",
   "tab.community": "Comunidad",
@@ -405,6 +404,7 @@
   "tab.eval": "Laboratorio de Evaluación",
   "tab.files": "Archivos",
   "tab.home": "Inicio",
+  "tab.image": "Imagen",
   "tab.knowledgeBase": "Biblioteca",
   "tab.marketplace": "Mercado",
   "tab.me": "Yo",

locales/es-ES/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "Para modelos de generación de imágenes Gemini 3; controla la resolución de las imágenes generadas.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "Para modelos de imágenes Gemini 3.1 Flash; controla la resolución de las imágenes generadas (admite 512px).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "Para Claude, Qwen3 y similares; controla el presupuesto de tokens para el razonamiento.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "Para GLM-5 y GLM-4.7; controla el presupuesto de tokens para razonamiento (máximo 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "Para la serie Qwen3; controla el presupuesto de tokens para razonamiento (máximo 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "Para OpenAI y otros modelos con capacidad de razonamiento; controla el esfuerzo de razonamiento.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "Para la serie GPT-5+; controla la verbosidad del resultado.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "Para algunos modelos Doubao; permite que el modelo decida si debe pensar en profundidad.",

locales/es-ES/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev es un modelo multimodal de generación y edición de imágenes de Black Forest Labs, basado en una arquitectura Rectified Flow Transformer con 12 mil millones de parámetros. Se centra en generar, reconstruir, mejorar o editar imágenes bajo condiciones contextuales dadas. Combina la generación controlada de los modelos de difusión con el modelado contextual de Transformers, ofreciendo resultados de alta calidad para tareas como inpainting, outpainting y reconstrucción de escenas visuales.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev es un modelo de lenguaje multimodal de código abierto (MLLM) de Black Forest Labs, optimizado para tareas de imagen y texto. Combina comprensión y generación de imagen/texto. Basado en LLMs avanzados (como Mistral-7B), utiliza un codificador visual cuidadosamente diseñado y ajuste por etapas para lograr coordinación multimodal y razonamiento complejo.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: Versión ligera para respuestas rápidas.",
+  "GLM-4.5.description": "GLM-4.5: Modelo de alto rendimiento para razonamiento, programación y tareas de agentes.",
+  "GLM-4.6.description": "GLM-4.6: Modelo de la generación anterior.",
+  "GLM-4.7.description": "GLM-4.7 es el modelo insignia más reciente de Zhipu, mejorado para escenarios de codificación agentiva con capacidades de programación avanzadas, planificación de tareas a largo plazo y colaboración con herramientas.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: Versión optimizada de GLM-5 con inferencia más rápida para tareas de programación.",
+  "GLM-5.description": "GLM-5 es el modelo base insignia de próxima generación de Zhipu, diseñado específicamente para Ingeniería Agentiva. Ofrece productividad confiable en sistemas de ingeniería complejos y tareas agentivas de largo alcance. En capacidades de programación y agentes, GLM-5 logra un rendimiento de vanguardia entre los modelos de código abierto.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) es un modelo innovador para dominios diversos y tareas complejas.",
   "HY-Image-V3.0.description": "Potentes capacidades de extracción de características de la imagen original y preservación de detalles, ofreciendo una textura visual más rica y produciendo imágenes de alta precisión, bien compuestas y de calidad profesional.",
   "HelloMeme.description": "HelloMeme es una herramienta de IA que genera memes, GIFs o videos cortos a partir de imágenes o movimientos proporcionados. No requiere habilidades de dibujo ni programación: solo una imagen de referencia para crear contenido divertido, atractivo y estilísticamente coherente.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "Nuevo modelo de razonamiento interno con 80K de cadena de pensamiento y 1M de entrada, con rendimiento comparable a los mejores modelos globales.",
   "MiniMax-M2-Stable.description": "Diseñado para codificación eficiente y flujos de trabajo de agentes, con mayor concurrencia para uso comercial.",
   "MiniMax-M2.1-Lightning.description": "Potentes capacidades de programación multilingüe, experiencia de desarrollo completamente mejorada. Más rápido y eficiente.",
+  "MiniMax-M2.1-highspeed.description": "Potentes capacidades de programación multilingüe con inferencia más rápida y eficiente.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 es un modelo insignia de código abierto de MiniMax, enfocado en resolver tareas complejas del mundo real. Sus principales fortalezas son sus capacidades de programación multilingüe y su habilidad para resolver tareas complejas como un Agente.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: Misma rendimiento, más rápido y ágil (aproximadamente 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: Mismo rendimiento que M2.5 con inferencia más rápida.",
   "MiniMax-M2.5.description": "MiniMax-M2.5 es un modelo insignia de código abierto de gran tamaño de MiniMax, enfocado en resolver tareas complejas del mundo real. Sus principales fortalezas son las capacidades de programación multilingüe y la habilidad para resolver tareas complejas como un Agente.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: Mismo rendimiento que M2.7 con inferencia significativamente más rápida.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: Comenzando el camino hacia la mejora recursiva, capacidades de ingeniería de primer nivel en el mundo real.",
+  "MiniMax-M2.description": "MiniMax M2: Modelo de la generación anterior.",
   "MiniMax-Text-01.description": "MiniMax-01 introduce atención lineal a gran escala más allá de los Transformers clásicos, con 456B de parámetros y 45.9B activados por paso. Logra rendimiento de primer nivel y admite hasta 4M tokens de contexto (32× GPT-4o, 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 es un modelo de razonamiento híbrido de atención a gran escala con pesos abiertos, con un total de 456 mil millones de parámetros y ~45.9 mil millones activos por token. Admite de forma nativa un contexto de 1 millón y utiliza Flash Attention para reducir los FLOPs en un 75% en generación de 100K tokens frente a DeepSeek R1. Con una arquitectura MoE más CISPO y entrenamiento RL de atención híbrida, logra un rendimiento líder en razonamiento de entradas largas y tareas reales de ingeniería de software.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 redefine la eficiencia de los agentes. Es un modelo MoE compacto, rápido y rentable con un total de 230 mil millones y 10 mil millones de parámetros activos, diseñado para tareas de programación y agentes de primer nivel mientras mantiene una fuerte inteligencia general. Con solo 10 mil millones de parámetros activos, rivaliza con modelos mucho más grandes, lo que lo hace ideal para aplicaciones de alta eficiencia.",
   "Moonshot-Kimi-K2-Instruct.description": "1 billón de parámetros totales con 32 mil millones activos. Entre los modelos sin modo de razonamiento, es de los mejores en conocimiento avanzado, matemáticas y programación, y destaca en tareas generales de agentes. Optimizado para cargas de trabajo de agentes, puede ejecutar acciones, no solo responder preguntas. Ideal para conversaciones improvisadas, chat general y experiencias con agentes como un modelo de reflejo sin razonamiento prolongado.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46,7 mil millones) es un modelo de instrucciones de alta precisión para cálculos complejos.",
   "OmniConsistency.description": "OmniConsistency mejora la coherencia de estilo y la generalización en tareas de imagen a imagen mediante la introducción de Transformadores de Difusión a gran escala (DiTs) y datos estilizados emparejados, evitando la degradación del estilo.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Una versión actualizada del modelo Phi-3-mini.",
   "Phi-3.5-vision-instrust.description": "Una versión actualizada del modelo Phi-3-vision.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 es un modelo de lenguaje de código abierto optimizado para capacidades de agente, sobresaliendo en programación, uso de herramientas, seguimiento de instrucciones y planificación a largo plazo. El modelo admite desarrollo de software multilingüe y ejecución de flujos de trabajo complejos en múltiples pasos, logrando una puntuación de 74.0 en SWE-bench Verified y superando a Claude Sonnet 4.5 en escenarios multilingües.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 es el último modelo de lenguaje desarrollado por MiniMax, entrenado mediante aprendizaje por refuerzo a gran escala en cientos de miles de entornos complejos del mundo real. Con una arquitectura MoE y 229 mil millones de parámetros, logra un rendimiento líder en la industria en tareas como programación, uso de herramientas de agentes, búsqueda y escenarios de oficina.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct es un modelo LLM de 7 mil millones de parámetros ajustado para instrucciones de la serie Qwen2. Utiliza arquitectura Transformer con SwiGLU, sesgo QKV en atención y atención de consulta agrupada, y maneja entradas extensas. Tiene un rendimiento destacado en comprensión del lenguaje, generación, tareas multilingües, programación, matemáticas y razonamiento, superando a la mayoría de los modelos abiertos y compitiendo con modelos propietarios. Supera a Qwen1.5-7B-Chat en múltiples pruebas.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct forma parte de la última serie de LLM de Alibaba Cloud. El modelo de 7 mil millones ofrece mejoras notables en programación y matemáticas, admite más de 29 idiomas y mejora el seguimiento de instrucciones, la comprensión de datos estructurados y la generación de salidas estructuradas (especialmente JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct es el último modelo LLM de Alibaba Cloud enfocado en programación. Basado en Qwen2.5 y entrenado con 5,5 billones de tokens, mejora significativamente la generación, razonamiento y corrección de código, manteniendo fortalezas en matemáticas y tareas generales, proporcionando una base sólida para agentes de programación.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL es un nuevo modelo visión-lenguaje de Qwen con gran capacidad de comprensión visual. Analiza texto, gráficos y diseños en imágenes, comprende videos largos y eventos, admite razonamiento y uso de herramientas, anclaje de objetos en múltiples formatos y salidas estructuradas. Mejora la resolución dinámica y el entrenamiento con tasa de fotogramas para comprensión de video y aumenta la eficiencia del codificador visual.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking es un modelo VLM de código abierto de Zhipu AI y el Laboratorio KEG de Tsinghua, diseñado para cognición multimodal compleja. Basado en GLM-4-9B-0414, añade razonamiento en cadena y aprendizaje por refuerzo para mejorar significativamente el razonamiento entre modalidades y la estabilidad.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat es el modelo GLM-4 de código abierto de Zhipu AI. Tiene un rendimiento sólido en semántica, matemáticas, razonamiento, programación y conocimiento. Más allá del chat multivuelta, admite navegación web, ejecución de código, llamadas a herramientas personalizadas y razonamiento con textos largos. Soporta 26 idiomas (incluidos chino, inglés, japonés, coreano y alemán). Tiene buenos resultados en AlignBench-v2, MT-Bench, MMLU y C-Eval, y admite hasta 128K de contexto para uso académico y empresarial.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B se destila de Qwen2.5-Math-7B y se ajusta con 800K muestras curadas de DeepSeek-R1. Tiene un rendimiento destacado, con un 92.8% en MATH-500, 55.5% en AIME 2024 y una calificación de 1189 en CodeForces para un modelo de 7B.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 es un modelo de razonamiento impulsado por aprendizaje por refuerzo que reduce la repetición y mejora la legibilidad. Utiliza datos de arranque en frío antes del RL para potenciar aún más el razonamiento, iguala a OpenAI-o1 en tareas de matemáticas, programación y razonamiento, y mejora los resultados generales mediante un entrenamiento cuidadoso.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus es una versión actualizada del modelo V3.1, posicionado como un LLM híbrido para agentes. Corrige problemas reportados por usuarios y mejora la estabilidad, coherencia lingüística y reduce caracteres anómalos o mezclas de chino/inglés. Integra modos de razonamiento y no razonamiento con plantillas de chat para cambiar de forma flexible. También mejora el rendimiento de los agentes de código y búsqueda para un uso más fiable de herramientas y tareas de múltiples pasos.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 es un modelo que combina alta eficiencia computacional con excelente razonamiento y rendimiento como Agente. Su enfoque se basa en tres avances tecnológicos clave: DeepSeek Sparse Attention (DSA), un mecanismo de atención eficiente que reduce significativamente la complejidad computacional mientras mantiene el rendimiento del modelo, optimizado específicamente para escenarios de contexto largo; un marco de aprendizaje por refuerzo escalable que permite que el rendimiento del modelo rivalice con GPT-5, con su versión de alta computación igualando a Gemini-3.0-Pro en capacidades de razonamiento; y una tubería de síntesis de tareas de Agente a gran escala diseñada para integrar capacidades de razonamiento en escenarios de uso de herramientas, mejorando así el seguimiento de instrucciones y la generalización en entornos interactivos complejos. El modelo obtuvo medallas de oro en la Olimpiada Internacional de Matemáticas (IMO) y la Olimpiada Internacional de Informática (IOI) de 2025.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 es la versión más reciente y potente de Kimi K2. Es un modelo MoE de primer nivel con 1 billón de parámetros totales y 32 mil millones activos. Sus características clave incluyen mayor inteligencia en programación con agentes, mejoras significativas en pruebas de referencia y tareas reales de agentes, además de una estética y usabilidad mejoradas en programación frontend.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo es la variante Turbo optimizada para velocidad de razonamiento y rendimiento, manteniendo el razonamiento de múltiples pasos y uso de herramientas de K2 Thinking. Es un modelo MoE con aproximadamente 1 billón de parámetros totales, contexto nativo de 256K y llamadas a herramientas estables a gran escala para escenarios de producción con necesidades estrictas de latencia y concurrencia.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 es un modelo agente multimodal nativo de código abierto, basado en Kimi-K2-Base, entrenado con aproximadamente 1.5 billones de tokens mixtos de visión y texto. El modelo adopta una arquitectura MoE con 1T de parámetros totales y 32B de parámetros activos, soportando una ventana de contexto de 256K, integrando de forma fluida capacidades de comprensión visual y lingüística.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 es el modelo insignia de nueva generación de Zhipu con un total de 355 mil millones de parámetros y 32 mil millones de parámetros activos, completamente mejorado en diálogo general, razonamiento y capacidades de agentes. GLM-4.7 mejora el Pensamiento Intercalado e introduce Pensamiento Preservado y Pensamiento a Nivel de Turno.",
   "Pro/zai-org/glm-5.description": "GLM-5 es el modelo de lenguaje grande de próxima generación de Zhipu, enfocado en ingeniería de sistemas complejos y tareas de Agente de larga duración. Los parámetros del modelo se han ampliado a 744 mil millones (40 mil millones activos) e integran DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ es un modelo de investigación experimental centrado en mejorar el razonamiento.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview es un modelo de investigación de Qwen enfocado en razonamiento visual, con fortalezas en la comprensión de escenas complejas y problemas matemáticos visuales.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ es un modelo de investigación experimental centrado en mejorar el razonamiento de IA.",
   "Qwen/QwQ-32B.description": "QwQ es un modelo de razonamiento de la familia Qwen. En comparación con los modelos estándar ajustados para instrucciones, añade capacidades de pensamiento y razonamiento que mejoran significativamente el rendimiento en tareas complejas. QwQ-32B es un modelo de razonamiento de tamaño medio competitivo con modelos líderes como DeepSeek-R1 y o1-mini. Utiliza RoPE, SwiGLU, RMSNorm y sesgo QKV en atención, con 64 capas y 40 cabezales de atención Q (8 KV en GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 es la última versión de edición de Qwen-Image del equipo Qwen. Basado en el modelo Qwen-Image de 20 mil millones de parámetros, amplía su potente renderizado de texto hacia la edición de imágenes para realizar ediciones textuales precisas. Utiliza una arquitectura de control dual, enviando entradas a Qwen2.5-VL para control semántico y a un codificador VAE para control de apariencia, permitiendo ediciones tanto a nivel semántico como visual. Admite ediciones locales (agregar/quitar/modificar) y ediciones semánticas de alto nivel como creación de IP y transferencia de estilo, preservando el significado. Logra resultados SOTA en múltiples pruebas de referencia.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Modelo Skylark de segunda generación. Skylark2-pro-turbo-8k ofrece inferencia más rápida a menor costo con una ventana de contexto de 8K.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 es un modelo GLM de próxima generación con 32 mil millones de parámetros, comparable en rendimiento a OpenAI GPT y la serie DeepSeek V3/R1.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 es un modelo GLM de 9 mil millones de parámetros que hereda las técnicas de GLM-4-32B, ofreciendo una implementación más ligera. Tiene buen rendimiento en generación de código, diseño web, generación de SVG y redacción basada en búsqueda.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking es un modelo VLM de código abierto de Zhipu AI y Tsinghua KEG Lab, diseñado para cognición multimodal compleja. Basado en GLM-4-9B-0414, agrega razonamiento en cadena y RL para mejorar significativamente el razonamiento cruzado y la estabilidad.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 es un modelo de razonamiento profundo construido a partir de GLM-4-32B-0414 con datos de arranque en frío y aprendizaje por refuerzo ampliado, entrenado adicionalmente en matemáticas, código y lógica. Mejora significativamente la capacidad matemática y la resolución de tareas complejas respecto al modelo base.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 es un modelo GLM pequeño de 9 mil millones de parámetros que conserva las fortalezas del código abierto y ofrece una capacidad impresionante. Tiene un rendimiento destacado en razonamiento matemático y tareas generales, liderando su clase de tamaño entre los modelos abiertos.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat es el modelo GLM-4 de código abierto de Zhipu AI. Tiene un rendimiento sólido en semántica, matemáticas, razonamiento, código y conocimiento. Además de conversación multivuelta, admite navegación web, ejecución de código, llamadas a herramientas personalizadas y razonamiento de textos largos. Soporta 26 idiomas (incluidos chino, inglés, japonés, coreano y alemán). Tiene buen rendimiento en AlignBench-v2, MT-Bench, MMLU y C-Eval, y admite hasta 128K de contexto para uso académico y empresarial.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B es el primer modelo de razonamiento de contexto largo (LRM) entrenado con RL, optimizado para razonamiento de textos largos. Su RL de expansión progresiva de contexto permite una transferencia estable de contextos cortos a largos. Supera a OpenAI-o3-mini y Qwen3-235B-A22B en siete puntos de referencia de QA de documentos de contexto largo, rivalizando con Claude-3.7-Sonnet-Thinking. Es especialmente fuerte en matemáticas, lógica y razonamiento de múltiples pasos.",
   "Yi-34B-Chat.description": "Yi-1.5-34B mantiene las sólidas capacidades lingüísticas generales de la serie, mientras que el entrenamiento incremental con 500 mil millones de tokens de alta calidad mejora significativamente la lógica matemática y la programación.",
   "abab5.5-chat.description": "Diseñado para escenarios de productividad con manejo de tareas complejas y generación eficiente de texto para uso profesional.",
   "abab5.5s-chat.description": "Diseñado para conversación con personajes en chino, ofreciendo diálogos de alta calidad en chino para diversas aplicaciones.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet destaca en programación, redacción y razonamiento complejo.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet con pensamiento extendido para tareas de razonamiento complejo.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet es una versión mejorada con mayor contexto y capacidades ampliadas.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 es el modelo Haiku más rápido e inteligente de Anthropic, con velocidad relámpago y pensamiento extendido.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 es un modelo rápido y eficiente para diversas tareas.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking es una variante avanzada que puede mostrar su proceso de razonamiento.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 es el modelo más reciente y capaz de Anthropic para tareas altamente complejas, destacando en rendimiento, inteligencia, fluidez y comprensión.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 es el modelo más poderoso de Anthropic para tareas altamente complejas, destacando en rendimiento, inteligencia, fluidez y comprensión.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 es el modelo insignia de Anthropic, combinando inteligencia excepcional con rendimiento escalable, ideal para tareas complejas que requieren respuestas y razonamiento de la más alta calidad.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 es el modelo más inteligente de Anthropic para construir agentes y programar.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking puede generar respuestas casi instantáneas o pensamiento paso a paso extendido con proceso visible.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 es el modelo más inteligente de Anthropic hasta la fecha, ofreciendo respuestas casi instantáneas o pensamiento extendido paso a paso con control detallado para usuarios de API.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 es el modelo más inteligente de Anthropic hasta la fecha.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 es la mejor combinación de velocidad e inteligencia de Anthropic.",
   "claude-sonnet-4.description": "Claude Sonnet 4 es la última generación con un rendimiento mejorado en todas las tareas.",
   "codegeex-4.description": "CodeGeeX-4 es un potente asistente de codificación con soporte multilingüe para preguntas y respuestas y autocompletado de código, mejorando la productividad de los desarrolladores.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B es un modelo multilingüe de generación de código que admite autocompletado y generación de código, interpretación de código, búsqueda web, llamadas a funciones y preguntas y respuestas a nivel de repositorio, cubriendo una amplia gama de escenarios de desarrollo de software. Es un modelo de código de primer nivel con menos de 10 mil millones de parámetros.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "Los modelos destilados DeepSeek-R1 utilizan aprendizaje por refuerzo (RL) y datos de arranque en frío para mejorar el razonamiento y establecer nuevos estándares en tareas múltiples con modelos abiertos.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "Los modelos destilados DeepSeek-R1 utilizan aprendizaje por refuerzo (RL) y datos de arranque en frío para mejorar el razonamiento y establecer nuevos estándares en tareas múltiples con modelos abiertos.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B es una destilación de Qwen2.5-32B afinada con 800,000 muestras curadas de DeepSeek-R1. Destaca en matemáticas, programación y razonamiento, logrando excelentes resultados en AIME 2024, MATH-500 (94.3% de precisión) y GPQA Diamond.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B se destila de Qwen2.5-Math-7B y se ajusta con 800K muestras curadas de DeepSeek-R1. Tiene un rendimiento destacado, con un 92.8% en MATH-500, 55.5% en AIME 2024 y una calificación de 1189 en CodeForces para un modelo de 7B.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 mejora el razonamiento mediante aprendizaje por refuerzo (RL) y datos de arranque en frío, estableciendo nuevos estándares en tareas múltiples con modelos abiertos y superando a OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 mejora DeepSeek-V2-Chat y DeepSeek-Coder-V2-Instruct, combinando capacidades generales y de programación. Mejora la redacción y el seguimiento de instrucciones para una mejor alineación con las preferencias, mostrando avances significativos en AlpacaEval 2.0, ArenaHard, AlignBench y MT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus es una versión actualizada del modelo V3.1, concebido como un agente híbrido. Corrige problemas reportados por usuarios y mejora la estabilidad, coherencia lingüística y reduce caracteres anómalos o mezclas de chino/inglés. Integra modos de pensamiento y no pensamiento con plantillas de chat para cambiar de forma flexible. También mejora el rendimiento de los agentes de código y búsqueda para un uso más confiable de herramientas y tareas de múltiples pasos.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 es un modelo de razonamiento de nueva generación con capacidades mejoradas para razonamiento complejo y cadenas de pensamiento, ideal para tareas de análisis profundo.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 es un modelo de razonamiento de próxima generación con capacidades mejoradas de razonamiento complejo y cadenas de pensamiento.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 es un modelo visión-lenguaje MoE basado en DeepSeekMoE-27B con activación dispersa, logrando un alto rendimiento con solo 4.5B de parámetros activos. Destaca en preguntas visuales, OCR, comprensión de documentos/tablas/gráficos y anclaje visual.",
+  "deepseek-chat.description": "DeepSeek V3.2 equilibra razonamiento y longitud de salida para tareas diarias de QA y agentes. Los puntos de referencia públicos alcanzan niveles de GPT-5, y es el primero en integrar pensamiento en el uso de herramientas, liderando evaluaciones de agentes de código abierto.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B es un modelo de lenguaje para código entrenado con 2T de tokens (87% código, 13% texto en chino/inglés). Introduce una ventana de contexto de 16K y tareas de completado intermedio, ofreciendo completado de código a nivel de proyecto y relleno de fragmentos.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 es un modelo de código MoE de código abierto que tiene un rendimiento sólido en tareas de programación, comparable a GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 es un modelo de código MoE de código abierto que tiene un rendimiento sólido en tareas de programación, comparable a GPT-4 Turbo.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "Versión completa rápida de DeepSeek R1 con búsqueda web en tiempo real, combinando capacidad a escala 671B y respuesta ágil.",
   "deepseek-r1-online.description": "Versión completa de DeepSeek R1 con 671B de parámetros y búsqueda web en tiempo real, ofreciendo mejor comprensión y generación.",
   "deepseek-r1.description": "DeepSeek-R1 utiliza datos de arranque en frío antes del aprendizaje por refuerzo y tiene un rendimiento comparable a OpenAI-o1 en matemáticas, programación y razonamiento.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking es un modelo de razonamiento profundo que genera cadenas de pensamiento antes de las salidas para mayor precisión, con resultados de competencia destacados y razonamiento comparable a Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 es un modelo MoE eficiente para procesamiento rentable.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B es el modelo de DeepSeek centrado en código con fuerte generación de código.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 es un modelo MoE con 671 mil millones de parámetros, con fortalezas destacadas en programación, capacidad técnica, comprensión de contexto y manejo de textos largos.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp introduce atención dispersa para mejorar la eficiencia de entrenamiento e inferencia en textos largos, a un precio más bajo que deepseek-v3.1.",
   "deepseek-v3.2-speciale.description": "En tareas altamente complejas, el modelo Speciale supera significativamente a la versión estándar, pero consume considerablemente más tokens y genera mayores costos. Actualmente, DeepSeek-V3.2-Speciale está destinado solo para uso en investigación, no admite llamadas de herramientas y no ha sido optimizado específicamente para conversaciones cotidianas o tareas de escritura.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think es un modelo de pensamiento profundo completo con razonamiento de cadenas largas más sólido.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 es el modelo de programación más reciente de DeepSeek con fuertes capacidades de razonamiento.",
   "deepseek-v3.description": "DeepSeek-V3 es un potente modelo MoE con 671 mil millones de parámetros totales y 37 mil millones activos por token.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small es una versión multimodal ligera para entornos con recursos limitados y alta concurrencia.",
   "deepseek-vl2.description": "DeepSeek VL2 es un modelo multimodal para comprensión imagen-texto y preguntas visuales detalladas.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K es un modelo de pensamiento rápido con contexto de 32K para razonamiento complejo y chat de múltiples turnos.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview es una vista previa del modelo de pensamiento para evaluación y pruebas.",
   "ernie-x1.1.description": "ERNIE X1.1 es un modelo de pensamiento en vista previa para evaluación y pruebas.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5, desarrollado por el equipo Seed de ByteDance, admite edición y composición de múltiples imágenes. Ofrece consistencia mejorada de sujetos, seguimiento preciso de instrucciones, comprensión de lógica espacial, expresión estética, diseño de carteles y logotipos con renderizado de texto e imagen de alta precisión.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0, desarrollado por ByteDance Seed, admite entradas de texto e imagen para generación de imágenes altamente controlable y de alta calidad a partir de indicaciones.",
   "fal-ai/flux-kontext/dev.description": "Modelo FLUX.1 centrado en la edición de imágenes, compatible con entradas de texto e imagen.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] acepta texto e imágenes de referencia como entrada, permitiendo ediciones locales dirigidas y transformaciones globales complejas de escenas.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] es un modelo de generación de imágenes con una inclinación estética hacia imágenes más realistas y naturales.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "Un potente modelo nativo multimodal de generación de imágenes.",
   "fal-ai/imagen4/preview.description": "Modelo de generación de imágenes de alta calidad de Google.",
   "fal-ai/nano-banana.description": "Nano Banana es el modelo multimodal nativo más nuevo, rápido y eficiente de Google, que permite generación y edición de imágenes mediante conversación.",
+  "fal-ai/qwen-image-edit.description": "Un modelo profesional de edición de imágenes del equipo Qwen, que admite ediciones semánticas y de apariencia, edición precisa de texto en chino/inglés, transferencia de estilo, rotación y más.",
+  "fal-ai/qwen-image.description": "Un modelo potente de generación de imágenes del equipo Qwen con fuerte renderizado de texto en chino y estilos visuales diversos.",
   "flux-1-schnell.description": "Modelo de texto a imagen con 12 mil millones de parámetros de Black Forest Labs que utiliza destilación difusiva adversarial latente para generar imágenes de alta calidad en 1 a 4 pasos. Compite con alternativas cerradas y se lanza bajo licencia Apache-2.0 para uso personal, de investigación y comercial.",
   "flux-dev.description": "FLUX.1 [dev] es un modelo destilado con pesos abiertos para uso no comercial. Mantiene calidad de imagen casi profesional y seguimiento de instrucciones mientras funciona de manera más eficiente, utilizando mejor los recursos que modelos estándar del mismo tamaño.",
   "flux-kontext-max.description": "Generación y edición de imágenes contextual de última generación, combinando texto e imágenes para resultados precisos y coherentes.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro es el modelo de razonamiento más avanzado de Google, capaz de razonar sobre código, matemáticas y problemas STEM, y analizar grandes conjuntos de datos, bases de código y documentos con contexto largo.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash es el modelo más inteligente diseñado para la velocidad, combinando inteligencia de vanguardia con una excelente fundamentación en búsquedas.",
   "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 diálogo multimodal.",
+  "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 y también admite chat multimodal.",
   "gemini-3-pro-preview.description": "Gemini 3 Pro es el agente más potente de Google y modelo de codificación emocional, que ofrece visuales más ricos e interacción más profunda sobre un razonamiento de última generación.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) es el modelo nativo de generación de imágenes más rápido de Google con soporte de pensamiento, generación conversacional de imágenes y edición.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) ofrece calidad de imagen a nivel Pro a velocidad Flash con soporte de chat multimodal.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview es el modelo multimodal más rentable de Google, optimizado para tareas agentivas de alto volumen, traducción y procesamiento de datos.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview mejora las capacidades de razonamiento de Gemini 3 Pro y añade soporte para un nivel de pensamiento medio.",
   "gemini-flash-latest.description": "Última versión de Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "Variante de pensamiento largo de K2 de alta velocidad con contexto de 256k, razonamiento profundo sólido y salida de 60–100 tokens/segundo.",
   "kimi-k2-thinking.description": "kimi-k2-thinking es un modelo de pensamiento de Moonshot AI con capacidades generales de agentes y razonamiento. Destaca en razonamiento profundo y puede resolver problemas complejos mediante el uso de herramientas en múltiples pasos.",
   "kimi-k2-turbo-preview.description": "kimi-k2 es un modelo base MoE con sólidas capacidades de programación y agentes (1T de parámetros totales, 32B activos), superando a otros modelos abiertos en razonamiento, programación, matemáticas y benchmarks de agentes.",
+  "kimi-k2.5.description": "Kimi K2.5 es el modelo más versátil de Kimi hasta la fecha, con una arquitectura multimodal nativa que admite entradas de visión y texto, modos de 'pensamiento' y 'no pensamiento', y tareas tanto conversacionales como de agentes.",
   "kimi-k2.description": "Kimi-K2 es un modelo base MoE de Moonshot AI con sólidas capacidades de programación y agentes, con un total de 1T de parámetros y 32B activos. En benchmarks de razonamiento general, programación, matemáticas y tareas de agentes, supera a otros modelos abiertos.",
   "kimi-k2:1t.description": "Kimi K2 es un gran modelo MoE LLM de Moonshot AI con 1T de parámetros totales y 32B activos por pasada. Está optimizado para capacidades de agentes, incluyendo uso avanzado de herramientas, razonamiento y síntesis de código.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (gratis por tiempo limitado) se enfoca en la comprensión de código y automatización para agentes de programación eficientes.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K admite 32,768 tokens para contextos de longitud media, ideal para documentos largos y diálogos complejos en creación de contenido, informes y sistemas de chat.",
   "moonshot-v1-8k-vision-preview.description": "Los modelos de visión Kimi (incluidos moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) pueden comprender contenido de imágenes como texto, colores y formas de objetos.",
   "moonshot-v1-8k.description": "Moonshot V1 8K está optimizado para generación de texto corto con rendimiento eficiente, manejando 8,192 tokens para chats breves, notas y contenido rápido.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B es un modelo de código LLM de código abierto optimizado con RL a gran escala para producir parches robustos y listos para producción. Obtiene un 60.4% en SWE-bench Verified, estableciendo un nuevo récord de modelo abierto para tareas automatizadas de ingeniería de software como corrección de errores y revisión de código.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 es la versión más nueva y potente de Kimi K2. Es un modelo MoE de primer nivel con 1T total y 32B de parámetros activos. Sus características clave incluyen mayor inteligencia en programación de agentes con mejoras significativas en benchmarks y tareas reales, además de mejor estética y usabilidad en código frontend.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking es el modelo de pensamiento más reciente y poderoso de código abierto. Amplía enormemente la profundidad de razonamiento de múltiples pasos y mantiene un uso estable de herramientas en 200–300 llamadas consecutivas, estableciendo nuevos récords en Humanity's Last Exam (HLE), BrowseComp y otros puntos de referencia. Sobresale en codificación, matemáticas, lógica y escenarios de agentes. Construido sobre una arquitectura MoE con ~1 billón de parámetros totales, admite una ventana de contexto de 256K y llamadas de herramientas.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 es la variante instructiva de la serie Kimi, adecuada para el uso de herramientas y generación de código de alta calidad.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "El próximo generador de código Qwen optimizado para generación de código complejo de múltiples archivos, depuración y flujos de trabajo de agentes de alto rendimiento. Diseñado para una fuerte integración de herramientas y un rendimiento de razonamiento mejorado.",
   "qwen3-coder-plus.description": "Modelo de código Qwen. La última serie Qwen3-Coder se basa en Qwen3 y ofrece sólidas capacidades de agente de codificación, uso de herramientas e interacción con entornos para programación autónoma, con excelente rendimiento en código y capacidad general sólida.",
   "qwen3-coder:480b.description": "Modelo de alto rendimiento de Alibaba para tareas de agente y programación con contexto largo.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: Modelo Qwen con mejor rendimiento para tareas de programación complejas y de múltiples pasos con soporte de pensamiento.",
   "qwen3-max-preview.description": "Modelo Qwen con mejor rendimiento para tareas complejas y de múltiples pasos. La vista previa admite razonamiento.",
   "qwen3-max.description": "Los modelos Qwen3 Max ofrecen grandes mejoras sobre la serie 2.5 en capacidad general, comprensión en chino/inglés, seguimiento de instrucciones complejas, tareas abiertas subjetivas, capacidad multilingüe y uso de herramientas, con menos alucinaciones. La última versión qwen3-max mejora la programación agente y el uso de herramientas respecto a qwen3-max-preview. Este lanzamiento alcanza el estado del arte en el campo y está dirigido a necesidades de agentes más complejas.",
   "qwen3-next-80b-a3b-instruct.description": "Modelo de próxima generación Qwen3 de código abierto sin razonamiento. En comparación con la versión anterior (Qwen3-235B-A22B-Instruct-2507), mejora la comprensión del chino, el razonamiento lógico y la generación de texto.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ es un modelo de razonamiento de la familia Qwen. En comparación con los modelos estándar ajustados por instrucciones, ofrece capacidades de pensamiento y razonamiento que mejoran significativamente el rendimiento en tareas difíciles. QwQ-32B es un modelo de razonamiento de tamaño medio que compite con los mejores modelos como DeepSeek-R1 y o1-mini.",
   "qwq_32b.description": "Modelo de razonamiento de tamaño medio de la familia Qwen. En comparación con los modelos estándar ajustados por instrucciones, las capacidades de pensamiento y razonamiento de QwQ mejoran significativamente el rendimiento en tareas difíciles.",
   "r1-1776.description": "R1-1776 es una variante postentrenada de DeepSeek R1 diseñada para proporcionar información factual sin censura ni sesgo.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro de ByteDance admite generación de texto a video, imagen a video (primer cuadro, primer+último cuadro) y generación de audio sincronizado con visuales.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite de BytePlus presenta generación aumentada con recuperación web para información en tiempo real, interpretación mejorada de indicaciones complejas y consistencia de referencia mejorada para creación visual profesional.",
   "solar-mini-ja.description": "Solar Mini (Ja) amplía Solar Mini con un enfoque en japonés, manteniendo un rendimiento eficiente y sólido en inglés y coreano.",
   "solar-mini.description": "Solar Mini es un modelo LLM compacto que supera a GPT-3.5, con una sólida capacidad multilingüe compatible con inglés y coreano, ofreciendo una solución eficiente de bajo consumo.",
   "solar-pro.description": "Solar Pro es un LLM de alta inteligencia de Upstage, enfocado en el seguimiento de instrucciones en una sola GPU, con puntuaciones IFEval superiores a 80. Actualmente admite inglés; el lanzamiento completo estaba previsto para noviembre de 2024 con soporte de idiomas ampliado y contexto más largo.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "El modelo insignia de razonamiento lingüístico de Stepfun. Este modelo tiene capacidades de razonamiento de primer nivel y capacidades de ejecución rápidas y confiables. Es capaz de descomponer y planificar tareas complejas, llamar herramientas de manera rápida y confiable para realizar tareas, y ser competente en diversas tareas complejas como razonamiento lógico, matemáticas, ingeniería de software e investigación profunda.",
   "step-3.description": "Este modelo posee una fuerte percepción visual y razonamiento complejo, manejando con precisión el entendimiento de conocimientos multidominio, análisis matemático-visual y una amplia gama de tareas de análisis visual cotidiano.",
   "step-r1-v-mini.description": "Modelo de razonamiento con sólida comprensión de imágenes que puede procesar imágenes y texto, y luego generar texto tras un razonamiento profundo. Destaca en razonamiento visual y ofrece rendimiento de primer nivel en matemáticas, programación y razonamiento textual, con una ventana de contexto de 100K.",
+  "stepfun-ai/step3.description": "Step3 es un modelo de razonamiento multimodal de vanguardia de StepFun, construido sobre una arquitectura MoE con un total de 321 mil millones y 38 mil millones de parámetros activos. Su diseño de extremo a extremo minimiza el costo de decodificación mientras ofrece razonamiento de visión-lenguaje de primer nivel. Con diseño MFA y AFD, se mantiene eficiente tanto en aceleradores insignia como de gama baja. El preentrenamiento utiliza más de 20T tokens de texto y 4T tokens de texto-imagen en muchos idiomas. Alcanza un rendimiento líder en modelos abiertos en matemáticas, código y puntos de referencia multimodales.",
   "taichu4_vl_2b_nothinking.description": "La versión sin pensamiento del modelo Taichu4.0-VL 2B presenta un menor uso de memoria, un diseño ligero, velocidad de respuesta rápida y fuertes capacidades de comprensión multimodal.",
   "taichu4_vl_32b.description": "La versión con pensamiento del modelo Taichu4.0-VL 32B es adecuada para tareas complejas de comprensión y razonamiento multimodal, demostrando un rendimiento sobresaliente en razonamiento matemático multimodal, capacidades de agente multimodal y comprensión general de imágenes y visuales.",
   "taichu4_vl_32b_nothinking.description": "La versión sin pensamiento del modelo Taichu4.0-VL 32B está diseñada para escenarios complejos de comprensión de imagen y texto y preguntas y respuestas de conocimiento visual, destacándose en subtitulado de imágenes, preguntas y respuestas visuales, comprensión de videos y tareas de localización visual.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air es un modelo base para aplicaciones de agentes que utiliza una arquitectura de Mezcla de Expertos (MoE). Está optimizado para el uso de herramientas, navegación web, ingeniería de software y programación frontend, e integra agentes de código como Claude Code y Roo Code. Emplea razonamiento híbrido para abordar tanto escenarios complejos como situaciones cotidianas.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V es el último modelo VLM de Zhipu AI, basado en el modelo de texto insignia GLM-4.5-Air (106B en total, 12B activos) con una arquitectura MoE que ofrece alto rendimiento a menor costo. Sigue la línea de pensamiento de GLM-4.1V-Thinking y añade 3D-RoPE para mejorar el razonamiento espacial en 3D. Optimizado mediante preentrenamiento, SFT y RL, maneja imágenes, videos y documentos extensos, y se posiciona entre los mejores modelos abiertos en 41 benchmarks multimodales públicos. Un modo de pensamiento configurable permite equilibrar velocidad y profundidad.",
   "zai-org/GLM-4.6.description": "En comparación con GLM-4.5, GLM-4.6 amplía el contexto de 128K a 200K para abordar tareas de agentes más complejas. Obtiene mejores puntuaciones en benchmarks de código y muestra un rendimiento superior en aplicaciones reales como Claude Code, Cline, Roo Code y Kilo Code, incluyendo una mejor generación de páginas frontend. El razonamiento ha sido mejorado y se admite el uso de herramientas durante el proceso, fortaleciendo su capacidad general. Se integra mejor en marcos de trabajo de agentes, mejora los agentes de búsqueda y herramientas, y ofrece un estilo de escritura más natural y preferido por los usuarios, así como una mayor naturalidad en la simulación de roles.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V logra precisión SOTA en comprensión visual para su escala de parámetros y es el primero en integrar de forma nativa capacidades de Llamada de Función en la arquitectura del modelo de visión, cerrando la brecha entre \"percepción visual\" y \"acciones ejecutables\" y proporcionando una base técnica unificada para agentes multimodales en escenarios empresariales reales. La ventana de contexto visual se extiende a 128k, admitiendo procesamiento de transmisiones de video largas y análisis de múltiples imágenes de alta resolución.",
   "zai/glm-4.5-air.description": "GLM-4.5 y GLM-4.5-Air son nuestros modelos insignia más recientes para aplicaciones de agentes, ambos con arquitectura MoE. GLM-4.5 cuenta con 355B en total y 32B activos por pasada; GLM-4.5-Air es más liviano, con 106B en total y 12B activos.",
   "zai/glm-4.5.description": "La serie GLM-4.5 está diseñada para agentes. El modelo insignia GLM-4.5 combina razonamiento, programación y habilidades de agente con 355B de parámetros totales (32B activos) y ofrece modos de operación dual como sistema de razonamiento híbrido.",
   "zai/glm-4.5v.description": "GLM-4.5V se basa en GLM-4.5-Air, heredando técnicas comprobadas de GLM-4.1V-Thinking y escalando con una sólida arquitectura MoE de 106B parámetros.",

locales/es-ES/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure ofrece modelos de IA avanzados, incluyendo las series GPT-3.5 y GPT-4, para diversos tipos de datos y tareas complejas, con un enfoque en IA segura, confiable y sostenible.",
   "azureai.description": "Azure proporciona modelos de IA avanzados, incluyendo las series GPT-3.5 y GPT-4, para diversos tipos de datos y tareas complejas, con un enfoque en IA segura, confiable y sostenible.",
   "baichuan.description": "Baichuan AI se enfoca en modelos fundacionales con alto rendimiento en conocimiento del chino, procesamiento de contexto largo y generación creativa. Sus modelos (Baichuan 4, Baichuan 3 Turbo, Baichuan 3 Turbo 128k) están optimizados para distintos escenarios y ofrecen gran valor.",
+  "bailiancodingplan.description": "El Plan de Codificación Bailian de Aliyun es un servicio de codificación especializado en IA que proporciona acceso a modelos optimizados para codificación como Qwen, GLM, Kimi y MiniMax a través de un punto de acceso dedicado.",
   "bedrock.description": "Amazon Bedrock proporciona a las empresas modelos avanzados de lenguaje y visión, incluyendo Anthropic Claude y Meta Llama 3.1, desde opciones ligeras hasta de alto rendimiento para tareas de texto, chat e imagen.",
   "bfl.description": "Un laboratorio líder en investigación de IA de frontera que construye la infraestructura visual del futuro.",
   "cerebras.description": "Cerebras es una plataforma de inferencia basada en su sistema CS-3, enfocada en baja latencia y alto rendimiento para tareas en tiempo real como generación de código y agentes.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Las APIs sin servidor de Gitee AI ofrecen servicios de inferencia LLM listos para usar para desarrolladores.",
   "github.description": "Con GitHub Models, los desarrolladores pueden trabajar como ingenieros de IA utilizando modelos líderes en la industria.",
   "githubcopilot.description": "Accede a los modelos Claude, GPT y Gemini con tu suscripción a GitHub Copilot.",
+  "glmcodingplan.description": "El Plan de Codificación GLM proporciona acceso a los modelos de Zhipu AI, incluidos GLM-5 y GLM-4.7, para tareas de codificación mediante una suscripción de tarifa fija.",
   "google.description": "La familia Gemini de Google es su IA de propósito general más avanzada, desarrollada por Google DeepMind para uso multimodal en texto, código, imágenes, audio y video. Escala desde centros de datos hasta dispositivos móviles con gran eficiencia y alcance.",
   "groq.description": "El motor de inferencia LPU de Groq ofrece un rendimiento de referencia excepcional con velocidad y eficiencia sobresalientes, estableciendo un alto estándar para la inferencia LLM en la nube de baja latencia.",
   "higress.description": "Higress es una puerta de enlace de API nativa en la nube creada dentro de Alibaba para abordar el impacto de recarga de Tengine en conexiones de larga duración y brechas en el balanceo de carga gRPC/Dubbo.",
@@ -29,9 +31,12 @@
   "infiniai.description": "Proporciona a los desarrolladores de aplicaciones servicios LLM de alto rendimiento, fáciles de usar y seguros, cubriendo todo el flujo de trabajo desde el desarrollo del modelo hasta su despliegue en producción.",
   "internlm.description": "Una organización de código abierto centrada en la investigación de modelos grandes y herramientas, que ofrece una plataforma eficiente y fácil de usar para acceder a modelos y algoritmos de vanguardia.",
   "jina.description": "Fundada en 2020, Jina AI es una empresa líder en búsqueda con IA. Su pila de búsqueda incluye modelos vectoriales, reordenadores y pequeños modelos de lenguaje para construir aplicaciones generativas y multimodales confiables y de alta calidad.",
+  "kimicodingplan.description": "Kimi Code de Moonshot AI proporciona acceso a los modelos Kimi, incluidos K2.5, para tareas de codificación.",
   "lmstudio.description": "LM Studio es una aplicación de escritorio para desarrollar y experimentar con LLMs en tu ordenador.",
+  "lobehub.description": "LobeHub Cloud utiliza APIs oficiales para acceder a modelos de IA y mide el uso con Créditos vinculados a los tokens de los modelos.",
   "longcat.description": "LongCat es una serie de modelos grandes de inteligencia artificial generativa desarrollados de manera independiente por Meituan. Está diseñado para mejorar la productividad interna de la empresa y permitir aplicaciones innovadoras mediante una arquitectura computacional eficiente y sólidas capacidades multimodales.",
   "minimax.description": "Fundada en 2021, MiniMax desarrolla IA de propósito general con modelos fundacionales multimodales, incluyendo modelos de texto MoE con billones de parámetros, modelos de voz y visión, junto con aplicaciones como Hailuo AI.",
+  "minimaxcodingplan.description": "El Plan de Tokens MiniMax proporciona acceso a los modelos MiniMax, incluidos M2.7, para tareas de codificación mediante una suscripción de tarifa fija.",
   "mistral.description": "Mistral ofrece modelos avanzados generales, especializados y de investigación para razonamiento complejo, tareas multilingües y generación de código, con llamadas a funciones para integraciones personalizadas.",
   "modelscope.description": "ModelScope es la plataforma de modelos como servicio de Alibaba Cloud, que ofrece una amplia gama de modelos de IA y servicios de inferencia.",
   "moonshot.description": "Moonshot, de Moonshot AI (Beijing Moonshot Technology), ofrece múltiples modelos de PLN para casos de uso como creación de contenido, investigación, recomendaciones y análisis médico, con sólido soporte para contexto largo y generación compleja.",
@@ -64,6 +69,7 @@
   "vertexai.description": "La familia Gemini de Google es su IA de propósito general más avanzada, desarrollada por Google DeepMind para uso multimodal en texto, código, imágenes, audio y video. Escala desde centros de datos hasta dispositivos móviles, mejorando la eficiencia y flexibilidad de despliegue.",
   "vllm.description": "vLLM es una biblioteca rápida y fácil de usar para inferencia y servicio de LLMs.",
   "volcengine.description": "La plataforma de servicios de modelos de ByteDance ofrece acceso seguro, completo y rentable a modelos, además de herramientas de extremo a extremo para datos, ajuste fino, inferencia y evaluación.",
+  "volcenginecodingplan.description": "El Plan de Codificación Volcengine de ByteDance proporciona acceso a múltiples modelos de codificación, incluidos Doubao-Seed-Code, GLM-4.7, DeepSeek-V3.2 y Kimi-K2.5, mediante una suscripción de tarifa fija.",
   "wenxin.description": "Una plataforma empresarial todo en uno para modelos fundacionales y desarrollo de aplicaciones nativas de IA, que ofrece herramientas de extremo a extremo para flujos de trabajo de modelos y aplicaciones de IA generativa.",
   "xai.description": "xAI desarrolla IA para acelerar el descubrimiento científico, con la misión de profundizar la comprensión humana del universo.",
   "xiaomimimo.description": "Xiaomi MiMo ofrece un servicio de modelo conversacional con una API compatible con OpenAI. El modelo mimo-v2-flash admite razonamiento profundo, salida en streaming, llamadas a funciones, una ventana de contexto de 256K y una salida máxima de 128K.",

locales/es-ES/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "Soporta tarjeta de crédito / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "Soporta tarjeta de crédito",
   "plans.btn.soon": "Próximamente",
+  "plans.cancelDowngrade": "Cancelar la degradación programada",
+  "plans.cancelDowngradeSuccess": "La degradación programada ha sido cancelada",
   "plans.changePlan": "Elegir Plan",
   "plans.cloud.history": "Historial de conversaciones ilimitado",
   "plans.cloud.sync": "Sincronización global en la nube",
@@ -215,6 +217,7 @@
   "plans.current": "Plan Actual",
   "plans.downgradePlan": "Plan de Degradación",
   "plans.downgradeTip": "Ya has cambiado de suscripción. No puedes realizar otras operaciones hasta que se complete el cambio",
+  "plans.downgradeWillCancel": "Esta acción cancelará la degradación de plan programada",
   "plans.embeddingStorage.embeddings": "entradas",
   "plans.embeddingStorage.title": "Almacenamiento Vectorial",
   "plans.embeddingStorage.tooltip": "Una página de documento (1000-1500 caracteres) genera aproximadamente 1 entrada vectorial. (Estimado con OpenAI Embeddings, puede variar según el modelo)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "Confirmar Selección",
   "plans.payonce.popconfirm": "Después del pago único, deberás esperar a que expire la suscripción para cambiar de plan o ciclo de facturación. Por favor confirma tu selección.",
   "plans.payonce.tooltip": "El pago único requiere esperar a que expire la suscripción para cambiar de plan o ciclo de facturación",
+  "plans.pendingDowngrade": "Degradación pendiente",
   "plans.plan.enterprise.contactSales": "Contactar Ventas",
   "plans.plan.enterprise.title": "Empresarial",
   "plans.plan.free.desc": "Para usuarios nuevos",
@@ -366,6 +370,7 @@
   "summary.title": "Resumen de Facturación",
   "summary.usageThisMonth": "Ver tu uso de este mes.",
   "summary.viewBillingHistory": "Ver Historial de Pagos",
+  "switchDowngradeTarget": "Cambiar el objetivo de degradación",
   "switchPlan": "Cambiar Plan",
   "switchToMonthly.desc": "Después del cambio, la facturación mensual se aplicará al finalizar el plan anual actual.",
   "switchToMonthly.title": "Cambiar a Facturación Mensual",

locales/fa-IR/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "اتصال ناموفق بود",
   "sync.title": "وضعیت همگام‌سازی",
   "sync.unconnected.tip": "اتصال به سرور سیگنال‌دهی ناموفق بود و کانال ارتباطی همتا به همتا برقرار نشد. لطفاً اتصال شبکه را بررسی کرده و دوباره تلاش کنید.",
-  "tab.aiImage": "آثار هنری",
   "tab.audio": "صوت",
   "tab.chat": "گفت‌وگو",
   "tab.community": "جامعه",
@@ -405,6 +404,7 @@
   "tab.eval": "آزمایشگاه ارزیابی",
   "tab.files": "فایل‌ها",
   "tab.home": "خانه",
+  "tab.image": "تصویر",
   "tab.knowledgeBase": "کتابخانه",
   "tab.marketplace": "بازار",
   "tab.me": "من",

locales/fa-IR/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "برای مدل‌های تولید تصویر Gemini 3؛ وضوح تصویر تولیدی را کنترل می‌کند.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "برای مدل‌های تصویر فلش جمینی ۳.۱؛ وضوح تصاویر تولید شده را کنترل می‌کند (پشتیبانی از ۵۱۲ پیکسل).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "برای Claude، Qwen3 و مدل‌های مشابه؛ بودجه توکن برای استدلال را کنترل می‌کند.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "برای GLM-5 و GLM-4.7؛ بودجه توکن برای استدلال را کنترل می‌کند (حداکثر ۳۲k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "برای سری Qwen3؛ بودجه توکن برای استدلال را کنترل می‌کند (حداکثر ۸۰k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "برای مدل‌های OpenAI و سایر مدل‌های دارای توانایی استدلال؛ میزان تلاش استدلالی را کنترل می‌کند.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "برای سری GPT-5+؛ میزان تفصیل خروجی را کنترل می‌کند.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "برای برخی مدل‌های Doubao؛ به مدل اجازه می‌دهد تصمیم بگیرد که آیا عمیق فکر کند یا نه.",

locales/fa-IR/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev یک مدل چندوجهی برای تولید و ویرایش تصویر از آزمایشگاه Black Forest است که بر پایه معماری Rectified Flow Transformer با ۱۲ میلیارد پارامتر ساخته شده است. این مدل بر تولید، بازسازی، بهبود یا ویرایش تصاویر در شرایط زمینه‌ای مشخص تمرکز دارد. با ترکیب قدرت تولید قابل کنترل مدل‌های انتشار با مدل‌سازی زمینه‌ای ترنسفورمر، خروجی‌های باکیفیتی برای وظایفی مانند inpainting، outpainting و بازسازی صحنه‌های بصری ارائه می‌دهد.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev یک مدل زبان چندوجهی متن-تصویر متن‌باز از آزمایشگاه Black Forest است که برای وظایف درک و تولید تصویر/متن بهینه‌سازی شده است. این مدل بر پایه LLMهای پیشرفته (مانند Mistral-7B) ساخته شده و از رمزگذار بینایی طراحی‌شده و تنظیمات چندمرحله‌ای دستورالعمل بهره می‌برد تا هماهنگی چندوجهی و استدلال پیچیده را ممکن سازد.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: نسخه سبک برای پاسخ‌های سریع.",
+  "GLM-4.5.description": "GLM-4.5: مدل با عملکرد بالا برای استدلال، کدنویسی و وظایف عامل.",
+  "GLM-4.6.description": "GLM-4.6: مدل نسل قبلی.",
+  "GLM-4.7.description": "GLM-4.7 جدیدترین مدل پرچمدار Zhipu است که برای سناریوهای کدنویسی عامل بهبود یافته است و قابلیت‌های کدنویسی، برنامه‌ریزی وظایف بلندمدت و همکاری ابزار را ارتقا داده است.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: نسخه بهینه‌سازی شده GLM-5 با استنتاج سریع‌تر برای وظایف کدنویسی.",
+  "GLM-5.description": "GLM-5 مدل پرچمدار نسل بعدی Zhipu است که برای مهندسی عامل طراحی شده است. این مدل بهره‌وری قابل اعتمادی را در مهندسی سیستم‌های پیچیده و وظایف عامل بلندمدت ارائه می‌دهد. در قابلیت‌های کدنویسی و عامل، GLM-5 عملکرد پیشرفته‌ای در میان مدل‌های متن‌باز دارد.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) مدلی نوآورانه برای حوزه‌های متنوع و وظایف پیچیده است.",
   "HY-Image-V3.0.description": "قابلیت‌های قدرتمند استخراج ویژگی‌های تصویر اصلی و حفظ جزئیات، ارائه بافت بصری غنی‌تر و تولید تصاویر با دقت بالا، ترکیب‌بندی مناسب و کیفیت تولید حرفه‌ای.",
   "HelloMeme.description": "HelloMeme یک ابزار هوش مصنوعی برای تولید میم، گیف یا ویدیوهای کوتاه از تصاویر یا حرکاتی است که ارائه می‌دهید. بدون نیاز به مهارت طراحی یا کدنویسی، تنها با یک تصویر مرجع، محتوایی سرگرم‌کننده، جذاب و از نظر سبک هماهنگ تولید می‌کند.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "یک مدل استدلالی داخلی جدید با ۸۰ هزار زنجیره تفکر و ورودی ۱ میلیون توکن، با عملکردی در سطح مدل‌های برتر جهانی.",
   "MiniMax-M2-Stable.description": "طراحی‌شده برای کدنویسی کارآمد و جریان‌های کاری عامل‌محور، با هم‌زمانی بالاتر برای استفاده تجاری.",
   "MiniMax-M2.1-Lightning.description": "قابلیت‌های قدرتمند برنامه‌نویسی چندزبانه با تجربه‌ای کاملاً ارتقاء‌یافته. سریع‌تر و کارآمدتر.",
+  "MiniMax-M2.1-highspeed.description": "قابلیت‌های قدرتمند برنامه‌نویسی چندزبانه با استنتاج سریع‌تر و کارآمدتر.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 یک مدل بزرگ متن‌باز پیشرفته از MiniMax است که بر حل وظایف پیچیده دنیای واقعی تمرکز دارد. نقاط قوت اصلی آن شامل توانایی برنامه‌نویسی چندزبانه و قابلیت عمل به‌عنوان یک عامل هوشمند برای حل مسائل پیچیده است.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: همان عملکرد، سریع‌تر و چابک‌تر (تقریباً 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: همان عملکرد M2.5 با استنتاج سریع‌تر.",
   "MiniMax-M2.5.description": "MiniMax-M2.5 یک مدل بزرگ متن‌باز پرچمدار از MiniMax است که بر حل وظایف پیچیده دنیای واقعی تمرکز دارد. نقاط قوت اصلی آن توانایی برنامه‌نویسی چندزبانه و قابلیت حل وظایف پیچیده به عنوان یک عامل (Agent) است.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: همان عملکرد M2.7 با استنتاج به‌طور قابل توجهی سریع‌تر.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: آغاز سفر بهبود خودبازگشتی، قابلیت‌های مهندسی واقعی برتر.",
+  "MiniMax-M2.description": "MiniMax M2: مدل نسل قبلی.",
   "MiniMax-Text-01.description": "MiniMax-01 توجه خطی در مقیاس بزرگ را فراتر از ترنسفورمرهای کلاسیک معرفی می‌کند، با ۴۵۶ میلیارد پارامتر و ۴۵.۹ میلیارد پارامتر فعال در هر عبور. این مدل عملکردی در سطح برتر ارائه می‌دهد و تا ۴ میلیون توکن زمینه را پشتیبانی می‌کند (۳۲ برابر GPT-4o، ۲۰ برابر Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 یک مدل استدلال توجه ترکیبی با وزن‌های باز و 456 میلیارد پارامتر کل و ~45.9 میلیارد پارامتر فعال در هر توکن است. این مدل به‌طور بومی از 1 میلیون زمینه پشتیبانی می‌کند و با استفاده از Flash Attention، FLOPs را در تولید 100 هزار توکن نسبت به DeepSeek R1 تا 75٪ کاهش می‌دهد. با معماری MoE به‌علاوه CISPO و آموزش RL توجه ترکیبی، عملکرد پیشرو در استدلال ورودی طولانی و وظایف مهندسی نرم‌افزار واقعی را ارائه می‌دهد.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 کارایی عامل را بازتعریف می‌کند. این مدل MoE جمع‌وجور، سریع و مقرون‌به‌صرفه با 230 میلیارد پارامتر کل و 10 میلیارد پارامتر فعال است که برای وظایف کدنویسی و عامل سطح بالا طراحی شده است و در عین حال هوش عمومی قوی را حفظ می‌کند. با تنها 10 میلیارد پارامتر فعال، با مدل‌های بسیار بزرگ‌تر رقابت می‌کند و برای کاربردهای با کارایی بالا ایده‌آل است.",
   "Moonshot-Kimi-K2-Instruct.description": "با ۱ تریلیون پارامتر کل و ۳۲ میلیارد فعال، در میان مدل‌های غیرتفکری، در دانش پیشرفته، ریاضی و کدنویسی در سطح برتر قرار دارد و در وظایف عمومی عامل‌ها نیز قوی‌تر است. برای بارهای کاری عامل‌ها بهینه شده و می‌تواند اقدام کند، نه فقط پاسخ دهد. برای چت عمومی، بداهه‌گویی و تجربه‌های عامل‌محور در سطح واکنشی بدون تفکر طولانی بهترین گزینه است.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (۴۶.۷ میلیارد) یک مدل دستورالعمل‌محور با دقت بالا برای محاسبات پیچیده است.",
   "OmniConsistency.description": "OmniConsistency با معرفی ترنسفورمرهای انتشار در مقیاس بزرگ (DiTs) و داده‌های سبک‌دهی‌شده جفت‌شده، ثبات سبک و تعمیم‌پذیری را در وظایف تصویر به تصویر بهبود می‌بخشد و از تخریب سبک جلوگیری می‌کند.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "نسخه به‌روزشده مدل Phi-3-mini.",
   "Phi-3.5-vision-instrust.description": "نسخه به‌روزشده مدل Phi-3-vision.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 یک مدل زبان بزرگ متن‌باز است که برای قابلیت‌های عامل بهینه‌سازی شده و در برنامه‌نویسی، استفاده از ابزارها، پیروی از دستورالعمل‌ها و برنامه‌ریزی بلندمدت عملکرد برجسته‌ای دارد. این مدل از توسعه نرم‌افزار چندزبانه و اجرای جریان‌های کاری پیچیده چندمرحله‌ای پشتیبانی می‌کند و با کسب امتیاز ۷۴.۰ در SWE-bench Verified، در سناریوهای چندزبانه از Claude Sonnet 4.5 پیشی گرفته است.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 جدیدترین مدل زبان بزرگ توسعه‌یافته توسط MiniMax است که از طریق یادگیری تقویتی در مقیاس بزرگ در صدها هزار محیط پیچیده و واقعی آموزش دیده است. با معماری MoE و 229 میلیارد پارامتر، عملکرد پیشرو در صنعت را در وظایفی مانند برنامه‌نویسی، فراخوانی ابزار عامل، جستجو و سناریوهای اداری ارائه می‌دهد.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct یک مدل LLM با ۷ میلیارد پارامتر در سری Qwen2 است که با معماری ترنسفورمر، SwiGLU، بایاس QKV توجه و توجه گروهی طراحی شده و ورودی‌های بزرگ را مدیریت می‌کند. این مدل در درک زبان، تولید، وظایف چندزبانه، کدنویسی، ریاضی و استدلال عملکرد قوی دارد و از بسیاری از مدل‌های باز پیشی می‌گیرد و با مدل‌های اختصاصی رقابت می‌کند. در چندین معیار از Qwen1.5-7B-Chat بهتر عمل می‌کند.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct بخشی از جدیدترین سری LLM علی‌بابا کلود است. این مدل ۷ میلیاردی پیشرفت‌های قابل توجهی در کدنویسی و ریاضی دارد، از بیش از ۲۹ زبان پشتیبانی می‌کند و در پیروی از دستورالعمل‌ها، درک داده‌های ساختاریافته و تولید خروجی ساختاریافته (به‌ویژه JSON) بهبود یافته است.",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct جدیدترین مدل LLM متمرکز بر کد از علی‌بابا کلود است. بر پایه Qwen2.5 ساخته شده و با ۵.۵ تریلیون توکن آموزش دیده، تولید کد، استدلال و اصلاح را به‌طور قابل توجهی بهبود می‌بخشد و در عین حال توانایی‌های ریاضی و عمومی را حفظ می‌کند، و پایه‌ای قوی برای عامل‌های کدنویسی فراهم می‌کند.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL یک مدل جدید زبان-بینایی از سری Qwen با درک بصری قوی است. این مدل متن، نمودارها و چیدمان‌ها را در تصاویر تحلیل می‌کند، ویدیوهای طولانی و رویدادها را درک می‌کند، از استدلال و استفاده از ابزار پشتیبانی می‌کند، اشیاء را در قالب‌های مختلف مکان‌یابی می‌کند و خروجی‌های ساختاریافته تولید می‌کند. همچنین وضوح پویا و نرخ فریم را برای درک ویدیو بهبود می‌بخشد و کارایی رمزگذار بینایی را افزایش می‌دهد.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking یک مدل VLM متن‌باز از Zhipu AI و آزمایشگاه KEG دانشگاه Tsinghua است که برای شناخت چندوجهی پیچیده طراحی شده است. بر پایه GLM-4-9B-0414 ساخته شده و با افزودن زنجیره تفکر و یادگیری تقویتی، استدلال میان‌وجهی و پایداری را به‌طور قابل توجهی بهبود می‌بخشد.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat مدل متن‌باز GLM-4 از Zhipu AI است. این مدل در معناشناسی، ریاضی، استدلال، کدنویسی و دانش عملکرد قوی دارد. فراتر از چت چندنوبتی، از مرور وب، اجرای کد، فراخوانی ابزارهای سفارشی و استدلال متون طولانی پشتیبانی می‌کند. از ۲۶ زبان (از جمله چینی، انگلیسی، ژاپنی، کره‌ای، آلمانی) پشتیبانی می‌کند. در معیارهایی مانند AlignBench-v2، MT-Bench، MMLU و C-Eval عملکرد خوبی دارد و تا ۱۲۸ هزار توکن زمینه را برای استفاده‌های علمی و تجاری پشتیبانی می‌کند.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B از Qwen2.5-Math-7B استخراج شده و بر روی 800 هزار نمونه DeepSeek-R1 منتخب تنظیم شده است. این مدل عملکرد قوی دارد، با 92.8٪ در MATH-500، 55.5٪ در AIME 2024 و رتبه 1189 CodeForces برای یک مدل 7 میلیاردی.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 یک مدل استدلالی مبتنی بر یادگیری تقویتی است که تکرار را کاهش داده و خوانایی را بهبود می‌بخشد. با استفاده از داده‌های شروع سرد پیش از RL، استدلال را بیشتر تقویت می‌کند، در وظایف ریاضی، کدنویسی و استدلال با OpenAI-o1 برابری می‌کند و با آموزش دقیق، نتایج کلی را بهبود می‌بخشد.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus نسخه به‌روزشده مدل V3.1 است که به‌عنوان یک LLM عامل ترکیبی طراحی شده است. مشکلات گزارش‌شده کاربران را رفع کرده، پایداری و سازگاری زبانی را بهبود داده و نویسه‌های غیرعادی و ترکیب چینی/انگلیسی را کاهش داده است. حالت‌های تفکری و غیرتفکری را با قالب‌های چت یکپارچه می‌کند تا امکان جابجایی انعطاف‌پذیر فراهم شود. همچنین عملکرد عامل کد و عامل جستجو را برای استفاده مطمئن‌تر از ابزارها و وظایف چندمرحله‌ای بهبود می‌بخشد.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 مدلی است که کارایی محاسباتی بالا را با استدلال و عملکرد عامل عالی ترکیب می‌کند. رویکرد آن بر سه پیشرفت کلیدی فناوری استوار است: DeepSeek Sparse Attention (DSA)، یک مکانیزم توجه کارآمد که پیچیدگی محاسباتی را به طور قابل توجهی کاهش می‌دهد در حالی که عملکرد مدل را حفظ می‌کند و به طور خاص برای سناریوهای با زمینه طولانی بهینه شده است؛ یک چارچوب یادگیری تقویتی مقیاس‌پذیر که از طریق آن عملکرد مدل می‌تواند با GPT-5 رقابت کند و نسخه با محاسبات بالا آن می‌تواند با Gemini-3.0-Pro در قابلیت‌های استدلال رقابت کند؛ و یک خط لوله سنتز وظایف عامل در مقیاس بزرگ که با هدف ادغام قابلیت‌های استدلال در سناریوهای استفاده از ابزار طراحی شده است و در نتیجه پیروی از دستورالعمل‌ها و تعمیم در محیط‌های تعاملی پیچیده را بهبود می‌بخشد. این مدل عملکرد مدال طلا را در المپیاد بین‌المللی ریاضی (IMO) و المپیاد بین‌المللی انفورماتیک (IOI) سال 2025 به دست آورد.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 جدیدترین و قدرتمندترین نسخه Kimi K2 است. این مدل MoE سطح بالا با ۱ تریلیون پارامتر کل و ۳۲ میلیارد پارامتر فعال است. ویژگی‌های کلیدی شامل هوش کدنویسی عامل‌محور قوی‌تر با پیشرفت‌های قابل توجه در معیارها و وظایف واقعی عامل‌ها، به‌علاوه زیبایی‌شناسی و قابلیت استفاده بهتر در کدنویسی رابط کاربری است.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo نسخه توربو بهینه‌شده برای سرعت استدلال و توان عملیاتی است، در حالی که استدلال چندمرحله‌ای و استفاده از ابزار K2 Thinking را حفظ می‌کند. این مدل MoE با حدود ۱ تریلیون پارامتر کل، زمینه بومی ۲۵۶ هزار توکن و فراخوانی ابزار در مقیاس بزرگ پایدار برای سناریوهای تولیدی با نیازهای سخت‌گیرانه‌تر در تأخیر و هم‌زمانی است.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 یک مدل عامل چندوجهی بومی متن‌باز است که بر پایه Kimi-K2-Base ساخته شده و با حدود ۱.۵ تریلیون توکن ترکیبی بینایی و متنی آموزش دیده است. این مدل از معماری MoE با ۱ تریلیون پارامتر کل و ۳۲ میلیارد پارامتر فعال بهره می‌برد و از پنجره متنی ۲۵۶ هزار توکن پشتیبانی می‌کند و درک زبان و تصویر را به‌صورت یکپارچه ارائه می‌دهد.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 مدل پرچمدار نسل جدید Zhipu با 355 میلیارد پارامتر کل و 32 میلیارد پارامتر فعال است که به‌طور کامل در قابلیت‌های گفتگوی عمومی، استدلال و عامل ارتقا یافته است. GLM-4.7 تفکر متداخل را بهبود می‌بخشد و تفکر حفظ‌شده و تفکر سطح چرخش را معرفی می‌کند.",
   "Pro/zai-org/glm-5.description": "GLM-5 مدل زبان بزرگ نسل بعدی Zhipu است که بر مهندسی سیستم‌های پیچیده و وظایف عامل با مدت زمان طولانی تمرکز دارد. پارامترهای مدل به 744 میلیارد (40 میلیارد فعال) گسترش یافته و DeepSeek Sparse Attention را ادغام می‌کند.",
   "QwQ-32B-Preview.description": "Qwen QwQ یک مدل تحقیقاتی آزمایشی است که بر بهبود توانایی استدلال تمرکز دارد.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview یک مدل تحقیقاتی از Qwen است که بر استدلال بصری تمرکز دارد و در درک صحنه‌های پیچیده و مسائل ریاضی بصری قوی است.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ یک مدل تحقیقاتی آزمایشی است که بر بهبود استدلال هوش مصنوعی تمرکز دارد.",
   "Qwen/QwQ-32B.description": "QwQ یک مدل استدلال از خانواده Qwen است. در مقایسه با مدل‌های استاندارد تنظیم‌شده با دستورالعمل، این مدل تفکر و استدلال را اضافه می‌کند که عملکرد مدل را در وظایف دشوار به‌طور قابل توجهی بهبود می‌بخشد. QwQ-32B یک مدل استدلال میان‌رده است که با مدل‌های برتر مانند DeepSeek-R1 و o1-mini رقابت می‌کند. این مدل از RoPE، SwiGLU، RMSNorm و بایاس QKV در توجه استفاده می‌کند و دارای ۶۴ لایه و ۴۰ سر توجه Q (با ۸ KV در GQA) است.",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 جدیدترین نسخه ویرایش مدل Qwen-Image از تیم Qwen است. این مدل بر پایه Qwen-Image با ۲۰ میلیارد پارامتر ساخته شده و قابلیت رندر دقیق متن را به ویرایش تصویر گسترش می‌دهد. با استفاده از معماری کنترل دوگانه، ورودی‌ها را به Qwen2.5-VL برای کنترل معنایی و به رمزگذار VAE برای کنترل ظاهر ارسال می‌کند و امکان ویرایش در سطح معنا و ظاهر را فراهم می‌سازد. این مدل از ویرایش‌های محلی (افزودن/حذف/تغییر) و ویرایش‌های معنایی سطح بالا مانند خلق IP و انتقال سبک پشتیبانی می‌کند و در عین حال معنا را حفظ می‌نماید. این مدل در چندین معیار عملکرد پیشرفته‌ای (SOTA) دارد.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "مدل نسل دوم Skylark. نسخه Skylark2-pro-turbo-8k استنتاج سریع‌تری با هزینه کمتر ارائه می‌دهد و از پنجره متنی ۸ هزار توکن پشتیبانی می‌کند.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 یک مدل نسل جدید GLM با ۳۲ میلیارد پارامتر است که از نظر عملکرد با مدل‌های OpenAI GPT و سری DeepSeek V3/R1 قابل مقایسه است.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 یک مدل ۹ میلیاردی GLM است که تکنیک‌های GLM-4-32B را به ارث برده و در عین حال استقرار سبک‌تری را ارائه می‌دهد. این مدل در تولید کد، طراحی وب، تولید SVG و نگارش مبتنی بر جستجو عملکرد خوبی دارد.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking یک مدل VLM متن‌باز از Zhipu AI و آزمایشگاه KEG دانشگاه Tsinghua است که برای شناخت چندوجهی پیچیده طراحی شده است. این مدل بر اساس GLM-4-9B-0414 ساخته شده و استدلال زنجیره‌ای و RL را اضافه می‌کند تا استدلال بین‌وجهی و پایداری را به‌طور قابل توجهی بهبود بخشد.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 یک مدل استدلال عمیق است که بر پایه GLM-4-32B-0414 با داده‌های شروع سرد و یادگیری تقویتی گسترده ساخته شده و آموزش بیشتری در زمینه ریاضی، کدنویسی و منطق دیده است. این مدل توانایی حل مسائل پیچیده و ریاضی را نسبت به مدل پایه به‌طور چشمگیری افزایش می‌دهد.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 یک مدل GLM کوچک با ۹ میلیارد پارامتر است که در عین حفظ مزایای متن‌باز، عملکرد چشمگیری ارائه می‌دهد. این مدل در استدلال ریاضی و وظایف عمومی بسیار قوی عمل کرده و در میان مدل‌های هم‌رده خود پیشتاز است.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat مدل متن‌باز GLM-4 از Zhipu AI است. این مدل در زمینه‌های معناشناسی، ریاضی، استدلال، کدنویسی و دانش عملکرد قوی دارد. علاوه بر گفت‌وگوی چندمرحله‌ای، از مرور وب، اجرای کد، فراخوانی ابزارهای سفارشی و استدلال متون بلند پشتیبانی می‌کند. این مدل از ۲۶ زبان (از جمله چینی، انگلیسی، ژاپنی، کره‌ای و آلمانی) پشتیبانی می‌کند و در آزمون‌هایی مانند AlignBench-v2، MT-Bench، MMLU و C-Eval عملکرد خوبی دارد. همچنین تا ۱۲۸ هزار توکن زمینه را برای کاربردهای علمی و تجاری پشتیبانی می‌کند.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B اولین مدل استدلال زمینه طولانی (LRM) است که با RL آموزش دیده و برای استدلال متن طولانی بهینه شده است. RL گسترش زمینه پیشرفته آن انتقال پایدار از زمینه کوتاه به طولانی را امکان‌پذیر می‌کند. این مدل در هفت معیار QA سند زمینه طولانی از OpenAI-o3-mini و Qwen3-235B-A22B پیشی می‌گیرد و با Claude-3.7-Sonnet-Thinking رقابت می‌کند. این مدل به‌ویژه در ریاضیات، منطق و استدلال چندمرحله‌ای قوی است.",
   "Yi-34B-Chat.description": "Yi-1.5-34B ضمن حفظ توانایی‌های زبانی قوی سری Yi، با آموزش افزایشی بر روی ۵۰۰ میلیارد توکن با کیفیت، توانایی‌های منطق ریاضی و کدنویسی را به‌طور قابل توجهی بهبود داده است.",
   "abab5.5-chat.description": "برای سناریوهای بهره‌وری طراحی شده است و توانایی انجام وظایف پیچیده و تولید متن کارآمد برای استفاده حرفه‌ای را دارد.",
   "abab5.5s-chat.description": "برای گفت‌وگوی شخصیت‌محور به زبان چینی طراحی شده و گفت‌وگوی با کیفیت بالا به زبان چینی را در کاربردهای مختلف ارائه می‌دهد.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet در برنامه‌نویسی، نویسندگی و استدلال‌های پیچیده عملکردی برجسته دارد.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet با قابلیت تفکر پیشرفته برای انجام وظایف استدلالی پیچیده طراحی شده است.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet نسخه‌ای ارتقاءیافته با زمینه و قابلیت‌های گسترده‌تر است.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 سریع‌ترین و هوشمندترین مدل Haiku Anthropic است که با سرعت فوق‌العاده و تفکر گسترده ارائه می‌شود.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 مدلی سریع و کارآمد برای انجام وظایف گوناگون است.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking یک نسخه پیشرفته است که می‌تواند فرآیند استدلال خود را آشکار کند.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 جدیدترین و توانمندترین مدل Anthropic برای وظایف بسیار پیچیده است که در عملکرد، هوش، روانی و درک برتری دارد.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 قدرتمندترین مدل Anthropic برای وظایف بسیار پیچیده است که در عملکرد، هوش، روانی و درک برتری دارد.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 مدل پرچم‌دار Anthropic است که هوش برجسته را با عملکرد مقیاس‌پذیر ترکیب می‌کند و برای وظایف پیچیده‌ای که نیاز به پاسخ‌های باکیفیت و استدلال دارند، ایده‌آل است.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 هوشمندترین مدل Anthropic برای ساخت عوامل و کدنویسی است.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking می‌تواند پاسخ‌های تقریباً فوری یا تفکر گام‌به‌گام طولانی با فرآیند قابل مشاهده تولید کند.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 هوشمندترین مدل Anthropic تا به امروز است که پاسخ‌های تقریباً فوری یا تفکر مرحله‌به‌مرحله گسترده با کنترل دقیق برای کاربران API ارائه می‌دهد.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 هوشمندترین مدل Anthropic تا به امروز است.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 بهترین ترکیب سرعت و هوش Anthropic است.",
   "claude-sonnet-4.description": "Claude Sonnet 4 نسل جدیدی از این مدل با عملکرد بهبود یافته در تمامی وظایف است.",
   "codegeex-4.description": "CodeGeeX-4 یک دستیار هوش مصنوعی قدرتمند برای برنامه‌نویسی است که از پرسش و پاسخ چندزبانه و تکمیل کد پشتیبانی می‌کند تا بهره‌وری توسعه‌دهندگان را افزایش دهد.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B یک مدل تولید کد چندزبانه است که از تکمیل و تولید کد، مفسر کد، جستجوی وب، فراخوانی توابع و پرسش و پاسخ در سطح مخزن پشتیبانی می‌کند و طیف گسترده‌ای از سناریوهای توسعه نرم‌افزار را پوشش می‌دهد. این مدل یکی از بهترین مدل‌های کد زیر ۱۰ میلیارد پارامتر است.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "مدل‌های تقطیرشده DeepSeek-R1 با استفاده از یادگیری تقویتی و داده‌های شروع سرد، توانایی استدلال را بهبود داده و معیارهای چندوظیفه‌ای جدیدی را در مدل‌های متن‌باز ثبت می‌کنند.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "مدل‌های تقطیرشده DeepSeek-R1 با استفاده از یادگیری تقویتی و داده‌های شروع سرد، توانایی استدلال را بهبود داده و معیارهای چندوظیفه‌ای جدیدی را در مدل‌های متن‌باز ثبت می‌کنند.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B از Qwen2.5-32B تقطیر شده و با ۸۰۰ هزار نمونه انتخاب‌شده از DeepSeek-R1 آموزش دیده است. این مدل در ریاضی، برنامه‌نویسی و استدلال عملکرد درخشانی دارد و نتایج قوی‌ای در AIME 2024، MATH-500 (با دقت ۹۴.۳٪) و GPQA Diamond کسب کرده است.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B از Qwen2.5-Math-7B استخراج شده و بر روی 800 هزار نمونه DeepSeek-R1 منتخب تنظیم شده است. این مدل عملکرد قوی دارد، با 92.8٪ در MATH-500، 55.5٪ در AIME 2024 و رتبه 1189 CodeForces برای یک مدل 7 میلیاردی.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 با استفاده از داده‌های شروع سرد پیش از یادگیری تقویتی، توانایی استدلال را بهبود داده و معیارهای چندوظیفه‌ای جدیدی را در مدل‌های متن‌باز ثبت کرده و از OpenAI-o1-mini پیشی گرفته است.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 نسخه ارتقاءیافته DeepSeek-V2-Chat و DeepSeek-Coder-V2-Instruct است که توانایی‌های عمومی و برنامه‌نویسی را ترکیب می‌کند. این مدل در نوشتن و پیروی از دستورالعمل‌ها بهبود یافته و در معیارهایی مانند AlpacaEval 2.0، ArenaHard، AlignBench و MT-Bench پیشرفت چشمگیری نشان داده است.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus نسخه به‌روزشده مدل V3.1 است که به‌عنوان یک عامل ترکیبی LLM طراحی شده است. این مدل مشکلات گزارش‌شده کاربران را رفع کرده، ثبات و سازگاری زبانی را بهبود بخشیده و نویسه‌های غیرعادی و ترکیب چینی/انگلیسی را کاهش داده است. این مدل حالت‌های تفکر و غیرتفکر را با قالب‌های چت ترکیب کرده و امکان جابجایی انعطاف‌پذیر را فراهم می‌کند. همچنین عملکرد عامل کدنویسی و جستجو را برای استفاده مطمئن‌تر از ابزارها و انجام وظایف چندمرحله‌ای بهبود داده است.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 یک مدل استدلال نسل بعدی با توانایی استدلال پیچیده و زنجیره تفکر برای وظایف تحلیلی عمیق است.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 یک مدل استدلال نسل بعدی با قابلیت‌های استدلال پیچیده‌تر و زنجیره‌ای از تفکر است.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 یک مدل بینایی-زبانی MoE مبتنی بر DeepSeekMoE-27B با فعال‌سازی پراکنده است که تنها با ۴.۵ میلیارد پارامتر فعال عملکرد قوی‌ای دارد. این مدل در پاسخ به سوالات بصری، OCR، درک اسناد/جداول/نمودارها و پایه‌گذاری بصری عملکرد درخشانی دارد.",
+  "deepseek-chat.description": "DeepSeek V3.2 تعادل بین استدلال و طول خروجی را برای وظایف روزانه QA و عامل برقرار می‌کند. معیارهای عمومی به سطح GPT-5 می‌رسند و این مدل اولین مدلی است که تفکر را در استفاده از ابزار ادغام می‌کند و ارزیابی‌های عامل متن‌باز را رهبری می‌کند.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B یک مدل زبان برنامه‌نویسی است که با ۲ تریلیون توکن (۸۷٪ کد، ۱۳٪ متن چینی/انگلیسی) آموزش دیده است. این مدل دارای پنجره متنی ۱۶K و وظایف تکمیل در میانه است که تکمیل کد در سطح پروژه و پر کردن قطعات کد را فراهم می‌کند.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 یک مدل کدنویسی MoE متن‌باز است که در وظایف برنامه‌نویسی عملکردی هم‌سطح با GPT-4 Turbo دارد.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 یک مدل کدنویسی MoE متن‌باز است که در وظایف برنامه‌نویسی عملکردی هم‌سطح با GPT-4 Turbo دارد.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "نسخه کامل سریع DeepSeek R1 با جستجوی وب در زمان واقعی که توانایی در مقیاس ۶۷۱B را با پاسخ‌دهی سریع‌تر ترکیب می‌کند.",
   "deepseek-r1-online.description": "نسخه کامل DeepSeek R1 با ۶۷۱ میلیارد پارامتر و جستجوی وب در زمان واقعی که درک و تولید قوی‌تری را ارائه می‌دهد.",
   "deepseek-r1.description": "DeepSeek-R1 پیش از یادگیری تقویتی از داده‌های شروع سرد استفاده می‌کند و در وظایف ریاضی، کدنویسی و استدلال عملکردی هم‌سطح با OpenAI-o1 دارد.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking یک مدل استدلال عمیق است که زنجیره‌ای از تفکر را قبل از خروجی‌ها برای دقت بالاتر تولید می‌کند و نتایج رقابتی برتر و استدلالی قابل مقایسه با Gemini-3.0-Pro ارائه می‌دهد.",
   "deepseek-v2.description": "DeepSeek V2 یک مدل MoE کارآمد است که پردازش مقرون‌به‌صرفه را امکان‌پذیر می‌سازد.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B مدل متمرکز بر کدنویسی DeepSeek است که توانایی بالایی در تولید کد دارد.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 یک مدل MoE با ۶۷۱ میلیارد پارامتر است که در برنامه‌نویسی، توانایی‌های فنی، درک زمینه و پردازش متون بلند عملکرد برجسته‌ای دارد.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "مدل deepseek-v3.2-exp با معرفی توجه پراکنده، کارایی آموزش و استنتاج در متون بلند را بهبود می‌بخشد و نسبت به deepseek-v3.1 قیمت پایین‌تری دارد.",
   "deepseek-v3.2-speciale.description": "در وظایف بسیار پیچیده، مدل Speciale به‌طور قابل‌توجهی از نسخه استاندارد بهتر عمل می‌کند، اما مصرف توکن بیشتری دارد و هزینه‌های بالاتری ایجاد می‌کند. در حال حاضر، DeepSeek-V3.2-Speciale فقط برای استفاده تحقیقاتی در نظر گرفته شده است، از فراخوانی ابزار پشتیبانی نمی‌کند و به‌طور خاص برای مکالمات روزمره یا وظایف نوشتاری بهینه نشده است.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think یک مدل تفکر عمیق کامل است که توانایی استدلال زنجیره‌ای بلندتری دارد.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 جدیدترین مدل کدنویسی DeepSeek با قابلیت‌های استدلال قوی است.",
   "deepseek-v3.description": "DeepSeek-V3 یک مدل MoE قدرتمند با ۶۷۱ میلیارد پارامتر کل و ۳۷ میلیارد پارامتر فعال در هر توکن است.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small نسخه چندوجهی سبک‌وزن برای استفاده در شرایط محدود منابع و هم‌زمانی بالا است.",
   "deepseek-vl2.description": "DeepSeek VL2 یک مدل چندوجهی برای درک تصویر-متن و پاسخ‌گویی دقیق بصری است.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K یک مدل تفکر سریع با زمینه ۳۲K برای استدلال پیچیده و گفت‌وگوی چندمرحله‌ای است.",
   "ernie-x1.1-preview.description": "پیش‌نمایش ERNIE X1.1 یک مدل تفکر برای ارزیابی و آزمایش است.",
   "ernie-x1.1.description": "ERNIE X1.1 یک مدل تفکر پیش‌نمایش برای ارزیابی و آزمایش است.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5 که توسط تیم Seed ByteDance ساخته شده است، از ویرایش و ترکیب چندتصویری پشتیبانی می‌کند. ویژگی‌های آن شامل سازگاری موضوعی بهبود یافته، پیروی دقیق از دستورالعمل‌ها، درک منطق فضایی، بیان زیبایی‌شناختی، طراحی پوستر و لوگو با رندر متن-تصویر دقیق است.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0 که توسط تیم Seed ByteDance ساخته شده است، از ورودی‌های متن و تصویر برای تولید تصویر با کیفیت بالا و قابل کنترل از طریق درخواست‌ها پشتیبانی می‌کند.",
   "fal-ai/flux-kontext/dev.description": "مدل FLUX.1 با تمرکز بر ویرایش تصویر که از ورودی‌های متنی و تصویری پشتیبانی می‌کند.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] ورودی‌های متنی و تصاویر مرجع را می‌پذیرد و امکان ویرایش‌های محلی هدفمند و تغییرات پیچیده در صحنه کلی را فراهم می‌کند.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] یک مدل تولید تصویر با تمایل زیبایی‌شناسی به تصاویر طبیعی و واقع‌گرایانه‌تر است.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "یک مدل قدرتمند بومی چندوجهی برای تولید تصویر.",
   "fal-ai/imagen4/preview.description": "مدل تولید تصویر با کیفیت بالا از گوگل.",
   "fal-ai/nano-banana.description": "Nano Banana جدیدترین، سریع‌ترین و کارآمدترین مدل چندوجهی بومی گوگل است که امکان تولید و ویرایش تصویر از طریق مکالمه را فراهم می‌کند.",
+  "fal-ai/qwen-image-edit.description": "یک مدل ویرایش تصویر حرفه‌ای از تیم Qwen که از ویرایش‌های معنایی و ظاهری، ویرایش دقیق متن چینی/انگلیسی، انتقال سبک، چرخش و موارد دیگر پشتیبانی می‌کند.",
+  "fal-ai/qwen-image.description": "یک مدل قدرتمند تولید تصویر از تیم Qwen با رندر متن چینی قوی و سبک‌های بصری متنوع.",
   "flux-1-schnell.description": "مدل تبدیل متن به تصویر با ۱۲ میلیارد پارامتر از Black Forest Labs که از تقطیر انتشار تقابلی نهفته برای تولید تصاویر با کیفیت بالا در ۱ تا ۴ مرحله استفاده می‌کند. این مدل با جایگزین‌های بسته رقابت می‌کند و تحت مجوز Apache-2.0 برای استفاده شخصی، تحقیقاتی و تجاری منتشر شده است.",
   "flux-dev.description": "FLUX.1 [dev] یک مدل تقطیر شده با وزن‌های باز برای استفاده غیرتجاری است. این مدل کیفیت تصویر نزدیک به حرفه‌ای و پیروی از دستورالعمل را حفظ می‌کند و در عین حال کارآمدتر اجرا می‌شود و منابع را بهتر از مدل‌های استاندارد هم‌سایز استفاده می‌کند.",
   "flux-kontext-max.description": "تولید و ویرایش تصویر متنی-زمینه‌ای پیشرفته که متن و تصویر را برای نتایج دقیق و منسجم ترکیب می‌کند.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro پرچم‌دار مدل‌های استدلالی گوگل است که از زمینه‌های طولانی برای انجام وظایف پیچیده پشتیبانی می‌کند.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash هوشمندترین مدل طراحی‌شده برای سرعت است که هوش پیشرفته را با قابلیت جست‌وجوی دقیق ترکیب می‌کند.",
   "gemini-3-pro-image-preview.description": "Gemini 3 Pro Image (Nano Banana Pro) مدل تولید تصویر گوگل است که از گفتگوی چندوجهی نیز پشتیبانی می‌کند.",
+  "gemini-3-pro-image-preview:image.description": "Gemini 3 Pro Image (Nano Banana Pro) مدل تولید تصویر گوگل است و همچنین از چت چندوجهی پشتیبانی می‌کند.",
   "gemini-3-pro-preview.description": "Gemini 3 Pro قدرتمندترین مدل عامل و کدنویسی احساسی گوگل است که تعاملات بصری غنی‌تر و تعامل عمیق‌تری را بر پایه استدلال پیشرفته ارائه می‌دهد.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) سریع‌ترین مدل تولید تصویر بومی گوگل با پشتیبانی از تفکر، تولید و ویرایش تصویر مکالمه‌ای است.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) کیفیت تصویر سطح حرفه‌ای را با سرعت Flash ارائه می‌دهد و از چت چندوجهی پشتیبانی می‌کند.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview اقتصادی‌ترین مدل چندوجهی گوگل است که برای وظایف عامل‌محور با حجم بالا، ترجمه و پردازش داده‌ها بهینه شده است.",
   "gemini-3.1-pro-preview.description": "پیش‌نمایش Gemini 3.1 Pro قابلیت‌های استدلال بهبود یافته را به Gemini 3 Pro اضافه می‌کند و از سطح تفکر متوسط پشتیبانی می‌کند.",
   "gemini-flash-latest.description": "آخرین نسخه منتشرشده از Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "نسخه سریع K2 با تفکر طولانی، دارای پنجره متنی ۲۵۶هزار توکن، استدلال عمیق قوی و خروجی ۶۰ تا ۱۰۰ توکن در ثانیه.",
   "kimi-k2-thinking.description": "kimi-k2-thinking مدل تفکر Moonshot AI با توانایی‌های عمومی در عامل‌سازی و استدلال است. این مدل در استدلال عمیق برتری دارد و می‌تواند مسائل دشوار را از طریق استفاده چندمرحله‌ای از ابزارها حل کند.",
   "kimi-k2-turbo-preview.description": "kimi-k2 یک مدل پایه MoE با قابلیت‌های قوی در برنامه‌نویسی و عامل‌سازی است (۱ تریلیون پارامتر کل، ۳۲ میلیارد فعال) که در معیارهای استدلال، برنامه‌نویسی، ریاضی و عامل از سایر مدل‌های متن‌باز پیشی می‌گیرد.",
+  "kimi-k2.5.description": "Kimi K2.5 همه‌کاره‌ترین مدل Kimi تا به امروز است که دارای معماری چندوجهی بومی است و از ورودی‌های دیداری و متنی، حالت‌های 'تفکر' و 'غیرتفکر' و وظایف مکالمه‌ای و عامل پشتیبانی می‌کند.",
   "kimi-k2.description": "Kimi-K2 یک مدل پایه MoE از Moonshot AI با قابلیت‌های قوی در برنامه‌نویسی و عامل‌سازی است که در مجموع دارای ۱ تریلیون پارامتر و ۳۲ میلیارد فعال است. در معیارهای استدلال عمومی، برنامه‌نویسی، ریاضی و وظایف عامل از سایر مدل‌های متن‌باز پیشی می‌گیرد.",
   "kimi-k2:1t.description": "Kimi K2 یک مدل زبانی بزرگ MoE از Moonshot AI با ۱ تریلیون پارامتر کل و ۳۲ میلیارد فعال در هر عبور است. این مدل برای قابلیت‌های عامل از جمله استفاده پیشرفته از ابزار، استدلال و ترکیب کد بهینه‌سازی شده است.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (رایگان برای مدت محدود) بر درک کد و خودکارسازی برای عامل‌های برنامه‌نویسی کارآمد تمرکز دارد.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K از ۳۲٬۷۶۸ توکن برای زمینه‌های متوسط پشتیبانی می‌کند و برای اسناد بلند و گفتگوهای پیچیده در تولید محتوا، گزارش‌ها و سامانه‌های چت ایده‌آل است.",
   "moonshot-v1-8k-vision-preview.description": "مدل‌های بینایی Kimi (شامل moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) قادر به درک محتوای تصاویر مانند متن، رنگ‌ها و اشکال اشیاء هستند.",
   "moonshot-v1-8k.description": "Moonshot V1 8K برای تولید متون کوتاه بهینه‌سازی شده و عملکردی کارآمد دارد. این مدل تا ۸٬۱۹۲ توکن را برای چت‌های کوتاه، یادداشت‌ها و محتوای سریع مدیریت می‌کند.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B یک مدل کد متن‌باز LLM است که با RL در مقیاس بزرگ بهینه شده است تا پچ‌های قوی و آماده تولید ایجاد کند. این مدل با امتیاز 60.4٪ در SWE-bench Verified، رکورد جدیدی برای وظایف مهندسی نرم‌افزار خودکار مانند رفع اشکال و بررسی کد در مدل‌های متن‌باز ثبت کرده است.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 جدیدترین و قدرتمندترین نسخه Kimi K2 است. این مدل MoE سطح بالا با ۱ تریلیون پارامتر کل و ۳۲ میلیارد پارامتر فعال است. ویژگی‌های کلیدی آن شامل هوش برنامه‌نویسی عامل‌محور قوی‌تر، بهبود چشمگیر در آزمون‌ها و وظایف واقعی عامل‌ها، و کدنویسی ظاهری و کاربردی بهتر در رابط کاربری است.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking جدیدترین و قدرتمندترین مدل تفکر متن‌باز است. عمق استدلال چندمرحله‌ای را به طور قابل توجهی گسترش می‌دهد و استفاده پایدار از ابزار را در 200–300 تماس متوالی حفظ می‌کند و رکوردهای جدیدی در Humanity's Last Exam (HLE)، BrowseComp و سایر معیارها ثبت می‌کند. در کدنویسی، ریاضیات، منطق و سناریوهای عامل برتری دارد. بر اساس معماری MoE با ~1 تریلیون پارامتر کل ساخته شده است، از یک پنجره زمینه 256K و تماس با ابزار پشتیبانی می‌کند.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 نسخه instruct از سری Kimi است که برای تولید کد با کیفیت بالا و استفاده از ابزارها مناسب است.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "کدنویس نسل بعدی Qwen که برای تولید کد چندفایلی پیچیده، اشکال‌زدایی و جریان‌های کاری عامل با توان بالا بهینه شده است. طراحی شده برای ادغام ابزار قوی و عملکرد استدلال بهبود یافته.",
   "qwen3-coder-plus.description": "مدل کدنویسی Qwen. سری جدید Qwen3-Coder بر پایه Qwen3 ساخته شده و توانایی‌های قوی در عامل‌های کدنویس، استفاده از ابزارها و تعامل با محیط برای برنامه‌نویسی خودکار دارد، با عملکرد عالی در کد و توانایی عمومی قوی.",
   "qwen3-coder:480b.description": "مدل با عملکرد بالا از علی‌بابا برای وظایف عامل و کدنویسی با پشتیبانی از زمینه طولانی.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: بهترین مدل Qwen برای وظایف کدنویسی پیچیده و چندمرحله‌ای با پشتیبانی از تفکر.",
   "qwen3-max-preview.description": "بهترین مدل Qwen برای وظایف پیچیده و چندمرحله‌ای. نسخه پیش‌نمایش از تفکر پشتیبانی می‌کند.",
   "qwen3-max.description": "مدل‌های Qwen3 Max نسبت به سری 2.5 پیشرفت‌های چشمگیری در توانایی عمومی، درک زبان چینی/انگلیسی، پیروی از دستورالعمل‌های پیچیده، وظایف باز ذهنی، توانایی چندزبانه و استفاده از ابزار دارند، با کاهش خطاهای توهمی. نسخه جدید qwen3-max توانایی برنامه‌نویسی عامل‌محور و استفاده از ابزار را نسبت به qwen3-max-preview بهبود داده است. این نسخه به سطح پیشرفته در حوزه خود رسیده و برای نیازهای پیچیده‌تر عامل‌ها طراحی شده است.",
   "qwen3-next-80b-a3b-instruct.description": "مدل متن‌باز نسل بعدی Qwen3 بدون قابلیت تفکر. نسبت به نسخه قبلی (Qwen3-235B-A22B-Instruct-2507)، درک زبان چینی بهتر، استدلال منطقی قوی‌تر و تولید متن بهبود یافته‌ای دارد.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ یک مدل استدلال در خانواده Qwen است. در مقایسه با مدل‌های تنظیم‌شده با دستورالعمل استاندارد، توانایی تفکر و استدلال آن عملکرد پایین‌دستی را به‌ویژه در مسائل دشوار به‌طور قابل توجهی بهبود می‌بخشد. QwQ-32B یک مدل استدلال میان‌رده است که با مدل‌های برتر مانند DeepSeek-R1 و o1-mini رقابت می‌کند.",
   "qwq_32b.description": "مدل استدلال میان‌رده در خانواده Qwen. در مقایسه با مدل‌های تنظیم‌شده با دستورالعمل استاندارد، توانایی تفکر و استدلال QwQ عملکرد پایین‌دستی را به‌ویژه در مسائل دشوار به‌طور قابل توجهی بهبود می‌بخشد.",
   "r1-1776.description": "R1-1776 نسخه پس‌آموزشی مدل DeepSeek R1 است که برای ارائه اطلاعات واقعی، بدون سانسور و بی‌طرف طراحی شده است.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro توسط ByteDance از متن به ویدیو، تصویر به ویدیو (فریم اول، فریم اول+آخر) و تولید صوتی همگام با تصاویر پشتیبانی می‌کند.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite توسط BytePlus دارای تولید تقویت‌شده با بازیابی وب برای اطلاعات بلادرنگ، تفسیر پیچیده درخواست‌ها و بهبود سازگاری مرجع برای خلق بصری حرفه‌ای است.",
   "solar-mini-ja.description": "Solar Mini (ژاپنی) نسخه‌ای از Solar Mini با تمرکز بر زبان ژاپنی است که در عین حال عملکرد قوی و کارآمدی در زبان‌های انگلیسی و کره‌ای حفظ می‌کند.",
   "solar-mini.description": "Solar Mini یک مدل زبانی فشرده است که عملکردی بهتر از GPT-3.5 دارد و با پشتیبانی چندزبانه قوی از زبان‌های انگلیسی و کره‌ای، راه‌حلی کارآمد با حجم کم ارائه می‌دهد.",
   "solar-pro.description": "Solar Pro یک مدل زبانی هوشمند از Upstage است که برای پیروی از دستورالعمل‌ها روی یک GPU طراحی شده و امتیاز IFEval بالای ۸۰ دارد. در حال حاضر از زبان انگلیسی پشتیبانی می‌کند؛ انتشار کامل آن برای نوامبر ۲۰۲۴ با پشتیبانی زبانی گسترده‌تر و زمینه طولانی‌تر برنامه‌ریزی شده است.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "مدل استدلال زبانی پرچمدار Stepfun. این مدل دارای قابلیت‌های استدلال برتر و قابلیت‌های اجرای سریع و قابل اعتماد است. قادر به تجزیه و برنامه‌ریزی وظایف پیچیده، فراخوانی ابزارها به سرعت و با اطمینان برای انجام وظایف و شایستگی در وظایف پیچیده مختلف مانند استدلال منطقی، ریاضیات، مهندسی نرم‌افزار و تحقیقات عمیق است.",
   "step-3.description": "این مدل دارای درک بصری قوی و استدلال پیچیده است و درک دانش میان‌رشته‌ای، تحلیل ریاضی-تصویری و طیف گسترده‌ای از وظایف تحلیل بصری روزمره را با دقت انجام می‌دهد.",
   "step-r1-v-mini.description": "مدل استدلال با درک قوی تصویر که می‌تواند تصاویر و متون را پردازش کرده و پس از استدلال عمیق، متن تولید کند. در استدلال بصری، ریاضی، کدنویسی و استدلال متنی عملکردی در سطح بالا دارد و از پنجره زمینه ۱۰۰ هزار توکن پشتیبانی می‌کند.",
+  "stepfun-ai/step3.description": "Step3 یک مدل استدلال چندوجهی پیشرفته از StepFun است که بر اساس معماری MoE با 321 میلیارد پارامتر کل و 38 میلیارد پارامتر فعال ساخته شده است. طراحی انتها به انتهای آن هزینه رمزگشایی را به حداقل می‌رساند و در عین حال استدلال زبان-تصویر سطح بالا را ارائه می‌دهد. با طراحی MFA و AFD، این مدل بر روی شتاب‌دهنده‌های پرچمدار و کم‌هزینه کارآمد باقی می‌ماند. پیش‌آموزش آن از بیش از 20 تریلیون توکن متنی و 4 تریلیون توکن متن-تصویر در بسیاری از زبان‌ها استفاده می‌کند. این مدل به عملکرد پیشرو در مدل‌های متن‌باز در معیارهای ریاضی، کد و چندوجهی دست می‌یابد.",
   "taichu4_vl_2b_nothinking.description": "نسخه بدون تفکر مدل Taichu4.0-VL 2B دارای مصرف حافظه کمتر، طراحی سبک، سرعت پاسخ سریع و قابلیت‌های درک چندوجهی قوی است.",
   "taichu4_vl_32b.description": "نسخه تفکر مدل Taichu4.0-VL 32B برای وظایف درک و استدلال چندوجهی پیچیده مناسب است و عملکرد برجسته‌ای در استدلال ریاضی چندوجهی، قابلیت‌های عامل چندوجهی و درک عمومی تصویر و بصری نشان می‌دهد.",
   "taichu4_vl_32b_nothinking.description": "نسخه بدون تفکر مدل Taichu4.0-VL 32B برای سناریوهای درک تصویر و متن پیچیده و پرسش و پاسخ دانش بصری طراحی شده است و در زیرنویس تصویر، پرسش و پاسخ بصری، درک ویدئو و وظایف مکان‌یابی بصری برتری دارد.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air یک مدل پایه برای برنامه‌های عامل با معماری Mixture-of-Experts است. این مدل برای استفاده از ابزار، مرور وب، مهندسی نرم‌افزار و کدنویسی فرانت‌اند بهینه شده و با عامل‌های کد مانند Claude Code و Roo Code ادغام می‌شود. از استدلال ترکیبی برای مدیریت وظایف پیچیده و روزمره استفاده می‌کند.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V جدیدترین مدل VLM از Zhipu AI است که بر پایه مدل متنی پرچم‌دار GLM-4.5-Air (با ۱۰۶ میلیارد پارامتر کل و ۱۲ میلیارد فعال) ساخته شده و از معماری MoE برای عملکرد قوی با هزینه کمتر بهره می‌برد. این مدل مسیر GLM-4.1V-Thinking را دنبال کرده و با افزودن 3D-RoPE استدلال فضایی سه‌بعدی را بهبود می‌بخشد. با پیش‌آموزش، SFT و RL بهینه‌سازی شده و تصاویر، ویدیو و اسناد بلند را پردازش می‌کند و در ۴۱ معیار چندوجهی عمومی در میان مدل‌های متن‌باز رتبه برتر دارد. حالت تفکر قابل تنظیم به کاربران امکان می‌دهد بین سرعت و عمق تعادل برقرار کنند.",
   "zai-org/GLM-4.6.description": "در مقایسه با GLM-4.5، مدل GLM-4.6 زمینه را از ۱۲۸ هزار به ۲۰۰ هزار توکن گسترش می‌دهد تا وظایف عامل پیچیده‌تری را مدیریت کند. در معیارهای کد امتیاز بالاتری کسب کرده و عملکرد واقعی بهتری در برنامه‌هایی مانند Claude Code، Cline، Roo Code و Kilo Code دارد، از جمله تولید بهتر صفحات فرانت‌اند. استدلال بهبود یافته و استفاده از ابزار در حین استدلال پشتیبانی می‌شود که توانایی کلی را تقویت می‌کند. این مدل بهتر در چارچوب‌های عامل ادغام می‌شود، عامل‌های ابزار/جستجو را بهبود می‌بخشد و سبک نوشتاری و نقش‌آفرینی طبیعی‌تری دارد.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V دقت درک بصری پیشرفته‌ای را برای مقیاس پارامتر خود به دست می‌آورد و اولین مدلی است که قابلیت‌های فراخوانی تابع را به‌طور بومی در معماری مدل دیداری ادغام می‌کند، شکاف بین 'ادراک بصری' و 'اقدامات اجرایی' را پر می‌کند و پایه فنی یکپارچه‌ای برای عوامل چندوجهی در سناریوهای واقعی کسب‌وکار فراهم می‌کند. پنجره زمینه بصری به 128 هزار گسترش یافته و از پردازش جریان ویدیویی طولانی و تحلیل چندتصویری با وضوح بالا پشتیبانی می‌کند.",
   "zai/glm-4.5-air.description": "GLM-4.5 و GLM-4.5-Air جدیدترین مدل‌های پرچم‌دار ما برای برنامه‌های عامل هستند که هر دو از معماری MoE استفاده می‌کنند. GLM-4.5 دارای ۳۵۵ میلیارد پارامتر کل و ۳۲ میلیارد فعال در هر عبور است؛ GLM-4.5-Air نسخه سبک‌تر با ۱۰۶ میلیارد کل و ۱۲ میلیارد فعال است.",
   "zai/glm-4.5.description": "سری GLM-4.5 برای عامل‌ها طراحی شده است. مدل پرچم‌دار GLM-4.5 استدلال، کدنویسی و مهارت‌های عامل را با ۳۵۵ میلیارد پارامتر کل (۳۲ میلیارد فعال) ترکیب می‌کند و دو حالت عملیاتی به‌عنوان یک سیستم استدلال ترکیبی ارائه می‌دهد.",
   "zai/glm-4.5v.description": "GLM-4.5V بر پایه GLM-4.5-Air ساخته شده، تکنیک‌های اثبات‌شده GLM-4.1V-Thinking را به ارث برده و با معماری MoE قدرتمند ۱۰۶ میلیارد پارامتری مقیاس یافته است.",

locales/fa-IR/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure مدل‌های پیشرفته هوش مصنوعی از جمله سری GPT-3.5 و GPT-4 را برای انواع داده‌ها و وظایف پیچیده ارائه می‌دهد، با تمرکز بر ایمنی، قابلیت اطمینان و پایداری.",
   "azureai.description": "Azure مدل‌های پیشرفته هوش مصنوعی از جمله سری GPT-3.5 و GPT-4 را برای انواع داده‌ها و وظایف پیچیده ارائه می‌دهد، با تمرکز بر ایمنی، قابلیت اطمینان و پایداری.",
   "baichuan.description": "Baichuan AI بر توسعه مدل‌های پایه با عملکرد قوی در دانش چینی، پردازش متون بلند و تولید خلاقانه تمرکز دارد. مدل‌های آن (Baichuan 4، Baichuan 3 Turbo، Baichuan 3 Turbo 128k) برای سناریوهای مختلف بهینه‌سازی شده‌اند و ارزش بالایی ارائه می‌دهند.",
+  "bailiancodingplan.description": "طرح کدنویسی علی‌بابا بایلیان یک سرویس تخصصی هوش مصنوعی برای کدنویسی است که دسترسی به مدل‌های بهینه‌سازی شده کدنویسی از Qwen، GLM، Kimi و MiniMax را از طریق یک نقطه پایانی اختصاصی فراهم می‌کند.",
   "bedrock.description": "Amazon Bedrock مدل‌های زبانی و تصویری پیشرفته‌ای مانند Anthropic Claude و Meta Llama 3.1 را برای شرکت‌ها فراهم می‌کند، از گزینه‌های سبک تا قدرتمند برای وظایف متنی، گفتگو و تصویری.",
   "bfl.description": "یک آزمایشگاه پیشرو در تحقیقات هوش مصنوعی مرزی که زیرساخت‌های بصری آینده را می‌سازد.",
   "cerebras.description": "Cerebras یک پلتفرم استنتاج مبتنی بر سیستم CS-3 است که بر ارائه خدمات LLM با تأخیر بسیار پایین و توان عملیاتی بالا برای وظایف بلادرنگ مانند تولید کد و عامل‌ها تمرکز دارد.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Gitee AI Serverless APIها خدمات استنتاج LLM آماده‌به‌کار را برای توسعه‌دهندگان فراهم می‌کنند.",
   "github.description": "با مدل‌های GitHub، توسعه‌دهندگان می‌توانند مانند مهندسان هوش مصنوعی با مدل‌های پیشرو در صنعت کار کنند.",
   "githubcopilot.description": "از طریق اشتراک GitHub Copilot خود به مدل‌های Claude، GPT و Gemini دسترسی پیدا کنید.",
+  "glmcodingplan.description": "طرح کدنویسی GLM دسترسی به مدل‌های هوش مصنوعی Zhipu شامل GLM-5 و GLM-4.7 را برای وظایف کدنویسی از طریق اشتراک با هزینه ثابت فراهم می‌کند.",
   "google.description": "خانواده Gemini گوگل پیشرفته‌ترین هوش مصنوعی چندمنظوره این شرکت است که توسط Google DeepMind برای استفاده چندوجهی در متن، کد، تصویر، صدا و ویدیو ساخته شده و از مراکز داده تا دستگاه‌های همراه مقیاس‌پذیر است.",
   "groq.description": "موتور استنتاج LPU شرکت Groq عملکردی برجسته با سرعت و بهره‌وری بالا ارائه می‌دهد و استانداردی جدید برای استنتاج LLM با تأخیر پایین در فضای ابری تعیین می‌کند.",
   "higress.description": "Higress یک دروازه API بومی ابری است که در داخل Alibaba برای رفع مشکلات بارگذاری مجدد Tengine در اتصالات بلندمدت و بهبود توازن بار gRPC/Dubbo طراحی شده است.",
@@ -29,9 +31,12 @@
   "infiniai.description": "خدمات LLM با عملکرد بالا، کاربری آسان و امنیت بالا را برای توسعه‌دهندگان اپلیکیشن در تمام مراحل از توسعه مدل تا استقرار تولیدی فراهم می‌کند.",
   "internlm.description": "یک سازمان متن‌باز متمرکز بر تحقیقات مدل‌های بزرگ و ابزارهای مرتبط که پلتفرمی کارآمد و آسان برای استفاده ارائه می‌دهد تا مدل‌ها و الگوریتم‌های پیشرفته را در دسترس قرار دهد.",
   "jina.description": "Jina AI که در سال 2020 تأسیس شد، یک شرکت پیشرو در زمینه جستجوی هوش مصنوعی است. پشته جستجوی آن شامل مدل‌های برداری، رتبه‌بندها و مدل‌های زبانی کوچک برای ساخت اپلیکیشن‌های جستجوی مولد و چندوجهی با کیفیت بالا است.",
+  "kimicodingplan.description": "Kimi Code از Moonshot AI دسترسی به مدل‌های Kimi شامل K2.5 را برای وظایف کدنویسی فراهم می‌کند.",
   "lmstudio.description": "LM Studio یک اپلیکیشن دسکتاپ برای توسعه و آزمایش مدل‌های زبانی بزرگ روی رایانه شخصی شماست.",
+  "lobehub.description": "LobeHub Cloud از API‌های رسمی برای دسترسی به مدل‌های هوش مصنوعی استفاده می‌کند و مصرف را با اعتباراتی که به توکن‌های مدل مرتبط هستند اندازه‌گیری می‌کند.",
   "longcat.description": "لانگ‌کت مجموعه‌ای از مدل‌های بزرگ هوش مصنوعی تولیدی است که به‌طور مستقل توسط میتوآن توسعه داده شده است. این مدل‌ها برای افزایش بهره‌وری داخلی شرکت و امکان‌پذیر کردن کاربردهای نوآورانه از طریق معماری محاسباتی کارآمد و قابلیت‌های چندوجهی قدرتمند طراحی شده‌اند.",
   "minimax.description": "MiniMax که در سال 2021 تأسیس شد، هوش مصنوعی چندمنظوره با مدل‌های پایه چندوجهی از جمله مدل‌های متنی با پارامترهای تریلیونی، مدل‌های گفتاری و تصویری توسعه می‌دهد و اپ‌هایی مانند Hailuo AI را ارائه می‌کند.",
+  "minimaxcodingplan.description": "طرح توکن MiniMax دسترسی به مدل‌های MiniMax شامل M2.7 را برای وظایف کدنویسی از طریق اشتراک با هزینه ثابت فراهم می‌کند.",
   "mistral.description": "Mistral مدل‌های عمومی، تخصصی و تحقیقاتی پیشرفته‌ای برای استدلال پیچیده، وظایف چندزبانه و تولید کد ارائه می‌دهد و از فراخوانی توابع برای یکپارچه‌سازی سفارشی پشتیبانی می‌کند.",
   "modelscope.description": "ModelScope پلتفرم مدل به‌عنوان‌سرویس Alibaba Cloud است که مجموعه‌ای گسترده از مدل‌های هوش مصنوعی و خدمات استنتاج را ارائه می‌دهد.",
   "moonshot.description": "Moonshot، از شرکت Moonshot AI (Beijing Moonshot Technology)، مدل‌های NLP متعددی برای کاربردهایی مانند تولید محتوا، تحقیق، توصیه‌گری و تحلیل پزشکی ارائه می‌دهد و از پردازش متون بلند و تولید پیچیده پشتیبانی می‌کند.",
@@ -64,6 +69,7 @@
   "vertexai.description": "خانواده Gemini گوگل پیشرفته‌ترین هوش مصنوعی چندمنظوره این شرکت است که توسط Google DeepMind برای استفاده چندوجهی در متن، کد، تصویر، صدا و ویدیو ساخته شده و از مراکز داده تا دستگاه‌های همراه مقیاس‌پذیر است.",
   "vllm.description": "vLLM یک کتابخانه سریع و آسان برای استنتاج و ارائه مدل‌های زبانی بزرگ است.",
   "volcengine.description": "پلتفرم خدمات مدل ByteDance دسترسی ایمن، غنی از ویژگی و مقرون‌به‌صرفه به مدل‌ها را به همراه ابزارهای کامل برای داده، تنظیم دقیق، استنتاج و ارزیابی فراهم می‌کند.",
+  "volcenginecodingplan.description": "طرح کدنویسی Volcengine از ByteDance دسترسی به چندین مدل کدنویسی شامل Doubao-Seed-Code، GLM-4.7، DeepSeek-V3.2 و Kimi-K2.5 را از طریق اشتراک با هزینه ثابت فراهم می‌کند.",
   "wenxin.description": "یک پلتفرم جامع سازمانی برای مدل‌های پایه و توسعه اپلیکیشن‌های بومی هوش مصنوعی که ابزارهای کامل برای گردش کار مدل‌ها و اپلیکیشن‌های مولد ارائه می‌دهد.",
   "xai.description": "xAI برای تسریع کشف‌های علمی هوش مصنوعی می‌سازد، با مأموریتی برای تعمیق درک بشر از جهان.",
   "xiaomimimo.description": "شیائومی MiMo یک سرویس مدل مکالمه‌ای با API سازگار با OpenAI ارائه می‌دهد. مدل mimo-v2-flash از استدلال عمیق، خروجی به‌صورت جریانی، فراخوانی توابع، پنجره متنی ۲۵۶ هزار توکن و حداکثر خروجی ۱۲۸ هزار توکن پشتیبانی می‌کند.",

locales/fa-IR/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "پشتیبانی از کارت اعتباری / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "پشتیبانی از کارت اعتباری",
   "plans.btn.soon": "به‌زودی",
+  "plans.cancelDowngrade": "لغو کاهش برنامه زمان‌بندی شده",
+  "plans.cancelDowngradeSuccess": "کاهش برنامه زمان‌بندی شده لغو شد",
   "plans.changePlan": "انتخاب طرح",
   "plans.cloud.history": "تاریخچه گفتگو نامحدود",
   "plans.cloud.sync": "همگام‌سازی ابری جهانی",
@@ -215,6 +217,7 @@
   "plans.current": "طرح فعلی",
   "plans.downgradePlan": "طرح کاهش‌یافته هدف",
   "plans.downgradeTip": "شما قبلاً طرح اشتراک را تغییر داده‌اید. تا زمان تکمیل تغییر، نمی‌توانید عملیات دیگری انجام دهید",
+  "plans.downgradeWillCancel": "این اقدام کاهش برنامه زمان‌بندی شده شما را لغو خواهد کرد",
   "plans.embeddingStorage.embeddings": "ورودی",
   "plans.embeddingStorage.title": "ذخیره‌سازی برداری",
   "plans.embeddingStorage.tooltip": "یک صفحه سند (۱۰۰۰ تا ۱۵۰۰ کاراکتر) تقریباً یک ورودی برداری تولید می‌کند. (بر اساس Embeddings OpenAI تخمین زده شده، ممکن است بسته به مدل متفاوت باشد)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "تأیید انتخاب",
   "plans.payonce.popconfirm": "پس از پرداخت یک‌باره، باید تا پایان اشتراک صبر کنید تا بتوانید طرح را تغییر دهید یا چرخه پرداخت را عوض کنید. لطفاً انتخاب خود را تأیید کنید.",
   "plans.payonce.tooltip": "در پرداخت یک‌باره، تا پایان اشتراک نمی‌توان طرح یا چرخه پرداخت را تغییر داد",
+  "plans.pendingDowngrade": "کاهش برنامه در انتظار",
   "plans.plan.enterprise.contactSales": "تماس با فروش",
   "plans.plan.enterprise.title": "سازمانی",
   "plans.plan.free.desc": "برای کاربران جدید",
@@ -366,6 +370,7 @@
   "summary.title": "خلاصه صورتحساب",
   "summary.usageThisMonth": "استفاده این ماه خود را مشاهده کنید.",
   "summary.viewBillingHistory": "مشاهده تاریخچه پرداخت",
+  "switchDowngradeTarget": "تغییر هدف کاهش برنامه",
   "switchPlan": "تغییر طرح",
   "switchToMonthly.desc": "پس از تغییر، پرداخت ماهانه پس از پایان طرح سالانه فعلی فعال می‌شود.",
   "switchToMonthly.title": "تغییر به پرداخت ماهانه",

locales/fr-FR/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Échec de la connexion",
   "sync.title": "État de la synchronisation",
   "sync.unconnected.tip": "La connexion au serveur de signalement a échoué, et le canal de communication pair-à-pair ne peut pas être établi. Veuillez vérifier votre réseau et réessayer.",
-  "tab.aiImage": "Illustration",
   "tab.audio": "Audio",
   "tab.chat": "Discussion",
   "tab.community": "Communauté",
@@ -405,6 +404,7 @@
   "tab.eval": "Laboratoire d'évaluation",
   "tab.files": "Fichiers",
   "tab.home": "Accueil",
+  "tab.image": "Image",
   "tab.knowledgeBase": "Bibliothèque",
   "tab.marketplace": "Place de marché",
   "tab.me": "Moi",

locales/fr-FR/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "Pour les modèles de génération d’images Gemini 3 ; contrôle la résolution des images générées.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "Pour les modèles d'images Gemini 3.1 Flash ; contrôle la résolution des images générées (prend en charge 512px).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "Pour Claude, Qwen3 et similaires ; contrôle le budget de jetons pour le raisonnement.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "Pour GLM-5 et GLM-4.7 ; contrôle le budget de tokens pour le raisonnement (max 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "Pour la série Qwen3 ; contrôle le budget de tokens pour le raisonnement (max 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "Pour OpenAI et autres modèles capables de raisonnement ; contrôle l’effort de raisonnement.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "Pour la série GPT-5+ ; contrôle la verbosité de la sortie.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "Pour certains modèles Doubao ; permet au modèle de décider s’il doit réfléchir en profondeur.",

locales/fr-FR/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev est un modèle multimodal de génération et d’édition d’images développé par Black Forest Labs, basé sur une architecture Rectified Flow Transformer avec 12 milliards de paramètres. Il se concentre sur la génération, la reconstruction, l’amélioration ou l’édition d’images selon des conditions contextuelles données. Il combine les atouts de la génération contrôlable des modèles de diffusion avec la modélisation contextuelle des Transformers, produisant des résultats de haute qualité pour des tâches telles que l’inpainting, l’outpainting et la reconstruction de scènes visuelles.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev est un modèle de langage multimodal open source (MLLM) de Black Forest Labs, optimisé pour les tâches image-texte, combinant compréhension et génération d’images et de textes. Construit sur des LLM avancés (comme Mistral-7B), il utilise un encodeur visuel soigneusement conçu et un ajustement par instructions en plusieurs étapes pour permettre la coordination multimodale et le raisonnement sur des tâches complexes.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air : Version légère pour des réponses rapides.",
+  "GLM-4.5.description": "GLM-4.5 : Modèle haute performance pour le raisonnement, le codage et les tâches d'agent.",
+  "GLM-4.6.description": "GLM-4.6 : Modèle de génération précédente.",
+  "GLM-4.7.description": "GLM-4.7 est le dernier modèle phare de Zhipu, optimisé pour les scénarios de codage agentique avec des capacités de codage améliorées, une planification des tâches à long terme et une collaboration avec des outils.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo : Version optimisée de GLM-5 avec une inférence plus rapide pour les tâches de codage.",
+  "GLM-5.description": "GLM-5 est le modèle de base phare de nouvelle génération de Zhipu, conçu pour l'ingénierie agentique. Il offre une productivité fiable dans les systèmes complexes et les tâches agentiques à long terme. En matière de codage et de capacités d'agent, GLM-5 atteint des performances de pointe parmi les modèles open source.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) est un modèle innovant pour des domaines variés et des tâches complexes.",
   "HY-Image-V3.0.description": "Capacités puissantes d'extraction des caractéristiques de l'image originale et de préservation des détails, offrant une texture visuelle plus riche et produisant des visuels de haute précision, bien composés et de qualité professionnelle.",
   "HelloMeme.description": "HelloMeme est un outil d’IA qui génère des mèmes, GIFs ou courtes vidéos à partir des images ou mouvements que vous fournissez. Aucune compétence en dessin ou en codage n’est requise : une simple image de référence suffit pour créer un contenu amusant, attrayant et stylistiquement cohérent.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "Un nouveau modèle de raisonnement interne avec 80 000 chaînes de pensée et 1 million d’entrées, offrant des performances comparables aux meilleurs modèles mondiaux.",
   "MiniMax-M2-Stable.description": "Conçu pour un codage efficace et des flux de travail d’agents, avec une plus grande simultanéité pour un usage commercial.",
   "MiniMax-M2.1-Lightning.description": "Puissantes capacités de programmation multilingue, expérience de codage entièrement améliorée. Plus rapide et plus efficace.",
+  "MiniMax-M2.1-highspeed.description": "Capacités de programmation multilingues puissantes avec une inférence plus rapide et plus efficace.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 est un modèle phare open source de MiniMax, conçu pour résoudre des tâches complexes du monde réel. Ses principaux atouts résident dans ses capacités de programmation multilingue et sa faculté à résoudre des problèmes complexes en tant qu'agent.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning : Même performance, plus rapide et plus agile (environ 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed : Même performance que M2.5 avec une inférence plus rapide.",
   "MiniMax-M2.5.description": "MiniMax-M2.5 est un modèle phare open-source de grande taille développé par MiniMax, axé sur la résolution de tâches complexes du monde réel. Ses principaux atouts sont ses capacités de programmation multilingue et sa capacité à résoudre des tâches complexes en tant qu'Agent.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed : Même performance que M2.7 avec une inférence significativement plus rapide.",
+  "MiniMax-M2.7.description": "MiniMax M2.7 : Début du voyage vers l'amélioration récursive de soi, capacités d'ingénierie de pointe dans le monde réel.",
+  "MiniMax-M2.description": "MiniMax M2 : Modèle de génération précédente.",
   "MiniMax-Text-01.description": "MiniMax-01 introduit une attention linéaire à grande échelle au-delà des Transformers classiques, avec 456 milliards de paramètres et 45,9 milliards activés par passage. Il atteint des performances de premier plan et prend en charge jusqu’à 4 millions de jetons de contexte (32× GPT-4o, 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 est un modèle de raisonnement hybride à grande échelle avec des poids ouverts, comprenant 456 milliards de paramètres totaux et environ 45,9 milliards actifs par token. Il prend en charge nativement un contexte de 1 million et utilise Flash Attention pour réduire les FLOPs de 75 % sur une génération de 100 000 tokens par rapport à DeepSeek R1. Avec une architecture MoE, CISPO et un entraînement RL hybride-attention, il atteint des performances de pointe sur le raisonnement à long terme et les tâches d'ingénierie logicielle réelle.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 redéfinit l'efficacité des agents. C'est un modèle MoE compact, rapide et économique avec 230 milliards de paramètres totaux et 10 milliards actifs, conçu pour des tâches de codage et d'agent de haut niveau tout en conservant une intelligence générale solide. Avec seulement 10 milliards de paramètres actifs, il rivalise avec des modèles beaucoup plus grands, ce qui le rend idéal pour des applications à haute efficacité.",
   "Moonshot-Kimi-K2-Instruct.description": "1 000 milliards de paramètres totaux avec 32 milliards actifs. Parmi les modèles non pensants, il excelle dans les connaissances de pointe, les mathématiques et le codage, et se montre plus performant dans les tâches générales d’agent. Optimisé pour les charges de travail d’agents, il peut agir, et pas seulement répondre. Idéal pour les conversations générales, improvisées et les expériences d’agents, en tant que modèle réflexe sans réflexion prolongée.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46,7B) est un modèle d’instruction de haute précision pour les calculs complexes.",
   "OmniConsistency.description": "OmniConsistency améliore la cohérence stylistique et la généralisation dans les tâches image-à-image en introduisant des Diffusion Transformers (DiTs) à grande échelle et des données stylisées appariées, évitant ainsi la dégradation du style.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Une version mise à jour du modèle Phi-3-mini.",
   "Phi-3.5-vision-instrust.description": "Une version mise à jour du modèle Phi-3-vision.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 est un modèle de langage open source de grande taille, optimisé pour les capacités d’agent. Il excelle en programmation, utilisation d’outils, suivi d’instructions et planification à long terme. Le modèle prend en charge le développement logiciel multilingue et l’exécution de flux de travail complexes en plusieurs étapes, atteignant un score de 74,0 sur SWE-bench Verified et surpassant Claude Sonnet 4.5 dans des scénarios multilingues.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 est le dernier modèle de langage développé par MiniMax, entraîné par apprentissage par renforcement à grande échelle dans des centaines de milliers d'environnements complexes et réels. Doté d'une architecture MoE avec 229 milliards de paramètres, il atteint des performances de pointe dans des tâches telles que la programmation, l'appel d'outils d'agent, la recherche et les scénarios bureautiques.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct est un LLM de 7 milliards de paramètres ajusté pour les instructions, de la série Qwen2. Il utilise une architecture Transformer avec SwiGLU, un biais QKV pour l’attention et une attention à requêtes groupées, capable de gérer de grandes entrées. Il excelle en compréhension linguistique, génération, tâches multilingues, codage, mathématiques et raisonnement, surpassant la plupart des modèles open source et rivalisant avec les modèles propriétaires. Il dépasse Qwen1.5-7B-Chat sur plusieurs benchmarks.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct fait partie de la dernière série de LLM d’Alibaba Cloud. Ce modèle de 7 milliards apporte des améliorations notables en codage et mathématiques, prend en charge plus de 29 langues et améliore le suivi des instructions, la compréhension des données structurées et la génération de sorties structurées (notamment en JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct est le dernier LLM d’Alibaba Cloud axé sur le code. Basé sur Qwen2.5 et entraîné sur 5,5T de jetons, il améliore considérablement la génération de code, le raisonnement et la correction, tout en conservant ses forces en mathématiques et en intelligence générale, constituant une base solide pour les agents de codage.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL est un nouveau modèle vision-langage de la série Qwen, doté d’une forte compréhension visuelle. Il analyse le texte, les graphiques et les mises en page dans les images, comprend les vidéos longues et les événements, prend en charge le raisonnement et l’utilisation d’outils, l’ancrage d’objets multi-formats et les sorties structurées. Il améliore la résolution dynamique et l’entraînement à fréquence d’images pour la compréhension vidéo, tout en augmentant l’efficacité de l’encodeur visuel.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking est un modèle VLM open source développé par Zhipu AI et le laboratoire KEG de l’université Tsinghua, conçu pour la cognition multimodale complexe. Basé sur GLM-4-9B-0414, il ajoute un raisonnement en chaîne de pensée et un apprentissage par renforcement pour améliorer considérablement le raisonnement intermodal et la stabilité.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat est le modèle open source GLM-4 de Zhipu AI. Il offre de solides performances en sémantique, mathématiques, raisonnement, code et connaissances. Au-delà du chat multi-tours, il prend en charge la navigation web, l’exécution de code, les appels d’outils personnalisés et le raisonnement sur de longs textes. Il prend en charge 26 langues (dont le chinois, l’anglais, le japonais, le coréen et l’allemand). Il obtient de bons résultats sur AlignBench-v2, MT-Bench, MMLU et C-Eval, et prend en charge jusqu’à 128 000 jetons de contexte pour un usage académique et professionnel.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B est distillé à partir de Qwen2.5-Math-7B et affiné sur 800 000 échantillons DeepSeek-R1 sélectionnés. Il offre de solides performances, avec 92,8 % sur MATH-500, 55,5 % sur AIME 2024 et une note CodeForces de 1189 pour un modèle de 7 milliards de paramètres.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 est un modèle de raisonnement basé sur l’apprentissage par renforcement qui réduit la répétition et améliore la lisibilité. Il utilise des données de démarrage à froid avant l’entraînement RL pour renforcer encore le raisonnement, rivalise avec OpenAI-o1 sur les tâches de mathématiques, de code et de raisonnement, et améliore les résultats globaux grâce à un entraînement soigné.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus est une version mise à jour du modèle V3.1, positionnée comme un LLM hybride pour agents. Il corrige les problèmes signalés par les utilisateurs, améliore la stabilité, la cohérence linguistique et réduit les caractères anormaux ou mélangés chinois/anglais. Il intègre les modes Pensant et Non pensant avec des modèles de chat pour un basculement flexible. Il améliore également les performances des agents de code et de recherche pour une utilisation plus fiable des outils et des tâches multi-étapes.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 est un modèle qui combine une grande efficacité de calcul avec d'excellentes performances en raisonnement et en tâches d'Agent. Son approche repose sur trois percées technologiques clés : DeepSeek Sparse Attention (DSA), un mécanisme d'attention efficace qui réduit considérablement la complexité de calcul tout en maintenant les performances du modèle, optimisé spécifiquement pour les scénarios à long contexte ; un cadre d'apprentissage par renforcement évolutif permettant au modèle de rivaliser avec GPT-5, sa version haute performance égalant Gemini-3.0-Pro en capacités de raisonnement ; et un pipeline de synthèse de tâches d'Agent à grande échelle visant à intégrer les capacités de raisonnement dans les scénarios d'utilisation d'outils, améliorant ainsi le suivi des instructions et la généralisation dans des environnements interactifs complexes. Le modèle a obtenu des performances médaillées d'or aux Olympiades Internationales de Mathématiques (IMO) et d'Informatique (IOI) de 2025.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 est le tout dernier et le plus puissant modèle Kimi K2. Il s'agit d'un modèle MoE de premier plan avec 1T de paramètres totaux et 32B de paramètres actifs. Ses principales caractéristiques incluent une intelligence de codage agentique renforcée avec des gains significatifs sur les benchmarks et les tâches d'agents réels, ainsi qu'une esthétique et une convivialité améliorées pour le codage en interface utilisateur.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo est la variante Turbo optimisée pour la vitesse de raisonnement et le débit, tout en conservant le raisonnement multi-étapes et l'utilisation d'outils de K2 Thinking. Il s'agit d'un modèle MoE avec environ 1T de paramètres totaux, un contexte natif de 256K, et un appel d'outils à grande échelle stable pour des scénarios de production nécessitant une faible latence et une forte concurrence.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 est un agent multimodal natif open source, basé sur Kimi-K2-Base, entraîné sur environ 1,5 billion de jetons mêlant vision et texte. Le modèle adopte une architecture MoE avec 1T de paramètres totaux et 32B de paramètres actifs, prenant en charge une fenêtre de contexte de 256K, intégrant harmonieusement les capacités de compréhension visuelle et linguistique.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 est le modèle phare de nouvelle génération de Zhipu avec 355 milliards de paramètres totaux et 32 milliards actifs, entièrement amélioré en dialogue général, raisonnement et capacités d'agent. GLM-4.7 améliore la pensée entrelacée et introduit la pensée préservée et la pensée au niveau des tours.",
   "Pro/zai-org/glm-5.description": "GLM-5 est le modèle de langage de nouvelle génération de Zhipu, axé sur l'ingénierie de systèmes complexes et les tâches d'Agent de longue durée. Les paramètres du modèle ont été étendus à 744 milliards (40 milliards actifs) et intègrent DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ est un modèle de recherche expérimental axé sur l'amélioration du raisonnement.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview est un modèle de recherche de Qwen axé sur le raisonnement visuel, avec des forces dans la compréhension de scènes complexes et les problèmes mathématiques visuels.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ est un modèle de recherche expérimental axé sur l'amélioration du raisonnement de l'IA.",
   "Qwen/QwQ-32B.description": "QwQ est un modèle de raisonnement de la famille Qwen. Par rapport aux modèles classiques ajustés par instruction, il intègre des capacités de réflexion et de raisonnement qui améliorent considérablement les performances en aval, notamment sur les problèmes complexes. QwQ-32B est un modèle de taille moyenne compétitif avec les meilleurs modèles de raisonnement comme DeepSeek-R1 et o1-mini. Il utilise RoPE, SwiGLU, RMSNorm et un biais QKV dans l'attention, avec 64 couches et 40 têtes d'attention Q (8 KV en GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 est la dernière version d'édition d'image de l'équipe Qwen. Basé sur le modèle Qwen-Image de 20B, il étend ses capacités de rendu de texte à l'édition d'image pour des modifications textuelles précises. Il utilise une architecture à double contrôle, envoyant les entrées à Qwen2.5-VL pour le contrôle sémantique et à un encodeur VAE pour le contrôle de l'apparence, permettant des modifications à la fois sémantiques et visuelles. Il prend en charge les modifications locales (ajout/suppression/modification) ainsi que les modifications sémantiques de haut niveau comme la création d'IP et le transfert de style tout en préservant le sens. Il atteint des résultats SOTA sur plusieurs benchmarks.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Modèle Skylark de 2e génération. Skylark2-pro-turbo-8k offre une inférence plus rapide à moindre coût avec une fenêtre de contexte de 8K.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 est un modèle GLM de nouvelle génération avec 32 milliards de paramètres, comparable aux performances des séries OpenAI GPT et DeepSeek V3/R1.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 est un modèle GLM de 9 milliards de paramètres qui hérite des techniques de GLM-4-32B tout en offrant un déploiement plus léger. Il est performant en génération de code, conception web, génération SVG et rédaction basée sur la recherche.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking est un modèle VLM open source de Zhipu AI et du laboratoire Tsinghua KEG, conçu pour la cognition multimodale complexe. Basé sur GLM-4-9B-0414, il ajoute un raisonnement en chaîne et un apprentissage par renforcement pour améliorer significativement le raisonnement intermodal et la stabilité.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 est un modèle de raisonnement approfondi dérivé de GLM-4-32B-0414, enrichi de données de démarrage à froid et d'un apprentissage par renforcement étendu. Entraîné davantage sur les mathématiques, le code et la logique, il améliore significativement les capacités de résolution de tâches complexes par rapport au modèle de base.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 est un modèle GLM compact de 9 milliards de paramètres qui conserve les avantages de l'open source tout en offrant des performances impressionnantes. Il se distingue dans le raisonnement mathématique et les tâches générales, dominant sa catégorie de taille parmi les modèles ouverts.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat est le modèle GLM-4 open source de Zhipu AI. Il est performant en sémantique, mathématiques, raisonnement, code et connaissances. En plus du chat multi-tours, il prend en charge la navigation web, l'exécution de code, les appels d'outils personnalisés et le raisonnement sur de longs textes. Il prend en charge 26 langues (dont le chinois, l'anglais, le japonais, le coréen et l'allemand). Il obtient de bons résultats sur AlignBench-v2, MT-Bench, MMLU et C-Eval, et prend en charge jusqu'à 128K de contexte pour les usages académiques et professionnels.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B est le premier modèle de raisonnement à long contexte (LRM) entraîné avec RL, optimisé pour le raisonnement sur des textes longs. Son RL d'expansion progressive de contexte permet un transfert stable du contexte court au long. Il dépasse OpenAI-o3-mini et Qwen3-235B-A22B sur sept benchmarks de QA de documents à long contexte, rivalisant avec Claude-3.7-Sonnet-Thinking. Il est particulièrement performant en mathématiques, logique et raisonnement multi-étapes.",
   "Yi-34B-Chat.description": "Yi-1.5-34B conserve les solides capacités linguistiques générales de la série tout en utilisant un entraînement incrémental sur 500 milliards de tokens de haute qualité pour améliorer significativement la logique mathématique et la programmation.",
   "abab5.5-chat.description": "Conçu pour les scénarios de productivité, avec une gestion efficace des tâches complexes et une génération de texte professionnelle.",
   "abab5.5s-chat.description": "Conçu pour les conversations avec des personnages en chinois, offrant des dialogues de haute qualité pour diverses applications.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet excelle en programmation, en rédaction et en raisonnement complexe.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet avec réflexion étendue pour les tâches de raisonnement complexe.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet est une version améliorée avec un contexte étendu et des capacités accrues.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 est le modèle Haiku le plus rapide et le plus intelligent d'Anthropic, avec une vitesse fulgurante et une pensée étendue.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 est un modèle rapide et efficace pour diverses tâches.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking est une variante avancée capable de révéler son processus de raisonnement.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 est le dernier modèle d'Anthropic, le plus performant pour des tâches hautement complexes, excelle en performance, intelligence, fluidité et compréhension.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 est le modèle le plus puissant d'Anthropic pour des tâches hautement complexes, excelle en performance, intelligence, fluidité et compréhension.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 est le modèle phare d’Anthropic, combinant intelligence exceptionnelle et performance évolutive, idéal pour les tâches complexes nécessitant des réponses et un raisonnement de très haute qualité.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 est le modèle le plus intelligent d'Anthropic pour la création d'agents et le codage.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking peut produire des réponses quasi instantanées ou une réflexion détaillée étape par étape avec un processus visible.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 est le modèle le plus intelligent d'Anthropic à ce jour, offrant des réponses quasi-instantanées ou une pensée détaillée étape par étape avec un contrôle précis pour les utilisateurs d'API.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 est le modèle le plus intelligent d'Anthropic à ce jour.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 est la meilleure combinaison de vitesse et d'intelligence d'Anthropic.",
   "claude-sonnet-4.description": "Claude Sonnet 4 est la dernière génération avec des performances améliorées sur l’ensemble des tâches.",
   "codegeex-4.description": "CodeGeeX-4 est un assistant de codage IA puissant prenant en charge les questions-réponses multilingues et la complétion de code pour améliorer la productivité des développeurs.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B est un modèle multilingue de génération de code prenant en charge la complétion et la génération de code, l’interprétation de code, la recherche web, l’appel de fonctions et les questions-réponses au niveau des dépôts. Il couvre un large éventail de scénarios de développement logiciel et est l’un des meilleurs modèles de code sous 10 milliards de paramètres.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "Les modèles distillés DeepSeek-R1 utilisent l’apprentissage par renforcement (RL) et des données de démarrage à froid pour améliorer le raisonnement et établir de nouveaux standards sur les benchmarks multitâches open source.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "Les modèles distillés DeepSeek-R1 utilisent l’apprentissage par renforcement (RL) et des données de démarrage à froid pour améliorer le raisonnement et établir de nouveaux standards sur les benchmarks multitâches open source.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B est distillé à partir de Qwen2.5-32B et affiné sur 800 000 échantillons sélectionnés de DeepSeek-R1. Il excelle en mathématiques, programmation et raisonnement, avec d’excellents résultats sur AIME 2024, MATH-500 (94,3 % de précision) et GPQA Diamond.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B est distillé à partir de Qwen2.5-Math-7B et affiné sur 800 000 échantillons DeepSeek-R1 sélectionnés. Il offre de solides performances, avec 92,8 % sur MATH-500, 55,5 % sur AIME 2024 et une note CodeForces de 1189 pour un modèle de 7 milliards de paramètres.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 améliore le raisonnement grâce à l’apprentissage par renforcement et à des données de démarrage à froid, établissant de nouveaux standards multitâches open source et surpassant OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 améliore DeepSeek-V2-Chat et DeepSeek-Coder-V2-Instruct, combinant capacités générales et de codage. Il améliore la rédaction et le suivi des instructions pour un meilleur alignement des préférences, avec des gains significatifs sur AlpacaEval 2.0, ArenaHard, AlignBench et MT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus est une version mise à jour du modèle V3.1, positionnée comme un agent hybride LLM. Il corrige les problèmes signalés par les utilisateurs et améliore la stabilité, la cohérence linguistique, tout en réduisant les caractères anormaux et le mélange chinois/anglais. Il intègre les modes de pensée et non-pensée avec des modèles de chat pour un basculement flexible. Il améliore également les performances des agents de code et de recherche pour une utilisation plus fiable des outils et des tâches multi-étapes.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 est un modèle de raisonnement nouvelle génération avec un raisonnement complexe renforcé et une chaîne de pensée pour les tâches d’analyse approfondie.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 est un modèle de raisonnement de nouvelle génération avec des capacités renforcées de raisonnement complexe et de chaîne de pensée.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 est un modèle vision-langage MoE basé sur DeepSeekMoE-27B avec activation clairsemée, atteignant de hautes performances avec seulement 4,5B de paramètres actifs. Il excelle en QA visuelle, OCR, compréhension de documents/tableaux/graphes et ancrage visuel.",
+  "deepseek-chat.description": "DeepSeek V3.2 équilibre le raisonnement et la longueur des sorties pour les tâches quotidiennes de QA et d'agent. Les benchmarks publics atteignent les niveaux de GPT-5, et il est le premier à intégrer la pensée dans l'utilisation des outils, menant les évaluations d'agents open source.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B est un modèle de langage pour le code entraîné sur 2T de tokens (87 % de code, 13 % de texte en chinois/anglais). Il introduit une fenêtre de contexte de 16K et des tâches de remplissage au milieu, offrant une complétion de code à l’échelle du projet et un remplissage de fragments.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 est un modèle de code MoE open source performant sur les tâches de programmation, comparable à GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 est un modèle de code MoE open source performant sur les tâches de programmation, comparable à GPT-4 Turbo.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "Version complète rapide de DeepSeek R1 avec recherche web en temps réel, combinant des capacités à l’échelle de 671B et des réponses plus rapides.",
   "deepseek-r1-online.description": "Version complète de DeepSeek R1 avec 671B de paramètres et recherche web en temps réel, offrant une meilleure compréhension et génération.",
   "deepseek-r1.description": "DeepSeek-R1 utilise des données de démarrage à froid avant l’apprentissage par renforcement et affiche des performances comparables à OpenAI-o1 en mathématiques, codage et raisonnement.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking est un modèle de raisonnement profond qui génère une chaîne de pensée avant les sorties pour une précision accrue, avec des résultats de compétition de haut niveau et un raisonnement comparable à Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 est un modèle MoE efficace pour un traitement économique.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B est le modèle axé sur le code de DeepSeek avec une forte génération de code.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 est un modèle MoE de 671B paramètres avec des points forts en programmation, compréhension du contexte et traitement de longs textes.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp introduit l'attention clairsemée pour améliorer l'efficacité de l'entraînement et de l'inférence sur les textes longs, à un coût inférieur à celui de deepseek-v3.1.",
   "deepseek-v3.2-speciale.description": "Pour les tâches hautement complexes, le modèle Speciale surpasse significativement la version standard, mais consomme beaucoup plus de jetons et entraîne des coûts plus élevés. Actuellement, DeepSeek-V3.2-Speciale est destiné uniquement à la recherche, ne prend pas en charge les appels d'outils et n'a pas été spécifiquement optimisé pour les conversations ou les tâches d'écriture quotidiennes.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think est un modèle de réflexion approfondie complet, doté d'un raisonnement en chaîne plus puissant.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 est le dernier modèle de codage de DeepSeek avec de fortes capacités de raisonnement.",
   "deepseek-v3.description": "DeepSeek-V3 est un puissant modèle MoE avec 671 milliards de paramètres au total et 37 milliards actifs par jeton.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small est une version multimodale légère, conçue pour les environnements à ressources limitées et les cas d'utilisation à forte concurrence.",
   "deepseek-vl2.description": "DeepSeek VL2 est un modèle multimodal pour la compréhension image-texte et les questions-réponses visuelles de précision.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K est un modèle de réflexion rapide avec un contexte de 32K pour le raisonnement complexe et les dialogues multi-tours.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview est une préversion de modèle de réflexion pour l’évaluation et les tests.",
   "ernie-x1.1.description": "ERNIE X1.1 est un modèle de réflexion en aperçu pour évaluation et test.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5, développé par l'équipe Seed de ByteDance, prend en charge l'édition et la composition multi-images. Il offre une meilleure cohérence des sujets, un suivi précis des instructions, une compréhension de la logique spatiale, une expression esthétique, une mise en page de posters et la conception de logos avec un rendu texte-image de haute précision.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0, développé par ByteDance Seed, prend en charge les entrées texte et image pour une génération d'images hautement contrôlable et de haute qualité à partir de prompts.",
   "fal-ai/flux-kontext/dev.description": "Modèle FLUX.1 axé sur l’édition d’images, prenant en charge les entrées texte et image.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] accepte des textes et des images de référence en entrée, permettant des modifications locales ciblées et des transformations globales complexes de scènes.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] est un modèle de génération d’images avec une préférence esthétique pour des images plus réalistes et naturelles.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "Un puissant modèle natif multimodal de génération d’images.",
   "fal-ai/imagen4/preview.description": "Modèle de génération d’images de haute qualité développé par Google.",
   "fal-ai/nano-banana.description": "Nano Banana est le modèle multimodal natif le plus récent, le plus rapide et le plus efficace de Google, permettant la génération et l’édition d’images via la conversation.",
+  "fal-ai/qwen-image-edit.description": "Un modèle professionnel d'édition d'images de l'équipe Qwen, prenant en charge les modifications sémantiques et d'apparence, l'édition précise de texte en chinois/anglais, le transfert de style, la rotation et plus encore.",
+  "fal-ai/qwen-image.description": "Un modèle puissant de génération d'images de l'équipe Qwen avec un rendu texte chinois robuste et des styles visuels variés.",
   "flux-1-schnell.description": "Modèle texte-vers-image à 12 milliards de paramètres de Black Forest Labs utilisant la distillation par diffusion latente adversariale pour générer des images de haute qualité en 1 à 4 étapes. Il rivalise avec les alternatives propriétaires et est publié sous licence Apache-2.0 pour un usage personnel, de recherche et commercial.",
   "flux-dev.description": "FLUX.1 [dev] est un modèle distillé à poids ouverts pour un usage non commercial. Il conserve une qualité d’image proche du niveau professionnel et un bon suivi des instructions tout en étant plus efficace que les modèles standards de taille équivalente.",
   "flux-kontext-max.description": "Génération et édition d’images contextuelles de pointe, combinant texte et images pour des résultats précis et cohérents.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro est le modèle de raisonnement phare de Google, avec un support de long contexte pour les tâches complexes.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash est le modèle le plus intelligent conçu pour la vitesse, alliant intelligence de pointe et ancrage de recherche performant.",
   "gemini-3-pro-image-preview.description": "Gemini 3 Pro Image (Nano Banana Pro) est le modèle de génération d'images de Google qui prend également en charge le dialogue multimodal.",
+  "gemini-3-pro-image-preview:image.description": "Gemini 3 Pro Image (Nano Banana Pro) est le modèle de génération d'images de Google et prend également en charge le chat multimodal.",
   "gemini-3-pro-preview.description": "Gemini 3 Pro est le modèle agent et de codage le plus puissant de Google, offrant des visuels enrichis et une interaction plus poussée grâce à un raisonnement de pointe.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) est le modèle de génération d'images natif le plus rapide de Google avec prise en charge de la réflexion, génération et édition d'images conversationnelles.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) offre une qualité d'image de niveau Pro à une vitesse Flash avec prise en charge du chat multimodal.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview est le modèle multimodal le plus économique de Google, optimisé pour les tâches agentiques à haut volume, la traduction et le traitement des données.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview améliore Gemini 3 Pro avec des capacités de raisonnement renforcées et ajoute un support de niveau de réflexion moyen.",
   "gemini-flash-latest.description": "Dernière version de Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "Variante rapide de K2 pensée longue avec un contexte de 256k, un raisonnement profond puissant et une sortie de 60 à 100 tokens/seconde.",
   "kimi-k2-thinking.description": "kimi-k2-thinking est un modèle de raisonnement de Moonshot AI avec des capacités générales d’agent et de raisonnement. Il excelle dans le raisonnement profond et peut résoudre des problèmes complexes via l’utilisation d’outils en plusieurs étapes.",
   "kimi-k2-turbo-preview.description": "kimi-k2 est un modèle de base MoE avec de solides capacités en codage et en agents (1T de paramètres totaux, 32B actifs), surpassant les autres modèles open source courants en raisonnement, programmation, mathématiques et benchmarks d’agents.",
+  "kimi-k2.5.description": "Kimi K2.5 est le modèle le plus polyvalent de Kimi à ce jour, doté d'une architecture multimodale native qui prend en charge les entrées vision et texte, les modes 'pensée' et 'non-pensée', ainsi que les tâches conversationnelles et d'agent.",
   "kimi-k2.description": "Kimi-K2 est un modèle de base MoE de Moonshot AI avec de solides capacités en codage et en agents, totalisant 1T de paramètres avec 32B actifs. Sur les benchmarks de raisonnement général, de codage, de mathématiques et de tâches d’agent, il surpasse les autres modèles open source courants.",
   "kimi-k2:1t.description": "Kimi K2 est un grand LLM MoE de Moonshot AI avec 1T de paramètres totaux et 32B actifs par passage. Il est optimisé pour les capacités d’agent, y compris l’utilisation avancée d’outils, le raisonnement et la synthèse de code.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (gratuit pour une durée limitée) se concentre sur la compréhension du code et l’automatisation pour des agents de codage efficaces.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K prend en charge 32 768 jetons pour un contexte de longueur moyenne, idéal pour les documents longs et les dialogues complexes dans la création de contenu, les rapports et les systèmes de chat.",
   "moonshot-v1-8k-vision-preview.description": "Les modèles de vision Kimi (y compris moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) peuvent comprendre le contenu d’images comme le texte, les couleurs et les formes d’objets.",
   "moonshot-v1-8k.description": "Moonshot V1 8K est optimisé pour la génération de textes courts avec des performances efficaces, prenant en charge 8 192 jetons pour les discussions brèves, les notes et le contenu rapide.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B est un modèle de code open source optimisé avec un RL à grande échelle pour produire des correctifs robustes et prêts pour la production. Il obtient 60,4 % sur SWE-bench Verified, établissant un nouveau record pour les modèles ouverts dans des tâches d'ingénierie logicielle automatisée telles que la correction de bugs et la révision de code.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 est la version la plus récente et la plus puissante de Kimi K2. C’est un modèle MoE de premier plan avec 1T de paramètres totaux et 32B actifs. Ses points forts incluent une intelligence de codage agentique renforcée avec des gains significatifs sur les benchmarks et les tâches réelles, ainsi qu’un code frontend plus esthétique et plus utilisable.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking est le dernier et le plus puissant modèle de réflexion open-source. Il étend considérablement la profondeur de raisonnement multi-étapes et maintient une utilisation stable des outils sur 200–300 appels consécutifs, établissant de nouveaux records sur Humanity's Last Exam (HLE), BrowseComp et d'autres benchmarks. Il excelle en codage, mathématiques, logique et scénarios d'Agent. Construit sur une architecture MoE avec ~1T de paramètres totaux, il prend en charge une fenêtre de contexte de 256K et l'appel d'outils.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 est la variante instructive de la série Kimi, adaptée au code de haute qualité et à l’utilisation d’outils.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "Le prochain modèle Qwen coder optimisé pour la génération de code complexe multi-fichiers, le débogage et les flux de travail d'agent à haut débit. Conçu pour une forte intégration d'outils et des performances de raisonnement améliorées.",
   "qwen3-coder-plus.description": "Modèle de code Qwen. La dernière série Qwen3-Coder est basée sur Qwen3 et offre de solides capacités d’agent de codage, d’utilisation d’outils et d’interaction avec l’environnement pour la programmation autonome, avec d’excellentes performances en code et de bonnes capacités générales.",
   "qwen3-coder:480b.description": "Modèle haute performance d’Alibaba pour les tâches d’agent et de codage avec contexte long.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max : Modèle Qwen le plus performant pour des tâches de codage complexes et multi-étapes avec prise en charge de la pensée.",
   "qwen3-max-preview.description": "Modèle Qwen le plus performant pour les tâches complexes à étapes multiples. La version preview prend en charge le raisonnement.",
   "qwen3-max.description": "Les modèles Qwen3 Max offrent des gains importants par rapport à la série 2.5 en capacité générale, compréhension du chinois/anglais, suivi d’instructions complexes, tâches ouvertes subjectives, multilinguisme et utilisation d’outils, avec moins d’hallucinations. La dernière version améliore la programmation agentique et l’utilisation d’outils par rapport à qwen3-max-preview. Cette version atteint le SOTA dans son domaine et vise des besoins agents plus complexes.",
   "qwen3-next-80b-a3b-instruct.description": "Modèle open source Qwen3 de nouvelle génération sans raisonnement. Par rapport à la version précédente (Qwen3-235B-A22B-Instruct-2507), il offre une meilleure compréhension du chinois, un raisonnement logique renforcé et une génération de texte améliorée.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ est un modèle de raisonnement de la famille Qwen. Comparé aux modèles classiques ajustés par instruction, il apporte des capacités de réflexion et de raisonnement qui améliorent considérablement les performances en aval, notamment sur les problèmes complexes. QwQ-32B est un modèle de raisonnement de taille moyenne qui rivalise avec les meilleurs modèles comme DeepSeek-R1 et o1-mini.",
   "qwq_32b.description": "Modèle de raisonnement de taille moyenne de la famille Qwen. Comparé aux modèles classiques ajustés par instruction, les capacités de réflexion et de raisonnement de QwQ améliorent considérablement les performances en aval, notamment sur les problèmes complexes.",
   "r1-1776.description": "R1-1776 est une variante post-entraînée de DeepSeek R1 conçue pour fournir des informations factuelles non censurées et impartiales.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro de ByteDance prend en charge la génération de texte en vidéo, d'image en vidéo (première image, première+dernière image) et d'audio synchronisé avec les visuels.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite de BytePlus propose une génération augmentée par récupération web pour des informations en temps réel, une interprétation améliorée des prompts complexes et une meilleure cohérence des références pour la création visuelle professionnelle.",
   "solar-mini-ja.description": "Solar Mini (Ja) étend Solar Mini avec un accent sur le japonais tout en maintenant des performances efficaces et solides en anglais et en coréen.",
   "solar-mini.description": "Solar Mini est un modèle LLM compact surpassant GPT-3.5, avec de solides capacités multilingues en anglais et en coréen, offrant une solution efficace à faible empreinte.",
   "solar-pro.description": "Solar Pro est un LLM intelligent développé par Upstage, axé sur le suivi d'instructions sur un seul GPU, avec des scores IFEval supérieurs à 80. Il prend actuellement en charge l'anglais ; la version complète est prévue pour novembre 2024 avec un support linguistique élargi et un contexte plus long.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "Le modèle phare de raisonnement linguistique de Stepfun. Ce modèle possède des capacités de raisonnement de premier ordre et des capacités d'exécution rapides et fiables. Capable de décomposer et de planifier des tâches complexes, d'appeler des outils rapidement et de manière fiable pour exécuter des tâches, et compétent dans diverses tâches complexes telles que le raisonnement logique, les mathématiques, l'ingénierie logicielle et la recherche approfondie.",
   "step-3.description": "Ce modèle possède une forte perception visuelle et un raisonnement complexe, gérant avec précision la compréhension interdomaines, l’analyse mathématique-visuelle croisée et une large gamme de tâches d’analyse visuelle quotidienne.",
   "step-r1-v-mini.description": "Modèle de raisonnement avec une forte compréhension d’image, capable de traiter des images et du texte, puis de générer du texte après un raisonnement approfondi. Il excelle en raisonnement visuel et offre des performances de haut niveau en mathématiques, codage et raisonnement textuel, avec une fenêtre de contexte de 100K.",
+  "stepfun-ai/step3.description": "Step3 est un modèle de raisonnement multimodal de pointe de StepFun, basé sur une architecture MoE avec 321 milliards de paramètres totaux et 38 milliards actifs. Son design de bout en bout minimise le coût de décodage tout en offrant un raisonnement vision-langage de haut niveau. Avec les conceptions MFA et AFD, il reste efficace sur les accélérateurs haut de gamme et bas de gamme. L'entraînement préliminaire utilise plus de 20T de tokens texte et 4T de tokens image-texte dans de nombreuses langues. Il atteint des performances de pointe parmi les modèles ouverts sur les benchmarks de mathématiques, de code et multimodaux.",
   "taichu4_vl_2b_nothinking.description": "La version sans réflexion du modèle Taichu4.0-VL 2B présente une utilisation réduite de la mémoire, un design léger, une vitesse de réponse rapide et de solides capacités de compréhension multimodale.",
   "taichu4_vl_32b.description": "La version avec réflexion du modèle Taichu4.0-VL 32B est adaptée aux tâches complexes de compréhension et de raisonnement multimodal, démontrant des performances exceptionnelles en raisonnement mathématique multimodal, en capacités d'agent multimodal et en compréhension générale des images et visuels.",
   "taichu4_vl_32b_nothinking.description": "La version sans réflexion du modèle Taichu4.0-VL 32B est conçue pour des scénarios complexes de compréhension image-texte et de questions-réponses sur les connaissances visuelles, excellant en légendage d'images, en questions-réponses visuelles, en compréhension vidéo et en tâches de localisation visuelle.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air est un modèle de base pour les applications d’agents utilisant une architecture Mixture-of-Experts. Il est optimisé pour l’utilisation d’outils, la navigation web, l’ingénierie logicielle et le codage frontend, et s’intègre avec des agents de code comme Claude Code et Roo Code. Il utilise un raisonnement hybride pour gérer à la fois les scénarios complexes et quotidiens.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V est le dernier VLM de Zhipu AI, basé sur le modèle texte phare GLM-4.5-Air (106B total, 12B actifs) avec une architecture MoE pour de hautes performances à moindre coût. Il suit la voie GLM-4.1V-Thinking et ajoute 3D-RoPE pour améliorer le raisonnement spatial 3D. Optimisé par pré-entraînement, SFT et RL, il gère images, vidéos et documents longs, et se classe parmi les meilleurs modèles open source sur 41 benchmarks multimodaux publics. Un mode Thinking permet d’équilibrer vitesse et profondeur.",
   "zai-org/GLM-4.6.description": "Par rapport à GLM-4.5, GLM-4.6 étend le contexte de 128K à 200K pour des tâches d’agents plus complexes. Il obtient de meilleurs scores sur les benchmarks de code et montre de meilleures performances réelles dans des applications comme Claude Code, Cline, Roo Code et Kilo Code, y compris une meilleure génération de pages frontend. Le raisonnement est amélioré et l’utilisation d’outils est prise en charge pendant le raisonnement, renforçant les capacités globales. Il s’intègre mieux aux frameworks d’agents, améliore les agents de recherche/outils et offre un style d’écriture plus naturel et apprécié des utilisateurs.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V atteint une précision de compréhension visuelle SOTA pour son échelle de paramètres et est le premier à intégrer nativement des capacités d'appel de fonction dans l'architecture du modèle de vision, comblant le fossé entre 'perception visuelle' et 'actions exécutables' et fournissant une base technique unifiée pour les agents multimodaux dans des scénarios commerciaux réels. La fenêtre de contexte visuel est étendue à 128k, prenant en charge le traitement de flux vidéo longs et l'analyse multi-images haute résolution.",
   "zai/glm-4.5-air.description": "GLM-4.5 et GLM-4.5-Air sont nos derniers modèles phares pour les applications d’agents, tous deux utilisant MoE. GLM-4.5 a 355B au total et 32B actifs par passage ; GLM-4.5-Air est plus léger avec 106B au total et 12B actifs.",
   "zai/glm-4.5.description": "La série GLM-4.5 est conçue pour les agents. Le modèle phare GLM-4.5 combine raisonnement, codage et compétences d’agent avec 355B de paramètres totaux (32B actifs) et offre deux modes de fonctionnement en tant que système de raisonnement hybride.",
   "zai/glm-4.5v.description": "GLM-4.5V est basé sur GLM-4.5-Air, héritant des techniques éprouvées de GLM-4.1V-Thinking et s’appuyant sur une architecture MoE puissante de 106B paramètres.",

locales/fr-FR/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure propose des modèles d'IA avancés, notamment les séries GPT-3.5 et GPT-4, pour divers types de données et tâches complexes, avec un accent sur la sécurité, la fiabilité et la durabilité.",
   "azureai.description": "Azure fournit des modèles d'IA avancés, y compris les séries GPT-3.5 et GPT-4, pour des données variées et des tâches complexes, en mettant l'accent sur une IA sûre, fiable et durable.",
   "baichuan.description": "Baichuan AI se concentre sur les modèles fondamentaux performants en connaissances chinoises, traitement de contexte long et génération créative. Ses modèles (Baichuan 4, Baichuan 3 Turbo, Baichuan 3 Turbo 128k) sont optimisés pour différents scénarios et offrent une forte valeur ajoutée.",
+  "bailiancodingplan.description": "Le plan de codage Bailian d'Aliyun est un service d'IA spécialisé dans le codage, offrant un accès à des modèles optimisés pour le codage tels que Qwen, GLM, Kimi et MiniMax via un point d'accès dédié.",
   "bedrock.description": "Amazon Bedrock fournit aux entreprises des modèles avancés de langage et de vision, incluant Anthropic Claude et Meta Llama 3.1, allant d’options légères à haute performance pour les tâches de texte, de conversation et d’image.",
   "bfl.description": "Un laboratoire de recherche de pointe en IA visuelle construisant l'infrastructure visuelle de demain.",
   "cerebras.description": "Cerebras est une plateforme d'inférence basée sur son système CS-3, axée sur une latence ultra-faible et un débit élevé pour les charges de travail en temps réel comme la génération de code et les agents intelligents.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Les API serverless de Gitee AI offrent des services d'inférence LLM prêts à l'emploi pour les développeurs.",
   "github.description": "Avec GitHub Models, les développeurs peuvent créer comme des ingénieurs IA en utilisant des modèles de pointe.",
   "githubcopilot.description": "Accédez aux modèles Claude, GPT et Gemini grâce à votre abonnement GitHub Copilot.",
+  "glmcodingplan.description": "Le plan de codage GLM offre un accès aux modèles d'IA Zhipu, y compris GLM-5 et GLM-4.7, pour des tâches de codage via un abonnement à tarif fixe.",
   "google.description": "La famille Gemini de Google est son IA généraliste la plus avancée, développée par Google DeepMind pour un usage multimodal sur le texte, le code, les images, l’audio et la vidéo. Elle s’adapte des centres de données aux appareils mobiles avec une grande efficacité.",
   "groq.description": "Le moteur d'inférence LPU de Groq offre des performances de référence exceptionnelles avec une rapidité et une efficacité remarquables, établissant une nouvelle norme pour l'inférence LLM à faible latence dans le cloud.",
   "higress.description": "Higress est une passerelle API cloud-native développée par Alibaba pour résoudre les problèmes de rechargement de Tengine sur les connexions persistantes et les lacunes dans l’équilibrage de charge gRPC/Dubbo.",
@@ -29,9 +31,12 @@
   "infiniai.description": "Fournit aux développeurs d'applications des services LLM performants, simples d'utilisation et sécurisés, couvrant l'ensemble du flux de travail, du développement au déploiement en production.",
   "internlm.description": "Une organisation open source axée sur la recherche et les outils pour les grands modèles, offrant une plateforme efficace et accessible pour les modèles et algorithmes de pointe.",
   "jina.description": "Fondée en 2020, Jina AI est une entreprise leader en IA de recherche. Sa pile technologique comprend des modèles vectoriels, des rerankers et de petits modèles linguistiques pour créer des applications de recherche générative et multimodale fiables et de haute qualité.",
+  "kimicodingplan.description": "Kimi Code de Moonshot AI offre un accès aux modèles Kimi, y compris K2.5, pour des tâches de codage.",
   "lmstudio.description": "LM Studio est une application de bureau pour développer et expérimenter avec des LLMs sur votre ordinateur.",
+  "lobehub.description": "LobeHub Cloud utilise des API officielles pour accéder aux modèles d'IA et mesure l'utilisation avec des crédits liés aux jetons des modèles.",
   "longcat.description": "LongCat est une série de grands modèles d'IA générative développés indépendamment par Meituan. Elle est conçue pour améliorer la productivité interne de l'entreprise et permettre des applications innovantes grâce à une architecture informatique efficace et de puissantes capacités multimodales.",
   "minimax.description": "Fondée en 2021, MiniMax développe une IA généraliste avec des modèles fondamentaux multimodaux, incluant des modèles texte MoE à un billion de paramètres, des modèles vocaux et visuels, ainsi que des applications comme Hailuo AI.",
+  "minimaxcodingplan.description": "Le plan de jetons MiniMax offre un accès aux modèles MiniMax, y compris M2.7, pour des tâches de codage via un abonnement à tarif fixe.",
   "mistral.description": "Mistral propose des modèles avancés généralistes, spécialisés et de recherche pour le raisonnement complexe, les tâches multilingues et la génération de code, avec appels de fonctions pour des intégrations personnalisées.",
   "modelscope.description": "ModelScope est la plateforme de modèles en tant que service d'Alibaba Cloud, offrant un large éventail de modèles d'IA et de services d'inférence.",
   "moonshot.description": "Moonshot, de Moonshot AI (Beijing Moonshot Technology), propose plusieurs modèles NLP pour des cas d’usage comme la création de contenu, la recherche, les recommandations et l’analyse médicale, avec un fort support du contexte long et de la génération complexe.",
@@ -64,6 +69,7 @@
   "vertexai.description": "La famille Gemini de Google est son IA généraliste la plus avancée, développée par Google DeepMind pour un usage multimodal sur le texte, le code, les images, l’audio et la vidéo. Elle s’adapte des centres de données aux appareils mobiles, améliorant l’efficacité et la flexibilité de déploiement.",
   "vllm.description": "vLLM est une bibliothèque rapide et facile à utiliser pour l’inférence et le service de LLM.",
   "volcengine.description": "La plateforme de services de modèles de ByteDance offre un accès sécurisé, riche en fonctionnalités et compétitif en coût, avec des outils de bout en bout pour les données, l’ajustement, l’inférence et l’évaluation.",
+  "volcenginecodingplan.description": "Le plan de codage Volcengine de ByteDance offre un accès à plusieurs modèles de codage, y compris Doubao-Seed-Code, GLM-4.7, DeepSeek-V3.2 et Kimi-K2.5, via un abonnement à tarif fixe.",
   "wenxin.description": "Une plateforme tout-en-un pour les modèles fondamentaux et le développement d’applications IA-native en entreprise, offrant des outils de bout en bout pour les workflows de modèles et d’applications génératives.",
   "xai.description": "xAI développe une IA pour accélérer la découverte scientifique, avec pour mission d’approfondir la compréhension humaine de l’univers.",
   "xiaomimimo.description": "Xiaomi MiMo propose un service de modèle conversationnel avec une API compatible OpenAI. Le modèle mimo-v2-flash prend en charge le raisonnement approfondi, la sortie en streaming, l’appel de fonctions, une fenêtre de contexte de 256K et une sortie maximale de 128K.",

locales/fr-FR/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "Cartes bancaires / Alipay / WeChat Pay acceptés",
   "plans.btn.paymentDescForZarinpal": "Cartes bancaires acceptées",
   "plans.btn.soon": "Bientôt disponible",
+  "plans.cancelDowngrade": "Annuler la rétrogradation planifiée",
+  "plans.cancelDowngradeSuccess": "La rétrogradation planifiée a été annulée",
   "plans.changePlan": "Choisir un plan",
   "plans.cloud.history": "Historique de conversation illimité",
   "plans.cloud.sync": "Synchronisation cloud mondiale",
@@ -215,6 +217,7 @@
   "plans.current": "Plan actuel",
   "plans.downgradePlan": "Plan de rétrogradation",
   "plans.downgradeTip": "Vous avez déjà changé d’abonnement. Vous ne pouvez pas effectuer d’autres opérations tant que le changement n’est pas terminé",
+  "plans.downgradeWillCancel": "Cette action annulera la rétrogradation planifiée de votre abonnement",
   "plans.embeddingStorage.embeddings": "entrées",
   "plans.embeddingStorage.title": "Stockage vectoriel",
   "plans.embeddingStorage.tooltip": "Une page de document (1000-1500 caractères) génère environ 1 entrée vectorielle. (Estimation basée sur OpenAI Embeddings, peut varier selon le modèle)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "Confirmer la sélection",
   "plans.payonce.popconfirm": "Après un paiement unique, vous devrez attendre l’expiration de l’abonnement pour changer de plan ou de cycle de facturation. Veuillez confirmer votre choix.",
   "plans.payonce.tooltip": "Le paiement unique nécessite d’attendre l’expiration de l’abonnement pour changer de plan ou de cycle de facturation",
+  "plans.pendingDowngrade": "Rétrogradation en attente",
   "plans.plan.enterprise.contactSales": "Contacter les ventes",
   "plans.plan.enterprise.title": "Entreprise",
   "plans.plan.free.desc": "Pour les nouveaux utilisateurs",
@@ -366,6 +370,7 @@
   "summary.title": "Résumé de facturation",
   "summary.usageThisMonth": "Voir votre utilisation ce mois-ci.",
   "summary.viewBillingHistory": "Voir l’historique des paiements",
+  "switchDowngradeTarget": "Changer la cible de rétrogradation",
   "switchPlan": "Changer de plan",
   "switchToMonthly.desc": "Après le changement, la facturation mensuelle prendra effet à l’expiration du plan annuel actuel.",
   "switchToMonthly.title": "Passer à la facturation mensuelle",

locales/it-IT/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Connessione fallita",
   "sync.title": "Stato sincronizzazione",
   "sync.unconnected.tip": "Connessione al server di segnalazione fallita, impossibile stabilire il canale di comunicazione peer-to-peer. Controlla la rete e riprova.",
-  "tab.aiImage": "Illustrazioni",
   "tab.audio": "Audio",
   "tab.chat": "Chat",
   "tab.community": "Comunità",
@@ -405,6 +404,7 @@
   "tab.eval": "Laboratorio di Valutazione",
   "tab.files": "File",
   "tab.home": "Home",
+  "tab.image": "Immagine",
   "tab.knowledgeBase": "Libreria",
   "tab.marketplace": "Mercato",
   "tab.me": "Profilo",

locales/it-IT/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "Per i modelli di generazione immagini Gemini 3; controlla la risoluzione delle immagini generate.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "Per i modelli Gemini 3.1 Flash Image; controlla la risoluzione delle immagini generate (supporta 512px).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "Per Claude, Qwen3 e simili; controlla il budget di token per il ragionamento.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "Per GLM-5 e GLM-4.7; controlla il budget di token per il ragionamento (max 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "Per la serie Qwen3; controlla il budget di token per il ragionamento (max 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "Per OpenAI e altri modelli con capacità di ragionamento; controlla lo sforzo di ragionamento.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "Per la serie GPT-5+; controlla la verbosità dell'output.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "Per alcuni modelli Doubao; consente al modello di decidere se pensare in profondità.",

locales/it-IT/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev è un modello multimodale per generazione ed editing di immagini sviluppato da Black Forest Labs, basato su un'architettura Rectified Flow Transformer con 12 miliardi di parametri. Si concentra sulla generazione, ricostruzione, miglioramento o modifica di immagini in base a condizioni contestuali. Combina la generazione controllabile dei modelli di diffusione con la modellazione contestuale dei Transformer, supportando output di alta qualità per compiti come inpainting, outpainting e ricostruzione di scene visive.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev è un modello linguistico multimodale open-source (MLLM) di Black Forest Labs, ottimizzato per compiti immagine-testo e in grado di comprendere e generare contenuti visivi e testuali. Basato su LLM avanzati (come Mistral-7B), utilizza un encoder visivo progettato con cura e un tuning a più stadi per abilitare il coordinamento multimodale e il ragionamento su compiti complessi.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: Versione leggera per risposte rapide.",
+  "GLM-4.5.description": "GLM-4.5: Modello ad alte prestazioni per ragionamento, programmazione e attività agentiche.",
+  "GLM-4.6.description": "GLM-4.6: Modello della generazione precedente.",
+  "GLM-4.7.description": "GLM-4.7 è il modello di punta più recente di Zhipu, ottimizzato per scenari di programmazione agentica con capacità di codifica migliorate, pianificazione di compiti a lungo termine e collaborazione con strumenti.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: Versione ottimizzata di GLM-5 con inferenza più veloce per attività di programmazione.",
+  "GLM-5.description": "GLM-5 è il modello di base di nuova generazione di Zhipu, progettato per l'Ingegneria Agentica. Offre produttività affidabile in sistemi complessi e compiti agentici a lungo termine. Nelle capacità di programmazione e agentiche, GLM-5 raggiunge prestazioni all'avanguardia tra i modelli open-source.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B) è un modello innovativo per domini diversificati e compiti complessi.",
   "HY-Image-V3.0.description": "Potenti capacità di estrazione delle caratteristiche dell'immagine originale e di conservazione dei dettagli, offrendo una texture visiva più ricca e producendo immagini di alta precisione, ben composte e di qualità professionale.",
   "HelloMeme.description": "HelloMeme è uno strumento AI che genera meme, GIF o brevi video a partire da immagini o movimenti forniti. Non richiede abilità di disegno o programmazione: basta un'immagine di riferimento per creare contenuti divertenti, accattivanti e stilisticamente coerenti.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "Nuovo modello di ragionamento proprietario con 80K chain-of-thought e 1M di input, con prestazioni comparabili ai migliori modelli globali.",
   "MiniMax-M2-Stable.description": "Progettato per flussi di lavoro di codifica e agenti efficienti, con maggiore concorrenza per l'uso commerciale.",
   "MiniMax-M2.1-Lightning.description": "Potenti capacità di programmazione multilingue e un'esperienza di sviluppo completamente rinnovata. Più veloce ed efficiente.",
+  "MiniMax-M2.1-highspeed.description": "Potenti capacità di programmazione multilingue con inferenza più veloce ed efficiente.",
   "MiniMax-M2.1.description": "MiniMax-M2.1 è un modello open-source di punta di MiniMax, progettato per affrontare compiti complessi del mondo reale. I suoi punti di forza principali sono le capacità di programmazione multilingue e la risoluzione di compiti complessi come agente.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: Stessa prestazione, più veloce e agile (circa 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: Stesse prestazioni di M2.5 con inferenza più veloce.",
   "MiniMax-M2.5.description": "MiniMax-M2.5 è un modello open-source di punta di MiniMax, focalizzato sulla risoluzione di compiti complessi del mondo reale. I suoi punti di forza principali sono le capacità di programmazione multilingue e la capacità di risolvere compiti complessi come un Agente.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: Stesse prestazioni di M2.7 con inferenza significativamente più veloce.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: Inizio del percorso di auto-miglioramento ricorsivo, capacità ingegneristiche di alto livello nel mondo reale.",
+  "MiniMax-M2.description": "MiniMax M2: Modello della generazione precedente.",
   "MiniMax-Text-01.description": "MiniMax-01 introduce l'attenzione lineare su larga scala oltre i Transformer classici, con 456B parametri e 45,9B attivati per passaggio. Raggiunge prestazioni di alto livello e supporta fino a 4M token di contesto (32× GPT-4o, 20× Claude-3.5-Sonnet).",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1 è un modello di ragionamento a grande scala con pesi aperti e attenzione ibrida, con 456 miliardi di parametri totali e ~45,9 miliardi attivi per token. Supporta nativamente un contesto di 1 milione e utilizza Flash Attention per ridurre i FLOP del 75% nella generazione di 100K token rispetto a DeepSeek R1. Con un'architettura MoE più CISPO e addestramento RL con attenzione ibrida, raggiunge prestazioni leader nel ragionamento su input lunghi e compiti di ingegneria software reale.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2 ridefinisce l'efficienza degli agenti. È un modello MoE compatto, veloce e conveniente con 230 miliardi di parametri totali e 10 miliardi attivi, progettato per attività di programmazione e agenti di alto livello mantenendo una forte intelligenza generale. Con solo 10 miliardi di parametri attivi, rivaleggia con modelli molto più grandi, rendendolo ideale per applicazioni ad alta efficienza.",
   "Moonshot-Kimi-K2-Instruct.description": "1T parametri totali con 32B attivi. Tra i modelli non pensanti, è tra i migliori per conoscenze avanzate, matematica e programmazione, ed è più forte nei compiti generali da agente. Ottimizzato per carichi di lavoro da agente, può eseguire azioni, non solo rispondere a domande. Ideale per conversazioni improvvisate, chat generali e esperienze da agente, come modello reattivo senza riflessione prolungata.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46,7B) è un modello ad alta precisione per istruzioni complesse e calcoli avanzati.",
   "OmniConsistency.description": "OmniConsistency migliora la coerenza stilistica e la generalizzazione nei compiti immagine-a-immagine introducendo Diffusion Transformers (DiTs) su larga scala e dati stilizzati accoppiati, evitando il degrado dello stile.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Una versione aggiornata del modello Phi-3-mini.",
   "Phi-3.5-vision-instrust.description": "Una versione aggiornata del modello Phi-3-vision.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1 è un modello linguistico di grandi dimensioni open-source ottimizzato per capacità agentiche, eccellente nella programmazione, nell'uso di strumenti, nel seguire istruzioni e nella pianificazione a lungo termine. Supporta lo sviluppo software multilingue e l'esecuzione di flussi di lavoro complessi a più fasi, ottenendo un punteggio di 74,0 su SWE-bench Verified e superando Claude Sonnet 4.5 in scenari multilingue.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5 è l'ultimo modello linguistico di grandi dimensioni sviluppato da MiniMax, addestrato attraverso l'apprendimento per rinforzo su larga scala in centinaia di migliaia di ambienti complessi e reali. Con un'architettura MoE e 229 miliardi di parametri, raggiunge prestazioni leader nel settore in attività come programmazione, utilizzo di strumenti agentici, ricerca e scenari d'ufficio.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct è un LLM da 7B parametri ottimizzato per istruzioni nella serie Qwen2. Utilizza un'architettura Transformer con SwiGLU, bias QKV per l'attenzione e grouped-query attention, ed è in grado di gestire input di grandi dimensioni. Eccelle in comprensione linguistica, generazione, compiti multilingue, programmazione, matematica e ragionamento, superando la maggior parte dei modelli open-source e competendo con quelli proprietari. Supera Qwen1.5-7B-Chat in diversi benchmark.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct fa parte della nuova serie LLM di Alibaba Cloud. Il modello da 7B offre miglioramenti significativi in programmazione e matematica, supporta oltre 29 lingue e migliora il rispetto delle istruzioni, la comprensione dei dati strutturati e la generazione di output strutturati (in particolare JSON).",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct è l'ultimo LLM di Alibaba Cloud focalizzato sul codice. Basato su Qwen2.5 e addestrato su 5,5T token, migliora notevolmente la generazione, il ragionamento e la correzione del codice, mantenendo al contempo le capacità matematiche e generali, fornendo una solida base per agenti di programmazione.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL è un nuovo modello visione-linguaggio della serie Qwen con forte comprensione visiva. Analizza testo, grafici e layout nelle immagini, comprende video lunghi ed eventi, supporta il ragionamento e l'uso di strumenti, l'ancoraggio multi-formato degli oggetti e output strutturati. Migliora la risoluzione dinamica e l'addestramento a frame-rate per la comprensione video e aumenta l'efficienza dell'encoder visivo.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking è un modello VLM open-source sviluppato da Zhipu AI e dal laboratorio KEG della Tsinghua, progettato per la cognizione multimodale complessa. Basato su GLM-4-9B-0414, aggiunge ragionamento a catena e apprendimento per rinforzo (RL) per migliorare significativamente il ragionamento cross-modale e la stabilità.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat è il modello open-source GLM-4 di Zhipu AI. Eccelle in semantica, matematica, ragionamento, codice e conoscenza. Oltre alla chat multi-turno, supporta la navigazione web, l'esecuzione di codice, chiamate a strumenti personalizzati e ragionamento su testi lunghi. Supporta 26 lingue (tra cui cinese, inglese, giapponese, coreano, tedesco). Ottiene buoni risultati su AlignBench-v2, MT-Bench, MMLU e C-Eval, e supporta fino a 128K di contesto per usi accademici e aziendali.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B è distillato da Qwen2.5-Math-7B e ottimizzato su 800K campioni curati di DeepSeek-R1. Offre prestazioni elevate, con il 92,8% su MATH-500, il 55,5% su AIME 2024 e un rating CodeForces di 1189 per un modello da 7 miliardi.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 è un modello di ragionamento guidato da RL che riduce la ripetizione e migliora la leggibilità. Utilizza dati cold-start prima del RL per potenziare ulteriormente il ragionamento, eguaglia OpenAI-o1 in compiti di matematica, codice e ragionamento, migliorando i risultati complessivi grazie a un addestramento accurato.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus è una versione aggiornata del modello V3.1, posizionato come LLM ibrido per agenti. Risolve problemi segnalati dagli utenti e migliora la stabilità, la coerenza linguistica e riduce caratteri anomali e misti cinese/inglese. Integra modalità di pensiero e non-pensiero con template di chat per passaggi flessibili. Migliora anche le prestazioni di Code Agent e Search Agent per un uso più affidabile degli strumenti e compiti multi-step.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2 è un modello che combina un'elevata efficienza computazionale con eccellenti capacità di ragionamento e prestazioni come Agente. Il suo approccio si basa su tre principali innovazioni tecnologiche: DeepSeek Sparse Attention (DSA), un meccanismo di attenzione efficiente che riduce significativamente la complessità computazionale mantenendo le prestazioni del modello, ottimizzato specificamente per scenari a lungo contesto; un framework di apprendimento per rinforzo scalabile, attraverso il quale le prestazioni del modello possono competere con GPT-5, e la sua versione ad alta capacità computazionale può competere con Gemini-3.0-Pro nelle capacità di ragionamento; e una pipeline di sintesi di compiti per Agenti su larga scala, progettata per integrare le capacità di ragionamento negli scenari di utilizzo degli strumenti, migliorando così il rispetto delle istruzioni e la generalizzazione in ambienti interattivi complessi. Il modello ha ottenuto medaglie d'oro nelle Olimpiadi Internazionali di Matematica (IMO) e nelle Olimpiadi Internazionali di Informatica (IOI) del 2025.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 è la versione più recente e potente di Kimi K2. È un modello MoE di fascia alta con 1T di parametri totali e 32B attivi. Le caratteristiche principali includono un'intelligenza di codifica agentica più forte con miglioramenti significativi nei benchmark e nei compiti reali da agente, oltre a una migliore estetica e usabilità del codice frontend.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo è la variante Turbo ottimizzata per velocità di ragionamento e throughput, mantenendo il ragionamento multi-step e l'uso di strumenti di K2 Thinking. È un modello MoE con ~1T parametri totali, contesto nativo da 256K e chiamata stabile di strumenti su larga scala per scenari di produzione con requisiti più severi di latenza e concorrenza.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5 è un modello agente multimodale nativo open-source, basato su Kimi-K2-Base, addestrato su circa 1,5 trilioni di token misti visivi e testuali. Il modello adotta un'architettura MoE con 1T di parametri totali e 32B attivi, supporta una finestra di contesto di 256K e integra perfettamente le capacità di comprensione visiva e linguistica.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7 è il modello di punta di nuova generazione di Zhipu con 355 miliardi di parametri totali e 32 miliardi di parametri attivi, completamente aggiornato per dialoghi generali, ragionamento e capacità agentiche. GLM-4.7 migliora il Pensiero Intercalato e introduce il Pensiero Preservato e il Pensiero a Livello di Turno.",
   "Pro/zai-org/glm-5.description": "GLM-5 è il modello linguistico di prossima generazione di Zhipu, focalizzato sull'ingegneria di sistemi complessi e sui compiti di lunga durata per Agenti. I parametri del modello sono stati ampliati a 744 miliardi (40 miliardi attivi) e integrano DeepSeek Sparse Attention.",
   "QwQ-32B-Preview.description": "Qwen QwQ è un modello di ricerca sperimentale focalizzato sul miglioramento del ragionamento.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview è un modello di ricerca di Qwen focalizzato sul ragionamento visivo, con punti di forza nella comprensione di scene complesse e problemi di matematica visiva.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ è un modello di ricerca sperimentale focalizzato sul miglioramento del ragionamento dell'IA.",
   "Qwen/QwQ-32B.description": "QwQ è un modello di ragionamento della famiglia Qwen. Rispetto ai modelli standard ottimizzati per seguire istruzioni, integra capacità di pensiero e ragionamento che migliorano significativamente le prestazioni nei compiti complessi. QwQ-32B è un modello di medie dimensioni competitivo con i migliori modelli di ragionamento come DeepSeek-R1 e o1-mini. Utilizza RoPE, SwiGLU, RMSNorm e bias QKV nell'attenzione, con 64 layer e 40 teste di attenzione Q (8 KV in GQA).",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 è l'ultima versione di editing dell'immagine sviluppata dal team Qwen. Basato sul modello Qwen-Image da 20B, estende le potenti capacità di rendering del testo all'editing delle immagini per modifiche testuali precise. Utilizza un'architettura a doppio controllo, inviando gli input a Qwen2.5-VL per il controllo semantico e a un encoder VAE per il controllo dell'aspetto, consentendo modifiche sia semantiche che visive. Supporta modifiche locali (aggiunta/rimozione/modifica) e modifiche semantiche di alto livello come la creazione di IP e il trasferimento di stile, preservando il significato originale. Ottiene risultati SOTA in numerosi benchmark.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Modello Skylark di seconda generazione. Skylark2-pro-turbo-8k offre inferenza più veloce a costi inferiori con una finestra di contesto da 8K.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414 è un modello GLM open-source di nuova generazione con 32 miliardi di parametri, comparabile in prestazioni a OpenAI GPT e alla serie DeepSeek V3/R1.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414 è un modello GLM da 9 miliardi di parametri che eredita le tecniche di GLM-4-32B offrendo un'implementazione più leggera. Eccelle nella generazione di codice, progettazione web, generazione SVG e scrittura basata su ricerca.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking è un modello VLM open-source di Zhipu AI e Tsinghua KEG Lab, progettato per la cognizione multimodale complessa. Basato su GLM-4-9B-0414, aggiunge ragionamento a catena e RL per migliorare significativamente il ragionamento cross-modale e la stabilità.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414 è un modello di ragionamento profondo costruito a partire da GLM-4-32B-0414 con dati cold-start e RL esteso, ulteriormente addestrato su matematica, codice e logica. Migliora significativamente la capacità matematica e la risoluzione di compiti complessi rispetto al modello base.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414 è un modello GLM compatto da 9 miliardi di parametri che mantiene i punti di forza open-source offrendo capacità impressionanti. Eccelle nel ragionamento matematico e nei compiti generali, guidando la sua classe di dimensione tra i modelli open.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat è il modello GLM-4 open-source di Zhipu AI. Eccelle in semantica, matematica, ragionamento, codice e conoscenza. Oltre alla chat multi-turno, supporta navigazione web, esecuzione di codice, chiamate a strumenti personalizzati e ragionamento su testi lunghi. Supporta 26 lingue (inclusi cinese, inglese, giapponese, coreano, tedesco). Ottiene buoni risultati su AlignBench-v2, MT-Bench, MMLU e C-Eval, e supporta fino a 128K di contesto per uso accademico e aziendale.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B è il primo modello di ragionamento a lungo contesto (LRM) addestrato con RL, ottimizzato per il ragionamento su testi lunghi. La RL con espansione progressiva del contesto consente un trasferimento stabile da contesti brevi a lunghi. Supera OpenAI-o3-mini e Qwen3-235B-A22B su sette benchmark di QA su documenti a lungo contesto, rivaleggiando con Claude-3.7-Sonnet-Thinking. È particolarmente forte in matematica, logica e ragionamento multi-hop.",
   "Yi-34B-Chat.description": "Yi-1.5-34B mantiene le forti capacità linguistiche generali della serie, migliorando significativamente logica matematica e programmazione grazie a un addestramento incrementale su 500 miliardi di token di alta qualità.",
   "abab5.5-chat.description": "Progettato per scenari di produttività, gestisce compiti complessi e genera testo in modo efficiente per uso professionale.",
   "abab5.5s-chat.description": "Progettato per chat con personaggi in cinese, offrendo dialoghi di alta qualità per varie applicazioni.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet eccelle nella programmazione, nella scrittura e nel ragionamento complesso.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet con capacità di pensiero esteso per compiti di ragionamento complesso.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet è una versione aggiornata con contesto e funzionalità estese.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 è il modello Haiku più veloce e intelligente di Anthropic, con velocità fulminea e pensiero esteso.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 è un modello veloce ed efficiente per una varietà di compiti.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking è una variante avanzata in grado di mostrare il proprio processo di ragionamento.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 è il modello più recente e capace di Anthropic per compiti altamente complessi, eccellendo in prestazioni, intelligenza, fluidità e comprensione.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 è il modello più potente di Anthropic per compiti altamente complessi, eccellendo in prestazioni, intelligenza, fluidità e comprensione.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 è il modello di punta di Anthropic, che combina intelligenza eccezionale e prestazioni scalabili, ideale per compiti complessi che richiedono risposte e ragionamenti di altissima qualità.",
+  "claude-opus-4-6.description": "Claude Opus 4.6 è il modello più intelligente di Anthropic per la costruzione di agenti e la programmazione.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking può produrre risposte quasi istantanee o riflessioni estese passo dopo passo con processo visibile.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 è il modello più intelligente di Anthropic fino ad oggi, offrendo risposte quasi istantanee o pensiero esteso passo-passo con controllo dettagliato per gli utenti API.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 è il modello più intelligente di Anthropic fino ad oggi.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6 è la migliore combinazione di velocità e intelligenza di Anthropic.",
   "claude-sonnet-4.description": "Claude Sonnet 4 è la generazione più recente con prestazioni migliorate in tutti i compiti.",
   "codegeex-4.description": "CodeGeeX-4 è un potente assistente di codifica AI che supporta Q&A multilingue e completamento del codice per aumentare la produttività degli sviluppatori.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B è un modello multilingue di generazione di codice che supporta completamento e generazione di codice, interprete di codice, ricerca web, chiamata di funzioni e Q&A a livello di repository, coprendo un'ampia gamma di scenari di sviluppo software. È un modello di codice di alto livello con meno di 10B parametri.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "I modelli distillati DeepSeek-R1 utilizzano apprendimento per rinforzo (RL) e dati cold-start per migliorare il ragionamento e stabilire nuovi benchmark multi-task per modelli open-source.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "I modelli distillati DeepSeek-R1 utilizzano apprendimento per rinforzo (RL) e dati cold-start per migliorare il ragionamento e stabilire nuovi benchmark multi-task per modelli open-source.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B è distillato da Qwen2.5-32B e ottimizzato su 800.000 campioni curati da DeepSeek-R1. Eccelle in matematica, programmazione e ragionamento, ottenendo risultati eccellenti su AIME 2024, MATH-500 (94,3% di accuratezza) e GPQA Diamond.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B è distillato da Qwen2.5-Math-7B e ottimizzato su 800K campioni curati di DeepSeek-R1. Offre prestazioni elevate, con il 92,8% su MATH-500, il 55,5% su AIME 2024 e un rating CodeForces di 1189 per un modello da 7 miliardi.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 migliora il ragionamento grazie a dati cold-start e apprendimento per rinforzo, stabilendo nuovi benchmark multi-task per modelli open-source e superando OpenAI-o1-mini.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 aggiorna DeepSeek-V2-Chat e DeepSeek-Coder-V2-Instruct, combinando capacità generali e di programmazione. Migliora la scrittura e il rispetto delle istruzioni per un migliore allineamento alle preferenze, con progressi significativi su AlpacaEval 2.0, ArenaHard, AlignBench e MT-Bench.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus è una versione aggiornata del modello V3.1, concepito come agente ibrido LLM. Risolve problemi segnalati dagli utenti e migliora stabilità, coerenza linguistica e riduce caratteri anomali o misti cinese/inglese. Integra modalità di pensiero e non-pensiero con template di chat per passaggi flessibili. Migliora anche le prestazioni di Code Agent e Search Agent per un uso più affidabile degli strumenti e compiti multi-step.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 è un modello di nuova generazione per il ragionamento, con capacità avanzate di ragionamento complesso e chain-of-thought per compiti di analisi approfondita.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 è un modello di ragionamento di nuova generazione con capacità avanzate di ragionamento complesso e catena di pensiero.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 è un modello visione-linguaggio MoE basato su DeepSeekMoE-27B con attivazione sparsa, che raggiunge prestazioni elevate con solo 4,5B di parametri attivi. Eccelle in QA visivo, OCR, comprensione di documenti/tabelle/grafici e grounding visivo.",
+  "deepseek-chat.description": "DeepSeek V3.2 bilancia ragionamento e lunghezza dell'output per attività quotidiane di QA e agenti. I benchmark pubblici raggiungono livelli GPT-5 ed è il primo a integrare il pensiero nell'uso degli strumenti, guidando le valutazioni degli agenti open-source.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B è un modello linguistico per il codice addestrato su 2 trilioni di token (87% codice, 13% testo in cinese/inglese). Introduce una finestra di contesto da 16K e compiti di completamento intermedio, offrendo completamento di codice a livello di progetto e riempimento di snippet.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 è un modello MoE open-source per il codice che ottiene ottimi risultati nei compiti di programmazione, comparabile a GPT-4 Turbo.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 è un modello MoE open-source per il codice che ottiene ottimi risultati nei compiti di programmazione, comparabile a GPT-4 Turbo.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "DeepSeek R1 versione completa veloce con ricerca web in tempo reale, che combina capacità su scala 671B e risposte rapide.",
   "deepseek-r1-online.description": "DeepSeek R1 versione completa con 671 miliardi di parametri e ricerca web in tempo reale, che offre una comprensione e generazione più avanzate.",
   "deepseek-r1.description": "DeepSeek-R1 utilizza dati cold-start prima dell'RL e ottiene prestazioni comparabili a OpenAI-o1 in matematica, programmazione e ragionamento.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking è un modello di ragionamento profondo che genera una catena di pensiero prima degli output per una maggiore precisione, con risultati di competizione di alto livello e ragionamento comparabile a Gemini-3.0-Pro.",
   "deepseek-v2.description": "DeepSeek V2 è un modello MoE efficiente per un'elaborazione conveniente.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B è il modello DeepSeek focalizzato sul codice con forte capacità di generazione.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 è un modello MoE con 671 miliardi di parametri, con punti di forza nella programmazione, capacità tecnica, comprensione del contesto e gestione di testi lunghi.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp introduce l'attenzione sparsa per migliorare l'efficienza di addestramento e inferenza su testi lunghi, a un costo inferiore rispetto a deepseek-v3.1.",
   "deepseek-v3.2-speciale.description": "Per compiti altamente complessi, il modello Speciale supera significativamente la versione standard, ma consuma un numero considerevolmente maggiore di token e comporta costi più elevati. Attualmente, DeepSeek-V3.2-Speciale è destinato esclusivamente alla ricerca, non supporta l'uso di strumenti e non è stato specificamente ottimizzato per conversazioni quotidiane o compiti di scrittura.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think è un modello completo di pensiero profondo con capacità potenziate di ragionamento a catena lunga.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2 è l'ultimo modello di programmazione di DeepSeek con forti capacità di ragionamento.",
   "deepseek-v3.description": "DeepSeek-V3 è un potente modello MoE con 671 miliardi di parametri totali e 37 miliardi attivi per token.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small è una versione multimodale leggera, pensata per ambienti con risorse limitate e alta concorrenza.",
   "deepseek-vl2.description": "DeepSeek VL2 è un modello multimodale per la comprensione immagine-testo e domande visive dettagliate.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K è un modello di pensiero veloce con contesto da 32K per ragionamento complesso e chat multi-turno.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview è un’anteprima del modello di pensiero per valutazioni e test.",
   "ernie-x1.1.description": "ERNIE X1.1 è un'anteprima del modello di pensiero per valutazione e test.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5, sviluppato dal team Seed di ByteDance, supporta l'editing e la composizione multi-immagine. Presenta una maggiore coerenza del soggetto, un'interpretazione precisa delle istruzioni, comprensione della logica spaziale, espressione estetica, layout di poster e design di loghi con rendering testo-immagine ad alta precisione.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0, sviluppato da ByteDance Seed, supporta input di testo e immagini per la generazione di immagini altamente controllabile e di alta qualità a partire da prompt.",
   "fal-ai/flux-kontext/dev.description": "FLUX.1 è un modello focalizzato sull’editing di immagini, che supporta input di testo e immagini.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] accetta testo e immagini di riferimento come input, consentendo modifiche locali mirate e trasformazioni complesse della scena globale.",
   "fal-ai/flux/krea.description": "Flux Krea [dev] è un modello di generazione di immagini con una preferenza estetica per immagini più realistiche e naturali.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "Un potente modello nativo multimodale per la generazione di immagini.",
   "fal-ai/imagen4/preview.description": "Modello di generazione di immagini di alta qualità sviluppato da Google.",
   "fal-ai/nano-banana.description": "Nano Banana è il modello multimodale nativo più recente, veloce ed efficiente di Google, che consente la generazione e l’editing di immagini tramite conversazione.",
+  "fal-ai/qwen-image-edit.description": "Un modello professionale di editing di immagini del team Qwen, che supporta modifiche semantiche e di aspetto, editing preciso di testo in cinese/inglese, trasferimento di stile, rotazione e altro.",
+  "fal-ai/qwen-image.description": "Un potente modello di generazione di immagini del team Qwen con una forte resa del testo cinese e stili visivi diversificati.",
   "flux-1-schnell.description": "Modello testo-immagine da 12 miliardi di parametri di Black Forest Labs che utilizza la distillazione latente avversariale per generare immagini di alta qualità in 1-4 passaggi. Con licenza Apache-2.0 per uso personale, di ricerca e commerciale.",
   "flux-dev.description": "FLUX.1 [dev] è un modello distillato a pesi aperti per uso non commerciale. Mantiene una qualità d’immagine quasi professionale e capacità di seguire istruzioni, con maggiore efficienza rispetto ai modelli standard di pari dimensioni.",
   "flux-kontext-max.description": "Generazione ed editing di immagini contestuali all’avanguardia, combinando testo e immagini per risultati precisi e coerenti.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro è il modello di ragionamento più avanzato di Google, in grado di ragionare su codice, matematica e problemi STEM, e analizzare grandi dataset, basi di codice e documenti con contesto esteso.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash è il modello più intelligente progettato per la velocità, che combina intelligenza all'avanguardia con un eccellente ancoraggio alla ricerca.",
   "gemini-3-pro-image-preview.description": "Gemini 3 Pro Image (Nano Banana Pro) è il modello di generazione di immagini di Google che supporta anche il dialogo multimodale.",
+  "gemini-3-pro-image-preview:image.description": "Gemini 3 Pro Image (Nano Banana Pro) è il modello di generazione di immagini di Google e supporta anche la chat multimodale.",
   "gemini-3-pro-preview.description": "Gemini 3 Pro è il modello più potente di Google per agenti e codifica creativa, offrendo visuali più ricche e interazioni più profonde grazie a un ragionamento all'avanguardia.",
   "gemini-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2) è il modello di generazione di immagini nativo più veloce di Google con supporto al pensiero, generazione e modifica di immagini conversazionali.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) offre qualità di immagine di livello Pro a velocità Flash con supporto per chat multimodale.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview è il modello multimodale più economico di Google, ottimizzato per compiti agentici ad alto volume, traduzione e elaborazione dati.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview migliora Gemini 3 Pro con capacità di ragionamento avanzate e aggiunge supporto per un livello di pensiero medio.",
   "gemini-flash-latest.description": "Ultima versione di Gemini Flash",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "Variante K2 long-thinking ad alta velocità con contesto da 256k, ragionamento profondo avanzato e output da 60–100 token/sec.",
   "kimi-k2-thinking.description": "kimi-k2-thinking è un modello di ragionamento di Moonshot AI con capacità generali di agenti e ragionamento. Eccelle nel ragionamento profondo e può risolvere problemi complessi tramite l'uso di strumenti multi-step.",
   "kimi-k2-turbo-preview.description": "kimi-k2 è un modello base MoE con forti capacità di programmazione e agenti (1T di parametri totali, 32B attivi), che supera altri modelli open-source mainstream nei benchmark di ragionamento, programmazione, matematica e agenti.",
+  "kimi-k2.5.description": "Kimi K2.5 è il modello più versatile di Kimi fino ad oggi, con un'architettura multimodale nativa che supporta input visivi e testuali, modalità 'pensante' e 'non pensante', e attività sia conversazionali che agentiche.",
   "kimi-k2.description": "Kimi-K2 è un modello base MoE di Moonshot AI con forti capacità di programmazione e agenti, per un totale di 1T di parametri con 32B attivi. Nei benchmark per ragionamento generale, programmazione, matematica e compiti agentici, supera altri modelli open-source mainstream.",
   "kimi-k2:1t.description": "Kimi K2 è un grande LLM MoE di Moonshot AI con 1T di parametri totali e 32B attivi per passaggio. È ottimizzato per capacità agentiche tra cui uso avanzato di strumenti, ragionamento e sintesi di codice.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1 (gratuito per un periodo limitato) è focalizzato sulla comprensione del codice e sull'automazione per agenti di programmazione efficienti.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K supporta 32.768 token per contesti di media lunghezza, ideale per documenti lunghi e dialoghi complessi in creazione di contenuti, report e sistemi di chat.",
   "moonshot-v1-8k-vision-preview.description": "I modelli visivi Kimi (inclusi moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview) comprendono contenuti visivi come testo, colori e forme degli oggetti.",
   "moonshot-v1-8k.description": "Moonshot V1 8K è ottimizzato per la generazione di testi brevi con prestazioni efficienti, gestendo 8.192 token per chat brevi, appunti e contenuti rapidi.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B è un modello di codice open-source ottimizzato con RL su larga scala per produrre patch robuste e pronte per la produzione. Ottiene il 60,4% su SWE-bench Verified, stabilendo un nuovo record per modelli aperti in attività di ingegneria software automatizzata come correzione di bug e revisione del codice.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 è la versione più recente e potente della serie Kimi K2. È un modello MoE di fascia alta con 1T di parametri totali e 32B attivi. Tra le caratteristiche principali: maggiore intelligenza agentica nella programmazione, miglioramenti significativi nei benchmark e nei compiti reali per agenti, oltre a un'estetica e usabilità del codice frontend più curate.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking è il modello di pensiero open-source più recente e potente. Estende notevolmente la profondità del ragionamento multi-step e mantiene un utilizzo stabile degli strumenti per 200–300 chiamate consecutive, stabilendo nuovi record su Humanity's Last Exam (HLE), BrowseComp e altri benchmark. Eccelle in scenari di codifica, matematica, logica e agenti. Basato su un'architettura MoE con ~1 trilione di parametri totali, supporta una finestra di contesto di 256K e chiamate di strumenti.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711 è la variante instruct della serie Kimi, adatta per codice di alta qualità e uso di strumenti.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "Il coder Qwen di nuova generazione ottimizzato per la generazione di codice complesso multi-file, il debugging e i flussi di lavoro ad alta produttività per agenti. Progettato per una forte integrazione degli strumenti e prestazioni di ragionamento migliorate.",
   "qwen3-coder-plus.description": "Modello di codice Qwen. La serie Qwen3-Coder si basa su Qwen3 e offre forti capacità di agenti di programmazione, utilizzo di strumenti e interazione con l’ambiente per la programmazione autonoma, con prestazioni eccellenti nel codice e solide capacità generali.",
   "qwen3-coder:480b.description": "Modello ad alte prestazioni di Alibaba per attività di agenti e programmazione, con supporto a contesti lunghi.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: Il modello Qwen con le migliori prestazioni per compiti di programmazione complessi e multi-step con supporto al pensiero.",
   "qwen3-max-preview.description": "Il modello Qwen con le migliori prestazioni per compiti complessi e multi-step. La versione preview supporta il ragionamento.",
   "qwen3-max.description": "I modelli Qwen3 Max offrono miglioramenti significativi rispetto alla serie 2.5 in capacità generali, comprensione di cinese/inglese, esecuzione di istruzioni complesse, compiti soggettivi aperti, abilità multilingue e uso di strumenti, con meno allucinazioni. L'ultima versione qwen3-max migliora la programmazione agentica e l'uso degli strumenti rispetto a qwen3-max-preview. Questa release raggiunge lo stato dell’arte e risponde a esigenze agentiche più complesse.",
   "qwen3-next-80b-a3b-instruct.description": "Modello open-source di nuova generazione Qwen3 senza capacità di ragionamento. Rispetto alla versione precedente (Qwen3-235B-A22B-Instruct-2507), offre una migliore comprensione del cinese, un ragionamento logico più forte e una generazione di testo migliorata.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ è un modello di ragionamento della famiglia Qwen. Rispetto ai modelli standard ottimizzati per istruzioni, offre capacità di pensiero e ragionamento che migliorano significativamente le prestazioni nei compiti difficili. QwQ-32B è un modello di medie dimensioni che compete con i migliori modelli di ragionamento come DeepSeek-R1 e o1-mini.",
   "qwq_32b.description": "Modello di ragionamento di medie dimensioni della famiglia Qwen. Rispetto ai modelli standard ottimizzati per istruzioni, le capacità di pensiero e ragionamento di QwQ migliorano significativamente le prestazioni nei compiti difficili.",
   "r1-1776.description": "R1-1776 è una variante post-addestrata di DeepSeek R1 progettata per fornire informazioni fattuali non censurate e imparziali.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro di ByteDance supporta la generazione di video da testo, video da immagine (primo fotogramma, primo+ultimo fotogramma) e audio sincronizzato con i visual.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite di BytePlus presenta generazione aumentata da recupero web per informazioni in tempo reale, interpretazione migliorata di prompt complessi e maggiore coerenza di riferimento per la creazione visiva professionale.",
   "solar-mini-ja.description": "Solar Mini (Ja) estende Solar Mini con un focus sul giapponese, mantenendo prestazioni efficienti e solide in inglese e coreano.",
   "solar-mini.description": "Solar Mini è un LLM compatto che supera GPT-3.5, con forte capacità multilingue in inglese e coreano, offrendo una soluzione efficiente e leggera.",
   "solar-pro.description": "Solar Pro è un LLM ad alta intelligenza di Upstage, focalizzato sull’esecuzione di istruzioni su una singola GPU, con punteggi IFEval superiori a 80. Attualmente supporta l’inglese; il rilascio completo è previsto per novembre 2024 con supporto linguistico ampliato e contesto più lungo.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "Il modello di punta di Stepfun per il ragionamento linguistico. Questo modello ha capacità di ragionamento di altissimo livello e capacità di esecuzione rapide e affidabili. È in grado di scomporre e pianificare compiti complessi, chiamare strumenti rapidamente e in modo affidabile per eseguire compiti, ed essere competente in vari compiti complessi come ragionamento logico, matematica, ingegneria del software e ricerca approfondita.",
   "step-3.description": "Questo modello ha una forte percezione visiva e capacità di ragionamento complesso, gestendo con precisione la comprensione della conoscenza cross-domain, l’analisi matematica-visiva e una vasta gamma di compiti visivi quotidiani.",
   "step-r1-v-mini.description": "Modello di ragionamento con forte comprensione delle immagini, in grado di elaborare immagini e testo e generare testo dopo un ragionamento profondo. Eccelle nel ragionamento visivo e offre prestazioni di alto livello in matematica, programmazione e ragionamento testuale, con una finestra di contesto da 100K.",
+  "stepfun-ai/step3.description": "Step3 è un modello di ragionamento multimodale all'avanguardia di StepFun, basato su un'architettura MoE con 321 miliardi di parametri totali e 38 miliardi di parametri attivi. Il design end-to-end minimizza i costi di decodifica offrendo ragionamento visivo-linguistico di alto livello. Con design MFA e AFD, rimane efficiente sia su acceleratori di punta che di fascia bassa. Il pretraining utilizza oltre 20 trilioni di token di testo e 4 trilioni di token immagine-testo in molte lingue. Raggiunge prestazioni leader tra i modelli aperti su benchmark di matematica, codice e multimodale.",
   "taichu4_vl_2b_nothinking.description": "La versione No-Thinking del modello Taichu4.0-VL 2B presenta un utilizzo ridotto della memoria, un design leggero, una velocità di risposta rapida e forti capacità di comprensione multimodale.",
   "taichu4_vl_32b.description": "La versione Thinking del modello Taichu4.0-VL 32B è adatta per compiti complessi di comprensione e ragionamento multimodale, dimostrando prestazioni eccezionali nel ragionamento matematico multimodale, nelle capacità di agente multimodale e nella comprensione generale di immagini e contenuti visivi.",
   "taichu4_vl_32b_nothinking.description": "La versione No-Thinking del modello Taichu4.0-VL 32B è progettata per scenari complessi di comprensione immagine-testo e QA di conoscenze visive, eccellendo nella didascalia delle immagini, nel visual question answering, nella comprensione dei video e nei compiti di localizzazione visiva.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air è un modello base per applicazioni agentiche con architettura Mixture-of-Experts. Ottimizzato per l'uso di strumenti, navigazione web, ingegneria software e programmazione frontend, si integra con agenti di codice come Claude Code e Roo Code. Utilizza ragionamento ibrido per gestire sia scenari complessi che quotidiani.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V è il più recente VLM di Zhipu AI, basato sul modello testuale di punta GLM-4.5-Air (106B totali, 12B attivi) con architettura MoE per prestazioni elevate a costi ridotti. Segue il percorso GLM-4.1V-Thinking e aggiunge 3D-RoPE per migliorare il ragionamento spaziale 3D. Ottimizzato tramite pretraining, SFT e RL, gestisce immagini, video e documenti lunghi, classificandosi tra i migliori modelli open source su 41 benchmark multimodali pubblici. Una modalità Thinking consente di bilanciare velocità e profondità.",
   "zai-org/GLM-4.6.description": "Rispetto a GLM-4.5, GLM-4.6 estende il contesto da 128K a 200K per compiti agentici più complessi. Ottiene punteggi più alti nei benchmark di codice e mostra prestazioni superiori in applicazioni reali come Claude Code, Cline, Roo Code e Kilo Code, inclusa una migliore generazione di pagine frontend. Il ragionamento è migliorato e l'uso di strumenti è supportato durante il ragionamento, rafforzando le capacità complessive. Si integra meglio nei framework agentici, migliora gli agenti di ricerca/strumenti e offre uno stile di scrittura più naturale e preferito dagli utenti.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V raggiunge un'accuratezza SOTA nella comprensione visiva per la sua scala di parametri ed è il primo a integrare nativamente le capacità di Function Call nell'architettura del modello visivo, colmando il divario tra 'percezione visiva' e 'azioni eseguibili' e fornendo una base tecnica unificata per agenti multimodali in scenari aziendali reali. La finestra di contesto visivo è estesa a 128k, supportando l'elaborazione di flussi video lunghi e analisi multi-immagine ad alta risoluzione.",
   "zai/glm-4.5-air.description": "GLM-4.5 e GLM-4.5-Air sono i nostri modelli di punta più recenti per applicazioni agentiche, entrambi con architettura MoE. GLM-4.5 ha 355B totali e 32B attivi per passaggio; GLM-4.5-Air è più snello con 106B totali e 12B attivi.",
   "zai/glm-4.5.description": "La serie GLM-4.5 è progettata per agenti. Il modello di punta GLM-4.5 combina ragionamento, programmazione e capacità agentiche con 355B parametri totali (32B attivi) e offre modalità operative doppie come sistema di ragionamento ibrido.",
   "zai/glm-4.5v.description": "GLM-4.5V si basa su GLM-4.5-Air, ereditando le tecniche collaudate di GLM-4.1V-Thinking e scalando con una potente architettura MoE da 106B parametri.",

locales/it-IT/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure offre modelli AI avanzati, tra cui le serie GPT-3.5 e GPT-4, per diversi tipi di dati e compiti complessi, con un focus su sicurezza, affidabilità e sostenibilità.",
   "azureai.description": "Azure fornisce modelli AI avanzati, tra cui le serie GPT-3.5 e GPT-4, per diversi tipi di dati e compiti complessi, con un focus su sicurezza, affidabilità e sostenibilità.",
   "baichuan.description": "Baichuan AI si concentra su modelli fondamentali con elevate prestazioni nella conoscenza del cinese, elaborazione di contesti lunghi e generazione creativa. I suoi modelli (Baichuan 4, Baichuan 3 Turbo, Baichuan 3 Turbo 128k) sono ottimizzati per diversi scenari e offrono un grande valore.",
+  "bailiancodingplan.description": "Il piano di codifica Bailian di Aliyun è un servizio AI specializzato che offre accesso a modelli ottimizzati per la codifica come Qwen, GLM, Kimi e MiniMax tramite un endpoint dedicato.",
   "bedrock.description": "Amazon Bedrock fornisce alle imprese modelli linguistici e visivi avanzati, tra cui Anthropic Claude e Meta Llama 3.1, con opzioni leggere e ad alte prestazioni per compiti di testo, chat e immagini.",
   "bfl.description": "Un laboratorio di ricerca AI all'avanguardia che costruisce l'infrastruttura visiva del futuro.",
   "cerebras.description": "Cerebras è una piattaforma di inferenza basata sul sistema CS-3, focalizzata su latenza ultra-bassa e throughput elevato per servizi LLM in tempo reale come generazione di codice e agenti intelligenti.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Le API serverless di Gitee AI offrono servizi di inferenza LLM plug-and-play per sviluppatori.",
   "github.description": "Con i modelli GitHub, gli sviluppatori possono lavorare come ingegneri AI utilizzando modelli leader del settore.",
   "githubcopilot.description": "Accedi ai modelli Claude, GPT e Gemini tramite il tuo abbonamento a GitHub Copilot.",
+  "glmcodingplan.description": "Il piano di codifica GLM offre accesso ai modelli AI di Zhipu, inclusi GLM-5 e GLM-4.7, per attività di codifica tramite un abbonamento a tariffa fissa.",
   "google.description": "La famiglia Gemini di Google è la sua AI più avanzata per uso generale, sviluppata da Google DeepMind per l'uso multimodale su testo, codice, immagini, audio e video. Si adatta dai data center ai dispositivi mobili con grande efficienza e portata.",
   "groq.description": "Il motore di inferenza LPU di Groq offre prestazioni di riferimento eccezionali con velocità ed efficienza straordinarie, stabilendo un nuovo standard per l'inferenza LLM a bassa latenza nel cloud.",
   "higress.description": "Higress è un gateway API cloud-native creato da Alibaba per risolvere l'impatto del reload di Tengine sulle connessioni persistenti e le lacune nel bilanciamento del carico gRPC/Dubbo.",
@@ -29,9 +31,12 @@
   "infiniai.description": "Fornisce agli sviluppatori di app servizi LLM ad alte prestazioni, facili da usare e sicuri, lungo l'intero flusso di lavoro, dallo sviluppo del modello alla distribuzione in produzione.",
   "internlm.description": "Un'organizzazione open-source focalizzata sulla ricerca e gli strumenti per modelli di grandi dimensioni, che offre una piattaforma efficiente e facile da usare per rendere accessibili modelli e algoritmi all'avanguardia.",
   "jina.description": "Fondata nel 2020, Jina AI è un'azienda leader nell'AI per la ricerca. Il suo stack include modelli vettoriali, reranker e piccoli modelli linguistici per costruire app di ricerca generativa e multimodale affidabili e di alta qualità.",
+  "kimicodingplan.description": "Kimi Code di Moonshot AI offre accesso ai modelli Kimi, inclusi K2.5, per attività di codifica.",
   "lmstudio.description": "LM Studio è un'app desktop per sviluppare e sperimentare con LLM direttamente sul tuo computer.",
+  "lobehub.description": "LobeHub Cloud utilizza API ufficiali per accedere ai modelli AI e misura l'utilizzo con Crediti legati ai token dei modelli.",
   "longcat.description": "LongCat è una serie di modelli AI generativi di grandi dimensioni sviluppati indipendentemente da Meituan. È progettato per migliorare la produttività interna dell'azienda e consentire applicazioni innovative attraverso un'architettura computazionale efficiente e potenti capacità multimodali.",
   "minimax.description": "Fondata nel 2021, MiniMax sviluppa AI generali con modelli fondamentali multimodali, inclusi modelli testuali MoE da trilioni di parametri, modelli vocali e visivi, oltre ad app come Hailuo AI.",
+  "minimaxcodingplan.description": "Il piano di token MiniMax offre accesso ai modelli MiniMax, inclusi M2.7, per attività di codifica tramite un abbonamento a tariffa fissa.",
   "mistral.description": "Mistral offre modelli avanzati generali, specializzati e di ricerca per ragionamento complesso, compiti multilingue e generazione di codice, con supporto per chiamate di funzione per integrazioni personalizzate.",
   "modelscope.description": "ModelScope è la piattaforma di modelli-as-a-service di Alibaba Cloud, che offre un'ampia gamma di modelli AI e servizi di inferenza.",
   "moonshot.description": "Moonshot, di Moonshot AI (Beijing Moonshot Technology), offre diversi modelli NLP per casi d'uso come creazione di contenuti, ricerca, raccomandazioni e analisi medica, con forte supporto per contesti lunghi e generazione complessa.",
@@ -64,6 +69,7 @@
   "vertexai.description": "La famiglia Gemini di Google è la sua AI più avanzata per uso generale, sviluppata da Google DeepMind per l'uso multimodale su testo, codice, immagini, audio e video. Si adatta dai data center ai dispositivi mobili, migliorando efficienza e flessibilità di distribuzione.",
   "vllm.description": "vLLM è una libreria veloce e facile da usare per inferenza e servizio di LLM.",
   "volcengine.description": "La piattaforma di servizi di modelli di ByteDance offre accesso sicuro, ricco di funzionalità e competitivo nei costi, oltre a strumenti end-to-end per dati, fine-tuning, inferenza e valutazione.",
+  "volcenginecodingplan.description": "Il piano di codifica Volcengine di ByteDance offre accesso a diversi modelli di codifica, inclusi Doubao-Seed-Code, GLM-4.7, DeepSeek-V3.2 e Kimi-K2.5, tramite un abbonamento a tariffa fissa.",
   "wenxin.description": "Una piattaforma aziendale all-in-one per modelli fondamentali e sviluppo di app AI-native, che offre strumenti end-to-end per flussi di lavoro di modelli e applicazioni generative.",
   "xai.description": "xAI sviluppa intelligenza artificiale per accelerare la scoperta scientifica, con la missione di approfondire la comprensione dell'universo da parte dell'umanità.",
   "xiaomimimo.description": "Xiaomi MiMo offre un servizio di modelli conversazionali con un'API compatibile con OpenAI. Il modello mimo-v2-flash supporta il ragionamento avanzato, l'output in streaming, le chiamate di funzione, una finestra di contesto di 256K e una produzione massima di 128K.",

locales/it-IT/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "Supporta carta di credito / Alipay / WeChat Pay",
   "plans.btn.paymentDescForZarinpal": "Supporta carta di credito",
   "plans.btn.soon": "Prossimamente",
+  "plans.cancelDowngrade": "Annulla downgrade programmato",
+  "plans.cancelDowngradeSuccess": "Il downgrade programmato è stato annullato",
   "plans.changePlan": "Scegli piano",
   "plans.cloud.history": "Cronologia conversazioni illimitata",
   "plans.cloud.sync": "Sincronizzazione cloud globale",
@@ -215,6 +217,7 @@
   "plans.current": "Piano attuale",
   "plans.downgradePlan": "Piano di downgrade",
   "plans.downgradeTip": "Hai già cambiato abbonamento. Non puoi effettuare altre operazioni finché il cambio non è completato",
+  "plans.downgradeWillCancel": "Questa azione annullerà il downgrade del piano programmato",
   "plans.embeddingStorage.embeddings": "voci",
   "plans.embeddingStorage.title": "Archiviazione vettoriale",
   "plans.embeddingStorage.tooltip": "Una pagina di documento (1000-1500 caratteri) genera circa 1 voce vettoriale. (Stima basata su OpenAI Embeddings, può variare in base al modello)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "Conferma selezione",
   "plans.payonce.popconfirm": "Dopo il pagamento una tantum, dovrai attendere la scadenza dell'abbonamento per cambiare piano o ciclo di fatturazione. Confermi la selezione?",
   "plans.payonce.tooltip": "Il pagamento una tantum richiede l'attesa della scadenza per cambiare piano o ciclo di fatturazione",
+  "plans.pendingDowngrade": "Downgrade in sospeso",
   "plans.plan.enterprise.contactSales": "Contatta il reparto vendite",
   "plans.plan.enterprise.title": "Enterprise",
   "plans.plan.free.desc": "Per utenti alle prime armi",
@@ -366,6 +370,7 @@
   "summary.title": "Riepilogo Fatturazione",
   "summary.usageThisMonth": "Visualizza il tuo utilizzo di questo mese.",
   "summary.viewBillingHistory": "Visualizza Cronologia Pagamenti",
+  "switchDowngradeTarget": "Cambia obiettivo del downgrade",
   "switchPlan": "Cambia Piano",
   "switchToMonthly.desc": "Dopo il cambio, la fatturazione mensile entrerà in vigore alla scadenza del piano annuale attuale.",
   "switchToMonthly.title": "Passa alla Fatturazione Mensile",

locales/ja-JP/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "接続失敗",
   "sync.title": "同期ステータス",
   "sync.unconnected.tip": "シグナリングサーバーへの接続に失敗しました。P2P 通信チャンネルを確立できません。ネットワークを確認して再試行してください",
-  "tab.aiImage": "ペインティング",
   "tab.audio": "オーディオ",
   "tab.chat": "チャット",
   "tab.community": "コミュニティ",
@@ -405,6 +404,7 @@
   "tab.eval": "評価ラボ",
   "tab.files": "ファイル",
   "tab.home": "ホーム",
+  "tab.image": "画像",
   "tab.knowledgeBase": "ライブラリ",
   "tab.marketplace": "マーケットプレイス",
   "tab.me": "自分",

locales/ja-JP/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "Gemini 3画像生成モデル向け；生成される画像の解像度を制御します。",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "Gemini 3.1 Flash Imageモデル用; 生成される画像の解像度を制御します（512pxをサポート）。",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "Claude、Qwen3などのモデル向け；推論に使用するトークンの予算を制御します。",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "GLM-5およびGLM-4.7用；推論のためのトークン予算を制御します（最大32k）。",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "Qwen3シリーズ用；推論のためのトークン予算を制御します（最大80k）。",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "OpenAIなどの推論対応モデル向け；推論の努力度を制御します。",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "GPT-5+シリーズ向け；出力の詳細度を制御します。",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "一部のDoubaoモデル向け；モデルが深く思考するかどうかを判断させます。",

locales/ja-JP/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev は、Black Forest Labs によるマルチモーダル画像生成・編集モデルで、12Bパラメータの Rectified Flow Transformer アーキテクチャに基づいています。与えられたコンテキスト条件下での画像生成、再構築、強化、編集に特化しており、拡散モデルの制御可能な生成能力と Transformer のコンテキストモデリングを組み合わせ、インペインティング、アウトペインティング、視覚シーン再構築などの高品質な出力を実現します。",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev は、Black Forest Labs によるオープンソースのマルチモーダル言語モデル（MLLM）で、画像とテキストの理解・生成を統合しています。高度な LLM（例：Mistral-7B）をベースに、精密に設計されたビジョンエンコーダと多段階の指示チューニングを用いて、マルチモーダルの連携と複雑なタスクの推論を可能にします。",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: 高速応答のための軽量版。",
+  "GLM-4.5.description": "GLM-4.5: 推論、コーディング、エージェントタスク向けの高性能モデル。",
+  "GLM-4.6.description": "GLM-4.6: 前世代モデル。",
+  "GLM-4.7.description": "GLM-4.7は智譜の最新フラッグシップモデルで、エージェンティックコーディングシナリオ向けに強化され、コーディング能力、長期タスク計画、ツール連携が向上しています。",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: コーディングタスク向けに推論速度を最適化したGLM-5の改良版。",
+  "GLM-5.description": "GLM-5は智譜の次世代フラッグシップ基盤モデルで、エージェンティックエンジニアリング向けに特化されています。複雑なシステムエンジニアリングや長期的なエージェンティックタスクにおいて信頼性の高い生産性を提供します。コーディングとエージェント能力において、GLM-5はオープンソースモデルの中で最先端の性能を達成しています。",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2（13B）は、多様な分野と複雑なタスクに対応する革新的なモデルです。",
   "HY-Image-V3.0.description": "強力なオリジナル画像の特徴抽出と詳細保持機能により、より豊かな視覚的テクスチャを提供し、高精度で構図の優れた、プロダクション品質のビジュアルを生成します。",
   "HelloMeme.description": "HelloMeme は、提供された画像や動作からミーム、GIF、ショート動画を生成するAIツールです。絵を描くスキルやコーディングスキルは不要で、参照画像を用意するだけで、楽しく魅力的でスタイルの一貫したコンテンツを作成できます。",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "80Kの思考連鎖と1Mの入力を備えた新しい社内推論モデルで、世界トップクラスのモデルに匹敵する性能を発揮します。",
   "MiniMax-M2-Stable.description": "効率的なコーディングとエージェントワークフローのために設計され、商用利用における高い同時実行性を実現します。",
   "MiniMax-M2.1-Lightning.description": "強力な多言語プログラミング機能を備え、プログラミング体験を全面的にアップグレード。より高速かつ効率的に。",
+  "MiniMax-M2.1-highspeed.description": "強力な多言語プログラミング能力と高速かつ効率的な推論。",
   "MiniMax-M2.1.description": "MiniMax-M2.1は、MiniMaxが開発したフラッグシップのオープンソース大規模モデルで、複雑な現実世界のタスク解決に特化しています。多言語プログラミング能力とエージェントとしての高度なタスク処理能力が主な強みです。",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: 同じ性能で、より高速かつ機敏（約100 tps）。",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: M2.5と同等の性能で推論速度が向上。",
   "MiniMax-M2.5.description": "MiniMax-M2.5は、MiniMaxによるフラッグシップのオープンソース大規模モデルで、複雑な現実世界のタスクを解決することに焦点を当てています。その主な強みは、多言語プログラミング能力とエージェントとして複雑なタスクを解決する能力です。",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: M2.7と同等の性能で推論速度が大幅に向上。",
+  "MiniMax-M2.7.description": "MiniMax M2.7: 再帰的自己改善の旅を開始し、実世界のトップエンジニアリング能力を備えています。",
+  "MiniMax-M2.description": "MiniMax M2: 前世代モデル。",
   "MiniMax-Text-01.description": "MiniMax-01は、従来のTransformerを超える大規模な線形アテンションを導入し、4560億のパラメータと1パスあたり45.9億のアクティブパラメータを持ちます。最大400万トークンのコンテキストをサポートし（GPT-4oの32倍、Claude-3.5-Sonnetの20倍）、最高水準の性能を実現します。",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1はオープンウェイトの大規模ハイブリッドアテンション推論モデルで、総パラメータ数456B、トークンごとに約45.9Bがアクティブです。ネイティブで1Mコンテキストをサポートし、Flash Attentionを使用してDeepSeek R1に比べて100Kトークン生成時のFLOPsを75%削減します。MoEアーキテクチャにCISPOとハイブリッドアテンションRLトレーニングを組み合わせ、長い入力推論や実際のソフトウェアエンジニアリングタスクで優れた性能を発揮します。",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2はエージェント効率を再定義します。230Bの総パラメータと10Bのアクティブパラメータを持つコンパクトで高速、コスト効率の高いMoEモデルで、トップレベルのコーディングとエージェントタスクに対応しながら、強力な一般知能を維持します。アクティブパラメータが10Bのみで、はるかに大きなモデルに匹敵する性能を発揮し、高効率アプリケーションに最適です。",
   "Moonshot-Kimi-K2-Instruct.description": "総パラメータ1兆、アクティブパラメータ32Bの非思考型モデルで、最先端の知識、数学、コーディングにおいてトップクラスの性能を誇ります。一般的なエージェントタスクにも強く、質問に答えるだけでなく行動も可能です。即興的な会話や一般的なチャット、エージェント体験に最適な、反射レベルのモデルです。",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO（46.7B）は、複雑な計算に対応する高精度な命令モデルです。",
   "OmniConsistency.description": "OmniConsistencyは、大規模なDiffusion Transformer（DiT）とペア化されたスタイル付きデータを導入することで、画像間タスクにおけるスタイルの一貫性と汎化性能を向上させ、スタイルの劣化を防ぎます。",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Phi-3-miniモデルのアップデート版です。",
   "Phi-3.5-vision-instrust.description": "Phi-3-visionモデルのアップデート版です。",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1は、エージェント機能に最適化されたオープンソースの大規模言語モデルであり、プログラミング、ツールの活用、指示の遵守、長期的な計画に優れています。このモデルは多言語でのソフトウェア開発や複雑なマルチステップのワークフロー実行をサポートし、SWE-bench Verifiedで74.0のスコアを達成し、多言語シナリオにおいてClaude Sonnet 4.5を上回る性能を示しています。",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5はMiniMaxによって開発された最新の大規模言語モデルで、数十万の複雑な実世界環境での大規模強化学習を通じてトレーニングされています。229Bのパラメータを持つMoEアーキテクチャを特徴とし、プログラミング、エージェントツールの呼び出し、検索、オフィスシナリオなどのタスクで業界最高の性能を達成します。",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instructは、Qwen2シリーズの7B命令調整済みLLMです。TransformerアーキテクチャにSwiGLU、QKVバイアス、グループ化クエリアテンションを採用し、大規模入力に対応。言語理解、生成、多言語、コーディング、数学、推論において優れた性能を発揮し、多くのオープンモデルを上回り、プロプライエタリモデルと競合します。Qwen1.5-7B-Chatを複数のベンチマークで上回ります。",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instructは、Alibaba Cloudの最新LLMシリーズの一部です。7Bモデルは、コーディングと数学で顕著な向上を示し、29以上の言語をサポート。命令追従、構造化データの理解、構造化出力（特にJSON）を改善しています。",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instructは、Alibaba Cloudの最新コード特化型LLMです。Qwen2.5をベースに5.5兆トークンで訓練され、コード生成、推論、修復を大幅に改善。数学や汎用能力も維持し、コーディングエージェントの強力な基盤を提供します。",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VLは、Qwenシリーズの新しいビジョン・ランゲージモデルで、強力な視覚理解を備えています。画像内のテキスト、チャート、レイアウトを分析し、長時間の動画やイベントを理解。推論やツール使用、マルチフォーマットのオブジェクト認識、構造化出力に対応。動画理解のための動的解像度とフレームレート学習を改善し、ビジョンエンコーダの効率も向上しています。",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinkingは、Zhipu AIと清華大学KEG研究室によるオープンソースのVLMで、複雑なマルチモーダル認知のために設計されています。GLM-4-9B-0414をベースに、思考連鎖推論と強化学習を追加し、クロスモーダル推論と安定性を大幅に向上させています。",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chatは、Zhipu AIによるオープンソースのGLM-4モデルです。意味理解、数学、推論、コード、知識において高い性能を発揮します。マルチターンチャットに加え、ウェブブラウジング、コード実行、カスタムツール呼び出し、長文推論をサポート。中国語、英語、日本語、韓国語、ドイツ語など26言語に対応し、学術・ビジネス用途に最大128Kのコンテキストを提供します。",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7BはQwen2.5-Math-7Bから蒸留され、800Kの厳選されたDeepSeek-R1サンプルで微調整されています。MATH-500で92.8%、AIME 2024で55.5%、CodeForcesの7Bモデルとして1189の評価を達成しています。",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1は、強化学習による推論モデルで、繰り返しを減らし可読性を向上させます。RL前にコールドスタートデータを使用して推論をさらに強化し、数学、コード、推論タスクでOpenAI-o1に匹敵する性能を発揮。慎重な訓練により全体的な結果を向上させています。",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminusは、ハイブリッドエージェントLLMとして位置づけられたV3.1の改良版です。ユーザーから報告された問題を修正し、安定性と言語の一貫性を向上。中英混在や異常文字を削減。思考モードと非思考モードをチャットテンプレートで柔軟に切り替え可能。Code AgentとSearch Agentの性能も向上し、ツール使用やマルチステップタスクの信頼性が高まりました。",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2は、高い計算効率と優れた推論およびエージェント性能を兼ね備えたモデルです。そのアプローチは、計算複雑性を大幅に削減しながらモデル性能を維持する効率的な注意メカニズムであるDeepSeek Sparse Attention（DSA）、GPT-5に匹敵する性能を持つスケーラブルな強化学習フレームワーク、そしてツール使用シナリオに推論能力を統合する大規模エージェントタスク合成パイプラインという3つの主要な技術的ブレークスルーに基づいています。このモデルは、2025年国際数学オリンピック（IMO）および国際情報オリンピック（IOI）で金メダルを獲得しました。",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905 は、最新かつ最も高性能な Kimi K2 モデルです。1T の総パラメータと 32B のアクティブパラメータを持つ最上位の MoE モデルであり、エージェント型コーディング知能が強化され、ベンチマークおよび実世界のエージェントタスクにおいて大幅な性能向上を実現しています。さらに、フロントエンドのコード美学と使いやすさも改善されています。",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo は、K2 Thinking のマルチステップ推論とツール使用能力を維持しつつ、推論速度とスループットを最適化した Turbo バリアントです。約 1T の総パラメータを持つ MoE モデルで、ネイティブで 256K のコンテキスト長をサポートし、低レイテンシーかつ高同時実行性が求められる本番環境において安定した大規模ツール呼び出しが可能です。",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5は、Kimi-K2-Baseを基盤としたオープンソースのネイティブマルチモーダルエージェントモデルで、約1.5兆の視覚・テキストトークンで訓練されています。MoEアーキテクチャを採用し、総パラメータ数1兆、アクティブパラメータ数32B、256Kのコンテキストウィンドウをサポートし、視覚と言語の理解をシームレスに統合しています。",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7は智譜の新世代フラッグシップモデルで、総パラメータ355B、アクティブパラメータ32Bを持ち、一般的な対話、推論、エージェント能力が完全にアップグレードされています。GLM-4.7は交互思考を強化し、保存思考とターンレベル思考を導入しています。",
   "Pro/zai-org/glm-5.description": "GLM-5は、複雑なシステムエンジニアリングと長期間のエージェントタスクに焦点を当てたZhipuの次世代大規模言語モデルです。モデルパラメータは7440億（アクティブ40億）に拡張され、DeepSeek Sparse Attentionを統合しています。",
   "QwQ-32B-Preview.description": "Qwen QwQ は、推論能力の向上に焦点を当てた実験的研究モデルです。",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-PreviewはQwenによる研究モデルで、視覚的推論に焦点を当て、複雑なシーン理解や視覚的数学問題に強みを持っています。",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ は、AI の推論能力向上に焦点を当てた実験的研究モデルです。",
   "Qwen/QwQ-32B.description": "QwQ は Qwen ファミリーの推論モデルです。標準的な命令調整モデルと比較して、思考と推論の能力が追加されており、特に難易度の高い問題において下流タスクの性能を大幅に向上させます。QwQ-32B は中規模の推論モデルであり、DeepSeek-R1 や o1-mini などのトップ推論モデルと競合します。RoPE、SwiGLU、RMSNorm、Attention QKV バイアスを使用し、64 層、40 の Q アテンションヘッド（GQA では 8 KV）を備えています。",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509 は、Qwen チームによる Qwen-Image の最新編集バージョンです。20B パラメータの Qwen-Image モデルを基盤とし、強力なテキスト描画能力を画像編集に拡張し、精密なテキスト編集を可能にします。Qwen2.5-VL によるセマンティック制御と VAE エンコーダによる外観制御を組み合わせたデュアル制御アーキテクチャを採用し、意味レベルおよび外観レベルの編集を実現します。ローカル編集（追加／削除／修正）や、IP 作成やスタイル変換といった高次の意味編集にも対応し、意味を保持しながら編集が可能です。複数のベンチマークで SOTA（最先端）性能を達成しています。",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Skylark第2世代モデル。Skylark2-pro-turbo-8kは、8Kコンテキストウィンドウに対応し、低コストで高速な推論を実現します。",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414は、次世代のオープンGLMモデルで、32Bパラメータを持ち、OpenAI GPTやDeepSeek V3/R1シリーズと同等の性能を発揮します。",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414は、GLM-4-32Bの技術を継承しつつ、軽量なデプロイメントを可能にした9Bモデルです。コード生成、Webデザイン、SVG生成、検索ベースのライティングに優れた性能を発揮します。",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinkingは智譜AIと清華大学KEG研究所によるオープンソースVLMで、複雑なマルチモーダル認知のために設計されています。GLM-4-9B-0414を基盤に、チェーンオブソート推論とRLを追加し、クロスモーダル推論と安定性を大幅に向上させています。",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414は、GLM-4-32B-0414をベースに構築された深い推論モデルで、コールドスタートデータと拡張RLを活用し、数学、コード、論理に関する能力を大幅に強化しています。ベースモデルに比べ、複雑なタスク解決能力が大きく向上しています。",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414は、9Bパラメータの小型GLMモデルで、オープンソースの強みを維持しつつ、優れた性能を発揮します。数学的推論や一般的なタスクに強く、同サイズのオープンモデルの中でトップクラスの性能を誇ります。",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chatは、Zhipu AIによるオープンソースのGLM-4モデルで、意味理解、数学、推論、コード、知識において高い性能を発揮します。マルチターンチャットに加え、Webブラウジング、コード実行、カスタムツール呼び出し、長文推論をサポートします。中国語、英語、日本語、韓国語、ドイツ語など26言語に対応し、学術・ビジネス用途に最適な128Kコンテキストをサポートします。",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32BはRLでトレーニングされた初の長コンテキスト推論モデル（LRM）で、長文推論に最適化されています。その進行的コンテキスト拡張RLにより、短いコンテキストから長いコンテキストへの安定した移行が可能です。7つの長コンテキスト文書QAベンチマークでOpenAI-o3-miniやQwen3-235B-A22Bを上回り、Claude-3.7-Sonnet-Thinkingに匹敵します。数学、論理、多段階推論に特に強みを持っています。",
   "Yi-34B-Chat.description": "Yi-1.5-34Bは、シリーズの強力な言語能力を維持しつつ、500Bの高品質トークンによる段階的トレーニングにより、数学的論理とコーディング能力を大幅に向上させています。",
   "abab5.5-chat.description": "複雑なタスク処理とプロフェッショナルなテキスト生成に対応した生産性向けモデルです。",
   "abab5.5s-chat.description": "中国語のキャラクターチャットに特化し、さまざまなアプリケーションにおいて高品質な中国語対話を提供します。",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet は、コーディング、ライティング、複雑な推論に優れたモデルです。",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet は、複雑な推論タスクに対応するために思考能力を拡張したモデルです。",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet は、コンテキストと機能が強化されたアップグレード版です。",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5はAnthropicの最速かつ最も知的なHaikuモデルで、驚異的な速度と拡張された思考能力を備えています。",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 は、さまざまなタスクに対応する高速かつ効率的なモデルです。",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinkingは、推論プロセスを可視化できる高度なバリアントです。",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1はAnthropicの最新かつ最も能力の高いモデルで、非常に複雑なタスクにおいて性能、知性、流暢さ、理解力に優れています。",
+  "claude-opus-4-20250514.description": "Claude Opus 4はAnthropicの最強モデルで、非常に複雑なタスクにおいて性能、知性、流暢さ、理解力に優れています。",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5は、Anthropicのフラッグシップモデルで、卓越した知性とスケーラブルな性能を兼ね備え、最高品質の応答と推論が求められる複雑なタスクに最適です。",
+  "claude-opus-4-6.description": "Claude Opus 4.6はエージェント構築とコーディングにおいてAnthropicの最も知的なモデルです。",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinkingは、即時応答または段階的な思考プロセスを可視化しながら出力できます。",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4はAnthropicの最も知的なモデルで、APIユーザー向けに即時応答または段階的な思考を提供します。",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5はAnthropicの最も知的なモデルです。",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6は速度と知性の最適な組み合わせを提供します。",
   "claude-sonnet-4.description": "Claude Sonnet 4 は、あらゆるタスクにおいて性能が向上した最新世代のモデルです。",
   "codegeex-4.description": "CodeGeeX-4は、開発者の生産性を向上させる多言語対応のAIコーディングアシスタントで、Q&Aやコード補完をサポートします。",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9Bは、多言語コード生成モデルで、コード補完、生成、インタープリタ、Web検索、関数呼び出し、リポジトリレベルのQ&Aなど、幅広いソフトウェア開発シナリオに対応します。10B未満のパラメータで最高クラスのコードモデルです。",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "DeepSeek-R1 蒸留モデルは、強化学習（RL）とコールドスタートデータを活用して推論能力を向上させ、オープンモデルのマルチタスクベンチマークで新たな基準を打ち立てます。",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "DeepSeek-R1 蒸留モデルは、強化学習（RL）とコールドスタートデータを活用して推論能力を向上させ、オープンモデルのマルチタスクベンチマークで新たな基準を打ち立てます。",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B は Qwen2.5-32B をベースに蒸留され、80 万件の厳選された DeepSeek-R1 サンプルでファインチューニングされています。数学、プログラミング、推論に優れ、AIME 2024、MATH-500（94.3% 正答率）、GPQA Diamond で高い成果を上げています。",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7BはQwen2.5-Math-7Bから蒸留され、800Kの厳選されたDeepSeek-R1サンプルで微調整されています。MATH-500で92.8%、AIME 2024で55.5%、CodeForcesの7Bモデルとして1189の評価を達成しています。",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1 は強化学習（RL）とコールドスタートデータを活用して推論能力を向上させ、オープンモデルのマルチタスクベンチマークで新たな基準を打ち立て、OpenAI-o1-mini を上回る性能を発揮します。",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5 は DeepSeek-V2-Chat と DeepSeek-Coder-V2-Instruct を統合し、汎用能力とコーディング能力を兼ね備えたモデルです。文章生成と指示追従性が向上し、AlpacaEval 2.0、ArenaHard、AlignBench、MT-Bench で大きな進歩を示しています。",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus は V3.1 の改良版で、ハイブリッドエージェント LLM として位置づけられています。ユーザーから報告された問題を修正し、安定性と言語一貫性を向上させ、中国語と英語の混在や異常文字を削減しています。思考モードと非思考モードをチャットテンプレートで柔軟に切り替えられ、Code Agent や Search Agent の性能も向上し、ツール使用やマルチステップタスクの信頼性が高まりました。",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1 は次世代の推論モデルで、複雑な推論と連想思考に優れ、深い分析タスクに対応します。",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2は次世代推論モデルで、複雑な推論と連鎖的思考能力が強化されています。",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2 は DeepSeekMoE-27B をベースにした MoE 視覚言語モデルで、スパースアクティベーションにより、4.5B のアクティブパラメータで高性能を実現しています。視覚 QA、OCR、文書・表・チャート理解、視覚的グラウンディングに優れています。",
+  "deepseek-chat.description": "DeepSeek V3.2は日常的なQAやエージェントタスクのために推論と出力の長さをバランスさせています。公開ベンチマークでGPT-5レベルに達し、ツール使用に思考を統合した初のモデルで、オープンソースエージェント評価をリードしています。",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B は 2T トークン（コード 87%、中英テキスト 13%）で学習されたコード言語モデルです。16K のコンテキストウィンドウと Fill-in-the-Middle タスクを導入し、プロジェクトレベルのコード補完とスニペット補完を提供します。",
   "deepseek-coder-v2.description": "DeepSeek Coder V2 はオープンソースの MoE コードモデルで、コーディングタスクにおいて GPT-4 Turbo に匹敵する性能を発揮します。",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2 はオープンソースの MoE コードモデルで、コーディングタスクにおいて GPT-4 Turbo に匹敵する性能を発揮します。",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "DeepSeek R1 高速フルバージョンは、リアルタイムのウェブ検索を搭載し、671Bスケールの能力と高速応答を両立します。",
   "deepseek-r1-online.description": "DeepSeek R1 フルバージョンは、671Bパラメータとリアルタイムのウェブ検索を備え、より強力な理解と生成を提供します。",
   "deepseek-r1.description": "DeepSeek-R1は、強化学習前にコールドスタートデータを使用し、数学、コーディング、推論においてOpenAI-o1と同等の性能を発揮します。",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinkingは深い推論モデルで、出力前にチェーンオブソートを生成し、精度を向上させます。競技会でトップの結果を達成し、Gemini-3.0-Proに匹敵する推論能力を持っています。",
   "deepseek-v2.description": "DeepSeek V2は、コスト効率の高い処理を実現する効率的なMoEモデルです。",
   "deepseek-v2:236b.description": "DeepSeek V2 236Bは、コード生成に特化したDeepSeekのモデルで、強力なコード生成能力を持ちます。",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324は、671BパラメータのMoEモデルで、プログラミングや技術的能力、文脈理解、長文処理において優れた性能を発揮します。",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-expは、長文テキストの学習と推論効率を向上させるスパースアテンションを導入し、deepseek-v3.1よりも低価格で提供されます。",
   "deepseek-v3.2-speciale.description": "高度に複雑なタスクにおいて、Specialeモデルは標準バージョンを大幅に上回る性能を発揮しますが、トークン消費が多く、コストが高くなります。現在、DeepSeek-V3.2-Specialeは研究用途のみに提供されており、ツール呼び出しをサポートせず、日常会話や執筆タスク向けに最適化されていません。",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Thinkは、長い思考の連鎖に対応した完全な深層思考モデルです。",
+  "deepseek-v3.2.description": "DeepSeek-V3.2はDeepSeekの最新コーディングモデルで、強力な推論能力を備えています。",
   "deepseek-v3.description": "DeepSeek-V3は、671Bの総パラメータとトークンごとに37Bがアクティブな強力なMoEモデルです。",
   "deepseek-vl2-small.description": "DeepSeek VL2 Smallは、リソース制約や高同時接続環境向けの軽量マルチモーダルモデルです。",
   "deepseek-vl2.description": "DeepSeek VL2は、画像と言語の理解および精緻な視覚的質問応答に対応するマルチモーダルモデルです。",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K は、複雑な推論やマルチターン対話に対応した 32K コンテキストの高速思考モデルです。",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview は、評価およびテスト用の思考モデルプレビューです。",
   "ernie-x1.1.description": "ERNIE X1.1は評価とテスト用の思考モデルプレビューです。",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5はByteDance Seedチームによって構築され、複数画像の編集と合成をサポートします。主題の一貫性、正確な指示の追従、空間論理の理解、美的表現、ポスターのレイアウト、ロゴデザイン、高精度なテキスト画像レンダリングが強化されています。",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0はByteDance Seedによって構築され、テキストと画像入力をサポートし、プロンプトからの高度に制御可能で高品質な画像生成を提供します。",
   "fal-ai/flux-kontext/dev.description": "FLUX.1 モデルは画像編集に特化しており、テキストと画像の入力に対応しています。",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro] は、テキストと参照画像を入力として受け取り、局所的な編集や複雑なシーン全体の変換を可能にします。",
   "fal-ai/flux/krea.description": "Flux Krea [dev] は、よりリアルで自然な画像を生成する美的バイアスを持つ画像生成モデルです。",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "強力なネイティブマルチモーダル画像生成モデルです。",
   "fal-ai/imagen4/preview.description": "Google による高品質な画像生成モデルです。",
   "fal-ai/nano-banana.description": "Nano Banana は Google による最新・最速・最も効率的なネイティブマルチモーダルモデルで、会話を通じた画像生成と編集が可能です。",
+  "fal-ai/qwen-image-edit.description": "Qwenチームによるプロフェッショナルな画像編集モデルで、意味的および外観の編集、正確な中国語/英語のテキスト編集、スタイル転送、回転などをサポートします。",
+  "fal-ai/qwen-image.description": "Qwenチームによる強力な画像生成モデルで、中国語のテキストレンダリングと多様な視覚スタイルに優れています。",
   "flux-1-schnell.description": "Black Forest Labs による 120 億パラメータのテキストから画像への変換モデルで、潜在敵対的拡散蒸留を用いて 1～4 ステップで高品質な画像を生成します。クローズドな代替モデルに匹敵し、Apache-2.0 ライセンスのもと、個人・研究・商用利用が可能です。",
   "flux-dev.description": "FLUX.1 [dev] は、非商用利用向けのオープンウェイト蒸留モデルで、プロレベルに近い画像品質と指示追従性を維持しつつ、同サイズの標準モデルよりも効率的に動作します。",
   "flux-kontext-max.description": "最先端のコンテキスト画像生成・編集モデルで、テキストと画像を組み合わせて精密かつ一貫性のある結果を生成します。",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro は、Google による最も高度な推論モデルで、コード、数学、STEM 問題に対する推論や、大規模なデータセット、コードベース、文書の分析に対応します。",
   "gemini-3-flash-preview.description": "Gemini 3 Flash は、最先端の知能と優れた検索基盤を融合し、スピードに特化した最もスマートなモデルです。",
   "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-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image（Nano Banana 2）は、Googleの最速のネイティブ画像生成モデルで、思考サポート、対話型画像生成および編集を提供します。",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2)はプロレベルの画像品質をフラッシュ速度で提供し、マルチモーダルチャットをサポートします。",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite PreviewはGoogleの最もコスト効率の高いマルチモーダルモデルで、大量のエージェントタスク、翻訳、データ処理に最適化されています。",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Previewは、Gemini 3 Proの推論能力を強化し、中程度の思考レベルサポートを追加しています。",
   "gemini-flash-latest.description": "Gemini Flash の最新リリース",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "256kコンテキストに対応した高速K2長期思考バリアント。深い推論能力と毎秒60〜100トークンの出力速度を備えています。",
   "kimi-k2-thinking.description": "kimi-k2-thinking は、Moonshot AI による思考モデルで、一般的なエージェント機能と推論能力を備えています。深い推論に優れ、マルチステップのツール使用を通じて難問を解決できます。",
   "kimi-k2-turbo-preview.description": "kimi-k2 は、強力なコーディングおよびエージェント機能を備えた MoE 基盤モデルです（総パラメータ数 1T、アクティブ 32B）。推論、プログラミング、数学、エージェントベンチマークにおいて、他の主流のオープンモデルを上回る性能を発揮します。",
+  "kimi-k2.5.description": "Kimi K2.5はKimiの最も汎用性の高いモデルで、ネイティブのマルチモーダルアーキテクチャを備え、視覚とテキスト入力をサポートします。「思考」モードと「非思考」モード、会話およびエージェントタスクの両方に対応しています。",
   "kimi-k2.description": "Kimi-K2 は Moonshot AI による MoE ベースモデルで、強力なコーディングおよびエージェント機能を備えています。総パラメータ数は 1T、アクティブは 32B。一般的な推論、コーディング、数学、エージェントタスクのベンチマークにおいて、他の主流のオープンモデルを上回る性能を示します。",
   "kimi-k2:1t.description": "Kimi K2 は、Moonshot AI による大規模 MoE LLM で、総パラメータ数 1T、1回のフォワードパスでアクティブ 32B。高度なツール使用、推論、コード生成などのエージェント機能に最適化されています。",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1（期間限定無料）は、効率的なコーディングエージェントのためのコード理解と自動化に特化しています。",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32Kは、32,768トークンの中程度の長さのコンテキストをサポートし、長文ドキュメントや複雑な対話に最適で、コンテンツ制作、レポート、チャットシステムに適しています。",
   "moonshot-v1-8k-vision-preview.description": "Kimi Visionモデル（moonshot-v1-8k-vision-preview、moonshot-v1-32k-vision-preview、moonshot-v1-128k-vision-previewを含む）は、テキスト、色、物体の形状などの画像内容を理解できます。",
   "moonshot-v1-8k.description": "Moonshot V1 8Kは、短文生成に最適化されており、効率的なパフォーマンスで8,192トークンを処理し、短いチャット、メモ、迅速なコンテンツ作成に適しています。",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72Bは大規模RLで最適化されたオープンソースコードLLMで、堅牢で実用的なパッチを生成します。SWE-bench Verifiedで60.4%を記録し、バグ修正やコードレビューなどの自動ソフトウェアエンジニアリングタスクでオープンモデルの新記録を樹立しました。",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905は、最新かつ最強のKimi K2モデルです。1兆の総パラメータと32Bのアクティブパラメータを持つトップクラスのMoEモデルで、エージェント的なコーディング知能が強化され、ベンチマークや実世界のエージェントタスクで大きな成果を上げています。フロントエンドのコードの美しさと使いやすさも向上しています。",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinkingは、最新かつ最強のオープンソース思考モデルです。多段階推論の深さを大幅に拡張し、200～300回連続の安定したツール使用を維持します。Humanity's Last Exam（HLE）、BrowseComp、その他のベンチマークで新記録を樹立しました。コーディング、数学、論理、エージェントシナリオに優れています。約1兆の総パラメータを持つMoEアーキテクチャに基づき、256Kのコンテキストウィンドウとツール呼び出しをサポートします。",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711は、Kimiシリーズのインストラクションバリアントで、高品質なコード生成とツール使用に適しています。",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "次世代Qwenコーダーは、複雑なマルチファイルコード生成、デバッグ、高スループットエージェントワークフローに最適化されています。強力なツール統合と推論性能の向上を目指して設計されています。",
   "qwen3-coder-plus.description": "Qwenコードモデル。最新のQwen3-Coderシリーズは、Qwen3をベースにしており、自律的なプログラミングのための強力なコードエージェント機能、ツール使用、環境との対話を提供します。優れたコード性能と堅実な汎用能力を備えています。",
   "qwen3-coder:480b.description": "エージェントおよびコーディングタスク向けのAlibabaの高性能長文コンテキストモデルです。",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: 複雑で多段階のコーディングタスクにおいて思考サポートを備えた最高性能のQwenモデル。",
   "qwen3-max-preview.description": "複雑で多段階のタスクに対応する最高性能のQwenモデル。プレビュー版は思考機能をサポートします。",
   "qwen3-max.description": "Qwen3 Maxモデルは、2.5シリーズに比べて汎用能力、中国語/英語理解、複雑な指示の追従、主観的なオープンタスク、多言語対応、ツール使用において大幅な向上を実現し、幻覚の発生も抑制されています。最新のqwen3-maxは、qwen3-max-previewよりもエージェントプログラミングとツール使用が改善されており、分野別SOTAに到達し、より複雑なエージェントニーズに対応します。",
   "qwen3-next-80b-a3b-instruct.description": "次世代のQwen3非思考型オープンソースモデル。前バージョン（Qwen3-235B-A22B-Instruct-2507）と比較して、中国語理解、論理的推論、テキスト生成が向上しています。",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQは、Qwenファミリーの推論モデルです。標準的な指示調整モデルと比較して、思考と推論能力に優れ、特に難解な問題において下流性能を大幅に向上させます。QwQ-32Bは、DeepSeek-R1やo1-miniと競合する中規模の推論モデルです。",
   "qwq_32b.description": "Qwenファミリーの中規模推論モデル。標準的な指示調整モデルと比較して、QwQの思考と推論能力は、特に難解な問題において下流性能を大幅に向上させます。",
   "r1-1776.description": "R1-1776は、DeepSeek R1のポストトレーニングバリアントで、検閲のない偏りのない事実情報を提供するよう設計されています。",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro by ByteDanceはテキストからビデオ、画像からビデオ（最初のフレーム、最初+最後のフレーム）、視覚と同期した音声生成をサポートします。",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite by BytePlusはリアルタイム情報のためのウェブ検索補強生成、複雑なプロンプト解釈の強化、プロフェッショナルな視覚制作のための参照一貫性の向上を特徴としています。",
   "solar-mini-ja.description": "Solar Mini (Ja)は、Solar Miniを日本語に特化させたモデルで、英語と韓国語でも効率的かつ高性能な動作を維持します。",
   "solar-mini.description": "Solar Miniは、GPT-3.5を上回る性能を持つコンパクトなLLMで、英語と韓国語に対応した多言語機能を備え、効率的な小型ソリューションを提供します。",
   "solar-pro.description": "Solar Proは、Upstageが提供する高知能LLMで、単一GPU上での指示追従に特化し、IFEvalスコア80以上を記録しています。現在は英語に対応しており、2024年11月の正式リリースでは対応言語とコンテキスト長が拡張される予定です。",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "Stepfunのフラッグシップ言語推論モデル。このモデルは、トップクラスの推論能力と迅速かつ信頼性の高い実行能力を備えています。複雑なタスクを分解して計画し、ツールを迅速かつ確実に呼び出してタスクを実行し、論理推論、数学、ソフトウェアエンジニアリング、深い研究などのさまざまな複雑なタスクに対応できます。",
   "step-3.description": "このモデルは優れた視覚認識と複雑な推論能力を持ち、分野横断的な知識理解、数学と視覚の複合分析、日常的な視覚分析タスクに正確に対応します。",
   "step-r1-v-mini.description": "画像理解に優れた推論モデルで、画像とテキストを処理し、深い推論を経てテキストを生成します。視覚的推論に強く、数学、コーディング、テキスト推論において最高水準の性能を発揮し、100K のコンテキストウィンドウに対応します。",
+  "stepfun-ai/step3.description": "Step3はStepFunによる最先端のマルチモーダル推論モデルで、総パラメータ321B、アクティブパラメータ38Bを持つMoEアーキテクチャに基づいています。そのエンドツーエンド設計によりデコードコストを最小化しながら、トップレベルの視覚言語推論を提供します。MFAとAFD設計により、フラッグシップおよび低エンドアクセラレータの両方で効率を維持します。事前トレーニングには20T以上のテキストトークンと4Tの画像テキストトークンが多言語で使用されます。数学、コード、マルチモーダルベンチマークでオープンモデルの最高性能を達成しています。",
   "taichu4_vl_2b_nothinking.description": "Taichu4.0-VL 2BモデルのNo-Thinkingバージョンは、メモリ使用量が少なく、軽量設計、高速応答速度、強力なマルチモーダル理解能力を特徴としています。",
   "taichu4_vl_32b.description": "Taichu4.0-VL 32BモデルのThinkingバージョンは、複雑なマルチモーダル理解と推論タスクに適しており、マルチモーダル数学的推論、マルチモーダルエージェント能力、一般的な画像および視覚理解において優れた性能を示します。",
   "taichu4_vl_32b_nothinking.description": "Taichu4.0-VL 32BモデルのNo-Thinkingバージョンは、複雑な画像とテキストの理解および視覚知識QAシナリオ向けに設計されており、画像キャプション、視覚的質問応答、ビデオ理解、視覚的ローカリゼーションタスクに優れています。",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Airは、Mixture-of-Expertsアーキテクチャを採用したエージェントアプリケーション向けのベースモデルです。ツール使用、Webブラウジング、ソフトウェア開発、フロントエンドコーディングに最適化されており、Claude CodeやRoo Codeなどのコードエージェントと統合可能です。ハイブリッド推論により、複雑な推論と日常的なシナリオの両方に対応します。",
   "zai-org/GLM-4.5V.description": "GLM-4.5Vは、GLM-4.5-AirをベースにしたZhipu AIの最新VLMで、106B総パラメータ（12Bアクティブ）のMoEアーキテクチャを採用し、低コストで高性能を実現しています。GLM-4.1V-Thinkingの系譜を継承し、3D-RoPEにより3D空間推論を強化。事前学習、SFT、RLを通じて最適化され、画像、動画、長文文書を処理可能。41の公開マルチモーダルベンチマークでトップクラスの評価を獲得。Thinkingモードの切り替えにより、速度と深さのバランスを調整可能です。",
   "zai-org/GLM-4.6.description": "GLM-4.5と比較して、GLM-4.6はコンテキスト長を128Kから200Kに拡張し、より複雑なエージェントタスクに対応。コードベンチマークで高スコアを記録し、Claude Code、Cline、Roo Code、Kilo Codeなどのアプリで実用性能が向上。推論能力が強化され、推論中のツール使用も可能に。エージェントフレームワークへの統合性が向上し、ツール/検索エージェントの性能が強化。人間に好まれる文体やロールプレイの自然さも向上しています。",
+  "zai-org/GLM-4.6V.description": "GLM-4.6VはそのパラメータスケールにおいてSOTAの視覚理解精度を達成し、視覚モデルアーキテクチャにFunction Call機能をネイティブに統合した初のモデルです。「視覚的知覚」から「実行可能なアクション」へのギャップを埋め、実際のビジネスシナリオにおけるマルチモーダルエージェントの統一的な技術基盤を提供します。視覚コンテキストウィンドウは128kに拡張され、長いビデオストリーム処理や高解像度の複数画像分析をサポートします。",
   "zai/glm-4.5-air.description": "GLM-4.5およびGLM-4.5-Airは、エージェントアプリケーション向けの最新フラッグシップモデルで、いずれもMoEを採用。GLM-4.5は総パラメータ355B（32Bアクティブ）、GLM-4.5-Airはよりスリムな106B（12Bアクティブ）構成です。",
   "zai/glm-4.5.description": "GLM-4.5シリーズはエージェント向けに設計されており、フラッグシップのGLM-4.5は推論、コーディング、エージェントスキルを統合し、355B総パラメータ（32Bアクティブ）を持つハイブリッド推論システムとしてデュアル動作モードを提供します。",
   "zai/glm-4.5v.description": "GLM-4.5Vは、GLM-4.5-Airをベースに、実績あるGLM-4.1V-Thinking技術を継承し、強力な106BパラメータのMoEアーキテクチャでスケーリングされています。",

locales/ja-JP/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azureは、GPT-3.5およびGPT-4シリーズを含む高度なAIモデルを提供し、多様なデータタイプと複雑なタスクに対応。安全性、信頼性、持続可能性に重点を置いています。",
   "azureai.description": "Azureは、GPT-3.5およびGPT-4シリーズを含む高度なAIモデルを提供し、多様なデータタイプと複雑なタスクに対応。安全性、信頼性、持続可能性に重点を置いています。",
   "baichuan.description": "Baichuan AIは、中国語知識に強く、長文コンテキスト処理や創造的生成に優れた基盤モデルに注力しています。Baichuan 4、Baichuan 3 Turbo、Baichuan 3 Turbo 128kなど、さまざまなシナリオに最適化された高性能モデルを提供します。",
+  "bailiancodingplan.description": "阿里云百炼编码计划は、Qwen、GLM、Kimi、MiniMaxのコード最適化モデルに専用エンドポイントを通じてアクセスできる専門的なAIコーディングサービスです。",
   "bedrock.description": "Amazon Bedrockは、Anthropic ClaudeやMeta Llama 3.1などの高度な言語・ビジョンモデルを企業向けに提供し、軽量から高性能まで、テキスト、チャット、画像タスクに対応します。",
   "bfl.description": "次世代の視覚インフラを構築する先端AI研究所です。",
   "cerebras.description": "Cerebrasは、CS-3システム上に構築された推論プラットフォームで、コード生成やエージェントタスクなどのリアルタイム処理において超低遅延・高スループットのLLMサービスを提供します。",
@@ -21,6 +22,7 @@
   "giteeai.description": "Gitee AIのサーバーレスAPIは、開発者向けに即時利用可能なLLM推論サービスを提供します。",
   "github.description": "GitHub Modelsを使えば、開発者は業界最先端のモデルを活用してAIエンジニアとして開発できます。",
   "githubcopilot.description": "GitHub Copilot サブスクリプションを通じて、Claude、GPT、Gemini モデルにアクセスできます。",
+  "glmcodingplan.description": "GLMコーディングプランは、固定料金のサブスクリプションを通じてGLM-5およびGLM-4.7を含む智譜AIモデルへのアクセスを提供します。",
   "google.description": "GoogleのGeminiファミリーは、Google DeepMindが開発した最先端の汎用AIで、テキスト、コード、画像、音声、動画に対応するマルチモーダルAIです。データセンターからモバイルデバイスまでスケーラブルに展開可能です。",
   "groq.description": "GroqのLPU推論エンジンは、卓越した速度と効率でベンチマーク性能を発揮し、低遅延・クラウドベースのLLM推論において高い基準を打ち立てています。",
   "higress.description": "Higressは、Alibaba社内で開発されたクラウドネイティブAPIゲートウェイで、Tengineのリロードによる長時間接続への影響やgRPC/Dubboの負荷分散の課題を解決します。",
@@ -29,9 +31,12 @@
   "infiniai.description": "アプリ開発者向けに、モデル開発から本番展開までの全工程をカバーする高性能・使いやすく・安全なLLMサービスを提供します。",
   "internlm.description": "InternLMは、大規模モデルの研究とツール開発に特化したオープンソース組織で、最先端のモデルとアルゴリズムを誰でも使いやすく提供します。",
   "jina.description": "Jina AIは2020年に設立された検索AIのリーディングカンパニーで、ベクトルモデル、リランカー、小型言語モデルを含む検索スタックにより、高品質な生成・マルチモーダル検索アプリを構築できます。",
+  "kimicodingplan.description": "Moonshot AIのKimi Codeは、K2.5を含むKimiモデルへのアクセスを提供します。",
   "lmstudio.description": "LM Studioは、ローカルPC上でLLMの開発と実験ができるデスクトップアプリです。",
+  "lobehub.description": "LobeHub Cloudは公式APIを使用してAIモデルにアクセスし、モデルトークンに紐づけられたクレジットで使用量を測定します。",
   "longcat.description": "LongCatは、Meituanが独自に開発した生成AIの大型モデルシリーズです。効率的な計算アーキテクチャと強力なマルチモーダル機能を通じて、企業内部の生産性を向上させ、革新的なアプリケーションを可能にすることを目的としています。",
   "minimax.description": "MiniMaxは2021年に設立され、マルチモーダル基盤モデルを用いた汎用AIを開発しています。兆単位パラメータのMoEテキストモデル、音声モデル、ビジョンモデル、Hailuo AIなどのアプリを提供します。",
+  "minimaxcodingplan.description": "MiniMaxトークンプランは、固定料金のサブスクリプションを通じてM2.7を含むMiniMaxモデルへのアクセスを提供します。",
   "mistral.description": "Mistralは、複雑な推論、多言語タスク、コード生成に対応した高度な汎用・専門・研究モデルを提供し、関数呼び出しによるカスタム統合も可能です。",
   "modelscope.description": "ModelScopeは、Alibaba Cloudが提供するモデル・アズ・ア・サービス（MaaS）プラットフォームで、幅広いAIモデルと推論サービスを提供します。",
   "moonshot.description": "Moonshot AI（北京月之暗面科技）のMoonshotは、コンテンツ生成、研究、レコメンド、医療分析などの用途に対応した複数のNLPモデルを提供し、長文コンテキストや複雑な生成に強みを持ちます。",
@@ -64,6 +69,7 @@
   "vertexai.description": "GoogleのGeminiファミリーは、Google DeepMindが開発した最先端の汎用AIで、テキスト、コード、画像、音声、動画に対応するマルチモーダルAIです。データセンターからモバイルデバイスまでスケーラブルに展開可能で、効率性と柔軟な導入を実現します。",
   "vllm.description": "vLLMは、高速かつ使いやすいLLM推論・提供ライブラリです。",
   "volcengine.description": "ByteDanceのモデルサービスプラットフォームで、安全性が高く、機能豊富でコスト競争力のあるモデルアクセスと、データ、ファインチューニング、推論、評価のエンドツーエンドツールを提供します。",
+  "volcenginecodingplan.description": "ByteDanceのVolcengineコーディングプランは、固定料金のサブスクリプションを通じてDoubao-Seed-Code、GLM-4.7、DeepSeek-V3.2、Kimi-K2.5を含む複数のコーディングモデルへのアクセスを提供します。",
   "wenxin.description": "Wenxinは、基盤モデルとAIネイティブアプリ開発のための企業向けオールインワンプラットフォームで、生成AIモデルとアプリケーションのワークフローを支えるエンドツーエンドツールを提供します。",
   "xai.description": "xAIは、科学的発見を加速し、人類の宇宙理解を深めることを使命とするAIを開発しています。",
   "xiaomimimo.description": "Xiaomi MiMo は、OpenAI 互換の API を備えた会話型モデルサービスを提供します。mimo-v2-flash モデルは、高度な推論、ストリーミング出力、関数呼び出し、256K のコンテキストウィンドウ、および最大 128K の出力に対応しています。",

locales/ja-JP/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "クレジットカード / Alipay / WeChat Pay に対応",
   "plans.btn.paymentDescForZarinpal": "クレジットカードに対応",
   "plans.btn.soon": "近日公開",
+  "plans.cancelDowngrade": "予定されたダウングレードをキャンセル",
+  "plans.cancelDowngradeSuccess": "予定されたダウングレードがキャンセルされました",
   "plans.changePlan": "プランを選択",
   "plans.cloud.history": "無制限の会話履歴",
   "plans.cloud.sync": "グローバルクラウド同期",
@@ -215,6 +217,7 @@
   "plans.current": "現在のプラン",
   "plans.downgradePlan": "ダウングレード先プラン",
   "plans.downgradeTip": "すでにプランの切り替えを行っています。完了するまで他の操作はできません。",
+  "plans.downgradeWillCancel": "この操作は予定されたプランのダウングレードをキャンセルします",
   "plans.embeddingStorage.embeddings": "エントリ",
   "plans.embeddingStorage.title": "ベクトルストレージ",
   "plans.embeddingStorage.tooltip": "1ページのドキュメント（1000〜1500文字）は約1つのベクトルエントリを生成します（OpenAI Embeddingsを基にした推定。モデルにより異なる場合があります）",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "選択を確定",
   "plans.payonce.popconfirm": "一括払い後は、サブスクリプションの有効期限が切れるまでプラン変更や請求サイクルの変更はできません。選択内容をご確認ください。",
   "plans.payonce.tooltip": "一括払いでは、サブスクリプションの有効期限までプラン変更や請求サイクルの変更ができません",
+  "plans.pendingDowngrade": "ダウングレード保留中",
   "plans.plan.enterprise.contactSales": "営業に問い合わせる",
   "plans.plan.enterprise.title": "エンタープライズ版",
   "plans.plan.free.desc": "初めてのユーザー向け",
@@ -366,6 +370,7 @@
   "summary.title": "請求概要",
   "summary.usageThisMonth": "今月の使用状況を見る",
   "summary.viewBillingHistory": "支払い履歴を見る",
+  "switchDowngradeTarget": "ダウングレード対象を変更",
   "switchPlan": "プランを切り替える",
   "switchToMonthly.desc": "切り替え後、現在の年額プランの有効期限終了後に月額請求が適用されます。",
   "switchToMonthly.title": "月額請求に切り替え",

locales/ko-KR/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "연결 실패",
   "sync.title": "동기화 상태",
   "sync.unconnected.tip": "시그널링 서버 연결 실패로 P2P 통신 채널을 생성할 수 없습니다. 네트워크를 확인한 후 다시 시도하세요",
-  "tab.aiImage": "그림",
   "tab.audio": "오디오",
   "tab.chat": "채팅",
   "tab.community": "커뮤니티",
@@ -405,6 +404,7 @@
   "tab.eval": "평가 연구소",
   "tab.files": "파일",
   "tab.home": "홈",
+  "tab.image": "이미지",
   "tab.knowledgeBase": "자료실",
   "tab.marketplace": "마켓플레이스",
   "tab.me": "내 정보",

locales/ko-KR/modelProvider.json

@@ -231,6 +231,8 @@
   "providerModels.item.modelConfig.extendParams.options.imageResolution.hint": "Gemini 3 이미지 생성 모델용; 생성된 이미지의 해상도를 제어합니다.",
   "providerModels.item.modelConfig.extendParams.options.imageResolution2.hint": "Gemini 3.1 Flash Image 모델용; 생성된 이미지의 해상도를 제어합니다 (512px 지원).",
   "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken.hint": "Claude, Qwen3 등과 유사한 모델용; 추론에 사용할 토큰 예산을 제어합니다.",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken32k.hint": "GLM-5 및 GLM-4.7용; 추론을 위한 토큰 예산을 제어합니다(최대 32k).",
+  "providerModels.item.modelConfig.extendParams.options.reasoningBudgetToken80k.hint": "Qwen3 시리즈용; 추론을 위한 토큰 예산을 제어합니다(최대 80k).",
   "providerModels.item.modelConfig.extendParams.options.reasoningEffort.hint": "OpenAI 및 기타 추론 가능한 모델용; 추론 노력의 정도를 제어합니다.",
   "providerModels.item.modelConfig.extendParams.options.textVerbosity.hint": "GPT-5+ 시리즈용; 출력의 상세 정도를 제어합니다.",
   "providerModels.item.modelConfig.extendParams.options.thinking.hint": "일부 Doubao 모델용; 모델이 깊이 사고할지 여부를 스스로 결정하도록 허용합니다.",

locales/ko-KR/models.json

@@ -53,6 +53,12 @@
   "FLUX.1-Kontext-dev.description": "FLUX.1-Kontext-dev는 Black Forest Labs에서 개발한 다중 모달 이미지 생성 및 편집 모델로, 120억 매개변수의 Rectified Flow Transformer 아키텍처를 기반으로 합니다. 주어진 문맥 조건 하에서 이미지 생성, 복원, 향상, 편집을 수행하며, 디퓨전 모델의 제어 가능한 생성 능력과 트랜스포머 기반 문맥 모델링을 결합하여 인페인팅, 아웃페인팅, 시각적 장면 복원 등 고품질 작업을 지원합니다.",
   "FLUX.1-Kontext-pro.description": "FLUX.1 Kontext [pro]",
   "FLUX.1-dev.description": "FLUX.1-dev는 Black Forest Labs에서 개발한 오픈소스 다중 모달 언어 모델(MLLM)로, 이미지-텍스트 작업에 최적화되어 있으며 이미지/텍스트 이해 및 생성을 결합합니다. Mistral-7B와 같은 고급 LLM을 기반으로, 정교한 비전 인코더와 다단계 지시 튜닝을 통해 다중 모달 조정 및 복잡한 작업 추론을 가능하게 합니다.",
+  "GLM-4.5-Air.description": "GLM-4.5-Air: 빠른 응답을 위한 경량 버전.",
+  "GLM-4.5.description": "GLM-4.5: 추론, 코딩 및 에이전트 작업을 위한 고성능 모델.",
+  "GLM-4.6.description": "GLM-4.6: 이전 세대 모델.",
+  "GLM-4.7.description": "GLM-4.7은 Zhipu의 최신 플래그십 모델로, 에이전트 코딩 시나리오를 위해 향상된 코딩 기능, 장기 작업 계획 및 도구 협업을 제공합니다.",
+  "GLM-5-Turbo.description": "GLM-5-Turbo: 코딩 작업을 위한 추론 속도가 최적화된 GLM-5의 버전.",
+  "GLM-5.description": "GLM-5는 Zhipu의 차세대 플래그십 기초 모델로, 에이전트 엔지니어링을 위해 설계되었습니다. 복잡한 시스템 엔지니어링 및 장기 에이전트 작업에서 신뢰할 수 있는 생산성을 제공합니다. 코딩 및 에이전트 기능에서 GLM-5는 오픈소스 모델 중 최첨단 성능을 달성합니다.",
   "Gryphe/MythoMax-L2-13b.description": "MythoMax-L2 (13B)는 다양한 분야와 복잡한 작업을 위한 혁신적인 모델입니다.",
   "HY-Image-V3.0.description": "강력한 원본 이미지 특징 추출 및 세부 보존 기능을 통해 풍부한 시각적 텍스처를 제공하며, 높은 정확도와 잘 구성된 제작 등급의 비주얼을 생성합니다.",
   "HelloMeme.description": "HelloMeme은 사용자가 제공한 이미지나 동작을 기반으로 밈, GIF, 짧은 영상을 생성하는 AI 도구입니다. 그림이나 코딩 기술 없이도 참조 이미지 하나만으로 재미있고 매력적이며 스타일이 일관된 콘텐츠를 만들 수 있습니다.",
@@ -82,10 +88,17 @@
   "MiniMax-M1.description": "80K 체인 오브 싱킹과 100만 입력을 지원하는 새로운 자체 개발 추론 모델로, 세계 최고 수준의 모델과 유사한 성능을 제공합니다.",
   "MiniMax-M2-Stable.description": "상업적 사용을 위한 높은 동시성을 제공하며, 효율적인 코딩 및 에이전트 워크플로우에 최적화되어 있습니다.",
   "MiniMax-M2.1-Lightning.description": "강력한 다국어 프로그래밍 기능과 전면적으로 업그레이드된 코딩 경험. 더 빠르고 효율적입니다.",
+  "MiniMax-M2.1-highspeed.description": "강력한 다국어 프로그래밍 기능과 더 빠르고 효율적인 추론.",
   "MiniMax-M2.1.description": "MiniMax-M2.1은 MiniMax에서 개발한 대표적인 오픈소스 대형 모델로, 복잡한 실제 과제를 해결하는 데 중점을 둡니다. 다국어 프로그래밍 능력과 에이전트로서 복잡한 작업을 수행하는 능력이 핵심 강점입니다.",
   "MiniMax-M2.5-Lightning.description": "M2.5 Lightning: 동일한 성능, 더 빠르고 민첩한 속도 (약 100 tps).",
+  "MiniMax-M2.5-highspeed.description": "MiniMax M2.5 Highspeed: M2.5와 동일한 성능을 제공하며 추론 속도가 더 빠릅니다.",
   "MiniMax-M2.5.description": "MiniMax-M2.5는 MiniMax의 플래그십 오픈 소스 대형 모델로, 복잡한 실제 과제를 해결하는 데 중점을 둡니다. 이 모델의 핵심 강점은 다중 언어 프로그래밍 기능과 에이전트로서 복잡한 작업을 해결하는 능력입니다.",
+  "MiniMax-M2.7-highspeed.description": "MiniMax M2.7 Highspeed: M2.7과 동일한 성능을 제공하며 추론 속도가 크게 향상되었습니다.",
+  "MiniMax-M2.7.description": "MiniMax M2.7: 재귀적 자기 개선의 여정을 시작하며, 최고 수준의 실제 엔지니어링 기능을 제공합니다.",
+  "MiniMax-M2.description": "MiniMax M2: 이전 세대 모델.",
   "MiniMax-Text-01.description": "MiniMax-01은 기존 트랜스포머를 넘어선 대규모 선형 어텐션을 도입한 모델로, 4560억 파라미터 중 459억이 활성화됩니다. 최대 400만 토큰의 문맥을 지원하며, GPT-4o의 32배, Claude-3.5-Sonnet의 20배에 해당합니다.",
+  "MiniMaxAI/MiniMax-M1-80k.description": "MiniMax-M1은 456B 총 매개변수와 토큰당 약 45.9B 활성 매개변수를 가진 오픈 가중치 대규모 하이브리드 주의 추론 모델입니다. 1M 컨텍스트를 기본적으로 지원하며, Flash Attention을 사용하여 DeepSeek R1 대비 100K 토큰 생성 시 FLOPs를 75% 절감합니다. MoE 아키텍처와 CISPO 및 하이브리드 주의 RL 훈련을 통해 긴 입력 추론 및 실제 소프트웨어 엔지니어링 작업에서 선도적인 성능을 달성합니다.",
+  "MiniMaxAI/MiniMax-M2.description": "MiniMax-M2는 에이전트 효율성을 재정의합니다. 230B 총 매개변수와 10B 활성 매개변수를 가진 컴팩트하고 빠르며 비용 효율적인 MoE 모델로, 최고 수준의 코딩 및 에이전트 작업을 위해 설계되었으며 강력한 일반 지능을 유지합니다. 활성 매개변수가 10B에 불과하지만 훨씬 더 큰 모델과 경쟁하며 고효율 애플리케이션에 이상적입니다.",
   "Moonshot-Kimi-K2-Instruct.description": "총 1조 파라미터 중 320억이 활성화되는 모델로, 비사고형 모델 중 최상위 수준의 최신 지식, 수학, 코딩 성능을 보이며, 일반 에이전트 작업에서도 강력한 성능을 발휘합니다. 에이전트 워크로드에 최적화되어 단순한 응답을 넘어 행동 수행이 가능하며, 즉흥적이고 일반적인 대화 및 에이전트 경험에 적합한 반사 수준의 모델입니다.",
   "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO.description": "Nous Hermes 2 - Mixtral 8x7B-DPO (46.7B)는 복잡한 계산을 위한 고정밀 지시 모델입니다.",
   "OmniConsistency.description": "OmniConsistency는 대규모 Diffusion Transformer(DiT)와 스타일이 적용된 쌍 데이터셋을 도입하여 이미지-투-이미지 작업에서 스타일 일관성과 일반화를 향상시키며, 스타일 저하를 방지합니다.",
@@ -99,12 +112,14 @@
   "Phi-3.5-mini-instruct.description": "Phi-3-mini 모델의 업데이트 버전입니다.",
   "Phi-3.5-vision-instrust.description": "Phi-3-vision 모델의 업데이트 버전입니다.",
   "Pro/MiniMaxAI/MiniMax-M2.1.description": "MiniMax-M2.1은 에이전트 기능에 최적화된 오픈소스 대형 언어 모델로, 프로그래밍, 도구 사용, 지시 따르기, 장기 계획 수립에 뛰어난 성능을 보입니다. 이 모델은 다국어 소프트웨어 개발과 복잡한 다단계 워크플로우 실행을 지원하며, SWE-bench Verified에서 74.0점을 기록하고 다국어 시나리오에서 Claude Sonnet 4.5를 능가합니다.",
+  "Pro/MiniMaxAI/MiniMax-M2.5.description": "MiniMax-M2.5는 MiniMax가 개발한 최신 대규모 언어 모델로, 수십만 개의 복잡한 실제 환경에서 대규모 강화 학습을 통해 훈련되었습니다. 229억 개의 매개변수를 가진 MoE 아키텍처를 특징으로 하며, 프로그래밍, 에이전트 도구 호출, 검색 및 사무 시나리오와 같은 작업에서 업계 최고 성능을 달성합니다.",
   "Pro/Qwen/Qwen2-7B-Instruct.description": "Qwen2-7B-Instruct는 Qwen2 시리즈의 70억 매개변수 기반 지시 조정 LLM입니다. Transformer 아키텍처를 기반으로 SwiGLU, attention QKV bias, grouped-query attention을 사용하며, 대용량 입력을 처리할 수 있습니다. 언어 이해, 생성, 다국어 작업, 코딩, 수학, 추론 등 다양한 분야에서 강력한 성능을 발휘하며, 대부분의 오픈 모델을 능가하고 상용 모델과 경쟁합니다. 여러 벤치마크에서 Qwen1.5-7B-Chat을 능가합니다.",
   "Pro/Qwen/Qwen2.5-7B-Instruct.description": "Qwen2.5-7B-Instruct는 알리바바 클라우드의 최신 LLM 시리즈 중 하나입니다. 70억 매개변수 모델로 코딩과 수학에서 눈에 띄는 성능 향상을 보이며, 29개 이상의 언어를 지원합니다. 지시 따르기, 구조화된 데이터 이해, 구조화된 출력(특히 JSON) 생성 능력이 향상되었습니다.",
   "Pro/Qwen/Qwen2.5-Coder-7B-Instruct.description": "Qwen2.5-Coder-7B-Instruct는 알리바바 클라우드의 최신 코드 특화 LLM입니다. Qwen2.5를 기반으로 5.5조 토큰으로 학습되었으며, 코드 생성, 추론, 수정 능력을 크게 향상시켰습니다. 수학 및 일반적인 능력도 유지하며, 코딩 에이전트를 위한 강력한 기반을 제공합니다.",
   "Pro/Qwen/Qwen2.5-VL-7B-Instruct.description": "Qwen2.5-VL은 Qwen 시리즈의 새로운 비전-언어 모델로, 강력한 시각적 이해 능력을 갖추고 있습니다. 이미지 내 텍스트, 차트, 레이아웃을 분석하고, 긴 영상과 이벤트를 이해하며, 추론 및 도구 사용, 다양한 형식의 객체 정렬, 구조화된 출력 등을 지원합니다. 동적 해상도 및 프레임 속도 학습을 통해 영상 이해를 개선하고, 비전 인코더 효율성을 높였습니다.",
   "Pro/THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking은 Zhipu AI와 칭화대 KEG 연구실이 공동 개발한 오픈소스 VLM으로, 복잡한 멀티모달 인지를 위해 설계되었습니다. GLM-4-9B-0414를 기반으로 체인 오브 쏘트 추론과 강화 학습(RL)을 추가하여 교차 모달 추론과 안정성을 크게 향상시켰습니다.",
   "Pro/THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat은 Zhipu AI의 오픈소스 GLM-4 모델입니다. 의미 이해, 수학, 추론, 코드, 지식 등 다양한 분야에서 강력한 성능을 보입니다. 다중 턴 대화 외에도 웹 검색, 코드 실행, 사용자 정의 도구 호출, 장문 추론을 지원합니다. 중국어, 영어, 일본어, 한국어, 독일어 등 26개 언어를 지원하며, AlignBench-v2, MT-Bench, MMLU, C-Eval 등에서 우수한 성능을 보이고, 최대 128K 컨텍스트를 지원하여 학술 및 비즈니스 용도에 적합합니다.",
+  "Pro/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B는 Qwen2.5-Math-7B에서 증류되고 80만 개의 큐레이션된 DeepSeek-R1 샘플로 미세 조정되었습니다. MATH-500에서 92.8%, AIME 2024에서 55.5%, CodeForces에서 1189 점수를 기록하며 7B 모델로 강력한 성능을 발휘합니다.",
   "Pro/deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1은 반복을 줄이고 가독성을 높이기 위해 강화 학습(RL)을 적용한 추론 모델입니다. RL 이전에는 cold-start 데이터를 사용하여 추론 능력을 더욱 향상시켰으며, 수학, 코드, 추론 작업에서 OpenAI-o1과 유사한 성능을 보입니다. 정교한 학습을 통해 전반적인 성능을 개선했습니다.",
   "Pro/deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus는 하이브리드 에이전트 LLM으로 포지셔닝된 V3.1 모델의 업데이트 버전입니다. 사용자 피드백을 반영하여 안정성, 언어 일관성, 중문/영문 혼합 및 비정상 문자 문제를 개선했습니다. 사고 모드와 비사고 모드를 통합하고, 채팅 템플릿을 통해 유연한 전환이 가능합니다. 또한 코드 에이전트와 검색 에이전트의 성능을 향상시켜 도구 사용과 다단계 작업의 신뢰성을 높였습니다.",
   "Pro/deepseek-ai/DeepSeek-V3.2.description": "DeepSeek-V3.2는 높은 계산 효율성과 뛰어난 추론 및 에이전트 성능을 결합한 모델입니다. 이 모델은 세 가지 주요 기술적 돌파구를 기반으로 합니다: 계산 복잡성을 크게 줄이면서 모델 성능을 유지하는 효율적인 주의 메커니즘인 DeepSeek Sparse Attention(DSA), 긴 컨텍스트 시나리오에 최적화된 확장 가능한 강화 학습 프레임워크, 그리고 도구 사용 시나리오에 추론 능력을 통합하여 복잡한 상호작용 환경에서 지침 준수 및 일반화를 개선하는 대규모 에이전트 작업 합성 파이프라인. 이 모델은 2025년 국제 수학 올림피아드(IMO)와 국제 정보 올림피아드(IOI)에서 금메달 성과를 달성했습니다.",
@@ -112,8 +127,10 @@
   "Pro/moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905는 최신이자 가장 강력한 Kimi K2 모델입니다. 총 1조, 활성 320억 매개변수를 가진 최상급 MoE 모델로, 에이전트 기반 코딩 지능이 강화되어 벤치마크 및 실제 에이전트 작업에서 큰 성능 향상을 보입니다. 프론트엔드 코드의 미적 품질과 사용성도 개선되었습니다.",
   "Pro/moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking Turbo는 추론 속도와 처리량을 최적화한 Turbo 버전으로, K2 Thinking의 다단계 추론 및 도구 사용 능력을 유지합니다. 약 1조 매개변수를 가진 MoE 모델로, 기본 256K 컨텍스트를 지원하며, 대규모 도구 호출이 필요한 실시간 및 동시성 높은 환경에 적합합니다.",
   "Pro/moonshotai/Kimi-K2.5.description": "Kimi K2.5는 Kimi-K2-Base를 기반으로 구축된 오픈소스 네이티브 멀티모달 에이전트 모델로, 약 1.5조 개의 비전 및 텍스트 토큰으로 학습되었습니다. MoE 아키텍처를 채택하여 총 1조 파라미터 중 320억 개가 활성화되며, 256K 컨텍스트 윈도우를 지원하여 비전과 언어 이해를 자연스럽게 통합합니다.",
+  "Pro/zai-org/glm-4.7.description": "GLM-4.7은 Zhipu의 새로운 세대 플래그십 모델로, 355B 총 매개변수와 32B 활성 매개변수를 가지고 있으며 일반 대화, 추론 및 에이전트 기능에서 완전히 업그레이드되었습니다. GLM-4.7은 교차적 사고를 강화하고 보존적 사고 및 턴 수준 사고를 도입합니다.",
   "Pro/zai-org/glm-5.description": "GLM-5는 Zhipu의 차세대 대형 언어 모델로, 복잡한 시스템 엔지니어링과 장기 지속 에이전트 작업에 중점을 둡니다. 모델 파라미터는 7440억 개(활성화된 40억 개)로 확장되었으며, DeepSeek Sparse Attention을 통합합니다.",
   "QwQ-32B-Preview.description": "Qwen QwQ는 추론 능력 향상을 목표로 한 실험적 연구 모델입니다.",
+  "Qwen/QVQ-72B-Preview.description": "QVQ-72B-Preview는 복잡한 장면 이해와 시각적 수학 문제에서 강점을 가진 Qwen의 시각적 추론 연구 모델입니다.",
   "Qwen/QwQ-32B-Preview.description": "Qwen QwQ는 AI 추론 능력 향상을 목표로 한 실험적 연구 모델입니다.",
   "Qwen/QwQ-32B.description": "QwQ는 Qwen 계열의 추론 특화 모델입니다. 일반적인 지시 조정 모델과 비교해 사고 및 추론 능력이 추가되어, 특히 어려운 문제에서 다운스트림 성능을 크게 향상시킵니다. QwQ-32B는 DeepSeek-R1 및 o1-mini와 경쟁할 수 있는 중형 추론 모델로, RoPE, SwiGLU, RMSNorm, attention QKV bias를 사용하며, 64개 레이어와 40개의 Q attention 헤드(8개 KV in GQA)를 갖추고 있습니다.",
   "Qwen/Qwen-Image-Edit-2509.description": "Qwen-Image-Edit-2509는 Qwen 팀의 Qwen-Image 최신 편집 버전입니다. 200억 매개변수의 Qwen-Image 모델을 기반으로, 강력한 텍스트 렌더링 기능을 이미지 편집으로 확장하여 정밀한 텍스트 편집을 지원합니다. Qwen2.5-VL을 통한 의미 제어와 VAE 인코더를 통한 외형 제어를 결합한 이중 제어 아키텍처를 사용하여 의미 및 외형 수준의 편집이 가능합니다. 로컬 편집(추가/제거/수정)뿐 아니라 IP 생성, 스타일 전환 등 고차원 의미 편집도 지원하며, 의미를 보존합니다. 여러 벤치마크에서 SOTA 성능을 달성했습니다.",
@@ -197,9 +214,11 @@
   "Skylark2-pro-turbo-8k.description": "Skylark 2세대 모델. Skylark2-pro-turbo-8k는 8K 컨텍스트 윈도우를 지원하며, 더 빠른 추론 속도와 낮은 비용을 제공합니다.",
   "THUDM/GLM-4-32B-0414.description": "GLM-4-32B-0414는 32B 파라미터를 가진 차세대 오픈 GLM 모델로, OpenAI GPT 및 DeepSeek V3/R1 시리즈와 유사한 성능을 보입니다.",
   "THUDM/GLM-4-9B-0414.description": "GLM-4-9B-0414는 GLM-4-32B의 기술을 계승하면서도 경량화된 배포가 가능한 9B GLM 모델입니다. 코드 생성, 웹 디자인, SVG 생성, 검색 기반 글쓰기 등에서 우수한 성능을 발휘합니다.",
+  "THUDM/GLM-4.1V-9B-Thinking.description": "GLM-4.1V-9B-Thinking은 Zhipu AI와 Tsinghua KEG Lab에서 개발한 오픈소스 VLM으로, 복잡한 멀티모달 인지를 위해 설계되었습니다. GLM-4-9B-0414을 기반으로 체인 오브 사고 추론과 RL을 추가하여 크로스모달 추론과 안정성을 크게 향상시킵니다.",
   "THUDM/GLM-Z1-32B-0414.description": "GLM-Z1-32B-0414는 GLM-4-32B-0414를 기반으로 수학, 코드, 논리 분야에 대한 추가 학습과 강화학습을 통해 수학 능력과 복잡한 문제 해결 능력을 대폭 향상시킨 심층 추론 모델입니다.",
   "THUDM/GLM-Z1-9B-0414.description": "GLM-Z1-9B-0414는 9B 파라미터를 가진 소형 GLM 모델로, 오픈소스의 강점을 유지하면서도 뛰어난 성능을 제공합니다. 수학 추론과 일반 작업에서 강력한 성능을 보이며, 동급 오픈 모델 중 선두를 차지합니다.",
   "THUDM/glm-4-9b-chat.description": "GLM-4-9B-Chat은 Zhipu AI의 오픈소스 GLM-4 모델로, 의미 이해, 수학, 추론, 코드, 지식 등 다양한 분야에서 강력한 성능을 보입니다. 다중 턴 대화 외에도 웹 검색, 코드 실행, 사용자 정의 도구 호출, 장문 추론을 지원하며, 중국어, 영어, 일본어, 한국어, 독일어 등 26개 언어를 지원합니다. AlignBench-v2, MT-Bench, MMLU, C-Eval 등에서 우수한 성과를 보이며, 학술 및 비즈니스 용도로 최대 128K 컨텍스트를 지원합니다.",
+  "Tongyi-Zhiwen/QwenLong-L1-32B.description": "QwenLong-L1-32B는 RL로 훈련된 최초의 장문 추론 모델(LRM)로, 장문 텍스트 추론에 최적화되었습니다. 점진적 컨텍스트 확장 RL을 통해 짧은 컨텍스트에서 긴 컨텍스트로 안정적인 전환을 가능하게 합니다. 7개의 장문 문서 QA 벤치마크에서 OpenAI-o3-mini와 Qwen3-235B-A22B를 능가하며 Claude-3.7-Sonnet-Thinking과 경쟁합니다. 특히 수학, 논리 및 멀티홉 추론에서 강점을 보입니다.",
   "Yi-34B-Chat.description": "Yi-1.5-34B는 시리즈의 강력한 일반 언어 능력을 유지하면서도 500B 고품질 토큰에 대한 점진적 학습을 통해 수학 논리 및 코딩 능력을 크게 향상시켰습니다.",
   "abab5.5-chat.description": "복잡한 작업 처리와 효율적인 텍스트 생성을 통해 생산성 중심의 시나리오에 적합하게 설계되었습니다.",
   "abab5.5s-chat.description": "중국어 페르소나 대화에 최적화되어 다양한 응용 분야에서 고품질 중국어 대화를 제공합니다.",
@@ -291,10 +310,17 @@
   "claude-3.5-sonnet.description": "Claude 3.5 Sonnet은 코딩, 글쓰기, 복잡한 추론에서 뛰어난 성능을 발휘합니다.",
   "claude-3.7-sonnet-thought.description": "Claude 3.7 Sonnet은 복잡한 추론 작업을 위한 확장된 사고 기능을 갖춘 모델입니다.",
   "claude-3.7-sonnet.description": "Claude 3.7 Sonnet은 확장된 문맥 처리와 기능을 갖춘 업그레이드 버전입니다.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5는 Anthropic의 가장 빠르고 지능적인 Haiku 모델로, 번개 같은 속도와 확장된 사고를 제공합니다.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5는 다양한 작업에 빠르고 효율적으로 대응하는 모델입니다.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking은 자신의 추론 과정을 드러낼 수 있는 고급 변형 모델입니다.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1은 Anthropic의 최신 모델로, 매우 복잡한 작업에서 뛰어난 성능, 지능, 유창성 및 이해력을 발휘합니다.",
+  "claude-opus-4-20250514.description": "Claude Opus 4는 Anthropic의 가장 강력한 모델로, 매우 복잡한 작업에서 뛰어난 성능, 지능, 유창성 및 이해력을 발휘합니다.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5는 Anthropic의 플래그십 모델로, 탁월한 지능과 확장 가능한 성능을 결합하여 최고 품질의 응답과 추론이 필요한 복잡한 작업에 이상적입니다.",
+  "claude-opus-4-6.description": "Claude Opus 4.6은 에이전트 구축 및 코딩을 위한 Anthropic의 가장 지능적인 모델입니다.",
   "claude-sonnet-4-20250514-thinking.description": "Claude Sonnet 4 Thinking은 즉각적인 응답 또는 단계별 사고 과정을 시각적으로 보여주는 확장된 사고를 생성할 수 있습니다.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4는 Anthropic의 가장 지능적인 모델로, API 사용자에게 세밀한 제어를 제공하며 즉각적인 응답 또는 단계별 사고를 제공합니다.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5는 Anthropic의 가장 지능적인 모델입니다.",
+  "claude-sonnet-4-6.description": "Claude Sonnet 4.6은 속도와 지능의 최상의 조합을 제공합니다.",
   "claude-sonnet-4.description": "Claude Sonnet 4는 모든 작업에서 향상된 성능을 제공하는 최신 세대 모델입니다.",
   "codegeex-4.description": "CodeGeeX-4는 다국어 Q&A 및 코드 자동 완성을 지원하여 개발자의 생산성을 높이는 강력한 AI 코딩 도우미입니다.",
   "codegeex4-all-9b.description": "CodeGeeX4-ALL-9B는 코드 자동 완성 및 생성, 코드 인터프리터, 웹 검색, 함수 호출, 저장소 수준의 코드 Q&A를 지원하는 다국어 코드 생성 모델로, 다양한 소프트웨어 개발 시나리오를 포괄합니다. 10B 미만 파라미터 중 최고 수준의 코드 모델입니다.",
@@ -351,6 +377,7 @@
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B.description": "DeepSeek-R1 증류 모델은 RL 및 콜드 스타트 데이터를 활용하여 추론 능력을 향상시키고, 새로운 오픈 모델 멀티태스크 벤치마크를 설정합니다.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B.description": "DeepSeek-R1 증류 모델은 RL 및 콜드 스타트 데이터를 활용하여 추론 능력을 향상시키고, 새로운 오픈 모델 멀티태스크 벤치마크를 설정합니다.",
   "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B.description": "DeepSeek-R1-Distill-Qwen-32B는 Qwen2.5-32B에서 증류되었으며, 80만 개의 DeepSeek-R1 정제 샘플로 미세 조정되었습니다. 수학, 프로그래밍, 추론에서 뛰어난 성능을 보이며, AIME 2024, MATH-500(정확도 94.3%), GPQA Diamond에서 우수한 결과를 기록합니다.",
+  "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B.description": "DeepSeek-R1-Distill-Qwen-7B는 Qwen2.5-Math-7B에서 증류되고 80만 개의 큐레이션된 DeepSeek-R1 샘플로 미세 조정되었습니다. MATH-500에서 92.8%, AIME 2024에서 55.5%, CodeForces에서 1189 점수를 기록하며 7B 모델로 강력한 성능을 발휘합니다.",
   "deepseek-ai/DeepSeek-R1.description": "DeepSeek-R1은 RL 및 콜드 스타트 데이터를 활용하여 추론 능력을 향상시키며, 새로운 오픈 모델 멀티태스크 벤치마크를 설정하고 OpenAI-o1-mini를 능가합니다.",
   "deepseek-ai/DeepSeek-V2.5.description": "DeepSeek-V2.5는 DeepSeek-V2-Chat과 DeepSeek-Coder-V2-Instruct를 업그레이드하여 일반 및 코딩 능력을 통합합니다. 글쓰기 및 지시문 이행 능력을 향상시켜 선호도 정렬을 개선하며, AlpacaEval 2.0, ArenaHard, AlignBench, MT-Bench에서 큰 성능 향상을 보입니다.",
   "deepseek-ai/DeepSeek-V3.1-Terminus.description": "DeepSeek-V3.1-Terminus는 하이브리드 에이전트 LLM으로 포지셔닝된 V3.1 모델의 업데이트 버전입니다. 사용자 피드백 문제를 해결하고 안정성, 언어 일관성, 중문/영문 혼합 및 비정상 문자 출력을 개선합니다. 사고 및 비사고 모드를 통합하고 채팅 템플릿을 통해 유연하게 전환할 수 있으며, Code Agent 및 Search Agent 성능도 향상되어 도구 사용 및 다단계 작업에서 더 높은 신뢰성을 제공합니다.",
@@ -363,6 +390,7 @@
   "deepseek-ai/deepseek-v3.1.description": "DeepSeek V3.1은 복잡한 추론과 연쇄적 사고에 강한 차세대 추론 모델로, 심층 분석 작업에 적합합니다.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2는 복잡한 추론과 연쇄 사고 능력이 강화된 차세대 추론 모델입니다.",
   "deepseek-ai/deepseek-vl2.description": "DeepSeek-VL2는 DeepSeekMoE-27B 기반의 MoE 비전-언어 모델로, 희소 활성화를 통해 4.5B 활성 파라미터만으로도 뛰어난 성능을 발휘합니다. 시각적 QA, OCR, 문서/표/차트 이해, 시각적 정렬에 탁월합니다.",
+  "deepseek-chat.description": "DeepSeek V3.2는 일상 QA 및 에이전트 작업을 위해 추론과 출력 길이를 균형 있게 조정합니다. 공개 벤치마크에서 GPT-5 수준에 도달하며, 도구 사용에 사고를 통합한 최초의 모델로 오픈소스 에이전트 평가에서 선도적인 위치를 차지합니다.",
   "deepseek-coder-33B-instruct.description": "DeepSeek Coder 33B는 2T 토큰(코드 87%, 중/영문 텍스트 13%)으로 학습된 코드 언어 모델입니다. 16K 문맥 창과 중간 채우기(fit-in-the-middle) 작업을 도입하여 프로젝트 수준의 코드 완성과 코드 조각 보완을 지원합니다.",
   "deepseek-coder-v2.description": "DeepSeek Coder V2는 GPT-4 Turbo에 필적하는 성능을 보이는 오픈소스 MoE 코드 모델입니다.",
   "deepseek-coder-v2:236b.description": "DeepSeek Coder V2는 GPT-4 Turbo에 필적하는 성능을 보이는 오픈소스 MoE 코드 모델입니다.",
@@ -385,6 +413,7 @@
   "deepseek-r1-fast-online.description": "DeepSeek R1의 빠른 전체 버전으로, 실시간 웹 검색을 지원하며 671B 규모의 성능과 빠른 응답을 결합합니다.",
   "deepseek-r1-online.description": "DeepSeek R1 전체 버전은 671B 파라미터와 실시간 웹 검색을 지원하여 더 강력한 이해 및 생성 능력을 제공합니다.",
   "deepseek-r1.description": "DeepSeek-R1은 강화 학습 전 콜드 스타트 데이터를 사용하며, 수학, 코딩, 추론에서 OpenAI-o1과 유사한 성능을 보입니다.",
+  "deepseek-reasoner.description": "DeepSeek V3.2 Thinking은 출력 전에 사고 체인을 생성하여 정확성을 높이는 심층 추론 모델로, 최고 수준의 경쟁 결과와 Gemini-3.0-Pro에 필적하는 추론을 제공합니다.",
   "deepseek-v2.description": "DeepSeek V2는 비용 효율적인 처리를 위한 고효율 MoE 모델입니다.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B는 코드 생성에 강점을 가진 DeepSeek의 코드 특화 모델입니다.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324는 671B 파라미터의 MoE 모델로, 프로그래밍 및 기술 역량, 문맥 이해, 장문 처리에서 뛰어난 성능을 보입니다.",
@@ -395,6 +424,7 @@
   "deepseek-v3.2-exp.description": "deepseek-v3.2-exp는 희소 어텐션을 도입하여 장문 텍스트의 학습 및 추론 효율을 향상시키며, deepseek-v3.1보다 저렴한 비용으로 제공됩니다.",
   "deepseek-v3.2-speciale.description": "매우 복잡한 작업에서 Speciale 모델은 표준 버전보다 훨씬 뛰어난 성능을 발휘하지만, 상당히 많은 토큰을 소비하며 비용이 높습니다. 현재 DeepSeek-V3.2-Speciale는 연구용으로만 사용되며, 도구 호출을 지원하지 않으며 일상적인 대화나 작성 작업에 최적화되지 않았습니다.",
   "deepseek-v3.2-think.description": "DeepSeek V3.2 Think는 더욱 강력한 장기 연쇄 추론을 지원하는 완전한 심층 사고 모델입니다.",
+  "deepseek-v3.2.description": "DeepSeek-V3.2는 DeepSeek의 최신 코딩 모델로 강력한 추론 기능을 제공합니다.",
   "deepseek-v3.description": "DeepSeek-V3는 총 671B 파라미터 중 토큰당 37B가 활성화되는 강력한 MoE 모델입니다.",
   "deepseek-vl2-small.description": "DeepSeek VL2 Small은 자원이 제한되거나 동시 접속이 많은 환경을 위한 경량 멀티모달 모델입니다.",
   "deepseek-vl2.description": "DeepSeek VL2는 이미지-텍스트 이해와 정밀한 시각적 질의응답을 위한 멀티모달 모델입니다.",
@@ -483,6 +513,8 @@
   "ernie-x1-turbo-32k.description": "ERNIE X1 Turbo 32K는 복잡한 추론 및 다중 턴 대화를 위한 32K 컨텍스트의 고속 사고 모델입니다.",
   "ernie-x1.1-preview.description": "ERNIE X1.1 Preview는 평가 및 테스트를 위한 사고 모델 프리뷰입니다.",
   "ernie-x1.1.description": "ERNIE X1.1은 평가 및 테스트를 위한 사고 모델 프리뷰입니다.",
+  "fal-ai/bytedance/seedream/v4.5.description": "Seedream 4.5는 ByteDance Seed 팀에서 개발한 모델로, 다중 이미지 편집 및 구성 기능을 지원합니다. 향상된 주제 일관성, 정확한 지침 준수, 공간 논리 이해, 미적 표현, 포스터 레이아웃 및 로고 디자인과 고정밀 텍스트-이미지 렌더링을 제공합니다.",
+  "fal-ai/bytedance/seedream/v4.description": "Seedream 4.0은 ByteDance Seed에서 개발한 모델로, 텍스트 및 이미지 입력을 지원하며 프롬프트를 기반으로 고품질 이미지를 생성할 수 있습니다.",
   "fal-ai/flux-kontext/dev.description": "FLUX.1 모델은 이미지 편집에 중점을 두며, 텍스트와 이미지 입력을 지원합니다.",
   "fal-ai/flux-pro/kontext.description": "FLUX.1 Kontext [pro]는 텍스트와 참조 이미지를 입력으로 받아, 국소 편집과 복잡한 장면 변환을 정밀하게 수행할 수 있습니다.",
   "fal-ai/flux/krea.description": "Flux Krea [dev]는 보다 사실적이고 자연스러운 이미지 스타일에 중점을 둔 이미지 생성 모델입니다.",
@@ -490,6 +522,8 @@
   "fal-ai/hunyuan-image/v3.description": "강력한 네이티브 멀티모달 이미지 생성 모델입니다.",
   "fal-ai/imagen4/preview.description": "Google에서 개발한 고품질 이미지 생성 모델입니다.",
   "fal-ai/nano-banana.description": "Nano Banana는 Google의 최신, 가장 빠르고 효율적인 네이티브 멀티모달 모델로, 대화형 이미지 생성 및 편집을 지원합니다.",
+  "fal-ai/qwen-image-edit.description": "Qwen 팀에서 개발한 전문 이미지 편집 모델로, 의미 및 외형 편집, 정확한 중국어/영어 텍스트 편집, 스타일 전환, 회전 등을 지원합니다.",
+  "fal-ai/qwen-image.description": "Qwen 팀에서 개발한 강력한 이미지 생성 모델로, 중국어 텍스트 렌더링과 다양한 시각적 스타일에서 강점을 보입니다.",
   "flux-1-schnell.description": "Black Forest Labs에서 개발한 120억 파라미터 텍스트-이미지 모델로, 잠재 적대 확산 증류를 사용하여 1~4단계 내에 고품질 이미지를 생성합니다. Apache-2.0 라이선스로 개인, 연구, 상업적 사용이 가능합니다.",
   "flux-dev.description": "FLUX.1 [dev]는 오픈 가중치 증류 모델로, 비상업적 사용을 위해 설계되었습니다. 전문가 수준의 이미지 품질과 지시 따르기를 유지하면서도 더 효율적으로 작동하며, 동일 크기의 표준 모델보다 자원을 더 잘 활용합니다.",
   "flux-kontext-max.description": "최첨단 문맥 기반 이미지 생성 및 편집 모델로, 텍스트와 이미지를 결합하여 정밀하고 일관된 결과를 생성합니다.",
@@ -533,8 +567,10 @@
   "gemini-2.5-pro.description": "Gemini 2.5 Pro는 Google의 플래그십 추론 모델로, 복잡한 작업을 위한 장기 문맥 지원을 제공합니다.",
   "gemini-3-flash-preview.description": "Gemini 3 Flash는 속도를 위해 설계된 가장 스마트한 모델로, 최첨단 지능과 뛰어난 검색 기반을 결합합니다.",
   "gemini-3-pro-image-preview.description": "Gemini 3 Pro Image (Nano Banana Pro)는 구글의 이미지 생성 모델로, 멀티모달 대화도 지원합니다.",
+  "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-3.1-flash-image-preview.description": "Gemini 3.1 Flash Image (Nano Banana 2)는 구글의 가장 빠른 네이티브 이미지 생성 모델로, 사고 지원, 대화형 이미지 생성 및 편집을 제공합니다.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2)는 플래시 속도로 프로 수준의 이미지 품질을 제공하며 멀티모달 채팅을 지원합니다.",
   "gemini-3.1-flash-lite-preview.description": "Gemini 3.1 Flash-Lite Preview는 Google의 가장 비용 효율적인 다중 모드 모델로, 대량 에이전트 작업, 번역 및 데이터 처리에 최적화되어 있습니다.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview는 Gemini 3 Pro의 추론 능력을 강화하고 중간 사고 수준 지원을 추가합니다.",
   "gemini-flash-latest.description": "Gemini Flash 최신 버전",
@@ -769,6 +805,7 @@
   "kimi-k2-thinking-turbo.description": "256K 컨텍스트, 강력한 심층 추론, 초당 60~100 토큰 출력 속도를 갖춘 고속 K2 장기 사고 모델입니다.",
   "kimi-k2-thinking.description": "kimi-k2-thinking은 Moonshot AI의 사고 모델로, 일반적인 에이전트 및 추론 능력을 갖추고 있으며, 다단계 도구 사용을 통해 복잡한 문제를 해결할 수 있습니다.",
   "kimi-k2-turbo-preview.description": "kimi-k2는 MoE 기반의 모델로, 강력한 코딩 및 에이전트 기능을 갖추고 있으며(총 1조 파라미터, 활성 320억), 추론, 프로그래밍, 수학, 에이전트 벤치마크에서 주요 오픈 모델들을 능가합니다.",
+  "kimi-k2.5.description": "Kimi K2.5는 Kimi의 가장 다재다능한 모델로, 비전 및 텍스트 입력을 지원하는 네이티브 멀티모달 아키텍처를 특징으로 하며, '사고' 및 '비사고' 모드와 대화 및 에이전트 작업을 모두 지원합니다.",
   "kimi-k2.description": "Kimi-K2는 Moonshot AI의 MoE 기반 모델로, 총 1조 파라미터 중 320억이 활성화되며, 고급 도구 사용, 추론, 코드 생성 등 에이전트 기능에 최적화되어 있습니다.",
   "kimi-k2:1t.description": "Kimi K2는 Moonshot AI의 대규모 MoE LLM으로, 총 1조 파라미터 중 320억이 활성화됩니다. 고급 도구 사용, 추론, 코드 생성 등 에이전트 기능에 최적화되어 있습니다.",
   "kuaishou/kat-coder-pro-v1.description": "KAT-Coder-Pro-V1(한시적 무료)은 코드 이해 및 자동화에 중점을 둔 모델로, 효율적인 코딩 에이전트를 위한 기능을 제공합니다.",
@@ -930,6 +967,7 @@
   "moonshot-v1-32k.description": "Moonshot V1 32K는 32,768 토큰을 지원하는 중간 길이 컨텍스트 모델로, 콘텐츠 제작, 보고서, 대화 시스템에서 긴 문서와 복잡한 대화에 적합합니다.",
   "moonshot-v1-8k-vision-preview.description": "Kimi 비전 모델(moonshot-v1-8k-vision-preview/moonshot-v1-32k-vision-preview/moonshot-v1-128k-vision-preview 포함)은 텍스트, 색상, 객체 형태 등 이미지 내용을 이해할 수 있습니다.",
   "moonshot-v1-8k.description": "Moonshot V1 8K는 짧은 텍스트 생성을 위해 최적화된 모델로, 8,192 토큰을 처리하며 짧은 대화, 메모, 빠른 콘텐츠 생성에 적합합니다.",
+  "moonshotai/Kimi-Dev-72B.description": "Kimi-Dev-72B는 대규모 RL로 최적화된 오픈소스 코드 LLM으로, 견고하고 생산 준비된 패치를 생성합니다. SWE-bench Verified에서 60.4%를 기록하며 버그 수정 및 코드 리뷰와 같은 자동화된 소프트웨어 엔지니어링 작업에서 오픈 모델 기록을 세웠습니다.",
   "moonshotai/Kimi-K2-Instruct-0905.description": "Kimi K2-Instruct-0905는 가장 최신이자 강력한 Kimi K2 모델로, 총 1조 파라미터 중 320억이 활성화되는 최상급 MoE 모델입니다. 벤치마크 및 실제 에이전트 작업에서 뛰어난 Agentic Coding 지능을 보이며, 프론트엔드 코드의 미적 품질과 사용성도 향상되었습니다.",
   "moonshotai/Kimi-K2-Thinking.description": "Kimi K2 Thinking은 최신이자 가장 강력한 오픈 소스 사고 모델입니다. 다단계 추론 깊이를 크게 확장하고, 200~300회의 연속 호출 동안 안정적인 도구 사용을 유지하며, Humanity's Last Exam (HLE), BrowseComp 및 기타 벤치마크에서 새로운 기록을 세웠습니다. 코딩, 수학, 논리 및 에이전트 시나리오에서 뛰어난 성능을 발휘합니다. 약 1조 개의 총 파라미터를 가진 MoE 아키텍처를 기반으로 하며, 256K 컨텍스트 윈도우와 도구 호출을 지원합니다.",
   "moonshotai/kimi-k2-0711.description": "Kimi K2 0711은 Kimi 시리즈의 Instruct 변형으로, 고품질 코드 작성과 도구 사용에 적합합니다.",
@@ -1132,6 +1170,7 @@
   "qwen3-coder-next.description": "다중 파일 코드 생성, 디버깅 및 고속 에이전트 워크플로우에 최적화된 차세대 Qwen 코더입니다. 강력한 도구 통합과 향상된 추론 성능을 제공합니다.",
   "qwen3-coder-plus.description": "Qwen 코드 모델입니다. 최신 Qwen3-Coder 시리즈는 Qwen3 기반으로, 자율 프로그래밍을 위한 강력한 코딩 에이전트 기능, 도구 활용, 환경 상호작용을 제공하며, 우수한 코드 성능과 견고한 범용 능력을 갖추고 있습니다.",
   "qwen3-coder:480b.description": "Alibaba의 고성능 장문 컨텍스트 모델로, 에이전트 및 코딩 작업에 적합합니다.",
+  "qwen3-max-2026-01-23.description": "Qwen3 Max: 사고 지원을 통해 복잡하고 다단계 코딩 작업에서 최고의 성능을 발휘하는 Qwen 모델.",
   "qwen3-max-preview.description": "복잡하고 다단계 작업에 최적화된 Qwen 모델의 프리뷰 버전입니다. 사고 기능을 지원합니다.",
   "qwen3-max.description": "Qwen3 Max 모델은 2.5 시리즈 대비 전반적인 능력, 중영어 이해, 복잡한 지시 수행, 주관적 개방형 작업, 다국어 처리, 도구 활용 등에서 큰 향상을 보이며, 환각 현상도 줄였습니다. 최신 qwen3-max는 qwen3-max-preview보다 에이전트 프로그래밍과 도구 활용이 향상되었습니다. 이 릴리스는 분야별 SOTA 수준에 도달하며, 더 복잡한 에이전트 요구를 충족합니다.",
   "qwen3-next-80b-a3b-instruct.description": "차세대 Qwen3 오픈소스 모델로, 이전 버전(Qwen3-235B-A22B-Instruct-2507) 대비 중국어 이해, 논리적 추론, 텍스트 생성 능력이 향상되었습니다.",
@@ -1161,6 +1200,8 @@
   "qwq.description": "QwQ는 Qwen 계열의 추론 모델입니다. 일반적인 지시 조정 모델과 비교해 사고 및 추론 능력이 뛰어나며, 특히 어려운 문제에서 다운스트림 성능을 크게 향상시킵니다. QwQ-32B는 DeepSeek-R1 및 o1-mini와 경쟁할 수 있는 중형 추론 모델입니다.",
   "qwq_32b.description": "Qwen 계열의 중형 추론 모델입니다. 일반적인 지시 조정 모델과 비교해 QwQ의 사고 및 추론 능력은 특히 어려운 문제에서 다운스트림 성능을 크게 향상시킵니다.",
   "r1-1776.description": "R1-1776은 DeepSeek R1의 후속 학습 버전으로, 검열되지 않고 편향 없는 사실 정보를 제공합니다.",
+  "seedance-1-5-pro-251215.description": "Seedance 1.5 Pro는 ByteDance에서 개발한 모델로, 텍스트-비디오, 이미지-비디오(첫 프레임, 첫+마지막 프레임) 및 시각과 동기화된 오디오 생성을 지원합니다.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite는 BytePlus에서 개발한 모델로, 실시간 정보를 위한 웹 검색 증강 생성, 복잡한 프롬프트 해석 향상 및 전문적인 시각적 창작을 위한 참조 일관성을 제공합니다.",
   "solar-mini-ja.description": "Solar Mini (Ja)는 Solar Mini의 일본어 특화 버전으로, 영어와 한국어에서도 효율적이고 강력한 성능을 유지합니다.",
   "solar-mini.description": "Solar Mini는 GPT-3.5를 능가하는 성능을 가진 소형 LLM으로, 영어와 한국어를 지원하는 강력한 다국어 기능을 갖추고 있으며, 효율적인 경량 솔루션을 제공합니다.",
   "solar-pro.description": "Solar Pro는 Upstage의 고지능 LLM으로, 단일 GPU에서 지시 수행에 최적화되어 있으며, IFEval 점수 80 이상을 기록합니다. 현재는 영어를 지원하며, 2024년 11월 전체 릴리스 시 더 많은 언어와 긴 컨텍스트를 지원할 예정입니다.",
@@ -1196,6 +1237,7 @@
   "step-3.5-flash.description": "Stepfun의 플래그십 언어 추론 모델입니다. 이 모델은 최상급 추론 능력과 빠르고 신뢰할 수 있는 실행 능력을 갖추고 있습니다. 복잡한 작업을 분해하고 계획하며, 도구를 빠르고 신뢰성 있게 호출하여 작업을 수행할 수 있으며, 논리적 추론, 수학, 소프트웨어 엔지니어링 및 심층 연구와 같은 다양한 복잡한 작업에 능숙합니다.",
   "step-3.description": "강력한 시각 인식과 복잡한 추론 능력을 갖춘 모델로, 도메인 간 지식 이해, 수학-시각 교차 분석, 다양한 일상 시각 분석 작업을 정확하게 처리합니다.",
   "step-r1-v-mini.description": "이미지와 텍스트를 처리한 후 깊은 추론을 통해 텍스트를 생성하는 강력한 이미지 이해 추론 모델입니다. 시각 추론에 뛰어나며, 수학, 코딩, 텍스트 추론에서 최고 수준의 성능을 발휘하며, 100K 문맥 창을 지원합니다.",
+  "stepfun-ai/step3.description": "Step3는 StepFun에서 개발한 최첨단 멀티모달 추론 모델로, 321B 총 매개변수와 38B 활성 매개변수를 가진 MoE 아키텍처를 기반으로 합니다. 엔드 투 엔드 설계로 디코딩 비용을 최소화하면서 최고 수준의 비전-언어 추론을 제공합니다. MFA 및 AFD 설계를 통해 플래그십 및 저가형 가속기 모두에서 효율성을 유지합니다. 사전 훈련은 20T+ 텍스트 토큰과 4T 이미지-텍스트 토큰을 다양한 언어로 사용하며, 수학, 코드 및 멀티모달 벤치마크에서 선도적인 오픈 모델 성능을 달성합니다.",
   "taichu4_vl_2b_nothinking.description": "Taichu4.0-VL 2B 모델의 No-Thinking 버전은 메모리 사용량이 적고, 경량 설계, 빠른 응답 속도, 강력한 멀티모달 이해 능력을 특징으로 합니다.",
   "taichu4_vl_32b.description": "Taichu4.0-VL 32B 모델의 Thinking 버전은 복잡한 멀티모달 이해 및 추론 작업에 적합하며, 멀티모달 수학적 추론, 멀티모달 에이전트 능력, 일반 이미지 및 시각적 이해에서 뛰어난 성능을 보여줍니다.",
   "taichu4_vl_32b_nothinking.description": "Taichu4.0-VL 32B 모델의 No-Thinking 버전은 복잡한 이미지-텍스트 이해 및 시각적 지식 QA 시나리오에 적합하며, 이미지 캡션 생성, 시각적 질문 응답, 비디오 이해 및 시각적 위치 지정 작업에서 뛰어난 성능을 발휘합니다.",
@@ -1282,6 +1324,7 @@
   "zai-org/GLM-4.5-Air.description": "GLM-4.5-Air는 Mixture-of-Experts 아키텍처를 사용하는 에이전트 애플리케이션용 기본 모델입니다. 도구 사용, 웹 브라우징, 소프트웨어 엔지니어링, 프론트엔드 코딩에 최적화되어 있으며, Claude Code 및 Roo Code와 같은 코드 에이전트와 통합됩니다. 복잡한 추론과 일상적인 시나리오 모두를 처리할 수 있는 하이브리드 추론을 사용합니다.",
   "zai-org/GLM-4.5V.description": "GLM-4.5V는 GLM-4.5-Air 기반의 최신 VLM으로, 106B 총 파라미터(12B 활성)를 갖춘 MoE 아키텍처를 사용하여 낮은 비용으로 강력한 성능을 제공합니다. GLM-4.1V-Thinking 경로를 따르며, 3D-RoPE를 추가하여 3D 공간 추론을 향상시켰습니다. 사전학습, SFT, RL을 통해 최적화되었으며, 이미지, 비디오, 장문 문서를 처리할 수 있습니다. 41개 공개 멀티모달 벤치마크에서 오픈 모델 중 최고 순위를 기록했습니다. Thinking 모드 전환 기능을 통해 속도와 깊이를 조절할 수 있습니다.",
   "zai-org/GLM-4.6.description": "GLM-4.5와 비교해 GLM-4.6은 컨텍스트 길이를 128K에서 200K로 확장하여 더 복잡한 에이전트 작업을 처리할 수 있습니다. 코드 벤치마크에서 더 높은 점수를 기록하며, Claude Code, Cline, Roo Code, Kilo Code 등 실제 애플리케이션에서 더 강력한 성능을 보입니다. 추론 능력이 향상되었고, 추론 중 도구 사용이 가능하여 전반적인 역량이 강화되었습니다. 에이전트 프레임워크와의 통합이 개선되었으며, 도구/검색 에이전트 성능이 향상되고, 더 자연스러운 문체와 역할극 표현을 제공합니다.",
+  "zai-org/GLM-4.6V.description": "GLM-4.6V는 해당 매개변수 규모에서 SOTA 시각적 이해 정확도를 달성하며, 비전 모델 아키텍처에 Function Call 기능을 네이티브로 통합한 최초의 모델입니다. '시각적 인식'에서 '실행 가능한 작업'으로의 격차를 연결하며 실제 비즈니스 시나리오에서 멀티모달 에이전트를 위한 통합 기술 기반을 제공합니다. 시각적 컨텍스트 창은 128k로 확장되어 긴 비디오 스트림 처리 및 고해상도 다중 이미지 분석을 지원합니다.",
   "zai/glm-4.5-air.description": "GLM-4.5 및 GLM-4.5-Air는 에이전트 애플리케이션을 위한 최신 대표 모델로, 모두 MoE를 사용합니다. GLM-4.5는 총 355B 파라미터(32B 활성), GLM-4.5-Air는 더 슬림한 106B 총 파라미터(12B 활성)를 갖추고 있습니다.",
   "zai/glm-4.5.description": "GLM-4.5 시리즈는 에이전트를 위해 설계되었습니다. 대표 모델인 GLM-4.5는 355B 총 파라미터(32B 활성)를 갖추고 있으며, 추론, 코딩, 에이전트 기능을 결합한 하이브리드 추론 시스템으로 이중 작동 모드를 제공합니다.",
   "zai/glm-4.5v.description": "GLM-4.5V는 GLM-4.5-Air를 기반으로 하며, 검증된 GLM-4.1V-Thinking 기술을 계승하고, 106B 파라미터의 강력한 MoE 아키텍처로 확장되었습니다.",

locales/ko-KR/providers.json

@@ -8,6 +8,7 @@
   "azure.description": "Azure는 GPT-3.5 및 GPT-4 시리즈를 포함한 고급 AI 모델을 제공하며, 다양한 데이터 유형과 복잡한 작업을 안전하고 신뢰할 수 있으며 지속 가능한 방식으로 처리합니다.",
   "azureai.description": "Azure는 GPT-3.5 및 GPT-4 시리즈를 포함한 고급 AI 모델을 제공하며, 다양한 데이터 유형과 복잡한 작업을 안전하고 신뢰할 수 있으며 지속 가능한 방식으로 처리합니다.",
   "baichuan.description": "Baichuan AI는 중국어 지식, 장문 문맥 처리, 창의적 생성에서 뛰어난 성능을 보이는 기반 모델에 집중하며, Baichuan 4, Baichuan 3 Turbo, Baichuan 3 Turbo 128k 등 다양한 시나리오에 최적화된 모델을 제공합니다.",
+  "bailiancodingplan.description": "알리윈 백련 코딩 플랜은 Qwen, GLM, Kimi, MiniMax의 코딩 최적화 모델에 전용 엔드포인트를 통해 접근할 수 있는 전문 AI 코딩 서비스입니다.",
   "bedrock.description": "Amazon Bedrock은 기업을 위한 고급 언어 및 비전 모델을 제공하며, Anthropic Claude와 Meta Llama 3.1을 포함해 텍스트, 대화, 이미지 작업을 위한 경량부터 고성능 모델까지 지원합니다.",
   "bfl.description": "미래의 시각 인프라를 구축하는 선도적인 AI 연구소입니다.",
   "cerebras.description": "Cerebras는 CS-3 시스템 기반의 추론 플랫폼으로, 코드 생성 및 에이전트 작업과 같은 실시간 워크로드를 위한 초저지연, 고처리량 LLM 서비스를 제공합니다.",
@@ -21,6 +22,7 @@
   "giteeai.description": "Gitee AI 서버리스 API는 개발자를 위한 플러그 앤 플레이 LLM 추론 서비스를 제공합니다.",
   "github.description": "GitHub Models를 통해 개발자는 업계 최고 수준의 모델을 활용하여 AI 엔지니어로서 개발할 수 있습니다.",
   "githubcopilot.description": "GitHub Copilot 구독을 통해 Claude, GPT, Gemini 모델에 액세스할 수 있습니다.",
+  "glmcodingplan.description": "GLM 코딩 플랜은 고정 요금 구독을 통해 GLM-5 및 GLM-4.7을 포함한 Zhipu AI 모델에 접근하여 코딩 작업을 수행할 수 있습니다.",
   "google.description": "Google의 Gemini 시리즈는 Google DeepMind가 개발한 가장 진보된 범용 AI로, 텍스트, 코드, 이미지, 오디오, 비디오 등 멀티모달 작업을 지원하며, 데이터 센터부터 모바일 기기까지 확장성과 효율성을 갖추고 있습니다.",
   "groq.description": "Groq의 LPU 추론 엔진은 탁월한 속도와 효율성으로 뛰어난 벤치마크 성능을 제공하며, 저지연 클라우드 기반 LLM 추론의 기준을 제시합니다.",
   "higress.description": "Higress는 Alibaba 내부에서 개발된 클라우드 네이티브 API 게이트웨이로, Tengine 재시작 시 장기 연결에 미치는 영향을 줄이고 gRPC/Dubbo 로드 밸런싱의 한계를 해결합니다.",
@@ -29,9 +31,12 @@
   "infiniai.description": "모델 개발부터 실사용 배포까지 전 과정을 아우르는 고성능, 사용이 간편하고 안전한 LLM 서비스를 앱 개발자에게 제공합니다.",
   "internlm.description": "InternLM은 대규모 모델 연구 및 도구 개발에 집중하는 오픈소스 조직으로, 최신 모델과 알고리즘을 누구나 쉽게 사용할 수 있도록 효율적인 플랫폼을 제공합니다.",
   "jina.description": "2020년에 설립된 Jina AI는 선도적인 검색 AI 기업으로, 벡터 모델, 재정렬기, 소형 언어 모델을 포함한 검색 스택을 통해 신뢰성 높고 고품질의 생성형 및 멀티모달 검색 앱을 구축합니다.",
+  "kimicodingplan.description": "문샷 AI의 Kimi Code는 K2.5를 포함한 Kimi 모델에 접근하여 코딩 작업을 수행할 수 있습니다.",
   "lmstudio.description": "LM Studio는 데스크탑에서 LLM을 개발하고 실험할 수 있는 애플리케이션입니다.",
+  "lobehub.description": "LobeHub Cloud는 공식 API를 사용하여 AI 모델에 접근하며, 모델 토큰에 연결된 크레딧으로 사용량을 측정합니다.",
   "longcat.description": "LongCat은 Meituan에서 독자적으로 개발한 생성형 AI 대형 모델 시리즈입니다. 이는 효율적인 계산 아키텍처와 강력한 멀티모달 기능을 통해 내부 기업 생산성을 향상시키고 혁신적인 애플리케이션을 가능하게 하기 위해 설계되었습니다.",
   "minimax.description": "2021년에 설립된 MiniMax는 텍스트, 음성, 비전 등 멀티모달 기반의 범용 AI를 개발하며, 조 단위 파라미터의 MoE 텍스트 모델과 Hailuo AI와 같은 앱을 제공합니다.",
+  "minimaxcodingplan.description": "MiniMax 토큰 플랜은 고정 요금 구독을 통해 M2.7을 포함한 MiniMax 모델에 접근하여 코딩 작업을 수행할 수 있습니다.",
   "mistral.description": "Mistral은 복잡한 추론, 다국어 작업, 코드 생성에 적합한 고급 범용, 특화, 연구용 모델을 제공하며, 사용자 정의 통합을 위한 함수 호출 기능도 지원합니다.",
   "modelscope.description": "ModelScope는 Alibaba Cloud의 모델 서비스 플랫폼으로, 다양한 AI 모델과 추론 서비스를 제공합니다.",
   "moonshot.description": "Moonshot AI(베이징 Moonshot Technology)의 Moonshot은 콘텐츠 생성, 연구, 추천, 의료 분석 등 다양한 용도에 적합한 NLP 모델을 제공하며, 장문 문맥과 복잡한 생성 작업에 강점을 보입니다.",
@@ -64,6 +69,7 @@
   "vertexai.description": "Google의 Gemini 시리즈는 Google DeepMind가 개발한 가장 진보된 범용 AI로, 텍스트, 코드, 이미지, 오디오, 비디오 등 멀티모달 작업을 지원하며, 데이터 센터부터 모바일 기기까지 효율성과 배포 유연성을 제공합니다.",
   "vllm.description": "vLLM은 빠르고 사용이 간편한 LLM 추론 및 서비스용 라이브러리입니다.",
   "volcengine.description": "ByteDance의 모델 서비스 플랫폼은 안전하고 기능이 풍부하며 비용 경쟁력 있는 모델 접근성과 데이터, 파인튜닝, 추론, 평가를 위한 엔드투엔드 도구를 제공합니다.",
+  "volcenginecodingplan.description": "바이트댄스의 Volcengine 코딩 플랜은 Doubao-Seed-Code, GLM-4.7, DeepSeek-V3.2, Kimi-K2.5를 포함한 여러 코딩 모델에 고정 요금 구독을 통해 접근할 수 있습니다.",
   "wenxin.description": "Wenxin은 생성형 AI 모델 및 애플리케이션 워크플로우를 위한 엔드투엔드 도구를 제공하는 기업용 기반 모델 및 AI 네이티브 앱 개발 통합 플랫폼입니다.",
   "xai.description": "xAI는 과학적 발견을 가속화하고 인류의 우주에 대한 이해를 심화시키는 것을 목표로 AI를 개발합니다.",
   "xiaomimimo.description": "샤오미 MiMo는 OpenAI 호환 API를 통해 대화형 모델 서비스를 제공합니다. mimo-v2-flash 모델은 심층 추론, 스트리밍 출력, 함수 호출, 256K 컨텍스트 윈도우, 최대 128K 출력 기능을 지원합니다.",

locales/ko-KR/subscription.json

@@ -199,6 +199,8 @@
   "plans.btn.paymentDesc": "신용카드 / 알리페이 / 위챗페이 지원",
   "plans.btn.paymentDescForZarinpal": "신용카드 지원",
   "plans.btn.soon": "곧 출시",
+  "plans.cancelDowngrade": "예정된 다운그레이드 취소",
+  "plans.cancelDowngradeSuccess": "예정된 다운그레이드가 취소되었습니다",
   "plans.changePlan": "플랜 선택",
   "plans.cloud.history": "무제한 대화 기록",
   "plans.cloud.sync": "글로벌 클라우드 동기화",
@@ -215,6 +217,7 @@
   "plans.current": "현재 플랜",
   "plans.downgradePlan": "다운그레이드 대상 플랜",
   "plans.downgradeTip": "이미 구독 전환이 진행 중입니다. 완료 전까지 다른 작업을 수행할 수 없습니다.",
+  "plans.downgradeWillCancel": "이 작업은 예정된 요금제 다운그레이드를 취소합니다",
   "plans.embeddingStorage.embeddings": "항목",
   "plans.embeddingStorage.title": "벡터 저장소",
   "plans.embeddingStorage.tooltip": "문서 한 페이지(1000~1500자)는 약 1개의 벡터 항목을 생성합니다. (OpenAI Embeddings 기준, 모델에 따라 다를 수 있음)",
@@ -253,6 +256,7 @@
   "plans.payonce.ok": "선택 확인",
   "plans.payonce.popconfirm": "일시불 결제 후 구독이 만료될 때까지 플랜 변경 또는 결제 주기 변경이 불가능합니다. 선택을 확인해 주세요.",
   "plans.payonce.tooltip": "일시불 결제는 구독 만료 전까지 플랜 변경 또는 결제 주기 변경이 불가능합니다.",
+  "plans.pendingDowngrade": "대기 중인 다운그레이드",
   "plans.plan.enterprise.contactSales": "영업팀 문의",
   "plans.plan.enterprise.title": "엔터프라이즈",
   "plans.plan.free.desc": "처음 사용하는 사용자용",
@@ -366,6 +370,7 @@
   "summary.title": "결제 요약",
   "summary.usageThisMonth": "이번 달 사용량 보기",
   "summary.viewBillingHistory": "결제 내역 보기",
+  "switchDowngradeTarget": "다운그레이드 대상 변경",
   "switchPlan": "플랜 전환",
   "switchToMonthly.desc": "전환 후 현재 연간 플랜이 만료되면 월간 결제가 적용됩니다.",
   "switchToMonthly.title": "월간 결제로 전환",

locales/nl-NL/common.json

@@ -397,7 +397,6 @@
   "sync.status.unconnected": "Verbinding mislukt",
   "sync.title": "Synchronisatiestatus",
   "sync.unconnected.tip": "Verbinding met signaalserver mislukt, peer-to-peer communicatiekanaal kan niet worden opgezet. Controleer je netwerk en probeer het opnieuw.",
-  "tab.aiImage": "Kunstwerk",
   "tab.audio": "Audio",
   "tab.chat": "Chat",
   "tab.community": "Community",
@@ -405,6 +404,7 @@
   "tab.eval": "Evaluatie Lab",
   "tab.files": "Bestanden",
   "tab.home": "Home",
+  "tab.image": "Afbeelding",
   "tab.knowledgeBase": "Bibliotheek",
   "tab.marketplace": "Marktplaats",
   "tab.me": "Ik",