🐛 fix: restore cold replica state in HeterogeneousPersistenceHandler

Vercel serverless functions are stateless per-request, so `operationStates`
is empty on every `heteroIngest` call. loadOrCreateState always cold-creates.

#14539 fixed `toolMsgIdByCallId` restoration but left `accumulatedContent`,
`toolState.payloads`, and `toolState.persistedIds` empty on cold load,
causing two bugs:

- Content truncation: cold instance starts with `accumulatedContent=''`,
  accumulates only the current batch's text, then writes that shorter string
  on the next step boundary or terminal — overwriting the longer content the
  previous write had already stored in DB.

- Tool duplication / tools[] overwrite: `persistedIds={}` on cold load
  means every `tools_calling` event re-creates already-persisted tool
  messages, and `payloads=[]` means phase 1/3 writes only the current
  batch's tools, wiping previous tools from `assistant.tools[]`.

Fix: in `loadOrCreateState`, fetch the current assistant message and restore
`accumulatedContent`, `accumulatedReasoning`, `toolState.payloads`, and
`toolState.persistedIds` from it. Cold load is now equivalent to warm load.

Also adds two regression tests covering the cold-replica scenarios.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.agents/skills/local-testing/scripts/electron-dev.sh

@@ -76,9 +76,7 @@ find_project_pids() {
   port_pid=$(lsof -ti tcp:"$CDP_PORT" -sTCP:LISTEN 2>/dev/null || true)
   pids="$pids $port_pid"
 
-  # `|| true` because `grep -v '^$'` exits 1 when input has no non-empty
-  # lines, which (with pipefail + set -e) silently kills the caller.
-  echo "$pids" | tr ' ' '\n' | sort -u | grep -v '^$' | tr '\n' ' ' || true
+  echo "$pids" | tr ' ' '\n' | sort -u | grep -v '^$' | tr '\n' ' '
 }
 
 # Wait for the CDP HTTP endpoint to respond, with a deadline + early bail-out
@@ -148,7 +146,7 @@ do_stop() {
   for pid in $seed_pids; do
     all_pids="$all_pids $(expand_descendants "$pid")"
   done
-  all_pids=$(echo "$all_pids" | tr ' ' '\n' | sort -u | grep -v '^$' | tr '\n' ' ' || true)
+  all_pids=$(echo "$all_pids" | tr ' ' '\n' | sort -u | grep -v '^$' | tr '\n' ' ')
 
   if [ -z "$all_pids" ]; then
     echo "[electron-dev] No project Electron/vite processes found."
@@ -272,17 +270,10 @@ do_start() {
   # Launch in a new session (setsid) so the whole process tree shares a PGID
   # we can later signal in one shot. `setsid bash -c '... exec ...' &` keeps
   # the bash shell as the session leader; its PID is what we save.
-  # macOS doesn't ship setsid by default — fall back to plain bash; cleanup
-  # still works via `expand_descendants` walking the process tree.
-  local launch_cmd="
+  setsid bash -c "
     cd '$PROJECT_ROOT/apps/desktop'
     exec npx electron-vite dev -- --remote-debugging-port=$CDP_PORT
-  "
-  if command -v setsid >/dev/null 2>&1; then
-    setsid bash -c "$launch_cmd" >> "$ELECTRON_LOG" 2>&1 < /dev/null &
-  else
-    bash -c "$launch_cmd" >> "$ELECTRON_LOG" 2>&1 < /dev/null &
-  fi
+  " >> "$ELECTRON_LOG" 2>&1 < /dev/null &
   local launcher_pid=$!
   echo "$launcher_pid" > "$PIDFILE"
   echo "[electron-dev] Launcher PID (session leader): $launcher_pid"

apps/cli/src/commands/brief.ts

@@ -55,7 +55,7 @@ export function registerBriefCommand(program: Command) {
           typeBadge(b.type, b.priority),
           truncate(b.title, 40),
           truncate(b.summary, 50),
-          b.taskId ? pc.dim(b.taskId) : '-',
+          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),
         ]);
@@ -102,6 +102,7 @@ export function registerBriefCommand(program: Command) {
       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}`);
 
@@ -120,14 +121,14 @@ export function registerBriefCommand(program: Command) {
           for (const a of actions) {
             const cmd =
               a.type === 'comment'
-                ? `lh brief resolve ${b.id} --action ${a.key} -m "message"`
+                ? `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}                   # Approve`));
-          console.log(pc.dim(`  lh brief resolve ${b.id} --reply "revision notes"  # Request revision`));
+          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}`);

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

@@ -0,0 +1,172 @@
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { registerCronCommand } from './cron';
+
+const { mockTrpcClient } = vi.hoisted(() => ({
+  mockTrpcClient: {
+    agentCronJob: {
+      batchUpdateStatus: { mutate: vi.fn() },
+      create: { mutate: vi.fn() },
+      delete: { mutate: vi.fn() },
+      findById: { query: vi.fn() },
+      getStats: { query: vi.fn() },
+      list: { query: vi.fn() },
+      resetExecutions: { mutate: vi.fn() },
+      update: { mutate: vi.fn() },
+    },
+  },
+}));
+
+const { getTrpcClient: mockGetTrpcClient } = vi.hoisted(() => ({
+  getTrpcClient: vi.fn(),
+}));
+
+vi.mock('../api/client', () => ({ getTrpcClient: mockGetTrpcClient }));
+vi.mock('../utils/logger', () => ({
+  log: { debug: vi.fn(), error: vi.fn(), info: vi.fn(), warn: vi.fn() },
+  setVerbose: vi.fn(),
+}));
+
+describe('cron command', () => {
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let consoleSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    mockGetTrpcClient.mockResolvedValue(mockTrpcClient);
+    for (const method of Object.values(mockTrpcClient.agentCronJob)) {
+      for (const fn of Object.values(method)) {
+        (fn as ReturnType<typeof vi.fn>).mockReset();
+      }
+    }
+  });
+
+  afterEach(() => {
+    exitSpy.mockRestore();
+    consoleSpy.mockRestore();
+  });
+
+  function createProgram() {
+    const program = new Command();
+    program.exitOverride();
+    registerCronCommand(program);
+    return program;
+  }
+
+  describe('list', () => {
+    it('should list cron jobs', async () => {
+      mockTrpcClient.agentCronJob.list.query.mockResolvedValue({
+        data: [{ enabled: true, id: 'c1', name: 'Test Job', schedule: '* * * * *' }],
+      });
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'list']);
+
+      expect(mockTrpcClient.agentCronJob.list.query).toHaveBeenCalled();
+    });
+
+    it('should filter by agent-id', async () => {
+      mockTrpcClient.agentCronJob.list.query.mockResolvedValue({ data: [] });
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'list', '--agent-id', 'a1']);
+
+      expect(mockTrpcClient.agentCronJob.list.query).toHaveBeenCalledWith(
+        expect.objectContaining({ agentId: 'a1' }),
+      );
+    });
+  });
+
+  describe('view', () => {
+    it('should view cron job details', async () => {
+      mockTrpcClient.agentCronJob.findById.query.mockResolvedValue({
+        data: { enabled: true, id: 'c1', name: 'Test', schedule: '* * * * *' },
+      });
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'view', 'c1']);
+
+      expect(mockTrpcClient.agentCronJob.findById.query).toHaveBeenCalledWith({ id: 'c1' });
+    });
+  });
+
+  describe('create', () => {
+    it('should create a cron job', async () => {
+      mockTrpcClient.agentCronJob.create.mutate.mockResolvedValue({ data: { id: 'c1' } });
+
+      const program = createProgram();
+      await program.parseAsync([
+        'node',
+        'test',
+        'cron',
+        'create',
+        '--agent-id',
+        'a1',
+        '-s',
+        '* * * * *',
+        '-n',
+        'My Job',
+      ]);
+
+      expect(mockTrpcClient.agentCronJob.create.mutate).toHaveBeenCalledWith(
+        expect.objectContaining({ agentId: 'a1', cronPattern: '* * * * *', name: 'My Job' }),
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a cron job', async () => {
+      mockTrpcClient.agentCronJob.delete.mutate.mockResolvedValue({});
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'delete', 'c1', '--yes']);
+
+      expect(mockTrpcClient.agentCronJob.delete.mutate).toHaveBeenCalledWith({ id: 'c1' });
+    });
+  });
+
+  describe('toggle', () => {
+    it('should batch enable cron jobs', async () => {
+      mockTrpcClient.agentCronJob.batchUpdateStatus.mutate.mockResolvedValue({
+        data: { updatedCount: 2 },
+      });
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'toggle', 'c1', 'c2', '--enable']);
+
+      expect(mockTrpcClient.agentCronJob.batchUpdateStatus.mutate).toHaveBeenCalledWith({
+        enabled: true,
+        ids: ['c1', 'c2'],
+      });
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset execution count', async () => {
+      mockTrpcClient.agentCronJob.resetExecutions.mutate.mockResolvedValue({});
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'reset', 'c1', '--max', '100']);
+
+      expect(mockTrpcClient.agentCronJob.resetExecutions.mutate).toHaveBeenCalledWith({
+        id: 'c1',
+        newMaxExecutions: 100,
+      });
+    });
+  });
+
+  describe('stats', () => {
+    it('should get stats', async () => {
+      mockTrpcClient.agentCronJob.getStats.query.mockResolvedValue({
+        data: { totalJobs: 5, totalExecutions: 100 },
+      });
+
+      const program = createProgram();
+      await program.parseAsync(['node', 'test', 'cron', 'stats']);
+
+      expect(mockTrpcClient.agentCronJob.getStats.query).toHaveBeenCalled();
+    });
+  });
+});

apps/cli/src/commands/cron.ts

@@ -0,0 +1,271 @@
+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';
+
+export function registerCronCommand(program: Command) {
+  const cron = program.command('cron').description('Manage agent cron jobs');
+
+  // ── list ──────────────────────────────────────────────
+
+  cron
+    .command('list')
+    .description('List cron jobs')
+    .option('--agent-id <id>', 'Filter by agent ID')
+    .option('--enabled', 'Only show enabled jobs')
+    .option('--disabled', 'Only show disabled jobs')
+    .option('-L, --limit <n>', 'Page size', '20')
+    .option('--offset <n>', 'Offset', '0')
+    .option('--json [fields]', 'Output JSON, optionally specify fields (comma-separated)')
+    .action(
+      async (options: {
+        agentId?: string;
+        disabled?: boolean;
+        enabled?: boolean;
+        json?: string | boolean;
+        limit?: string;
+        offset?: string;
+      }) => {
+        const client = await getTrpcClient();
+
+        const input: Record<string, any> = {};
+        if (options.agentId) input.agentId = options.agentId;
+        if (options.enabled) input.enabled = true;
+        if (options.disabled) input.enabled = false;
+        if (options.limit) input.limit = Number.parseInt(options.limit, 10);
+        if (options.offset) input.offset = Number.parseInt(options.offset, 10);
+
+        const result = await client.agentCronJob.list.query(input as any);
+        const items = (result as any).data ?? [];
+
+        if (options.json !== undefined) {
+          const fields = typeof options.json === 'string' ? options.json : undefined;
+          outputJson(items, fields);
+          return;
+        }
+
+        if (items.length === 0) {
+          console.log('No cron jobs found.');
+          return;
+        }
+
+        const rows = items.map((j: any) => [
+          j.id || '',
+          truncate(j.name || '', 30),
+          j.schedule || '',
+          j.enabled ? pc.green('enabled') : pc.dim('disabled'),
+          `${j.executionCount ?? 0}/${j.maxExecutions ?? '∞'}`,
+          j.updatedAt ? timeAgo(j.updatedAt) : '',
+        ]);
+
+        printTable(rows, ['ID', 'NAME', 'SCHEDULE', 'STATUS', 'EXECUTIONS', 'UPDATED']);
+      },
+    );
+
+  // ── view ──────────────────────────────────────────────
+
+  cron
+    .command('view <id>')
+    .description('View cron job details')
+    .option('--json [fields]', 'Output JSON')
+    .action(async (id: string, options: { json?: string | boolean }) => {
+      const client = await getTrpcClient();
+      const result = await client.agentCronJob.findById.query({ id });
+      const job = (result as any).data;
+
+      if (options.json !== undefined) {
+        const fields = typeof options.json === 'string' ? options.json : undefined;
+        outputJson(job, fields);
+        return;
+      }
+
+      if (!job) {
+        log.error('Cron job not found.');
+        process.exit(1);
+      }
+
+      console.log(`${pc.bold('ID:')}          ${job.id}`);
+      console.log(`${pc.bold('Name:')}        ${job.name || ''}`);
+      console.log(`${pc.bold('Agent ID:')}    ${job.agentId || ''}`);
+      console.log(`${pc.bold('Schedule:')}    ${job.schedule || ''}`);
+      console.log(
+        `${pc.bold('Status:')}      ${job.enabled ? pc.green('enabled') : pc.dim('disabled')}`,
+      );
+      console.log(
+        `${pc.bold('Executions:')}  ${job.executionCount ?? 0}/${job.maxExecutions ?? '∞'}`,
+      );
+      if (job.prompt) console.log(`${pc.bold('Prompt:')}      ${truncate(job.prompt, 80)}`);
+      if (job.createdAt) console.log(`${pc.bold('Created:')}     ${timeAgo(job.createdAt)}`);
+      if (job.updatedAt) console.log(`${pc.bold('Updated:')}     ${timeAgo(job.updatedAt)}`);
+    });
+
+  // ── create ────────────────────────────────────────────
+
+  cron
+    .command('create')
+    .description('Create a cron job')
+    .requiredOption('--agent-id <id>', 'Agent ID')
+    .requiredOption('-s, --schedule <cron>', 'Cron schedule expression')
+    .option('-n, --name <name>', 'Job name')
+    .option('-p, --prompt <prompt>', 'Prompt text')
+    .option('--max-executions <n>', 'Maximum number of executions')
+    .option('--json', 'Output JSON')
+    .action(
+      async (options: {
+        agentId: string;
+        json?: boolean;
+        maxExecutions?: string;
+        name?: string;
+        prompt?: string;
+        schedule: string;
+      }) => {
+        const client = await getTrpcClient();
+
+        const input: Record<string, any> = {
+          agentId: options.agentId,
+          cronPattern: options.schedule,
+        };
+        if (options.name) input.name = options.name;
+        if (options.prompt) input.content = options.prompt;
+        if (options.maxExecutions) input.maxExecutions = Number.parseInt(options.maxExecutions, 10);
+
+        const result = await client.agentCronJob.create.mutate(input as any);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        const data = (result as any).data;
+        console.log(`${pc.green('✓')} Created cron job ${pc.bold(data?.id || '')}`);
+      },
+    );
+
+  // ── edit ───────────────────────────────────────────────
+
+  cron
+    .command('edit <id>')
+    .description('Update a cron job')
+    .option('-n, --name <name>', 'Job name')
+    .option('-s, --schedule <cron>', 'Cron schedule expression')
+    .option('-p, --prompt <prompt>', 'Prompt text')
+    .option('--max-executions <n>', 'Maximum number of executions')
+    .option('--enable', 'Enable the job')
+    .option('--disable', 'Disable the job')
+    .action(
+      async (
+        id: string,
+        options: {
+          disable?: boolean;
+          enable?: boolean;
+          maxExecutions?: string;
+          name?: string;
+          prompt?: string;
+          schedule?: string;
+        },
+      ) => {
+        const data: Record<string, any> = {};
+        if (options.name) data.name = options.name;
+        if (options.schedule) data.cronPattern = options.schedule;
+        if (options.prompt) data.content = options.prompt;
+        if (options.maxExecutions) data.maxExecutions = Number.parseInt(options.maxExecutions, 10);
+        if (options.enable) data.enabled = true;
+        if (options.disable) data.enabled = false;
+
+        if (Object.keys(data).length === 0) {
+          log.error(
+            'No changes specified. Use --name, --schedule, --prompt, --enable, or --disable.',
+          );
+          process.exit(1);
+        }
+
+        const client = await getTrpcClient();
+        await client.agentCronJob.update.mutate({ data, id } as any);
+        console.log(`${pc.green('✓')} Updated cron job ${pc.bold(id)}`);
+      },
+    );
+
+  // ── delete ────────────────────────────────────────────
+
+  cron
+    .command('delete <id>')
+    .description('Delete a cron job')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(async (id: string, options: { yes?: boolean }) => {
+      if (!options.yes) {
+        const confirmed = await confirm('Are you sure you want to delete this cron job?');
+        if (!confirmed) {
+          console.log('Cancelled.');
+          return;
+        }
+      }
+
+      const client = await getTrpcClient();
+      await client.agentCronJob.delete.mutate({ id });
+      console.log(`${pc.green('✓')} Deleted cron job ${pc.bold(id)}`);
+    });
+
+  // ── toggle ────────────────────────────────────────────
+
+  cron
+    .command('toggle <ids...>')
+    .description('Batch enable or disable cron jobs')
+    .option('--enable', 'Enable the jobs')
+    .option('--disable', 'Disable the jobs')
+    .action(async (ids: string[], options: { disable?: boolean; enable?: boolean }) => {
+      if (!options.enable && !options.disable) {
+        log.error('Specify --enable or --disable.');
+        process.exit(1);
+      }
+
+      const enabled = !!options.enable;
+      const client = await getTrpcClient();
+      const result = await client.agentCronJob.batchUpdateStatus.mutate({ enabled, ids });
+      const count = (result as any).data?.updatedCount ?? ids.length;
+      console.log(`${pc.green('✓')} ${enabled ? 'Enabled' : 'Disabled'} ${count} cron job(s)`);
+    });
+
+  // ── reset ─────────────────────────────────────────────
+
+  cron
+    .command('reset <id>')
+    .description('Reset execution count for a cron job')
+    .option('--max <n>', 'Set new max executions')
+    .action(async (id: string, options: { max?: string }) => {
+      const client = await getTrpcClient();
+
+      const input: Record<string, any> = { id };
+      if (options.max) input.newMaxExecutions = Number.parseInt(options.max, 10);
+
+      await client.agentCronJob.resetExecutions.mutate(input as any);
+      console.log(`${pc.green('✓')} Reset execution count for ${pc.bold(id)}`);
+    });
+
+  // ── stats ─────────────────────────────────────────────
+
+  cron
+    .command('stats')
+    .description('Get cron job execution statistics')
+    .option('--json', 'Output JSON')
+    .action(async (options: { json?: boolean }) => {
+      const client = await getTrpcClient();
+      const result = await client.agentCronJob.getStats.query();
+      const stats = (result as any).data;
+
+      if (options.json) {
+        console.log(JSON.stringify(stats, null, 2));
+        return;
+      }
+
+      if (!stats) {
+        console.log('No statistics available.');
+        return;
+      }
+
+      for (const [key, value] of Object.entries(stats as Record<string, any>)) {
+        console.log(`${pc.bold(key + ':')} ${value}`);
+      }
+    });
+}

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

@@ -145,7 +145,7 @@ export function registerReviewCommands(task: Command) {
 
   rc.command('add <id>')
     .description('Add a review rubric')
-    .requiredOption('-n, --name <name>', 'Rubric name (e.g. "Content Accuracy")')
+    .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)')

apps/cli/src/program.ts

@@ -8,6 +8,7 @@ import { registerBotCommand } from './commands/bot';
 import { registerCompletionCommand } from './commands/completion';
 import { registerConfigCommand } from './commands/config';
 import { registerConnectCommand } from './commands/connect';
+import { registerCronCommand } from './commands/cron';
 import { registerDeviceCommand } from './commands/device';
 import { registerDocCommand } from './commands/doc';
 import { registerEvalCommand } from './commands/eval';
@@ -59,6 +60,7 @@ export function createProgram() {
   registerAgentCommand(program);
   registerAgentGroupCommand(program);
   registerBotCommand(program);
+  registerCronCommand(program);
   registerGenerateCommand(program);
   registerFileCommand(program);
   registerHeteroCommand(program);

apps/desktop/scripts/i18nWorkflow/genDefaultLocale.ts

@@ -7,18 +7,18 @@ import { entryLocaleJsonFilepath, i18nConfig, localeDir, srcDefaultLocales } fro
 import { tagWhite, writeJSON } from './utils';
 
 export const genDefaultLocale = () => {
-  consola.info(`Default locale: ${i18nConfig.entryLocale}...`);
+  consola.info(`默认语言为 ${i18nConfig.entryLocale}...`);
 
   // Ensure entry locale directory exists
   const entryLocaleDir = localeDir(i18nConfig.entryLocale);
   if (!existsSync(entryLocaleDir)) {
     mkdirSync(entryLocaleDir, { recursive: true });
-    consola.info(`Creating directory: ${entryLocaleDir}`);
+    consola.info(`创建目录：${entryLocaleDir}`);
   }
 
   const resources = require(srcDefaultLocales);
   const data = Object.entries(resources.default);
-  consola.start(`Generating default locale JSON files, found ${data.length} namespaces...`);
+  consola.start(`生成默认语言 JSON 文件，发现 ${data.length} 个命名空间...`);
 
   for (const [ns, value] of data) {
     const filepath = entryLocaleJsonFilepath(`${ns}.json`);

apps/desktop/scripts/i18nWorkflow/genDiff.ts

@@ -13,7 +13,7 @@ import {
 import { readJSON, tagWhite, writeJSON } from './utils';
 
 export const genDiff = () => {
-  consola.start(`Comparing localization files between dev and prod environments...`);
+  consola.start(`对比开发与生产环境中的本地化文件...`);
 
   const resources = require(srcDefaultLocales);
   const data = Object.entries(resources.default);
@@ -21,7 +21,7 @@ export const genDiff = () => {
   for (const [ns, devJSON] of data) {
     const filepath = entryLocaleJsonFilepath(`${ns}.json`);
     if (!existsSync(filepath)) {
-      consola.info(`File does not exist, skipping: ${filepath}`);
+      consola.info(`文件不存在，跳过：${filepath}`);
       continue;
     }
 
@@ -50,7 +50,7 @@ export const genDiff = () => {
     }
 
     if (clearLocals.length > 0) {
-      consola.info('Cleaned up stale entries for the following locales:', clearLocals.join(', '));
+      consola.info('清理了以下语言的过期项目：', clearLocals.join(', '));
     }
     consola.success(tagWhite(ns), colors.gray(filepath));
   }

apps/desktop/scripts/i18nWorkflow/index.ts

@@ -21,15 +21,15 @@ const run = async () => {
   ensureLocalesDirs();
 
   // Diff analysis
-  split('Diff Analysis');
+  split('差异分析');
   genDiff();
 
   // Generate default locale files
-  split('Generate Default Locale Files');
+  split('生成默认语言文件');
   genDefaultLocale();
 
   // Generate i18n files
-  split('Generate i18n Files');
+  split('生成国际化文件');
 };
 
 run();

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

@@ -1,9 +1,7 @@
 import type { ChildProcess } from 'node:child_process';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { unlinkSync } from 'node:fs';
-import { access, appendFile, mkdir, unlink, writeFile } from 'node:fs/promises';
-import os from 'node:os';
+import { access, appendFile, mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import type { Readable, Writable } from 'node:stream';
 import { finished as streamFinished } from 'node:stream/promises';
@@ -16,8 +14,6 @@ import {
   CODEX_CLI_INSTALL_DOCS_URL,
   HeterogeneousAgentSessionErrorCode,
 } from '@lobechat/electron-client-ipc';
-import type { AskUserBridge } from '@lobechat/heterogeneous-agents/askUser';
-import { AskUserMcpServer } from '@lobechat/heterogeneous-agents/askUser';
 import type { AgentContentBlock } from '@lobechat/heterogeneous-agents/spawn';
 import {
   AgentStreamPipeline,
@@ -103,18 +99,6 @@ interface CancelSessionParams {
   sessionId: string;
 }
 
-interface SubmitInterventionParams {
-  cancelled?: boolean;
-  /** When set, signals user-cancelled or timeout — the bridge resolves with isError. */
-  cancelReason?: 'timeout' | 'user_cancelled';
-  /** Operation id stamped on the request the renderer is responding to. */
-  operationId: string;
-  /** Structured user answer; ignored when `cancelled` is true. */
-  result?: unknown;
-  /** Correlation key carried on the original `agent_intervention_request`. */
-  toolCallId: string;
-}
-
 interface StopSessionParams {
   sessionId: string;
 }
@@ -166,28 +150,10 @@ interface CliTraceSession {
  *
  * Lifecycle: startSession → sendPrompt → (heteroAgentEvent broadcasts) → stopSession
  */
-interface InterventionSlot {
-  bridge: AskUserBridge;
-  /** Resolves once bridge.events() iterator ends (after `cancelAll`). */
-  pumpDone: Promise<void>;
-  /** Path to the per-op temp `mcp.json` we wrote for `--mcp-config`. */
-  tmpConfigPath: string;
-}
-
 export default class HeterogeneousAgentCtr extends ControllerModule {
   static override readonly groupName = 'heterogeneousAgent';
 
   private sessions = new Map<string, AgentSession>();
-  /**
-   * Per-operation AskUserQuestion bridge state. Keyed by `operationId` so the
-   * `submitIntervention` IPC can route an answer to the right pending MCP
-   * handler regardless of which `sessionId` it belongs to (one session can
-   * fire many ops over its lifetime).
-   */
-  private opIdToIntervention = new Map<string, InterventionSlot>();
-  /** Lazy single MCP server, started on first claude-code prompt. */
-  private askUserMcpServer?: AskUserMcpServer;
-  private askUserMcpStartPromise?: Promise<AskUserMcpServer>;
 
   private resolveSessionCommand(session: AgentSession): string {
     const resolvedCommand = session.command.trim();
@@ -601,92 +567,6 @@ export default class HeterogeneousAgentCtr extends ControllerModule {
     }
   }
 
-  // ─── AskUserQuestion MCP server (LOBE-8725) ───
-
-  /**
-   * Lazy single-instance MCP server for CC's AskUserQuestion replacement.
-   * First claude-code prompt triggers `start()`; subsequent prompts reuse
-   * the same listener. Concurrent first-callers de-dupe via the in-flight
-   * promise so we don't bind two ports.
-   */
-  private async ensureAskUserMcpServerStarted(): Promise<AskUserMcpServer> {
-    if (this.askUserMcpServer) return this.askUserMcpServer;
-    if (!this.askUserMcpStartPromise) {
-      this.askUserMcpStartPromise = (async () => {
-        const server = new AskUserMcpServer();
-        await server.start();
-        this.askUserMcpServer = server;
-        logger.info('AskUserQuestion MCP server started:', server.url);
-        return server;
-      })().catch((err) => {
-        // Reset so a later sendPrompt can retry; surface the error.
-        this.askUserMcpStartPromise = undefined;
-        logger.error('Failed to start AskUserQuestion MCP server:', err);
-        throw err;
-      });
-    }
-    return this.askUserMcpStartPromise;
-  }
-
-  /**
-   * Register a per-op AskUserQuestion bridge, write its temp `mcp.json`,
-   * and start pumping the bridge's outbound events into the regular
-   * `heteroAgentEvent` broadcast. Caller must invoke the returned cleanup
-   * after the spawn finishes (success, error, or cancel) to remove the
-   * temp file and tear down the bridge.
-   *
-   * Pump errors are logged but never thrown — they don't fail the spawn.
-   */
-  private async setupInterventionForOp(
-    operationId: string,
-    sessionId: string,
-  ): Promise<{ cleanup: () => Promise<void>; tmpConfigPath: string }> {
-    const server = await this.ensureAskUserMcpServerStarted();
-    const bridge = server.registerOperation(operationId);
-    const tmpConfigPath = path.join(os.tmpdir(), `lobe-cc-mcp-${operationId}.json`);
-
-    // `alwaysLoad: true` is the undocumented CC flag that promotes our
-    // server's tool out of the deferred set so the model calls it directly
-    // (no ToolSearch hop). See LOBE-8725 spike notes — falls back to the
-    // 2-hop ToolSearch path if a future CC drops the flag, no breakage.
-    const config = {
-      mcpServers: {
-        lobe_cc: {
-          alwaysLoad: true,
-          type: 'http' as const,
-          url: server.urlForOperation(operationId),
-        },
-      },
-    };
-    await writeFile(tmpConfigPath, JSON.stringify(config), 'utf8');
-
-    // Pump bridge.events() into the `heteroAgentEvent` broadcast. The
-    // iterator only ends after `cancelAll()`, so `pumpDone` resolves at
-    // cleanup time and gates teardown.
-    const pumpDone = (async () => {
-      for await (const event of bridge.events()) {
-        this.broadcast('heteroAgentEvent', { event, sessionId });
-      }
-    })().catch((err) => {
-      logger.warn('AskUserQuestion bridge pump error:', err);
-    });
-
-    this.opIdToIntervention.set(operationId, { bridge, pumpDone, tmpConfigPath });
-
-    const cleanup = async () => {
-      // Unregistering on the server cancels all bridge pendings AND closes
-      // the events iterator (cancelAll fires from within unregisterOperation).
-      this.askUserMcpServer?.unregisterOperation(operationId);
-      await pumpDone;
-      this.opIdToIntervention.delete(operationId);
-      await unlink(tmpConfigPath).catch(() => {
-        /* file may already be gone if app crashed mid-prompt */
-      });
-    };
-
-    return { cleanup, tmpConfigPath };
-  }
-
   // ─── File cache ───
 
   private get fileCacheDir(): string {
@@ -817,58 +697,32 @@ export default class HeterogeneousAgentCtr extends ControllerModule {
       throw new Error(preflightError.message);
     }
 
-    // Stand up the AskUserQuestion MCP bridge for claude-code prompts BEFORE
-    // building the spawn plan so the driver can wire the temp config path
-    // into `--mcp-config`. Codex / future agents skip this entirely.
-    const intervention =
-      session.agentType === 'claude-code'
-        ? await this.setupInterventionForOp(params.operationId, session.sessionId).catch((err) => {
-            logger.warn('Failed to set up AskUserQuestion bridge — proceeding without it:', err);
-            return undefined;
-          })
-        : undefined;
-
-    let spawnPlan;
-    let traceSession;
-    let cwd: string;
-    try {
-      const driver = getHeterogeneousAgentDriver(session.agentType);
-      spawnPlan = await driver.buildSpawnPlan({
-        args: session.args,
-        helpers: {
-          buildClaudeStreamJsonInput: (prompt, imageList) =>
-            this.buildStreamJsonInput(prompt, imageList),
-          resolveCliImagePaths: (imageList) => this.resolveCliImagePaths(imageList),
-        },
-        imageList: params.imageList ?? [],
-        mcpConfigPath: intervention?.tmpConfigPath,
-        prompt: params.prompt,
-        resumeSessionId: session.agentSessionId,
-      });
-
-      // Fall back to the user's Desktop so the process never inherits
-      // the Electron parent's cwd (which is `/` when launched from Finder).
-      cwd = session.cwd || electronApp.getPath('desktop');
-      traceSession = await this.createCliTraceSession({
-        cliArgs: spawnPlan.args,
-        cwd,
-        imageList: params.imageList ?? [],
-        session,
-        stdinPayload: spawnPlan.stdinPayload,
-      });
-    } catch (err) {
-      // We never made it to spawn — the `proc.on('exit')` cleanup path
-      // won't run, so tear the intervention bridge down right here.
-      if (intervention) {
-        await intervention.cleanup().catch((cleanupErr) => {
-          logger.warn('AskUserQuestion cleanup error during pre-spawn failure:', cleanupErr);
-        });
-      }
-      throw err;
-    }
+    const driver = getHeterogeneousAgentDriver(session.agentType);
+    const spawnPlan = await driver.buildSpawnPlan({
+      args: session.args,
+      helpers: {
+        buildClaudeStreamJsonInput: (prompt, imageList) =>
+          this.buildStreamJsonInput(prompt, imageList),
+        resolveCliImagePaths: (imageList) => this.resolveCliImagePaths(imageList),
+      },
+      imageList: params.imageList ?? [],
+      prompt: params.prompt,
+      resumeSessionId: session.agentSessionId,
+    });
     const useStdin = spawnPlan.stdinPayload !== undefined;
     const cliArgs = spawnPlan.args;
 
+    // Fall back to the user's Desktop so the process never inherits
+    // the Electron parent's cwd (which is `/` when launched from Finder).
+    const cwd = session.cwd || electronApp.getPath('desktop');
+    const traceSession = await this.createCliTraceSession({
+      cliArgs,
+      cwd,
+      imageList: params.imageList ?? [],
+      session,
+      stdinPayload: spawnPlan.stdinPayload,
+    });
+
     return new Promise<void>((resolve, reject) => {
       logger.info('Spawning agent:', session.command, cliArgs.join(' '), `(cwd: ${cwd})`);
 
@@ -885,11 +739,7 @@ export default class HeterogeneousAgentCtr extends ControllerModule {
       const proc = spawn(session.command, cliArgs, {
         cwd,
         detached: process.platform !== 'win32',
-        // `spawnPlan.env` carries driver-mandated overrides (e.g. Claude Code
-        // sets `CLAUDE_CODE_ENTRYPOINT=sdk-ts` to unlock non-`-p` stream-json
-        // + control protocol). `session.env` still wins so the user can
-        // override anything via per-session config.
-        env: { ...process.env, ...proxyEnv, ...spawnPlan.env, ...session.env },
+        env: { ...process.env, ...proxyEnv, ...session.env },
         stdio: [useStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
       });
 
@@ -988,15 +838,6 @@ export default class HeterogeneousAgentCtr extends ControllerModule {
         void stdoutDrained
           .then(() => stdoutBroadcastQueue)
           .finally(async () => {
-            // Tear down the AskUserQuestion bridge / temp `mcp.json` for this
-            // op. Pending MCP handlers get a `session_ended` cancellation so
-            // they return cleanly even if CC was killed mid-tool-call.
-            if (intervention) {
-              await intervention.cleanup().catch((err) => {
-                logger.warn('AskUserQuestion cleanup error:', err);
-              });
-            }
-
             void this.writeCliTraceJson(traceSession, 'exit.json', {
               code,
               finishedAt: new Date().toISOString(),
@@ -1131,54 +972,10 @@ export default class HeterogeneousAgentCtr extends ControllerModule {
   }
 
   /**
-   * Renderer → main: deliver the user's answer to a pending CC AskUserQuestion
-   * (or signal cancellation). The matching bridge resolves its blocked
-   * `pending()` Promise, the local MCP handler returns to CC, and CC's
-   * `tool_result` flows back through the normal stream pipeline.
-   *
-   * Idempotent — late submissions for already-resolved tool calls are no-ops.
-   * No-op when called for an unknown opId; the bridge may have been cleaned
-   * up already (op finished / cancelled).
-   */
-  @IpcMethod()
-  async submitIntervention(params: SubmitInterventionParams): Promise<void> {
-    const slot = this.opIdToIntervention.get(params.operationId);
-    if (!slot) {
-      logger.warn('submitIntervention: no active intervention for operationId', params.operationId);
-      return;
-    }
-    slot.bridge.resolve(params.toolCallId, {
-      cancelReason: params.cancelled ? (params.cancelReason ?? 'user_cancelled') : undefined,
-      cancelled: params.cancelled,
-      result: params.result,
-    });
-  }
-
-  /**
-   * Synchronously unlink every pending intervention's temp `mcp.json`. The
-   * async exit-handler cleanup loses to Electron's main-process teardown
-   * often enough that we'd leak `lobe-cc-mcp-<opId>.json` files into
-   * `os.tmpdir()` on real shutdowns; sync unlink here is the only reliable
-   * guarantee. Safe to call multiple times.
-   */
-  private unlinkPendingInterventionConfigsSync = (): void => {
-    for (const [, intervention] of this.opIdToIntervention) {
-      try {
-        unlinkSync(intervention.tmpConfigPath);
-      } catch {
-        /* file may already be gone — fine */
-      }
-    }
-  };
-
-  /**
-   * Cleanup on app quit. `before-quit` covers the user-driven Cmd+Q /
-   * `app.quit()` path; SIGTERM / SIGINT cover external kills (test
-   * harnesses, OS shutdown) where Electron's lifecycle events never fire.
+   * Cleanup on app quit.
    */
   afterAppReady() {
     electronApp.on('before-quit', () => {
-      this.unlinkPendingInterventionConfigsSync();
       for (const [, session] of this.sessions) {
         if (session.process && !session.process.killed) {
           session.cancelledByUs = true;
@@ -1186,28 +983,6 @@ export default class HeterogeneousAgentCtr extends ControllerModule {
         }
       }
       this.sessions.clear();
-      // The exit handlers will tear each per-op intervention down, but if
-      // CC's stdio close races shutdown we'd leave the MCP server bound to
-      // a port. Stopping it here cancels every still-pending bridge with
-      // `session_ended` and closes the listener.
-      void this.askUserMcpServer?.stop().catch((err) => {
-        logger.warn('AskUserQuestion MCP server stop error:', err);
-      });
     });
-
-    const onSignal = (signal: NodeJS.Signals) => {
-      this.unlinkPendingInterventionConfigsSync();
-      // Defer to Electron's normal quit flow so the rest of the app gets a
-      // chance to tear down. The `before-quit` handler above is idempotent.
-      try {
-        electronApp.quit();
-      } catch {
-        /* during late shutdown app.quit may throw — fine */
-      }
-      // Last-resort exit if Electron is wedged and won't quit on its own.
-      setTimeout(() => process.exit(signal === 'SIGINT' ? 130 : 143), 1000).unref();
-    };
-    process.on('SIGTERM', onSignal);
-    process.on('SIGINT', onSignal);
   }
 }

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

@@ -802,131 +802,4 @@ describe('HeterogeneousAgentCtr', () => {
       expect(toolEnds.length).toBeGreaterThan(0);
     });
   });
-
-  describe('app-quit cleanup of AskUserQuestion temp configs (LOBE-8725)', () => {
-    // The async exit-handler cleanup races Electron's main-process teardown
-    // and used to leak `lobe-cc-mcp-<opId>.json` files in `os.tmpdir()` on
-    // every quit. The controller now unlinks pending intervention temp
-    // configs *synchronously* from `before-quit` AND from process signal
-    // handlers (SIGTERM / SIGINT — `before-quit` doesn't fire on external
-    // kills). These tests exercise both paths against real files.
-
-    /**
-     * Drop a temp `lobe-cc-mcp-<id>.json` and stash it on the controller's
-     * `opIdToIntervention` map under the same key, so the quit hook treats
-     * it like a real pending intervention and tries to unlink it.
-     */
-    const seedPendingIntervention = async (ctr: HeterogeneousAgentCtr, opId: string) => {
-      const tmpConfigPath = path.join(tmpdir(), `lobe-cc-mcp-test-${opId}.json`);
-      await writeFile(tmpConfigPath, '{"mcpServers":{}}');
-      const slot = {
-        bridge: {} as any,
-        pumpDone: Promise.resolve(),
-        tmpConfigPath,
-      };
-      (ctr as any).opIdToIntervention.set(opId, slot);
-      return tmpConfigPath;
-    };
-
-    const captureRegisteredHandler = (
-      registerSpy: ReturnType<typeof vi.fn> | ReturnType<typeof vi.spyOn>,
-      eventName: string,
-    ): (() => void) => {
-      const calls = (registerSpy as any).mock.calls as Array<[string, () => void]>;
-      const match = calls.findLast(([evt]) => evt === eventName);
-      if (!match) throw new Error(`no handler registered for "${eventName}"`);
-      return match[1];
-    };
-
-    it('before-quit synchronously unlinks every pending intervention temp config', async () => {
-      const electron = (await import('electron')) as any;
-      electron.app.on.mockClear();
-
-      const ctr = new HeterogeneousAgentCtr({
-        appStoragePath,
-        storeManager: { get: vi.fn() },
-      } as any);
-
-      const fileA = await seedPendingIntervention(ctr, 'opA');
-      const fileB = await seedPendingIntervention(ctr, 'opB');
-
-      ctr.afterAppReady();
-      const beforeQuit = captureRegisteredHandler(electron.app.on, 'before-quit');
-      beforeQuit();
-
-      await expect(access(fileA)).rejects.toThrow();
-      await expect(access(fileB)).rejects.toThrow();
-    });
-
-    it('SIGTERM handler unlinks pending intervention temp configs (external-kill path)', async () => {
-      // External kills (test harness, OS shutdown) skip Electron's lifecycle
-      // events entirely — `before-quit` never fires, so the controller has to
-      // hook the raw process signal too. Stub `process.on` so the handler is
-      // *recorded* but never actually attached to the test runner's process
-      // (otherwise the test leaks a SIGTERM listener that survives the test).
-      // Same for `process.exit` — the controller's fail-safe shouldn't get a
-      // chance to actually exit the worker if its `setTimeout(...).unref()`
-      // ever fires before mockRestore.
-      const electron = (await import('electron')) as any;
-      electron.app.on.mockClear();
-      const processOnSpy = vi.spyOn(process, 'on').mockImplementation(() => process);
-      const processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-
-      const ctr = new HeterogeneousAgentCtr({
-        appStoragePath,
-        storeManager: { get: vi.fn() },
-      } as any);
-      const file = await seedPendingIntervention(ctr, 'opSigterm');
-
-      ctr.afterAppReady();
-      const sigterm = captureRegisteredHandler(processOnSpy, 'SIGTERM');
-      sigterm();
-
-      await expect(access(file)).rejects.toThrow();
-
-      processOnSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('SIGINT handler unlinks pending intervention temp configs (Ctrl-C path)', async () => {
-      const electron = (await import('electron')) as any;
-      electron.app.on.mockClear();
-      const processOnSpy = vi.spyOn(process, 'on').mockImplementation(() => process);
-      const processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-
-      const ctr = new HeterogeneousAgentCtr({
-        appStoragePath,
-        storeManager: { get: vi.fn() },
-      } as any);
-      const file = await seedPendingIntervention(ctr, 'opSigint');
-
-      ctr.afterAppReady();
-      const sigint = captureRegisteredHandler(processOnSpy, 'SIGINT');
-      sigint();
-
-      await expect(access(file)).rejects.toThrow();
-
-      processOnSpy.mockRestore();
-      processExitSpy.mockRestore();
-    });
-
-    it('cleanup is idempotent — already-deleted files do not throw', async () => {
-      const electron = (await import('electron')) as any;
-      electron.app.on.mockClear();
-
-      const ctr = new HeterogeneousAgentCtr({
-        appStoragePath,
-        storeManager: { get: vi.fn() },
-      } as any);
-      const file = await seedPendingIntervention(ctr, 'opIdempotent');
-
-      // Pre-delete the file out from under the controller — simulates a
-      // partial cleanup race where the async exit handler beat us to it.
-      await unlink(file);
-
-      ctr.afterAppReady();
-      const beforeQuit = captureRegisteredHandler(electron.app.on, 'before-quit');
-      expect(() => beforeQuit()).not.toThrow();
-    });
-  });
 });

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

@@ -1,176 +0,0 @@
-import fs from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { type App } from '@/core/App';
-
-import LocalFileCtr from '../LocalFileCtr';
-
-// Real fs + real @lobechat/file-loaders end-to-end. We only mock the
-// boundaries we genuinely cannot run in a test process: electron IPC,
-// execa shell-outs, logger, net fetch.
-vi.mock('electron', () => ({
-  dialog: { showOpenDialog: vi.fn(), showSaveDialog: vi.fn() },
-  ipcMain: { handle: vi.fn() },
-  shell: { openPath: vi.fn() },
-}));
-
-vi.mock('execa', () => ({ execa: vi.fn() }));
-
-vi.mock('@/utils/logger', () => ({
-  createLogger: () => ({
-    debug: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-  }),
-}));
-
-vi.mock('@/utils/net-fetch', () => ({ netFetch: vi.fn() }));
-
-vi.mock('@/utils/file-system', () => ({ makeSureDirExist: vi.fn() }));
-
-const mockApp = {
-  appStoragePath: '/mock/app/storage',
-  getService: vi.fn(),
-  toolDetectorManager: { getBestTool: vi.fn(() => null) },
-} as unknown as App;
-
-describe('LocalFileCtr — readFile / readFiles (real fs)', () => {
-  const tmpDir = path.join(os.tmpdir(), 'localfilectr-readfile-test-' + process.pid);
-  let localFileCtr: LocalFileCtr;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    await mkdir(tmpDir, { recursive: true });
-    localFileCtr = new LocalFileCtr(mockApp);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { force: true, recursive: true });
-  });
-
-  describe('readFile', () => {
-    it('should read file successfully with default location', async () => {
-      const filePath = path.join(tmpDir, 'test.txt');
-      const content = 'line1\nline2\nline3\nline4\nline5';
-      await writeFile(filePath, content);
-
-      const result = await localFileCtr.readFile({ path: filePath });
-
-      expect(result).toEqual({
-        charCount: 29,
-        content,
-        createdTime: expect.any(Date),
-        fileType: 'txt',
-        filename: 'test.txt',
-        lineCount: 5,
-        loc: [0, 200],
-        modifiedTime: expect.any(Date),
-        totalCharCount: 29,
-        totalLineCount: 5,
-      });
-    });
-
-    it('should read file with custom location range', async () => {
-      const filePath = path.join(tmpDir, 'range.txt');
-      await writeFile(filePath, 'line1\nline2\nline3\nline4\nline5');
-
-      const result = await localFileCtr.readFile({ loc: [1, 3], path: filePath });
-
-      expect(result).toEqual({
-        charCount: 11,
-        content: 'line2\nline3',
-        createdTime: expect.any(Date),
-        fileType: 'txt',
-        filename: 'range.txt',
-        lineCount: 2,
-        loc: [1, 3],
-        modifiedTime: expect.any(Date),
-        totalCharCount: 29,
-        totalLineCount: 5,
-      });
-    });
-
-    it('should read full file content when fullContent is true', async () => {
-      const filePath = path.join(tmpDir, 'full.txt');
-      const content = 'line1\nline2\nline3\nline4\nline5';
-      await writeFile(filePath, content);
-
-      const result = await localFileCtr.readFile({ fullContent: true, path: filePath });
-
-      expect(result).toEqual({
-        charCount: 29,
-        content,
-        createdTime: expect.any(Date),
-        fileType: 'txt',
-        filename: 'full.txt',
-        lineCount: 5,
-        loc: [0, 5],
-        modifiedTime: expect.any(Date),
-        totalCharCount: 29,
-        totalLineCount: 5,
-      });
-    });
-
-    it('should handle file read error', async () => {
-      const result = await localFileCtr.readFile({
-        path: path.join(tmpDir, 'does-not-exist.txt'),
-      });
-
-      expect(result).toEqual({
-        charCount: 0,
-        content: expect.stringContaining('Error accessing or processing file'),
-        createdTime: expect.any(Date),
-        fileType: 'txt',
-        filename: 'does-not-exist.txt',
-        lineCount: 0,
-        loc: [0, 0],
-        modifiedTime: expect.any(Date),
-        totalCharCount: 0,
-        totalLineCount: 0,
-      });
-    });
-  });
-
-  describe('readFiles', () => {
-    it('should read multiple files successfully', async () => {
-      const file1 = path.join(tmpDir, 'a.txt');
-      const file2 = path.join(tmpDir, 'b.txt');
-      await writeFile(file1, 'content a');
-      await writeFile(file2, 'content b');
-
-      const result = await localFileCtr.readFiles({ paths: [file1, file2] });
-
-      expect(result).toEqual([
-        {
-          charCount: 9,
-          content: 'content a',
-          createdTime: expect.any(Date),
-          fileType: 'txt',
-          filename: 'a.txt',
-          lineCount: 1,
-          loc: [0, 200],
-          modifiedTime: expect.any(Date),
-          totalCharCount: 9,
-          totalLineCount: 1,
-        },
-        {
-          charCount: 9,
-          content: 'content b',
-          createdTime: expect.any(Date),
-          fileType: 'txt',
-          filename: 'b.txt',
-          lineCount: 1,
-          loc: [0, 200],
-          modifiedTime: expect.any(Date),
-          totalCharCount: 9,
-          totalLineCount: 1,
-        },
-      ]);
-    });
-  });
-});

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

@@ -106,6 +106,7 @@ const mockApp = {
 describe('LocalFileCtr', () => {
   let localFileCtr: LocalFileCtr;
   let mockShell: any;
+  let mockLoadFile: any;
   let mockFsPromises: any;
 
   beforeEach(async () => {
@@ -113,6 +114,7 @@ describe('LocalFileCtr', () => {
 
     // Import mocks
     mockShell = (await import('electron')).shell;
+    mockLoadFile = (await import('@lobechat/file-loaders')).loadFile;
     mockFsPromises = await import('node:fs/promises');
 
     localFileCtr = new LocalFileCtr(mockApp);
@@ -176,9 +178,91 @@ describe('LocalFileCtr', () => {
     });
   });
 
-  // readFile / readFiles e2e tests live in LocalFileCtr.readFile.test.ts so
-  // they exercise real fs + file-loaders without fighting the heavy mocks
-  // this suite needs for execa-driven tools, electron, and the like.
+  describe('readFile', () => {
+    it('should read file successfully with default location', async () => {
+      const mockFileContent = 'line1\nline2\nline3\nline4\nline5';
+      vi.mocked(mockLoadFile).mockResolvedValue({
+        content: mockFileContent,
+        filename: 'test.txt',
+        fileType: 'txt',
+        createdTime: new Date('2024-01-01'),
+        modifiedTime: new Date('2024-01-02'),
+      });
+
+      const result = await localFileCtr.readFile({ path: '/test/file.txt' });
+
+      expect(result.filename).toBe('test.txt');
+      expect(result.fileType).toBe('txt');
+      expect(result.totalLineCount).toBe(5);
+      expect(result.content).toBe(mockFileContent);
+    });
+
+    it('should read file with custom location range', async () => {
+      const mockFileContent = 'line1\nline2\nline3\nline4\nline5';
+      vi.mocked(mockLoadFile).mockResolvedValue({
+        content: mockFileContent,
+        filename: 'test.txt',
+        fileType: 'txt',
+        createdTime: new Date('2024-01-01'),
+        modifiedTime: new Date('2024-01-02'),
+      });
+
+      const result = await localFileCtr.readFile({ path: '/test/file.txt', loc: [1, 3] });
+
+      expect(result.content).toBe('line2\nline3');
+      expect(result.lineCount).toBe(2);
+      expect(result.totalLineCount).toBe(5);
+    });
+
+    it('should read full file content when fullContent is true', async () => {
+      const mockFileContent = 'line1\nline2\nline3\nline4\nline5';
+      vi.mocked(mockLoadFile).mockResolvedValue({
+        content: mockFileContent,
+        filename: 'test.txt',
+        fileType: 'txt',
+        createdTime: new Date('2024-01-01'),
+        modifiedTime: new Date('2024-01-02'),
+      });
+
+      const result = await localFileCtr.readFile({ path: '/test/file.txt', fullContent: true });
+
+      expect(result.content).toBe(mockFileContent);
+      expect(result.lineCount).toBe(5);
+      expect(result.charCount).toBe(mockFileContent.length);
+      expect(result.totalLineCount).toBe(5);
+      expect(result.totalCharCount).toBe(mockFileContent.length);
+      expect(result.loc).toEqual([0, 5]);
+    });
+
+    it('should handle file read error', async () => {
+      vi.mocked(mockLoadFile).mockRejectedValue(new Error('File not found'));
+
+      const result = await localFileCtr.readFile({ path: '/test/missing.txt' });
+
+      expect(result.content).toContain('Error accessing or processing file');
+      expect(result.lineCount).toBe(0);
+      expect(result.charCount).toBe(0);
+    });
+  });
+
+  describe('readFiles', () => {
+    it('should read multiple files successfully', async () => {
+      vi.mocked(mockLoadFile).mockResolvedValue({
+        content: 'file content',
+        filename: 'test.txt',
+        fileType: 'txt',
+        createdTime: new Date('2024-01-01'),
+        modifiedTime: new Date('2024-01-02'),
+      });
+
+      const result = await localFileCtr.readFiles({
+        paths: ['/test/file1.txt', '/test/file2.txt'],
+      });
+
+      expect(result).toHaveLength(2);
+      expect(mockLoadFile).toHaveBeenCalledTimes(2);
+    });
+  });
 
   describe('handleWriteFile', () => {
     it('should write file successfully', async () => {

apps/desktop/src/main/modules/heterogeneousAgent/drivers/claudeCode.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type {
-  HeterogeneousAgentBuildPlanHelpers,
-  HeterogeneousAgentBuildPlanParams,
-} from '../types';
-import { claudeCodeDriver } from './claudeCode';
-
-const stubHelpers: HeterogeneousAgentBuildPlanHelpers = {
-  buildClaudeStreamJsonInput: async () => '{"type":"user","message":{}}\n',
-  resolveCliImagePaths: async () => [],
-};
-
-const buildParams = (
-  overrides: Partial<HeterogeneousAgentBuildPlanParams> = {},
-): HeterogeneousAgentBuildPlanParams => ({
-  args: [],
-  helpers: stubHelpers,
-  imageList: [],
-  prompt: 'hi',
-  ...overrides,
-});
-
-describe('claudeCodeDriver', () => {
-  it('omits --mcp-config when mcpConfigPath is undefined', async () => {
-    const { args } = await claudeCodeDriver.buildSpawnPlan(buildParams());
-    expect(args).not.toContain('--mcp-config');
-  });
-
-  it('omits -p and returns the sdk-ts entrypoint env', async () => {
-    // No `-p`: `CLAUDE_CODE_ENTRYPOINT=sdk-ts` unlocks non-`-p` stream-json
-    // and opens the control protocol channel. The controller merges this env
-    // into the spawned child's env before calling spawn().
-    const plan = await claudeCodeDriver.buildSpawnPlan(buildParams());
-    expect(plan.args).not.toContain('-p');
-    expect(plan.env?.CLAUDE_CODE_ENTRYPOINT).toBe('sdk-ts');
-  });
-
-  it('appends --mcp-config <path> when mcpConfigPath is provided', async () => {
-    const { args } = await claudeCodeDriver.buildSpawnPlan(
-      buildParams({ mcpConfigPath: '/tmp/lobe-cc-mcp-op-1.json' }),
-    );
-    const idx = args.indexOf('--mcp-config');
-    expect(idx).toBeGreaterThan(-1);
-    expect(args[idx + 1]).toBe('/tmp/lobe-cc-mcp-op-1.json');
-  });
-
-  it('still pins --disallowedTools AskUserQuestion alongside --mcp-config', async () => {
-    // Even with our local MCP replacement available, CC's built-in stays
-    // disabled — leaving both visible would let the model double-register
-    // the same name and pick the broken one.
-    const { args } = await claudeCodeDriver.buildSpawnPlan(
-      buildParams({ mcpConfigPath: '/tmp/x.json' }),
-    );
-    const disallowedIdx = args.indexOf('--disallowedTools');
-    expect(disallowedIdx).toBeGreaterThan(-1);
-    expect(args[disallowedIdx + 1]).toBe('AskUserQuestion');
-  });
-
-  it('--mcp-config goes before --resume so user --args can still override the resume id', async () => {
-    const { args } = await claudeCodeDriver.buildSpawnPlan(
-      buildParams({ mcpConfigPath: '/tmp/x.json', resumeSessionId: 'cc-prev-1' }),
-    );
-    const mcpIdx = args.indexOf('--mcp-config');
-    const resumeIdx = args.indexOf('--resume');
-    expect(mcpIdx).toBeGreaterThan(-1);
-    expect(resumeIdx).toBeGreaterThan(-1);
-    expect(mcpIdx).toBeLessThan(resumeIdx);
-    expect(args[resumeIdx + 1]).toBe('cc-prev-1');
-  });
-});

apps/desktop/src/main/modules/heterogeneousAgent/drivers/claudeCode.ts

@@ -1,13 +1,12 @@
-import { CLAUDE_CODE_BASE_ARGS, CLAUDE_CODE_SPAWN_ENV } from '@lobechat/heterogeneous-agents/spawn';
-
 import type { HeterogeneousAgentBuildPlanParams, HeterogeneousAgentDriver } from '../types';
 
-// Desktop runs CC as the user (never root, so bypassPermissions is fine) and
-// renders the chat bubble live, so it always wants partial deltas. Compose
-// the shared invariant base args (`@lobechat/heterogeneous-agents/spawn`)
-// with those caller-specific flags.
-const DESKTOP_CLAUDE_CODE_ARGS = [
-  ...CLAUDE_CODE_BASE_ARGS,
+const CLAUDE_CODE_BASE_ARGS = [
+  '-p',
+  '--input-format',
+  'stream-json',
+  '--output-format',
+  'stream-json',
+  '--verbose',
   '--include-partial-messages',
   '--permission-mode',
   'bypassPermissions',
@@ -18,7 +17,6 @@ export const claudeCodeDriver: HeterogeneousAgentDriver = {
     args,
     helpers,
     imageList,
-    mcpConfigPath,
     prompt,
     resumeSessionId,
   }: HeterogeneousAgentBuildPlanParams) {
@@ -26,15 +24,10 @@ export const claudeCodeDriver: HeterogeneousAgentDriver = {
 
     return {
       args: [
-        ...DESKTOP_CLAUDE_CODE_ARGS,
-        // Wire the controller-managed temp mcp.json (AskUserQuestion server,
-        // see LOBE-8725) when present. Path-based config is required — CC
-        // does not accept inline JSON for `--mcp-config`.
-        ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath] : []),
+        ...CLAUDE_CODE_BASE_ARGS,
         ...(resumeSessionId ? ['--resume', resumeSessionId] : []),
         ...args,
       ],
-      env: { ...CLAUDE_CODE_SPAWN_ENV },
       stdinPayload,
     };
   },

apps/desktop/src/main/modules/heterogeneousAgent/types.ts

@@ -5,12 +5,6 @@ export interface HeterogeneousAgentImageAttachment {
 
 export interface HeterogeneousAgentBuildPlan {
   args: string[];
-  /**
-   * Extra environment variables the controller MUST merge into the spawned
-   * child's env. Used by Claude Code to set `CLAUDE_CODE_ENTRYPOINT=sdk-ts`,
-   * which unlocks non-`-p` stream-json + the control protocol side channel.
-   */
-  env?: Record<string, string>;
   stdinPayload?: string;
 }
 
@@ -26,12 +20,6 @@ export interface HeterogeneousAgentBuildPlanParams {
   args: string[];
   helpers: HeterogeneousAgentBuildPlanHelpers;
   imageList: HeterogeneousAgentImageAttachment[];
-  /**
-   * Optional path to an MCP config JSON written by the controller (e.g. for
-   * the local `lobe_cc` AskUserQuestion server). Drivers that recognize the
-   * field append `--mcp-config <path>`; others ignore it.
-   */
-  mcpConfigPath?: string;
   prompt: string;
   resumeSessionId?: string;
 }

apps/device-gateway/src/DeviceGatewayDO.ts

@@ -345,7 +345,7 @@ export class DeviceGatewayDO extends DurableObject<Env> {
     const sockets = this.getAuthenticatedSockets();
     if (sockets.length === 0) {
       return Response.json(
-        { content: 'Desktop device offline', error: 'DEVICE_OFFLINE', success: false },
+        { content: '桌面设备不在线', error: 'DEVICE_OFFLINE', success: false },
         { status: 503 },
       );
     }
@@ -395,7 +395,7 @@ export class DeviceGatewayDO extends DurableObject<Env> {
     } catch (err) {
       return Response.json(
         {
-          content: `Tool call timed out (${timeout / 1000}s)`,
+          content: `工具调用超时（${timeout / 1000}s）`,
           error: (err as Error).message,
           success: false,
         },

docs/.cdn.cache.json

@@ -1,6 +1,5 @@
 {
   "https://file.rene.wang/540830955-0fe626a3-0ddc-4f67-b595-3c5b3f1701e0.png": "/blog/assetsa8e504275f2cd891fabecca985998de0.webp",
-  "https://file.rene.wang/Changelog-Seedance.png": "/blog/assetsb2bf4ddf0a45ff887a993c18cb7ab983.webp",
   "https://file.rene.wang/changlog-04-14.png": "/blog/assets300abe7e259d293da6c5ed4f642a1be6.webp",
   "https://file.rene.wang/clipboard-1768907980491-9cc0669fc3a38.png": "/blog/assets8be3a46c8f9c5d3b61bc541f44b7f245.webp",
   "https://file.rene.wang/clipboard-1768908081787-ed9eb1cb78bdb.png": "/blog/assetsab009b79dd794f02aec24b7607f342e8.webp",
@@ -54,8 +53,6 @@
   "https://file.rene.wang/clipboard-1774923001079-89ce6aa271a62.png": "/blog/assets53e6ec9cf72554dbc1f8224fc0550a03.webp",
   "https://file.rene.wang/clipboard-1775701725582-123f8f8cf73f8.png": "/blog/assets7ea204859aeb5aa9be5810a20ba1669a.webp",
   "https://file.rene.wang/clipboard-1776909505252-94b051f3ea0a7.png": "/blog/assetsdfda32866c4bc59af0526e52f31d1da2.webp",
-  "https://file.rene.wang/clipboard-1777343750668-9b3dcb0dfff86.png": "/blog/assetsfa267a02f20bc5ba6f1273bcf27b7c9f.webp",
-  "https://file.rene.wang/clipboard-1778331942656-f33b41b2dc439.png": "/blog/assets71fe5959cbc6f0a89243d7262f48fafc.webp",
   "https://file.rene.wang/lobehub/467951f5-ad65-498d-aea9-fca8f35a4314.png": "/blog/assets907ea775d228958baca38e2dbb65939a.webp",
   "https://file.rene.wang/lobehub/58d91528-373a-4a42-b520-cf6cb1f8ce1e.png": "/blog/assets7dccdd4df55aede71001da649639437f.webp",
   "https://file.rene.wang/lobehub/ee700103-3c08-41dc-9ddf-c7705bb7bc6a.png": "/blog/assets196d679bc7071abbf71f2a8566f05aa3.webp",
@@ -471,5 +468,7 @@
   "https://github.com/user-attachments/assets/fa8fab19-ace2-4f85-8428-a3a0e28845bb": "/blog/assets/2d678631c55369ba7d753c3ffcb73782.webp",
   "https://github.com/user-attachments/assets/facdc83c-e789-4649-8060-7f7a10a1b1dd": "/blog/assets05b20e40c03ced0ec8707fed2e8e0f25.webp",
   "https://github.com/user-attachments/assets/fcdfb9c5-819a-488f-b28d-0857fe861219": "/blog/assets8477415ecec1f37e38ab38ff1217d0a7.webp",
-  "https://github.com/user-attachments/assets/fd60ab55-ead2-4930-ad00-fdf77662f5a0": "/blog/assets276a4e8748e9bd300b30dcd9d0e24980.webp"
-}
+  "https://github.com/user-attachments/assets/fd60ab55-ead2-4930-ad00-fdf77662f5a0": "/blog/assets276a4e8748e9bd300b30dcd9d0e24980.webp",
+  "https://file.rene.wang/clipboard-1777343750668-9b3dcb0dfff86.png": "/blog/assetsfa267a02f20bc5ba6f1273bcf27b7c9f.webp",
+  "https://file.rene.wang/Changelog-Seedance.png": "/blog/assetsb2bf4ddf0a45ff887a993c18cb7ab983.webp"
+}

docs/changelog/2026-05-04-task-scheduler.mdx

@@ -1,8 +1,9 @@
 ---
-title: Delegate Claude Code and Codex
+title: 'Delegate Claude Code and Codex'
 description: >-
-  Delegate Claude Code and Codex from inside LobeHub, with a redesigned home, a
-  Review tab for bulk git diffs, visual understanding, and a wave of new models.
+  Delegate Claude Code and Codex from inside LobeHub, with a redesigned home, a Review tab for bulk git diffs, visual understanding, and a wave of new models.
+
+
 tags:
   - Coding agent
   - Claude Code
@@ -13,12 +14,9 @@ tags:
 
 # Delegate Claude Code and Codex
 
-Now you can control coding agents in LobeHub. Simply click `Create Agent` and choose your coding agent. This feature is only available on desktop app.
-
-![](/blog/assets71fe5959cbc6f0a89243d7262f48fafc.webp)
-
 ## Features
 
+- New: Delegate Claude Code and Codex in LobeHub
 - Agent-specific topic grouping: switch the topic list to group by agent, with a friendlier empty state
 - Review tab: a new tab that aggregates bulk git diffs across a tree, \~9× faster on large repos
 - Local file mention snapshots: drag a file into chat and a snapshot is captured for the model to reason over

docs/changelog/2026-05-04-task-scheduler.zh-CN.mdx

@@ -1,8 +1,6 @@
 ---
 title: 在 LobeHub 中调度 Claude Code 与 Codex
-description: >-
-  在 LobeHub 中直接调度 Claude Code 与 Codex，全新首页、批量 git diff 的 Review
-  标签页、视觉理解工具，以及一批新模型。
+description: 在 LobeHub 中直接调度 Claude Code 与 Codex，全新首页、批量 git diff 的 Review 标签页、视觉理解工具，以及一批新模型。
 tags:
   - 编程 Agent
   - Claude Code
@@ -13,10 +11,6 @@ tags:
 
 # 在 LobeHub 中调度 Claude Code 与 Codex
 
-现在你可以在 LobeHub 内使用 Coding Agents。新建助手时选择你最喜欢的 Coding Agent 即可。此功能仅在桌面端可用。
-
-![](/blog/assets71fe5959cbc6f0a89243d7262f48fafc.webp)
-
 ## 新功能
 
 - 新增：在 LobeHub 中调度 Claude Code 与 Codex

locales/ar/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "البحث في القوالب...",
   "groupWizard.title": "إنشاء مجموعة",
   "groupWizard.useTemplate": "استخدام قالب",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} مستودعات محددة",
-  "heteroAgent.cloudRepo.noRepos": "لم يتم تكوين أي مستودعات. أضفها في إعدادات الوكيل.",
-  "heteroAgent.cloudRepo.notSet": "لم يتم تحديد أي مستودع",
-  "heteroAgent.cloudRepo.sectionTitle": "المستودعات",
   "heteroAgent.fullAccess.label": "وصول كامل",
   "heteroAgent.fullAccess.tooltip": "يعمل Claude Code محليًا مع صلاحية قراءة/كتابة كاملة في دليل العمل. تبديل أوضاع الصلاحيات غير متاح بعد.",
   "heteroAgent.resumeReset.cwdChanged": "تم تغيير دليل العمل. لا يمكن استئناف جلسة Claude Code السابقة إلا من دليلها الأصلي، لذا بدأت محادثة جديدة.",

locales/ar/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "حذف جماعي",
   "blog": "مدونة المنتج",
   "botIntegrationBanner.dismiss": "إغلاق",
-  "botIntegrationBanner.title": "تحدث إلى Lobe AI عبر تطبيقات المراسلة المفضلة لديك",
+  "botIntegrationBanner.title": "إضافة قنوات إلى LobeAI",
   "branching": "إنشاء موضوع فرعي",
   "branchingDisable": "ميزة \"الموضوع الفرعي\" غير متاحة في الوضع الحالي. لاستخدام هذه الميزة، يرجى التبديل إلى وضع قاعدة بيانات Postgres/Pglite أو استخدام LobeHub Cloud.",
   "branchingRequiresSavedTopic": "الموضوع الحالي غير محفوظ، يرجى حفظه أولاً لاستخدام ميزة الموضوع الفرعي",

locales/ar/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "الاحتفاظ بالجميع",
   "modifier.reject": "تراجع",
   "modifier.rejectAll": "تراجع عن الكل",
-  "skillFrontmatter.edit": "تحرير البيانات الوصفية",
-  "skillFrontmatter.empty": "لا توجد بيانات وصفية",
-  "skillFrontmatter.invalid.descriptionInvalid": "يجب أن تكون الوصف نصًا في سطر واحد.",
-  "skillFrontmatter.invalid.descriptionRequired": "الوصف مطلوب.",
-  "skillFrontmatter.invalid.mapping": "يجب أن تكون البيانات الوصفية بتنسيق YAML.",
-  "skillFrontmatter.invalid.nameInvalid": "يجب أن يتكون الاسم من أحرف صغيرة وأرقام وشرطات.",
-  "skillFrontmatter.invalid.nameLocked": "يجب أن يبقى الاسم {{name}}. قم بإعادة تسمية حزمة المهارة بدلاً من ذلك.",
-  "skillFrontmatter.invalid.nameRequired": "الاسم مطلوب.",
-  "skillFrontmatter.invalid.required": "البيانات الوصفية مطلوبة.",
-  "skillFrontmatter.invalid.syntax": "صيغة YAML غير صحيحة.",
-  "skillFrontmatter.saveFailed": "لم يتم حفظ البيانات الوصفية. حاول مرة أخرى أو استمر في التحرير.",
-  "skillFrontmatter.title": "بيانات وصفية للمهارة",
   "slash.compact": "ضغط السياق",
   "slash.h1": "عنوان 1",
   "slash.h2": "عنوان 2",

locales/ar/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "تم ربط حساب Telegram آخر بالفعل",
   "verify.confirm.title": "تأكيد الربط",
   "verify.confirm.workspace": "مساحة العمل: {{workspace}}",
-  "verify.error.alreadyConsumed": "تم استخدام هذا الرابط بالفعل لربط حساب. قم بتسجيل الدخول إلى حساب LobeHub الخاص بك لإدارة الاتصال، أو عد إلى البوت وأرسل /start مرة أخرى لإصدار رابط جديد.",
-  "verify.error.alreadyConsumedTitle": "تم استخدام هذا الرابط بالفعل",
   "verify.error.alreadyLinkedToOther": "هذا الحساب مرتبط بالفعل بحساب LobeHub مختلف. قم بتسجيل الدخول إلى هذا الحساب أولاً.",
   "verify.error.expired": "انتهت صلاحية هذا الرابط. يرجى العودة إلى البوت وإرسال /start مرة أخرى.",
   "verify.error.generic": "حدث خطأ ما. يرجى المحاولة مرة أخرى.",

locales/ar/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "نموذج جديد لإنشاء الفيديو مع تحسينات شاملة في حركة الجسم، والواقعية الفيزيائية، واتباع التعليمات.",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: نفس أداء M2.5 مع استدلال أسرع.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku هو أسرع وأصغر نموذج من Anthropic، مصمم لتقديم استجابات شبه فورية بأداء سريع ودقيق.",
   "claude-3-opus-20240229.description": "Claude 3 Opus هو أقوى نموذج من Anthropic للمهام المعقدة، يتميز بالأداء العالي، الذكاء، الطلاقة، والفهم.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet يوازن بين الذكاء والسرعة لتلبية احتياجات المؤسسات، ويوفر فائدة عالية بتكلفة أقل ونشر موثوق على نطاق واسع.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 هو النموذج الأسرع والأذكى من Anthropic، يتميز بسرعة البرق وقدرات استدلال موسعة.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 هو أسرع وأذكى نموذج هايكو من Anthropic، يتميز بسرعة البرق وتفكير ممتد.",
   "claude-haiku-4-5.description": "Claude Haiku 4.5 من Anthropic — نموذج Haiku من الجيل التالي مع تحسينات في التفكير والرؤية.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 هو نموذج Haiku الأسرع والأذكى من Anthropic، يتميز بسرعة البرق وقدرات استدلال موسعة.",
   "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-1-20250805.description": "Claude Opus 4.1 هو أحدث وأقوى نموذج من Anthropic للمهام المعقدة للغاية، يتميز بالأداء والذكاء والطلاقة والفهم.",
   "claude-opus-4-1.description": "Claude Opus 4.1 من Anthropic — نموذج تفكير متميز مع قدرات تحليل عميقة.",
-  "claude-opus-4-20250514.description": "Claude Opus 4 هو النموذج الأقوى من Anthropic للمهام المعقدة للغاية، يتميز بالأداء العالي، الذكاء، الطلاقة، والاستيعاب.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 هو أقوى نموذج من Anthropic للمهام المعقدة للغاية، يتميز بالأداء والذكاء والطلاقة والفهم.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 هو النموذج الرائد من Anthropic، يجمع بين الذكاء الاستثنائي والأداء القابل للتوسع، مثالي للمهام المعقدة التي تتطلب استجابات عالية الجودة وتفكير متقدم.",
   "claude-opus-4-5.description": "Claude Opus 4.5 من Anthropic — نموذج رئيسي مع تفكير وبرمجة من الدرجة الأولى.",
   "claude-opus-4-6.description": "Claude Opus 4.6 من Anthropic — نافذة سياق 1M نموذج رئيسي مع تفكير متقدم.",
@@ -334,7 +335,7 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 هو النموذج الأكثر ذكاءً من 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 يمكنه تقديم استجابات شبه فورية أو تفكير ممتد خطوة بخطوة مع عرض العملية.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 هو النموذج الأكثر ذكاءً من Anthropic حتى الآن، يقدم استجابات شبه فورية أو تفكير خطوة بخطوة ممتد مع تحكم دقيق لمستخدمي API.",
   "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 هو النموذج الأكثر ذكاءً من Anthropic حتى الآن.",
   "claude-sonnet-4-5.description": "Claude Sonnet 4.5 من Anthropic — نموذج Sonnet محسّن مع أداء برمجي معزز.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 من Anthropic — أحدث نموذج Sonnet مع برمجة واستخدام أدوات متفوقة.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) هو نموذج مبتكر يوفر فهمًا عميقًا للغة وتفاعلًا ذكيًا.",
   "deepseek-ai/deepseek-v3.1-terminus.description": "DeepSeek V3.1 هو نموذج تفكير من الجيل التالي يتمتع بقدرات أقوى في التفكير المعقد وسلسلة التفكير لمهام التحليل العميق.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 هو نموذج استدلال من الجيل التالي يتميز بقدرات استدلال معقدة وسلسلة التفكير.",
-  "deepseek-chat.description": "نموذج مفتوح المصدر جديد يجمع بين القدرات العامة والبرمجية. يحافظ على حوار النموذج العام وقوة البرمجة للنموذج البرمجي، مع تحسين توافق التفضيلات. كما يحسن DeepSeek-V2.5 الكتابة واتباع التعليمات.",
+  "deepseek-chat.description": "اسم مستعار متوافق لوضع عدم التفكير في DeepSeek V4 Flash. مقرر إيقافه — استخدم DeepSeek V4 Flash بدلاً منه.",
   "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.",
@@ -430,7 +431,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 V4. من المقرر إيقافه — يُرجى استخدام deepseek-v4-flash بدلاً منه.",
+  "deepseek-reasoner.description": "اسم مستعار متوافق لوضع التفكير في DeepSeek V4 Flash. مقرر إيقافه — استخدم DeepSeek V4 Flash بدلاً منه.",
   "deepseek-v2.description": "DeepSeek V2 هو نموذج MoE فعال لمعالجة منخفضة التكلفة.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B هو نموذج DeepSeek الموجه للبرمجة مع قدرات قوية في توليد الكود.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 هو نموذج MoE يحتوي على 671 مليار معلمة يتميز بقوة في البرمجة، والقدرات التقنية، وفهم السياق، والتعامل مع النصوص الطويلة.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 هو نموذج توليد صور من ByteDance Seed، يدعم إدخال النصوص والصور مع توليد صور عالية الجودة وقابلة للتحكم بدرجة كبيرة. يُولّد الصور من التعليمات النصية.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 هو أحدث نموذج متعدد الوسائط من ByteDance، يدمج قدرات تحويل النص إلى صورة، والصورة إلى صورة، وتوليد الصور بالجملة، مع دمج الفهم العام وقدرات الاستدلال. مقارنة بالإصدار السابق 4.0، يقدم جودة توليد محسّنة بشكل كبير، مع تحسين تناسق التحرير ودمج الصور المتعددة. يوفر تحكمًا أكثر دقة في التفاصيل البصرية، مما يجعل النصوص الصغيرة والوجوه الصغيرة أكثر طبيعية، ويحقق تخطيطًا وألوانًا أكثر انسجامًا، مما يعزز الجماليات العامة.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite هو أحدث نموذج لتوليد الصور من ByteDance. لأول مرة، يدمج قدرات الاسترجاع عبر الإنترنت، مما يسمح له بتضمين معلومات الويب في الوقت الفعلي وتعزيز حداثة الصور المولدة. كما تم ترقية ذكاء النموذج، مما يمكنه من تفسير التعليمات المعقدة والمحتوى البصري بدقة. بالإضافة إلى ذلك، يقدم تغطية محسّنة للمعرفة العالمية، وتناسقًا مرجعيًا، وجودة توليد في السيناريوهات المهنية، مما يلبي بشكل أفضل احتياجات الإبداع البصري على مستوى المؤسسات.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 من ByteDance هو أقوى نموذج لإنشاء الفيديو، يدعم إنشاء الفيديو متعدد الوسائط، تحرير الفيديو، تمديد الفيديو، تحويل النص إلى فيديو، وتحويل الصورة إلى فيديو مع صوت متزامن.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast من ByteDance يقدم نفس القدرات مثل Seedance 2.0 مع سرعات إنشاء أسرع وسعر أكثر تنافسية.",
   "emohaa.description": "Emohaa هو نموذج للصحة النفسية يتمتع بقدرات استشارية احترافية لمساعدة المستخدمين على فهم المشكلات العاطفية.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B هو نموذج مفتوح المصدر وخفيف الوزن، مصمم للنشر المحلي والمخصص.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview هو نموذج معاينة بسياق 8K لتقييم أداء ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 هو نموذج توليد الصور من ByteDance Seed، يدعم إدخال النصوص والصور مع توليد صور عالية الجودة وقابلة للتحكم بشكل كبير. يقوم بتوليد الصور من التعليمات النصية.",
+  "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] هو نموذج لتوليد الصور يتميز بميول جمالية نحو صور أكثر واقعية وطبيعية.",
@@ -527,8 +531,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 يتميز بعرض نصوص صينية مذهلة وأنماط بصرية متنوعة.",
+  "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-kontext-max.description": "توليد وتحرير صور سياقية متقدمة، تجمع بين النصوص والصور لتحقيق نتائج دقيقة ومتسقة.",
@@ -567,10 +571,10 @@
   "gemini-3-flash-preview.description": "Gemini 3 Flash هو أذكى نموذج تم تصميمه للسرعة، يجمع بين الذكاء المتقدم وأساس بحث ممتاز.",
   "gemini-3-flash.description": "Gemini 3 Flash من Google — نموذج فائق السرعة مع دعم الإدخال متعدد الوسائط.",
   "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-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) هو أسرع نموذج توليد صور أصلي من Google مع دعم التفكير، وتوليد الصور الحواري، وتحرير الصور.",
+  "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 هو النموذج الأكثر كفاءة من حيث التكلفة من Google، مُحسّن للمهام الوكيلة ذات الحجم الكبير، الترجمة، ومعالجة البيانات.",
   "gemini-3.1-pro-preview.description": "Gemini 3.1 Pro Preview يحسن من Gemini 3 Pro مع قدرات استدلال محسّنة ويضيف دعم مستوى التفكير المتوسط.",
   "gemini-3.1-pro.description": "Gemini 3.1 Pro من Google — نموذج متعدد الوسائط متميز مع نافذة سياق 1M.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "يسعدنا إطلاق Grok 4 Fast، أحدث تقدم في نماذج الاستدلال منخفضة التكلفة.",
   "grok-4.20-0309-non-reasoning.description": "نموذج غير تفكير للاستخدامات البسيطة.",
   "grok-4.20-0309-reasoning.description": "نموذج ذكي وسريع للغاية يفكر قبل الرد.",
+  "grok-4.20-beta-0309-non-reasoning.description": "نسخة غير تفكيرية للاستخدامات البسيطة.",
+  "grok-4.20-beta-0309-reasoning.description": "نموذج ذكي وسريع للغاية يفكر قبل الرد.",
   "grok-4.20-multi-agent-0309.description": "فريق من 4 أو 16 وكيلًا، يتفوق في حالات الاستخدام البحثية، لا يدعم حاليًا الأدوات على جانب العميل. يدعم فقط أدوات xAI على جانب الخادم (مثل X Search، أدوات البحث على الويب) وأدوات MCP البعيدة.",
   "grok-4.3.description": "أكثر نموذج لغة كبير يسعى للحقيقة في العالم.",
-  "grok-4.description": "أحدث نموذج Grok الرائد بأداء لا مثيل له في اللغة، الرياضيات، والاستدلال — نموذج شامل حقيقي. يشير حاليًا إلى grok-4-0709؛ نظرًا للموارد المحدودة، فإن سعره مؤقتًا أعلى بنسبة 10% من السعر الرسمي ومن المتوقع أن يعود إلى السعر الرسمي لاحقًا.",
+  "grok-4.description": "أحدث وأقوى نموذج رئيسي لدينا، يتميز في معالجة اللغة الطبيعية، الرياضيات، والتفكير—مثالي لجميع الاستخدامات.",
   "grok-code-fast-1.description": "يسعدنا إطلاق grok-code-fast-1، نموذج استدلال سريع وفعال من حيث التكلفة يتفوق في البرمجة التلقائية.",
   "grok-imagine-image-pro.description": "إنشاء صور من مطالبات نصية، تحرير الصور الموجودة باستخدام اللغة الطبيعية، أو تحسين الصور بشكل تكراري من خلال محادثات متعددة الأدوار.",
   "grok-imagine-image.description": "إنشاء صور من مطالبات نصية، تحرير الصور الموجودة باستخدام اللغة الطبيعية، أو تحسين الصور بشكل تكراري من خلال محادثات متعددة الأدوار.",
@@ -1227,6 +1233,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 مع دعم لغات موسع وسياق أطول.",

locales/ar/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "الأدوات",
   "skillDetail.trustWarning": "استخدم الموصلات فقط من المطورين الذين تثق بهم. لا تتحكم LobeHub في الأدوات التي يتيحها المطورون ولا يمكنها التحقق من أنها ستعمل كما هو متوقع أو أنها لن تتغير.",
   "skillInstallBanner.dismiss": "إغلاق",
-  "skillInstallBanner.title": "اربط تطبيقاتك المفضلة بـ Lobe AI",
+  "skillInstallBanner.title": "أضف المهارات إلى Lobe AI",
   "store.actions.cancel": "إلغاء",
   "store.actions.configure": "تهيئة",
   "store.actions.confirmUninstall": "سيؤدي إلغاء التثبيت إلى مسح إعدادات المهارة. هل ترغب في المتابعة؟",

locales/ar/providers.json

@@ -33,6 +33,7 @@
   "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 لأداء مهام الترميز عبر اشتراك ثابت الرسوم.",

locales/ar/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "واجهة برمجة التطبيقات",
   "heterogeneousStatus.auth.label": "طريقة التوثيق",
   "heterogeneousStatus.auth.subscription": "الاشتراك",
-  "heterogeneousStatus.cloud.githubDesc": "اختر بيانات اعتماد OAuth لـ GitHub للسماح للصندوق الرمل باستنساخ مستودعاتك الخاصة.",
-  "heterogeneousStatus.cloud.githubLabel": "اتصال GitHub",
-  "heterogeneousStatus.cloud.githubNoCreds": "لم يتم العثور على بيانات اعتماد GitHub.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "اختر بيانات اعتماد GitHub...",
-  "heterogeneousStatus.cloud.manageCredentials": "إدارة بيانات الاعتماد →",
-  "heterogeneousStatus.cloud.repoAdd": "إضافة",
-  "heterogeneousStatus.cloud.repoDesc": "أضف المستودعات إلى القائمة. قم بتبديل المستودع النشط من الشريط السفلي في عرض الدردشة.",
-  "heterogeneousStatus.cloud.repoLabel": "المستودعات",
-  "heterogeneousStatus.cloud.repoPlaceholder": "owner/repo أو https://github.com/owner/repo",
-  "heterogeneousStatus.cloud.tabLabel": "السحابة",
-  "heterogeneousStatus.cloud.tokenCancel": "إلغاء",
-  "heterogeneousStatus.cloud.tokenChange": "تغيير",
-  "heterogeneousStatus.cloud.tokenDesc": "رمز OAuth الخاص بـ Claude Code. يتم حفظه بأمان في بيانات الاعتماد بمجرد إرساله. قم بتشغيل `claude setup-token` في الطرفية الخاصة بك لتوليد واحد.",
-  "heterogeneousStatus.cloud.tokenLabel": "رمز Claude Code",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "الصق رمز OAuth الخاص بك هنا",
-  "heterogeneousStatus.cloud.tokenSave": "حفظ",
   "heterogeneousStatus.command.edit": "تحرير الأمر",
   "heterogeneousStatus.command.label": "أمر التشغيل",
   "heterogeneousStatus.command.placeholder": "اسم الأمر أو المسار المطلق",
-  "heterogeneousStatus.desktop.tabLabel": "سطح المكتب",
   "heterogeneousStatus.detecting": "يتم الآن اكتشاف واجهة سطر الأوامر لـ {{name}}...",
   "heterogeneousStatus.plan.label": "الخطة",
   "heterogeneousStatus.redetect": "إعادة الاكتشاف",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "اجلب قوة Linear مباشرة إلى مساعدك الذكي. أنشئ وحدث المشكلات، وأدر السبرينت، وتتبع تقدم المشاريع، وسهّل سير عمل التطوير — كل ذلك من خلال المحادثة الطبيعية.",
   "tools.lobehubSkill.providers.microsoft.description": "تقويم Outlook هو أداة جدولة مدمجة ضمن Microsoft Outlook تتيح للمستخدمين إنشاء المواعيد، تنظيم الاجتماعات، وإدارة الوقت والفعاليات بفعالية.",
   "tools.lobehubSkill.providers.microsoft.readme": "تكامل مع تقويم Outlook لعرض وإنشاء وإدارة فعالياتك بسلاسة. جدْوِل الاجتماعات، وتحقق من التوفر، واضبط التذكيرات، ونظّم وقتك — كل ذلك باستخدام أوامر اللغة الطبيعية.",
-  "tools.lobehubSkill.providers.notion.description": "Notion هو تطبيق تعاوني للإنتاجية وتدوين الملاحظات.",
-  "tools.lobehubSkill.providers.notion.readme": "اتصل بـ Notion للوصول إلى مساحة العمل الخاصة بك وإدارتها. قم بإنشاء الصفحات، والبحث عن المحتوى، وتحديث قواعد البيانات، وتنظيم قاعدة معارفك—كل ذلك من خلال محادثة طبيعية مع مساعدك الذكي.",
   "tools.lobehubSkill.providers.twitter.description": "X (تويتر سابقًا) هي منصة تواصل اجتماعي لمشاركة التحديثات الفورية، الأخبار، والتفاعل مع جمهورك من خلال المنشورات، الردود، والرسائل المباشرة.",
   "tools.lobehubSkill.providers.twitter.readme": "اتصل بـ X (تويتر) لنشر التغريدات، وإدارة الجدول الزمني، والتفاعل مع جمهورك. أنشئ المحتوى، وجدول المنشورات، وراقب الإشارات، وابنِ حضورك على وسائل التواصل الاجتماعي من خلال الذكاء الاصطناعي الحواري.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel هي منصة سحابية للمطورين الأماميين، توفر الاستضافة والدوال الخادمة لنشر التطبيقات بسهولة.",

locales/bg-BG/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "Търсене на шаблони...",
   "groupWizard.title": "Създай група",
   "groupWizard.useTemplate": "Използвай шаблон",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} хранилища избрани",
-  "heteroAgent.cloudRepo.noRepos": "Няма конфигурирани хранилища. Добавете ги в настройките на агента.",
-  "heteroAgent.cloudRepo.notSet": "Няма избрано хранилище",
-  "heteroAgent.cloudRepo.sectionTitle": "Хранилища",
   "heteroAgent.fullAccess.label": "Пълен достъп",
   "heteroAgent.fullAccess.tooltip": "Claude Code работи локално с пълен достъп за четене/запис в работната директория. Превключването на режимите на достъп все още не е налично.",
   "heteroAgent.resumeReset.cwdChanged": "Работната директория е променена. Предишната сесия на Claude Code може да бъде продължена само от оригиналната ѝ директория, затова е започнат нов разговор.",

locales/bg-BG/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "Групово изтриване",
   "blog": "Блог на продукта",
   "botIntegrationBanner.dismiss": "Затвори",
-  "botIntegrationBanner.title": "Говорете с Lobe AI в любимите си приложения за съобщения",
+  "botIntegrationBanner.title": "Добавяне на канали към LobeAI",
   "branching": "Създай подтема",
   "branchingDisable": "Функцията „Подтема“ не е налична в текущия режим. За да я използвате, превключете към режим Postgres/Pglite DB или използвайте LobeHub Cloud.",
   "branchingRequiresSavedTopic": "Текущата тема не е запазена, моля, запазете я, за да използвате функцията за подтема",

locales/bg-BG/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "Запази всички",
   "modifier.reject": "Отмени",
   "modifier.rejectAll": "Отмени всички",
-  "skillFrontmatter.edit": "Редактиране на метаданни",
-  "skillFrontmatter.empty": "Няма метаданни",
-  "skillFrontmatter.invalid.descriptionInvalid": "Описанието трябва да бъде текст на един ред.",
-  "skillFrontmatter.invalid.descriptionRequired": "Описанието е задължително.",
-  "skillFrontmatter.invalid.mapping": "Frontmatter трябва да бъде YAML mapping.",
-  "skillFrontmatter.invalid.nameInvalid": "Името трябва да използва малки букви, цифри и тирета.",
-  "skillFrontmatter.invalid.nameLocked": "Името трябва да остане {{name}}. Преименувайте пакета с умения вместо това.",
-  "skillFrontmatter.invalid.nameRequired": "Името е задължително.",
-  "skillFrontmatter.invalid.required": "Frontmatter е задължително.",
-  "skillFrontmatter.invalid.syntax": "Невалиден YAML синтаксис.",
-  "skillFrontmatter.saveFailed": "Метаданните не бяха запазени. Опитайте отново или продължете с редактирането.",
-  "skillFrontmatter.title": "Метаданни на умение",
   "slash.compact": "Компресирай контекста",
   "slash.h1": "Заглавие 1",
   "slash.h2": "Заглавие 2",

locales/bg-BG/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "Друг Telegram акаунт вече е свързан",
   "verify.confirm.title": "Потвърдете свързването",
   "verify.confirm.workspace": "Работно пространство: {{workspace}}",
-  "verify.error.alreadyConsumed": "Този линк вече е използван за свързване на акаунт. Влезте в този LobeHub акаунт, за да управлявате връзката, или се върнете към бота и изпратете /start отново, за да издадете нов линк.",
-  "verify.error.alreadyConsumedTitle": "Този линк вече е използван",
   "verify.error.alreadyLinkedToOther": "Този акаунт вече е свързан с друг акаунт в LobeHub. Първо влезте в този акаунт.",
   "verify.error.expired": "Тази връзка е изтекла. Моля, върнете се към бота и изпратете /start отново.",
   "verify.error.generic": "Нещо се обърка. Моля, опитайте отново.",

locales/bg-BG/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "Чисто нов модел за видео генериране с цялостни подобрения в движенията на тялото, физическата реалистичност и следването на инструкции.",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: Същата производителност като M2.5, но с по-бързо извеждане.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku е най-бързият и най-компактен модел на Anthropic, проектиран за почти мигновени отговори с бърза и точна производителност.",
   "claude-3-opus-20240229.description": "Claude 3 Opus е най-мощният модел на Anthropic за силно сложни задачи, отличаващ се с производителност, интелигентност, плавност и разбиране.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet балансира интелигентност и скорост за корпоративни натоварвания, осигурявайки висока полезност на по-ниска цена и надеждно мащабно внедряване.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 е най-бързият и най-умният Haiku модел на Anthropic, с мълниеносна скорост и разширено разсъждение.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 е най-бързият и интелигентен Haiku модел на Anthropic, с мълниеносна скорост и разширено мислене.",
   "claude-haiku-4-5.description": "Claude Haiku 4.5 от Anthropic — ново поколение Haiku с подобрено разсъждение и визия.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 е най-бързият и най-умен Haiku модел на Anthropic, с мълниеносна скорост и разширено разсъждение.",
   "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-1-20250805.description": "Claude Opus 4.1 е най-новият и най-способен модел на Anthropic за изключително сложни задачи, превъзхождащ в производителност, интелигентност, плавност и разбиране.",
   "claude-opus-4-1.description": "Claude Opus 4.1 от Anthropic — премиум модел за дълбок анализ и разсъждение.",
-  "claude-opus-4-20250514.description": "Claude Opus 4 е най-мощният модел на Anthropic за изключително сложни задачи, отличаващ се с висока производителност, интелигентност, плавност и разбиране.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 е най-мощният модел на Anthropic за изключително сложни задачи, превъзхождащ в производителност, интелигентност, плавност и разбиране.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 е флагманският модел на Anthropic, комбиниращ изключителна интелигентност с мащабируема производителност, идеален за сложни задачи, изискващи най-висококачествени отговори и разсъждение.",
   "claude-opus-4-5.description": "Claude Opus 4.5 от Anthropic — флагмански модел с върхово разсъждение и кодови умения.",
   "claude-opus-4-6.description": "Claude Opus 4.6 от Anthropic — флагман с 1M контекст и усъвършенствано разсъждение.",
@@ -334,8 +335,8 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 е най-интелигентният модел на 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 може да генерира почти мигновени отговори или разширено стъпка по стъпка мислене с видим процес.",
-  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic до момента.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 е най-интелигентният модел на Anthropic досега, предлагащ почти мигновени отговори или разширено стъпка по стъпка мислене с фино управление за API потребители.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic досега.",
   "claude-sonnet-4-5.description": "Claude Sonnet 4.5 от Anthropic — подобрен Sonnet с по‑силни кодови способности.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 от Anthropic — последният Sonnet с превъзходно кодиране и работа с инструменти.",
   "claude-sonnet-4.5.description": "Claude Sonnet 4.5 е най-интелигентният модел на Anthropic до момента.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) е иновативен модел, предлагащ дълбоко езиково разбиране и интеракция.",
   "deepseek-ai/deepseek-v3.1-terminus.description": "DeepSeek V3.1 е модел за разсъждение от ново поколение с по-силни способности за сложни разсъждения и верига от мисли за задълбочени аналитични задачи.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 е модел за разсъждение от следващо поколение с по-силни способности за сложни разсъждения и верига на мисълта.",
-  "deepseek-chat.description": "Нов модел с отворен код, който комбинира общи и кодови способности. Той запазва общия диалогов модел и силното кодиране на кодовия модел, с по-добро съответствие на предпочитанията. DeepSeek-V2.5 също така подобрява писането и следването на инструкции.",
+  "deepseek-chat.description": "Съвместимостен псевдоним за режим без мислене на DeepSeek V4 Flash. Планирано за премахване — използвайте DeepSeek V4 Flash вместо това.",
   "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.",
@@ -430,7 +431,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 V4 Flash режим на мислене. Планирано за премахване — използвайте deepseek-v4-flash вместо това.",
+  "deepseek-reasoner.description": "Съвместимостен псевдоним за режим с мислене на DeepSeek V4 Flash. Планирано за премахване — използвайте DeepSeek V4 Flash вместо това.",
   "deepseek-v2.description": "DeepSeek V2 е ефективен MoE модел за икономична обработка.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B е модел на DeepSeek, фокусиран върху програмиране, с висока производителност при генериране на код.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 е MoE модел с 671 милиарда параметъра, с изключителни способности в програмиране, технически задачи, разбиране на контекст и обработка на дълги текстове.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 е модел за генериране на изображения от ByteDance Seed, поддържащ вход от текст и изображения с високо контролируемо, висококачествено генериране на изображения. Генерира изображения от текстови подсказки.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 е най-новият мултимодален модел за изображения на ByteDance, интегриращ текст-към-изображение, изображение-към-изображение и групово генериране на изображения, като включва обща логика и способности за разсъждение. В сравнение с предишната версия 4.0, той предлага значително подобрено качество на генериране, с по-добра консистентност при редактиране и мулти-изображение сливане. Осигурява по-прецизен контрол върху визуалните детайли, като произвежда малък текст и малки лица по-естествено, и постига по-хармонично оформление и цветове, подобрявайки цялостната естетика.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite е най-новият модел за генериране на изображения на ByteDance. За първи път интегрира възможности за онлайн извличане, позволявайки му да включва информация в реално време от уеб и да подобрява актуалността на генерираните изображения. Интелигентността на модела също е подобрена, позволявайки прецизно интерпретиране на сложни инструкции и визуално съдържание. Освен това предлага подобрено глобално покритие на знания, консистентност на референциите и качество на генериране в професионални сценарии, по-добре отговаряйки на нуждите за визуално създаване на корпоративно ниво.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 от ByteDance е най-мощният модел за видео генериране, поддържащ мултимодално генериране на референтни видеа, редактиране на видеа, разширяване на видеа, текст-към-видео и изображение-към-видео със синхронизиран звук.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast от ByteDance предлага същите възможности като Seedance 2.0 с по-бързи скорости на генериране на по-конкурентна цена.",
   "emohaa.description": "Emohaa е модел за психично здраве с професионални консултантски способности, който помага на потребителите да разберат емоционални проблеми.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B е лек модел с отворен код за локално и персонализирано внедряване.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview е модел за предварителен преглед с 8K контекст за оценка на ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 е модел за генериране на изображения от ByteDance Seed, който поддържа текстови и визуални входове с високо контролируемо и висококачествено генериране на изображения. Генерира изображения от текстови подсказки.",
+  "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] е модел за генериране на изображения с естетично предпочитание към по-реалистични и естествени изображения.",
@@ -527,8 +531,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 с впечатляващо рендиране на китайски текст и разнообразни визуални стилове.",
+  "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-kontext-max.description": "Съвременно генериране и редактиране на изображения с контекст, комбиниращо текст и изображения за прецизни и последователни резултати.",
@@ -570,7 +574,7 @@
   "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) е най-бързият собствен модел на 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-3.1-pro.description": "Gemini 3.1 Pro от Google — премиум мултимодален модел с 1M контекст.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "С гордост представяме Grok 4 Fast – нашият най-нов напредък в икономичните логически модели.",
   "grok-4.20-0309-non-reasoning.description": "Неразсъждаващ вариант за прости случаи.",
   "grok-4.20-0309-reasoning.description": "Интелигентен, изключително бърз модел с разсъждение.",
+  "grok-4.20-beta-0309-non-reasoning.description": "Вариант без мислене за прости случаи на употреба.",
+  "grok-4.20-beta-0309-reasoning.description": "Интелигентен, изключително бърз модел, който разсъждава преди да отговори.",
   "grok-4.20-multi-agent-0309.description": "Екип от 4 или 16 агента — отличен за проучвания; поддържа само xAI сървърни инструменти.",
   "grok-4.3.description": "Най-истинно търсещият голям езиков модел в света",
-  "grok-4.description": "Най-новият флагман Grok с ненадмината производителност в езика, математиката и разсъжденията — истински универсален модел. В момента сочи към grok-4-0709; поради ограничени ресурси временно е с 10% по-висока цена от официалната и се очаква да се върне към официалната цена по-късно.",
+  "grok-4.description": "Нашият най-нов и най-силен флагмански модел, превъзхождащ в NLP, математика и разсъждения — идеален универсален инструмент.",
   "grok-code-fast-1.description": "С гордост представяме grok-code-fast-1 – бърз и икономичен логически модел, който се отличава в агентско програмиране.",
   "grok-imagine-image-pro.description": "Генерирайте изображения от текстови подсказки, редактирайте съществуващи изображения с естествен език или итеративно усъвършенствайте изображения чрез многократни разговори.",
   "grok-imagine-image.description": "Генерирайте изображения от текстови подсказки, редактирайте съществуващи изображения с естествен език или итеративно усъвършенствайте изображения чрез многократни разговори.",
@@ -1227,6 +1233,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 с разширена езикова поддръжка и по-дълъг контекст.",

locales/bg-BG/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "Инструменти",
   "skillDetail.trustWarning": "Използвайте само конектори от разработчици, на които имате доверие. LobeHub не контролира кои инструменти са предоставени от разработчиците и не може да гарантира, че ще работят според очакванията или че няма да бъдат променени.",
   "skillInstallBanner.dismiss": "Отхвърли",
-  "skillInstallBanner.title": "Свържете любимите си приложения с Lobe AI",
+  "skillInstallBanner.title": "Добавете умения към Lobe AI",
   "store.actions.cancel": "Отказ",
   "store.actions.configure": "Конфигурирай",
   "store.actions.confirmUninstall": "Деинсталирането ще изчисти конфигурацията на умението. Продължите ли?",

locales/bg-BG/providers.json

@@ -33,6 +33,7 @@
   "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, за задачи, свързани с програмиране, чрез абонамент с фиксирана такса.",

locales/bg-BG/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "Метод за удостоверяване",
   "heterogeneousStatus.auth.subscription": "Абонамент",
-  "heterogeneousStatus.cloud.githubDesc": "Изберете GitHub OAuth идентификационни данни, за да позволите на пясъчника да клонира вашите частни хранилища.",
-  "heterogeneousStatus.cloud.githubLabel": "Връзка с GitHub",
-  "heterogeneousStatus.cloud.githubNoCreds": "Не са намерени GitHub идентификационни данни.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "Изберете GitHub идентификационни данни...",
-  "heterogeneousStatus.cloud.manageCredentials": "Управление на идентификационни данни →",
-  "heterogeneousStatus.cloud.repoAdd": "Добавяне",
-  "heterogeneousStatus.cloud.repoDesc": "Добавете хранилища към списъка. Превключете активното от долната лента в изгледа на чата.",
-  "heterogeneousStatus.cloud.repoLabel": "Хранилища",
-  "heterogeneousStatus.cloud.repoPlaceholder": "owner/repo или https://github.com/owner/repo",
-  "heterogeneousStatus.cloud.tabLabel": "Облак",
-  "heterogeneousStatus.cloud.tokenCancel": "Отказ",
-  "heterogeneousStatus.cloud.tokenChange": "Промяна",
-  "heterogeneousStatus.cloud.tokenDesc": "Вашият Claude Code OAuth токен. Съхранява се сигурно в Идентификационни данни след подаване. Изпълнете `claude setup-token` в терминала си, за да генерирате такъв.",
-  "heterogeneousStatus.cloud.tokenLabel": "Claude Code токен",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "Поставете вашия OAuth токен тук",
-  "heterogeneousStatus.cloud.tokenSave": "Запазване",
   "heterogeneousStatus.command.edit": "Редактиране на команда",
   "heterogeneousStatus.command.label": "Команда за стартиране",
   "heterogeneousStatus.command.placeholder": "Име на команда или абсолютен път",
-  "heterogeneousStatus.desktop.tabLabel": "Работен плот",
   "heterogeneousStatus.detecting": "Откриване на {{name}} CLI...",
   "heterogeneousStatus.plan.label": "План",
   "heterogeneousStatus.redetect": "Повторно откриване",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "Използвайте възможностите на Linear директно чрез вашия AI асистент. Създавайте и актуализирайте задачи, управлявайте спринтове, следете напредъка на проекти и оптимизирайте работния си процес чрез естествен разговор.",
   "tools.lobehubSkill.providers.microsoft.description": "Outlook Calendar е интегриран инструмент за планиране в Microsoft Outlook, който позволява на потребителите да създават срещи, организират събития и управляват времето си ефективно.",
   "tools.lobehubSkill.providers.microsoft.readme": "Интегрирайте се с Outlook Calendar за лесно преглеждане, създаване и управление на събития. Насрочвайте срещи, проверявайте наличност, задавайте напомняния и координирайте времето си чрез естествени езикови команди.",
-  "tools.lobehubSkill.providers.notion.description": "Notion е приложение за съвместна продуктивност и водене на бележки.",
-  "tools.lobehubSkill.providers.notion.readme": "Свържете се с Notion, за да получите достъп и да управлявате вашето работно пространство. Създавайте страници, търсете съдържание, актуализирайте бази данни и организирайте вашата база знания—всичко това чрез естествен разговор с вашия AI асистент.",
   "tools.lobehubSkill.providers.twitter.description": "X (Twitter) е социална медийна платформа за споделяне на актуални новини, ангажиране с аудиторията чрез публикации, отговори и директни съобщения.",
   "tools.lobehubSkill.providers.twitter.readme": "Свържете се с X (Twitter), за да публикувате туитове, управлявате времевата си линия и взаимодействате с аудиторията си. Създавайте съдържание, планирайте публикации, следете споменавания и изграждайте присъствие в социалните мрежи чрез разговорен AI.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel е облачна платформа за фронтенд разработчици, предоставяща хостинг и serverless функции за лесно разгръщане на уеб приложения.",

locales/de-DE/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "Vorlagen durchsuchen...",
   "groupWizard.title": "Gruppe erstellen",
   "groupWizard.useTemplate": "Vorlage verwenden",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} Repositories ausgewählt",
-  "heteroAgent.cloudRepo.noRepos": "Keine Repositories konfiguriert. Fügen Sie diese in den Agenteneinstellungen hinzu.",
-  "heteroAgent.cloudRepo.notSet": "Kein Repository ausgewählt",
-  "heteroAgent.cloudRepo.sectionTitle": "Repositories",
   "heteroAgent.fullAccess.label": "Vollzugriff",
   "heteroAgent.fullAccess.tooltip": "Claude Code läuft lokal mit vollständigem Lese-/Schreibzugriff auf das Arbeitsverzeichnis. Das Umschalten von Berechtigungsmodi ist derzeit nicht verfügbar.",
   "heteroAgent.resumeReset.cwdChanged": "Arbeitsverzeichnis geändert. Die vorherige Claude-Code-Sitzung kann nur aus dem ursprünglichen Verzeichnis fortgesetzt werden, daher wurde eine neue Unterhaltung gestartet.",

locales/de-DE/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "Mehrfach löschen",
   "blog": "Produkt-Blog",
   "botIntegrationBanner.dismiss": "Schließen",
-  "botIntegrationBanner.title": "Sprich mit Lobe AI in deinen bevorzugten Messaging-Apps",
+  "botIntegrationBanner.title": "Kanäle zu LobeAI hinzufügen",
   "branching": "Unterthema erstellen",
   "branchingDisable": "Die Funktion „Unterthema“ ist im aktuellen Modus nicht verfügbar. Bitte wechseln Sie in den Postgres/PGlite-DB-Modus oder nutzen Sie LobeHub Cloud.",
   "branchingRequiresSavedTopic": "Das aktuelle Thema ist nicht gespeichert. Bitte speichern Sie es zuerst, um die Unterthema-Funktion zu nutzen.",

locales/de-DE/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "Alle beibehalten",
   "modifier.reject": "Zurücksetzen",
   "modifier.rejectAll": "Alle zurücksetzen",
-  "skillFrontmatter.edit": "Metadaten bearbeiten",
-  "skillFrontmatter.empty": "Keine Metadaten",
-  "skillFrontmatter.invalid.descriptionInvalid": "Die Beschreibung muss ein einzeiliger Text sein.",
-  "skillFrontmatter.invalid.descriptionRequired": "Die Beschreibung ist erforderlich.",
-  "skillFrontmatter.invalid.mapping": "Frontmatter muss eine YAML-Zuordnung sein.",
-  "skillFrontmatter.invalid.nameInvalid": "Der Name darf nur Kleinbuchstaben, Zahlen und Bindestriche enthalten.",
-  "skillFrontmatter.invalid.nameLocked": "Der Name muss {{name}} bleiben. Benennen Sie stattdessen das Skill-Bundle um.",
-  "skillFrontmatter.invalid.nameRequired": "Der Name ist erforderlich.",
-  "skillFrontmatter.invalid.required": "Frontmatter ist erforderlich.",
-  "skillFrontmatter.invalid.syntax": "Ungültige YAML-Syntax.",
-  "skillFrontmatter.saveFailed": "Metadaten wurden nicht gespeichert. Versuchen Sie es erneut oder bearbeiten Sie weiter.",
-  "skillFrontmatter.title": "Skill-Metadaten",
   "slash.compact": "Kontext komprimieren",
   "slash.h1": "Überschrift 1",
   "slash.h2": "Überschrift 2",

locales/de-DE/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "Ein anderes Telegram-Konto ist bereits verknüpft",
   "verify.confirm.title": "Verknüpfung bestätigen",
   "verify.confirm.workspace": "Arbeitsbereich: {{workspace}}",
-  "verify.error.alreadyConsumed": "Dieser Link wurde bereits verwendet, um ein Konto zu verbinden. Melden Sie sich bei diesem LobeHub-Konto an, um die Verbindung zu verwalten, oder kehren Sie zum Bot zurück und senden Sie /start erneut, um einen neuen Link zu erstellen.",
-  "verify.error.alreadyConsumedTitle": "Dieser Link wurde bereits verwendet",
   "verify.error.alreadyLinkedToOther": "Dieses Konto ist bereits mit einem anderen LobeHub-Konto verknüpft. Melden Sie sich zuerst bei diesem Konto an.",
   "verify.error.expired": "Dieser Link ist abgelaufen. Bitte kehren Sie zum Bot zurück und senden Sie erneut /start.",
   "verify.error.generic": "Etwas ist schiefgelaufen. Bitte versuchen Sie es erneut.",

locales/de-DE/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "Brandneues Videoerzeugungsmodell mit umfassenden Verbesserungen in Körperbewegung, physikalischem Realismus und Befolgung von Anweisungen.",
   "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 Programmierfähigkeiten mit schnellerer und effizienterer Inferenz.",
   "MiniMax-M2.1-highspeed.description": "Leistungsstarke mehrsprachige Programmierfähigkeiten, umfassend verbesserte Programmiererfahrung. Schneller und effizienter.",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: Gleiche Leistung wie M2.5 mit schnellerer Inferenz.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku ist das schnellste und kompakteste Modell von Anthropic, entwickelt für nahezu sofortige Antworten mit schneller, präziser Leistung.",
   "claude-3-opus-20240229.description": "Claude 3 Opus ist das leistungsstärkste Modell von Anthropic für hochkomplexe Aufgaben. Es überzeugt in Leistung, Intelligenz, Sprachfluss und Verständnis.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet bietet eine ausgewogene Kombination aus Intelligenz und Geschwindigkeit für Unternehmensanwendungen. Es liefert hohe Nutzbarkeit bei geringeren Kosten und zuverlässiger Skalierbarkeit.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 ist das schnellste und intelligenteste Haiku-Modell von Anthropic, mit blitzschneller Geschwindigkeit und erweitertem Denkvermögen.",
+  "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 von Anthropic — Next-Gen-Haiku mit verbessertem Reasoning und Vision.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 ist das schnellste und intelligenteste Haiku-Modell von Anthropic, mit blitzschneller Geschwindigkeit und erweiterten Denkfähigkeiten.",
   "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-1.description": "Claude Opus 4.1 von Anthropic — Premium-Reasoning-Modell mit tiefgehender Analysefähigkeit.",
-  "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 überzeugt.",
+  "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-5.description": "Claude Opus 4.5 von Anthropic — Flaggschiffmodell mit erstklassigem Reasoning und Coding.",
   "claude-opus-4-6.description": "Claude Opus 4.6 von Anthropic — Flaggschiffmodell mit 1M Kontextfenster und erweitertem Reasoning.",
@@ -334,7 +335,7 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 ist das intelligenteste Modell von Anthropic für die Entwicklung von Agenten und Programmierung.",
   "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 kann nahezu sofortige Antworten oder ausführliches 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-5.description": "Claude Sonnet 4.5 von Anthropic — weiterentwickeltes Sonnet mit verbesserter Coding-Leistung.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 von Anthropic — neuestes Sonnet mit überlegener Coding- und Tool-Nutzung.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) ist ein innovatives Modell mit tiefem Sprachverständnis und Interaktionsfähigkeit.",
   "deepseek-ai/deepseek-v3.1-terminus.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-chat.description": "Ein neues Open-Source-Modell, das allgemeine und Code-Fähigkeiten kombiniert. Es bewahrt den allgemeinen Dialog des Chat-Modells und die starken Codierungsfähigkeiten des Coder-Modells, mit besserer Präferenzabstimmung. DeepSeek-V2.5 verbessert auch das Schreiben und das Befolgen von Anweisungen.",
+  "deepseek-chat.description": "Kompatibilitätsalias für den DeepSeek V4 Flash-Modus ohne Denken. Zur Ausmusterung vorgesehen – verwenden Sie stattdessen DeepSeek V4 Flash.",
   "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.",
@@ -430,7 +431,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": "Kompatibilitätsalias für den DeepSeek V4 Flash-Denkmodus. Geplant für die Ausmusterung — verwenden Sie stattdessen deepseek-v4-flash.",
+  "deepseek-reasoner.description": "Kompatibilitätsalias für den DeepSeek V4 Flash-Denkmodus. Zur Ausmusterung vorgesehen – verwenden Sie stattdessen DeepSeek V4 Flash.",
   "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.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 ist ein Bildgenerierungsmodell von ByteDance Seed, das Text- und Bildeingaben unterstützt und eine hochgradig kontrollierbare, hochwertige Bildgenerierung ermöglicht. Es erzeugt Bilder aus Texteingaben.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 ist das neueste multimodale Bildmodell von ByteDance, das Text-zu-Bild, Bild-zu-Bild und Batch-Bilderzeugung integriert und dabei Allgemeinwissen und logisches Denken einbezieht. Im Vergleich zur vorherigen Version 4.0 bietet es eine deutlich verbesserte Generierungsqualität, bessere Konsistenz bei der Bearbeitung und Multi-Bild-Fusion. Es ermöglicht eine präzisere Kontrolle über visuelle Details, erzeugt kleine Texte und kleine Gesichter natürlicher und erreicht harmonischere Layouts und Farben, wodurch die Gesamtästhetik verbessert wird.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite ist das neueste Bildgenerierungsmodell von ByteDance. Erstmals integriert es Online-Retrieval-Funktionen, die es ermöglichen, Echtzeit-Webinformationen einzubeziehen und die Aktualität der generierten Bilder zu verbessern. Die Intelligenz des Modells wurde ebenfalls aufgerüstet, um komplexe Anweisungen und visuelle Inhalte präzise zu interpretieren. Darüber hinaus bietet es eine verbesserte globale Wissensabdeckung, Konsistenz bei Referenzen und Generierungsqualität in professionellen Szenarien, um den visuellen Erstellungsbedarf auf Unternehmensebene besser zu erfüllen.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 von ByteDance ist das leistungsstärkste Videoerzeugungsmodell, das multimodale Referenzvideoerzeugung, Videobearbeitung, Videoerweiterung, Text-zu-Video und Bild-zu-Video mit synchronisiertem Audio unterstützt.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast von ByteDance bietet die gleichen Funktionen wie Seedance 2.0 mit schnelleren Erzeugungsgeschwindigkeiten zu einem wettbewerbsfähigeren Preis.",
   "emohaa.description": "Emohaa ist ein Modell für psychische Gesundheit mit professionellen Beratungsfähigkeiten, das Nutzern hilft, emotionale Probleme zu verstehen.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B ist ein quelloffenes, leichtgewichtiges Modell für lokale und individuell angepasste Bereitstellungen.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview ist ein Vorschau-Modell mit 8K Kontextlänge zur Bewertung von ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 ist ein Bildgenerierungsmodell von ByteDance Seed, das Text- und Bildeingaben unterstützt und hochkontrollierbare, qualitativ hochwertige Bilder generiert. Es erstellt Bilder aus Textaufforderungen.",
+  "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 von Motiven, 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 Bilderzeugung 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.",
@@ -527,8 +531,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 optische Bearbeitungen unterstützt, präzise chinesischen und englischen Text bearbeitet und hochwertige Bearbeitungen wie Stilübertragungen und Objektrotation ermöglicht.",
-  "fal-ai/qwen-image.description": "Ein leistungsstarkes Bildgenerierungsmodell des Qwen-Teams mit beeindruckender chinesischer Textrendering und vielfältigen visuellen Stilen.",
+  "fal-ai/qwen-image-edit.description": "Ein professionelles Bildbearbeitungsmodell des Qwen-Teams, das semantische und optische Bearbeitungen, präzise chinesische/englische Textbearbeitung, Stilübertragungen, Drehungen 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": "Open-Source‑Bildgenerierungsmodell für Forschung und Entwicklung, effizient optimiert für nichtkommerzielle Innovationsforschung.",
   "flux-kontext-max.description": "Modernste kontextuelle Bildgenerierung und -bearbeitung, kombiniert Text und Bilder für präzise, kohärente Ergebnisse.",
@@ -570,7 +574,7 @@
   "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) 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-3.1-pro.description": "Gemini 3.1 Pro von Google — Premium-Multimodalmodell mit 1M Kontextfenster.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "Wir freuen uns, Grok 4 Fast vorzustellen – unser neuester Fortschritt bei kosteneffizienten Denkmodellen.",
   "grok-4.20-0309-non-reasoning.description": "Eine Non-Reasoning-Variante für einfache Anwendungsfälle.",
   "grok-4.20-0309-reasoning.description": "Intelligentes, extrem schnelles Modell, das vor der Antwort aktiv denkt.",
+  "grok-4.20-beta-0309-non-reasoning.description": "Eine Variante ohne Denkprozesse für einfache Anwendungsfälle.",
+  "grok-4.20-beta-0309-reasoning.description": "Intelligentes, blitzschnelles Modell, das vor der Antwort überlegt.",
   "grok-4.20-multi-agent-0309.description": "Ein Team aus 4 oder 16 Agenten, hervorragend für Rechercheaufgaben. Unterstützt derzeit keine clientseitigen Tools. Unterstützt ausschließlich serverseitige xAI-Tools (z. B. X Search, Web Search Tools) und Remote-MCP-Tools.",
   "grok-4.3.description": "Das wahrheitssuchendste große Sprachmodell der Welt",
-  "grok-4.description": "Das neueste Grok-Flaggschiff mit unvergleichlicher Leistung in Sprache, Mathematik und Logik — ein wahrer Alleskönner. Derzeit verweist es auf grok-4-0709; aufgrund begrenzter Ressourcen ist der Preis vorübergehend 10 % höher als der offizielle Preis und wird voraussichtlich später wieder auf den offiziellen Preis zurückkehren.",
+  "grok-4.description": "Unser neuestes und stärkstes Flaggschiff-Modell, das in NLP, Mathematik und logischem Denken herausragt – ein idealer Allrounder.",
   "grok-code-fast-1.description": "Wir freuen uns, grok-code-fast-1 vorzustellen – ein schnelles und kosteneffizientes Denkmodell, das sich besonders für agentenbasiertes Programmieren eignet.",
   "grok-imagine-image-pro.description": "Erstellen Sie Bilder aus Textvorgaben, bearbeiten Sie bestehende Bilder mit natürlicher Sprache oder verfeinern Sie Bilder iterativ durch mehrstufige Gespräche.",
   "grok-imagine-image.description": "Erstellen Sie Bilder aus Textvorgaben, bearbeiten Sie bestehende Bilder mit natürlicher Sprache oder verfeinern Sie Bilder iterativ durch mehrstufige Gespräche.",
@@ -1227,6 +1233,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 Audioerzeugung synchronisiert mit visuellen Inhalten.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite von BytePlus bietet webgestü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.",

locales/de-DE/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "Werkzeuge",
   "skillDetail.trustWarning": "Verwenden Sie nur Connectoren von vertrauenswürdigen Entwicklern. LobeHub hat keine Kontrolle darüber, welche Werkzeuge von Entwicklern bereitgestellt werden, und kann nicht garantieren, dass diese wie beabsichtigt funktionieren oder unverändert bleiben.",
   "skillInstallBanner.dismiss": "Schließen",
-  "skillInstallBanner.title": "Verbinde deine Lieblings-Apps mit Lobe AI",
+  "skillInstallBanner.title": "Funktionen zu Lobe AI hinzufügen",
   "store.actions.cancel": "Abbrechen",
   "store.actions.configure": "Konfigurieren",
   "store.actions.confirmUninstall": "Durch Deinstallation wird die Skill-Konfiguration gelöscht. Fortfahren?",

locales/de-DE/providers.json

@@ -33,6 +33,7 @@
   "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-Token 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.",

locales/de-DE/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "Authentifizierungsmethode",
   "heterogeneousStatus.auth.subscription": "Abonnement",
-  "heterogeneousStatus.cloud.githubDesc": "Wählen Sie eine GitHub-OAuth-Anmeldeinformation aus, um dem Sandbox das Klonen Ihrer privaten Repositories zu ermöglichen.",
-  "heterogeneousStatus.cloud.githubLabel": "GitHub-Verbindung",
-  "heterogeneousStatus.cloud.githubNoCreds": "Keine GitHub-Anmeldeinformationen gefunden.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "Wählen Sie eine GitHub-Anmeldeinformation aus...",
-  "heterogeneousStatus.cloud.manageCredentials": "Anmeldeinformationen verwalten →",
-  "heterogeneousStatus.cloud.repoAdd": "Hinzufügen",
-  "heterogeneousStatus.cloud.repoDesc": "Fügen Sie Repositories zur Liste hinzu. Wechseln Sie das aktive Repository über die untere Leiste in der Chat-Ansicht.",
-  "heterogeneousStatus.cloud.repoLabel": "Repositories",
-  "heterogeneousStatus.cloud.repoPlaceholder": "owner/repo oder https://github.com/owner/repo",
-  "heterogeneousStatus.cloud.tabLabel": "Cloud",
-  "heterogeneousStatus.cloud.tokenCancel": "Abbrechen",
-  "heterogeneousStatus.cloud.tokenChange": "Ändern",
-  "heterogeneousStatus.cloud.tokenDesc": "Ihr Claude Code OAuth-Token. Nach dem Absenden sicher in den Anmeldeinformationen gespeichert. Führen Sie `claude setup-token` in Ihrem Terminal aus, um einen zu generieren.",
-  "heterogeneousStatus.cloud.tokenLabel": "Claude Code Token",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "Fügen Sie hier Ihr OAuth-Token ein",
-  "heterogeneousStatus.cloud.tokenSave": "Speichern",
   "heterogeneousStatus.command.edit": "Befehl bearbeiten",
   "heterogeneousStatus.command.label": "Startbefehl",
   "heterogeneousStatus.command.placeholder": "Befehlname oder absoluter Pfad",
-  "heterogeneousStatus.desktop.tabLabel": "Desktop",
   "heterogeneousStatus.detecting": "{{name}} CLI wird erkannt...",
   "heterogeneousStatus.plan.label": "Plan",
   "heterogeneousStatus.redetect": "Erneut erkennen",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "Nutzen Sie die Funktionen von Linear direkt in Ihrem KI-Assistenten. Issues erstellen und aktualisieren, Sprints verwalten, Projektfortschritte verfolgen und Ihren Entwicklungsworkflow per Konversation optimieren.",
   "tools.lobehubSkill.providers.microsoft.description": "Outlook Kalender ist ein integriertes Planungstool in Microsoft Outlook, mit dem Nutzer Termine erstellen, Meetings organisieren und ihre Zeit effektiv verwalten können.",
   "tools.lobehubSkill.providers.microsoft.readme": "Integrieren Sie Outlook Kalender, um Ihre Termine nahtlos anzuzeigen, zu erstellen und zu verwalten. Meetings planen, Verfügbarkeiten prüfen, Erinnerungen setzen und Ihre Zeit per natürlicher Sprache koordinieren.",
-  "tools.lobehubSkill.providers.notion.description": "Notion ist eine kollaborative Produktivitäts- und Notizanwendung.",
-  "tools.lobehubSkill.providers.notion.readme": "Verbinden Sie sich mit Notion, um auf Ihren Arbeitsbereich zuzugreifen und ihn zu verwalten. Erstellen Sie Seiten, durchsuchen Sie Inhalte, aktualisieren Sie Datenbanken und organisieren Sie Ihre Wissensdatenbank – alles durch natürliche Gespräche mit Ihrem KI-Assistenten.",
   "tools.lobehubSkill.providers.twitter.description": "X (ehemals Twitter) ist eine Social-Media-Plattform für Echtzeit-Updates, Nachrichten und Interaktion mit Ihrem Publikum über Beiträge, Antworten und Direktnachrichten.",
   "tools.lobehubSkill.providers.twitter.readme": "Verbinden Sie sich mit X (Twitter), um Tweets zu posten, Ihre Timeline zu verwalten und mit Ihrem Publikum zu interagieren. Inhalte erstellen, Beiträge planen, Erwähnungen überwachen und Ihre Social-Media-Präsenz per Konversation ausbauen.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel ist eine Cloud‑Plattform für Frontend‑Entwickler und bietet Hosting sowie serverlose Funktionen, um Webanwendungen mühelos bereitzustellen.",

locales/en-US/chat.json

@@ -653,11 +653,10 @@
   "taskSchedule.weekdays.thu": "Thu",
   "taskSchedule.weekdays.tue": "Tue",
   "taskSchedule.weekdays.wed": "Wed",
-  "thread.closeSubagentThread": "Collapse SubAgent conversation",
+  "thread.closeSubagentThread": "Collapse subagent conversation",
   "thread.divider": "Subtopic",
-  "thread.openSubagentThread": "View full SubAgent conversation",
-  "thread.subagentBadge": "SubAgent",
-  "thread.subagentReadOnlyHint": "SubAgent conversations are read-only — execution is driven by the parent agent.",
+  "thread.openSubagentThread": "View full subagent conversation",
+  "thread.subagentBadge": "Subagent",
   "thread.threadMessageCount": "{{messageCount}} messages",
   "thread.title": "Subtopic",
   "todoProgress.allCompleted": "All tasks completed",

locales/en-US/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "Batch Delete",
   "blog": "Product Blog",
   "botIntegrationBanner.dismiss": "Dismiss",
-  "botIntegrationBanner.title": "Talk to Lobe AI on your favorite messaging apps",
+  "botIntegrationBanner.title": "Talk to Lobe AI on your favorite messaging apps.",
   "branching": "Create Subtopic",
   "branchingDisable": "The \"Sub-topic\" feature is unavailable in the current mode. To use this feature, please switch to Postgres/Pglite DB mode or use LobeHub Cloud.",
   "branchingRequiresSavedTopic": "Current topic is not saved, please save it first to use subtopic feature",

locales/en-US/home.json

@@ -6,7 +6,7 @@
   "brief.action.acknowledge": "Acknowledge",
   "brief.action.approve": "Approve",
   "brief.action.confirm": "Confirm",
-  "brief.action.confirmDone": "Confirm complete",
+  "brief.action.confirmDone": "Confirm",
   "brief.action.feedback": "Feedback",
   "brief.action.retry": "Retry",
   "brief.addFeedback": "Share feedback",
@@ -26,11 +26,6 @@
   "brief.viewRun": "View run",
   "project.create": "New project",
   "project.deleteConfirm": "This project will be deleted and can't be recovered. Confirm to continue.",
-  "recommendations.heteroAgent.cta": "Add Agent",
-  "recommendations.heteroAgent.description": "Detected the {{name}} CLI on this device — add {{name}} agent to chat with it from LobeHub.",
-  "recommendations.heteroAgent.tag": "Coding Agent",
-  "recommendations.heteroAgent.title": "Add {{name}} agent",
-  "recommendations.subtitle": "Some recommendations for your setup",
   "starter.createAgent": "Create Agent",
   "starter.createGroup": "Create Group",
   "starter.deepResearch": "Deep Research",

locales/en-US/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "Another {{platform}} account is already linked",
   "verify.confirm.title": "Confirm linking",
   "verify.confirm.workspace": "Workspace: {{workspace}}",
-  "verify.error.alreadyConsumed": "This link has already been used to connect an account. Sign in to that LobeHub account to manage the connection, or return to the bot and send /start again to issue a new link.",
-  "verify.error.alreadyConsumedTitle": "This link is already used",
   "verify.error.alreadyLinkedToOther": "This account is already linked to a different LobeHub account. Sign in to that account first.",
   "verify.error.expired": "This link has expired. Please return to the bot and send /start again.",
   "verify.error.generic": "Something went wrong. Please try again.",

locales/en-US/modelProvider.json

@@ -227,7 +227,6 @@
   "providerModels.item.modelConfig.extendParams.options.gpt5_2ProReasoningEffort.hint": "For GPT-5.2 Pro series; controls reasoning intensity.",
   "providerModels.item.modelConfig.extendParams.options.gpt5_2ReasoningEffort.hint": "For GPT-5.2 series; controls reasoning intensity.",
   "providerModels.item.modelConfig.extendParams.options.grok4_20ReasoningEffort.hint": "For Grok 4.20 series; controls reasoning intensity. Low/Medium uses 4 agents, High/XHigh uses 16 agents.",
-  "providerModels.item.modelConfig.extendParams.options.grok4_3ReasoningEffort.hint": "For Grok 4.3 series; controls reasoning intensity.",
   "providerModels.item.modelConfig.extendParams.options.hy3ReasoningEffort.hint": "For Hy3 models; controls reasoning intensity. no_think (ultra-fast response), low (quick reasoning), and high (deep reasoning)—to accommodate varying latency and depth requirements, from high-frequency interactions to complex engineering tasks.",
   "providerModels.item.modelConfig.extendParams.options.imageAspectRatio.hint": "For Gemini image generation models; controls aspect ratio of generated images.",
   "providerModels.item.modelConfig.extendParams.options.imageAspectRatio2.hint": "For Nano Banana 2; controls aspect ratio of generated images (supports extra-wide 1:4, 4:1, 1:8, 8:1).",

locales/en-US/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "Brand-new video generation model with comprehensive upgrades in body motion, physical realism, and instruction following.",
   "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 with faster and more efficient inference.",
   "MiniMax-M2.1-highspeed.description": "Powerful multilingual programming capabilities, comprehensively upgraded programming experience. Faster and more efficient.",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: Same performance as M2.5 with faster inference.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku is Anthropic’s fastest and most compact model, designed for near-instant responses with fast, accurate performance.",
   "claude-3-opus-20240229.description": "Claude 3 Opus is Anthropic’s most powerful model for highly complex tasks, excelling in performance, intelligence, fluency, and comprehension.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet balances intelligence and speed for enterprise workloads, delivering high utility at lower cost and reliable large-scale deployment.",
-  "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 by Anthropic — next-gen Haiku with enhanced reasoning and vision.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 is Anthropic’s fastest and smartest Haiku model, with lightning speed and extended reasoning.",
   "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-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-1.description": "Claude Opus 4.1 by Anthropic — premium reasoning model with deep analysis capabilities.",
-  "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-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-5.description": "Claude Opus 4.5 by Anthropic — flagship model with top-tier reasoning and coding.",
   "claude-opus-4-6.description": "Claude Opus 4.6 by Anthropic — 1M context window flagship with advanced reasoning.",
@@ -334,8 +335,8 @@
   "claude-opus-4.6-fast.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-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-5.description": "Claude Sonnet 4.5 by Anthropic — improved Sonnet with enhanced coding performance.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 by Anthropic — latest Sonnet with superior coding and tool use.",
   "claude-sonnet-4.5.description": "Claude Sonnet 4.5 is Anthropic’s most intelligent model to date.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) is an innovative model offering deep language understanding and interaction.",
   "deepseek-ai/deepseek-v3.1-terminus.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-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": "Compatibility alias for DeepSeek V4 Flash non-thinking mode. Slated for deprecation — use DeepSeek V4 Flash instead.",
   "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.",
@@ -430,7 +431,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": "Compatibility alias for DeepSeek V4 Flash thinking mode. Slated for deprecation — use deepseek-v4-flash instead.",
+  "deepseek-reasoner.description": "Compatibility alias for DeepSeek V4 Flash thinking mode. Slated for deprecation — use DeepSeek V4 Flash instead.",
   "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.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.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.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 is ByteDance’s latest multimodal image model, integrating text-to-image, image-to-image, and batch image generation capabilities, while incorporating commonsense and reasoning abilities. Compared to the previous 4.0 version, it delivers significantly improved generation quality, with better editing consistency and multi-image fusion. It offers more precise control over visual details, producing small text and small faces more naturally, and achieves more harmonious layout and color, enhancing overall aesthetics.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite is ByteDance’s latest image-generation model. For the first time, it integrates online retrieval capabilities, allowing it to incorporate real-time web information and enhance the timeliness of generated images. The model’s intelligence has also been upgraded, enabling precise interpretation of complex instructions and visual content. Additionally, it offers improved global knowledge coverage, reference consistency, and generation quality in professional scenarios, better meeting enterprise-level visual creation needs.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 by ByteDance is the most powerful video generation model, supporting multimodal reference video generation, video editing, video extension, text-to-video, and image-to-video with synchronized audio.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast by ByteDance offers the same capabilities as Seedance 2.0 with faster generation speeds at a more competitive price.",
   "emohaa.description": "Emohaa is a mental health model with professional counseling abilities to help users understand emotional issues.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B is an open-source lightweight model for local and customized deployment.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview is an 8K context preview model for evaluating ERNIE 4.5.",
@@ -519,7 +522,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.",
@@ -527,8 +531,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": "Open-source R&D image generation model, efficiently optimized for non-commercial innovation research.",
   "flux-kontext-max.description": "State-of-the-art contextual image generation and editing, combining text and images for precise, coherent results.",
@@ -567,10 +571,10 @@
   "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-flash.description": "Gemini 3 Flash by Google — ultra-fast model with multimodal input support.",
   "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-3.1-pro.description": "Gemini 3.1 Pro by Google — premium multimodal model with 1M context window.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "We’re excited to release Grok 4 Fast, our latest progress in cost-effective reasoning models.",
   "grok-4.20-0309-non-reasoning.description": "A non-reasoning variant for simple use cases",
   "grok-4.20-0309-reasoning.description": "Intelligent, blazing-fast model that reasons before responding",
+  "grok-4.20-beta-0309-non-reasoning.description": "A non-reasoning variant for simple use cases",
+  "grok-4.20-beta-0309-reasoning.description": "Intelligent, blazing-fast model that reasons before responding",
   "grok-4.20-multi-agent-0309.description": "A team of 4 or 16 agents, Excels at research use cases, Does not currently support client-side tools. Only supports xAI server side tools (eg X Search, Web Search tools) and remote MCP tools.",
   "grok-4.3.description": "The most truth-seeking large language model in the world",
-  "grok-4.description": "Latest Grok flagship with unmatched performance in language, math, and reasoning — a true all-rounder. Currently points to grok-4-0709; due to limited resources it is temporarily 10% higher than official pricing and is expected to return to official price later.",
+  "grok-4.description": "Our newest and strongest flagship model, excelling in NLP, math, and reasoning—an ideal all-rounder.",
   "grok-code-fast-1.description": "We’re excited to launch grok-code-fast-1, a fast and cost-effective reasoning model that excels at agentic coding.",
   "grok-imagine-image-pro.description": "Generate images from text prompts, edit existing images with natural language, or iteratively refine images through multi-turn conversations.",
   "grok-imagine-image.description": "Generate images from text prompts, edit existing images with natural language, or iteratively refine images through multi-turn conversations.",
@@ -1227,6 +1233,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.",

locales/en-US/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "Tools",
   "skillDetail.trustWarning": "Only use connectors from developers you trust. LobeHub does not control which tools developers make available and cannot verify that they will work as intended or that they won't change.",
   "skillInstallBanner.dismiss": "Dismiss",
-  "skillInstallBanner.title": "Connect your favorite apps to Lobe AI",
+  "skillInstallBanner.title": "Connect your favorite apps to Lobe AI.",
   "store.actions.cancel": "Cancel",
   "store.actions.configure": "Configure",
   "store.actions.confirmUninstall": "Uninstalling will clear Skill config. Continue?",

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

@@ -291,7 +291,7 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "Auth Method",
   "heterogeneousStatus.auth.subscription": "Subscription",
-  "heterogeneousStatus.cloud.githubDesc": "Select a GitHub OAuth credential to allow the sandbox to clone your private repositories.",
+  "heterogeneousStatus.cloud.githubDesc": "Select a GitHub credential to allow the sandbox to clone your private repositories.",
   "heterogeneousStatus.cloud.githubLabel": "GitHub Connection",
   "heterogeneousStatus.cloud.githubNoCreds": "No GitHub credentials found.",
   "heterogeneousStatus.cloud.githubPlaceholder": "Select a GitHub credential...",

locales/es-ES/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "Buscar plantillas...",
   "groupWizard.title": "Crear grupo",
   "groupWizard.useTemplate": "Usar plantilla",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} repositorios seleccionados",
-  "heteroAgent.cloudRepo.noRepos": "No hay repositorios configurados. Agrégalos en la configuración del agente.",
-  "heteroAgent.cloudRepo.notSet": "Ningún repositorio seleccionado",
-  "heteroAgent.cloudRepo.sectionTitle": "Repositorios",
   "heteroAgent.fullAccess.label": "Acceso completo",
   "heteroAgent.fullAccess.tooltip": "Claude Code se ejecuta localmente con acceso completo de lectura y escritura al directorio de trabajo. Cambiar los modos de permiso aún no está disponible.",
   "heteroAgent.resumeReset.cwdChanged": "El directorio de trabajo ha cambiado. La sesión anterior de Claude Code solo puede reanudarse desde su directorio original, por lo que se ha iniciado una nueva conversación.",

locales/es-ES/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "Eliminar en lote",
   "blog": "Blog del producto",
   "botIntegrationBanner.dismiss": "Cerrar",
-  "botIntegrationBanner.title": "Habla con Lobe AI en tus apps de mensajería favoritas",
+  "botIntegrationBanner.title": "Agregar canales a LobeAI",
   "branching": "Crear subtema",
   "branchingDisable": "La función de \"Subtema\" no está disponible en el modo actual. Para usar esta función, cambia al modo de base de datos Postgres/PGlite o utiliza LobeHub Cloud.",
   "branchingRequiresSavedTopic": "El tema actual no está guardado, guárdalo primero para usar la función de subtema",

locales/es-ES/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "Conservar todo",
   "modifier.reject": "Revertir",
   "modifier.rejectAll": "Revertir todo",
-  "skillFrontmatter.edit": "Editar metadatos",
-  "skillFrontmatter.empty": "Sin metadatos",
-  "skillFrontmatter.invalid.descriptionInvalid": "La descripción debe ser un texto de una sola línea.",
-  "skillFrontmatter.invalid.descriptionRequired": "La descripción es obligatoria.",
-  "skillFrontmatter.invalid.mapping": "Los metadatos deben ser un mapeo YAML.",
-  "skillFrontmatter.invalid.nameInvalid": "El nombre debe usar letras minúsculas, números y guiones.",
-  "skillFrontmatter.invalid.nameLocked": "El nombre debe permanecer como {{name}}. Renombra el paquete de habilidades en su lugar.",
-  "skillFrontmatter.invalid.nameRequired": "El nombre es obligatorio.",
-  "skillFrontmatter.invalid.required": "Los metadatos son obligatorios.",
-  "skillFrontmatter.invalid.syntax": "Sintaxis YAML inválida.",
-  "skillFrontmatter.saveFailed": "Los metadatos no se guardaron. Intenta nuevamente o sigue editando.",
-  "skillFrontmatter.title": "Metadatos de habilidades",
   "slash.compact": "Compactar contexto",
   "slash.h1": "Encabezado 1",
   "slash.h2": "Encabezado 2",

locales/es-ES/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "Otra cuenta de Telegram ya está vinculada",
   "verify.confirm.title": "Confirmar vinculación",
   "verify.confirm.workspace": "Espacio de trabajo: {{workspace}}",
-  "verify.error.alreadyConsumed": "Este enlace ya ha sido utilizado para conectar una cuenta. Inicia sesión en esa cuenta de LobeHub para gestionar la conexión, o regresa al bot y envía /start nuevamente para generar un nuevo enlace.",
-  "verify.error.alreadyConsumedTitle": "Este enlace ya ha sido utilizado",
   "verify.error.alreadyLinkedToOther": "Esta cuenta ya está vinculada a una cuenta diferente de LobeHub. Inicia sesión en esa cuenta primero.",
   "verify.error.expired": "Este enlace ha expirado. Por favor, regresa al bot y envía /start de nuevo.",
   "verify.error.generic": "Algo salió mal. Por favor, inténtalo de nuevo.",

locales/es-ES/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "Nuevo modelo de generación de video con mejoras integrales en movimiento corporal, realismo físico y seguimiento de instrucciones.",
   "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 con inferencia más rápida y eficiente.",
   "MiniMax-M2.1-highspeed.description": "Potentes capacidades de programación multilingüe, con una experiencia de programación completamente mejorada. Más rápido 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-highspeed.description": "MiniMax M2.5 Highspeed: Mismo rendimiento que M2.5 con inferencia más rápida.",
@@ -319,11 +320,11 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku es el modelo más rápido y compacto de Anthropic, diseñado para respuestas casi instantáneas con rendimiento rápido y preciso.",
   "claude-3-opus-20240229.description": "Claude 3 Opus es el modelo más potente de Anthropic para tareas altamente complejas, destacando en rendimiento, inteligencia, fluidez y comprensión.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet equilibra inteligencia y velocidad para cargas de trabajo empresariales, ofreciendo alta utilidad a menor costo y despliegue confiable a gran escala.",
-  "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 razonamiento extendido.",
+  "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 de Anthropic: Haiku de nueva generación con razonamiento y visión mejorados.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 es el modelo Haiku más rápido e inteligente de Anthropic, con velocidad relámpago y razonamiento extendido.",
   "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-1-20250805.description": "Claude Opus 4.1 es el modelo más reciente y avanzado de Anthropic para tareas altamente complejas, destacando en rendimiento, inteligencia, fluidez y comprensión.",
   "claude-opus-4-1.description": "Claude Opus 4.1 de Anthropic: modelo de razonamiento premium con profundas capacidades de análisis.",
   "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.",
@@ -334,7 +335,7 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 es el modelo más inteligente de Anthropic para construir agentes y programar.",
   "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 puede generar respuestas casi instantáneas o razonamientos detallados paso a paso con un 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-5.description": "Claude Sonnet 4.5 de Anthropic: versión mejorada de Sonnet con mayor rendimiento en programación.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 de Anthropic: última versión de Sonnet con programación superior y uso avanzado de herramientas.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) es un modelo innovador que ofrece una comprensión profunda del lenguaje y una interacción avanzada.",
   "deepseek-ai/deepseek-v3.1-terminus.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-chat.description": "Un nuevo modelo de código abierto que combina habilidades generales y de programación. Preserva el diálogo general del modelo de chat y la sólida capacidad de codificación del modelo de programación, con mejor alineación de preferencias. DeepSeek-V2.5 también mejora la escritura y el seguimiento de instrucciones.",
+  "deepseek-chat.description": "Alias de compatibilidad para el modo sin razonamiento de DeepSeek V4 Flash. Programado para ser descontinuado: utiliza DeepSeek V4 Flash en su lugar.",
   "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.",
@@ -430,7 +431,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": "Alias de compatibilidad para el modo de pensamiento rápido de DeepSeek V4. Programado para ser descontinuado — utiliza deepseek-v4-flash en su lugar.",
+  "deepseek-reasoner.description": "Alias de compatibilidad para el modo de razonamiento de DeepSeek V4 Flash. Programado para ser descontinuado: utiliza DeepSeek V4 Flash en su lugar.",
   "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.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 es un modelo de generación de imágenes de ByteDance Seed que admite entradas de texto e imagen con generación de imágenes de alta calidad y altamente controlable. Genera imágenes a partir de indicaciones de texto.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 es el último modelo multimodal de imágenes de ByteDance, que integra capacidades de texto a imagen, imagen a imagen y generación de imágenes por lotes, mientras incorpora sentido común y habilidades de razonamiento. En comparación con la versión 4.0 anterior, ofrece una calidad de generación significativamente mejorada, con mayor consistencia en la edición y fusión de múltiples imágenes. Proporciona un control más preciso sobre los detalles visuales, produciendo texto y rostros pequeños de manera más natural, y logra una disposición y color más armoniosos, mejorando la estética general.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite es el último modelo de generación de imágenes de ByteDance. Por primera vez, integra capacidades de recuperación en línea, permitiendo incorporar información web en tiempo real y mejorar la actualidad de las imágenes generadas. La inteligencia del modelo también ha sido mejorada, permitiendo una interpretación precisa de instrucciones complejas y contenido visual. Además, ofrece una mejor cobertura de conocimiento global, consistencia de referencia y calidad de generación en escenarios profesionales, satisfaciendo mejor las necesidades de creación visual a nivel empresarial.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 de ByteDance es el modelo de generación de video más poderoso, compatible con generación de video multimodal de referencia, edición de video, extensión de video, texto a video e imagen a video con audio sincronizado.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast de ByteDance ofrece las mismas capacidades que Seedance 2.0 con velocidades de generación más rápidas a un precio más competitivo.",
   "emohaa.description": "Emohaa es un modelo de salud mental con capacidades profesionales de asesoramiento para ayudar a los usuarios a comprender problemas emocionales.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B es un modelo ligero de código abierto para implementación local y personalizada.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview es un modelo de vista previa con contexto de 8K para evaluar ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 es un modelo de generación de imágenes de ByteDance Seed, que admite entradas de texto e imagen con generación de imágenes altamente controlable y de alta calidad. Genera imágenes a partir de indicaciones de texto.",
+  "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. Incluye 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-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 una 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.",
@@ -527,8 +531,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, edita texto en chino e inglés con precisión, y permite ediciones de alta calidad como transferencia de estilo y rotación de objetos.",
-  "fal-ai/qwen-image.description": "Un modelo poderoso de generación de imágenes del equipo Qwen con impresionante renderizado de texto en chino y estilos visuales diversos.",
+  "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 poderoso de generación de imágenes del equipo Qwen con un 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": "Modelo de generación de imágenes de I+D de código abierto, optimizado de forma eficiente para investigación innovadora no comercial.",
   "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.",
@@ -570,7 +574,7 @@
   "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) 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 para 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-3.1-pro.description": "Gemini 3.1 Pro de Google: modelo multimodal premium con ventana de contexto de 1M.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "Nos complace lanzar Grok 4 Fast, nuestro último avance en modelos de razonamiento rentables.",
   "grok-4.20-0309-non-reasoning.description": "Variante sin razonamiento para casos de uso simples.",
   "grok-4.20-0309-reasoning.description": "Modelo inteligente y rapidísimo que razona antes de responder.",
+  "grok-4.20-beta-0309-non-reasoning.description": "Una variante sin razonamiento para casos de uso simples.",
+  "grok-4.20-beta-0309-reasoning.description": "Modelo inteligente y ultrarrápido que razona antes de responder.",
   "grok-4.20-multi-agent-0309.description": "Equipo de 4 o 16 agentes. Destaca en casos de investigación. No admite herramientas del lado del cliente. Solo admite herramientas del lado del servidor de xAI (como X Search, Web Search) y herramientas MCP remotas.",
   "grok-4.3.description": "El modelo de lenguaje grande más orientado a la verdad en el mundo.",
-  "grok-4.description": "Último modelo insignia de Grok con un rendimiento inigualable en lenguaje, matemáticas y razonamiento — un verdadero todoterreno. Actualmente apunta a grok-4-0709; debido a recursos limitados, tiene un precio temporalmente un 10% más alto que el oficial y se espera que regrese al precio oficial más adelante.",
+  "grok-4.description": "Nuestro modelo insignia más nuevo y fuerte, destacando en PNL, matemáticas y razonamiento: un todoterreno ideal.",
   "grok-code-fast-1.description": "Nos complace lanzar grok-code-fast-1, un modelo de razonamiento rápido y rentable que destaca en codificación agente.",
   "grok-imagine-image-pro.description": "Genera imágenes a partir de indicaciones de texto, edita imágenes existentes con lenguaje natural o refina imágenes de manera iterativa a través de conversaciones de múltiples turnos.",
   "grok-imagine-image.description": "Genera imágenes a partir de indicaciones de texto, edita imágenes existentes con lenguaje natural o refina imágenes de manera iterativa a través de conversaciones de múltiples turnos.",
@@ -1227,6 +1233,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 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 mayor consistencia de referencia 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.",

locales/es-ES/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "Herramientas",
   "skillDetail.trustWarning": "Utiliza solo conectores de desarrolladores en los que confíes. LobeHub no controla qué herramientas ponen a disposición los desarrolladores ni puede garantizar que funcionen como se espera o que no cambien.",
   "skillInstallBanner.dismiss": "Descartar",
-  "skillInstallBanner.title": "Conecta tus apps favoritas a Lobe AI",
+  "skillInstallBanner.title": "Agrega habilidades a Lobe AI",
   "store.actions.cancel": "Cancelar",
   "store.actions.configure": "Configurar",
   "store.actions.confirmUninstall": "Desinstalar eliminará la configuración del Skill. ¿Continuar?",

locales/es-ES/providers.json

@@ -33,6 +33,7 @@
   "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 del modelo.",
   "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.",

locales/es-ES/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "Método de autenticación",
   "heterogeneousStatus.auth.subscription": "Suscripción",
-  "heterogeneousStatus.cloud.githubDesc": "Selecciona una credencial OAuth de GitHub para permitir que el sandbox clone tus repositorios privados.",
-  "heterogeneousStatus.cloud.githubLabel": "Conexión con GitHub",
-  "heterogeneousStatus.cloud.githubNoCreds": "No se encontraron credenciales de GitHub.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "Selecciona una credencial de GitHub...",
-  "heterogeneousStatus.cloud.manageCredentials": "Gestionar Credenciales →",
-  "heterogeneousStatus.cloud.repoAdd": "Agregar",
-  "heterogeneousStatus.cloud.repoDesc": "Agrega repositorios a la lista. Cambia el activo desde la barra inferior en la vista de chat.",
-  "heterogeneousStatus.cloud.repoLabel": "Repositorios",
-  "heterogeneousStatus.cloud.repoPlaceholder": "owner/repo o https://github.com/owner/repo",
-  "heterogeneousStatus.cloud.tabLabel": "Nube",
-  "heterogeneousStatus.cloud.tokenCancel": "Cancelar",
-  "heterogeneousStatus.cloud.tokenChange": "Cambiar",
-  "heterogeneousStatus.cloud.tokenDesc": "Tu token OAuth de Claude Code. Guardado de forma segura en Credenciales una vez enviado. Ejecuta `claude setup-token` en tu terminal para generar uno.",
-  "heterogeneousStatus.cloud.tokenLabel": "Token de Claude Code",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "Pega tu token OAuth aquí",
-  "heterogeneousStatus.cloud.tokenSave": "Guardar",
   "heterogeneousStatus.command.edit": "Editar comando",
   "heterogeneousStatus.command.label": "Comando de inicio",
   "heterogeneousStatus.command.placeholder": "Nombre del comando o ruta absoluta",
-  "heterogeneousStatus.desktop.tabLabel": "Escritorio",
   "heterogeneousStatus.detecting": "Detectando la CLI de {{name}}...",
   "heterogeneousStatus.plan.label": "Plan",
   "heterogeneousStatus.redetect": "Volver a detectar",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "Lleva el poder de Linear directamente a tu asistente de IA. Crea y actualiza incidencias, gestiona sprints, sigue el progreso de proyectos y optimiza tu flujo de desarrollo mediante conversación natural.",
   "tools.lobehubSkill.providers.microsoft.description": "Outlook Calendar es una herramienta de programación integrada en Microsoft Outlook que permite a los usuarios crear citas, organizar reuniones y gestionar su tiempo y eventos de forma eficaz.",
   "tools.lobehubSkill.providers.microsoft.readme": "Integra con Outlook Calendar para ver, crear y gestionar tus eventos sin complicaciones. Programa reuniones, consulta disponibilidad, establece recordatorios y organiza tu tiempo mediante comandos en lenguaje natural.",
-  "tools.lobehubSkill.providers.notion.description": "Notion es una aplicación colaborativa de productividad y toma de notas.",
-  "tools.lobehubSkill.providers.notion.readme": "Conéctate a Notion para acceder y gestionar tu espacio de trabajo. Crea páginas, busca contenido, actualiza bases de datos y organiza tu base de conocimiento, todo a través de una conversación natural con tu asistente de IA.",
   "tools.lobehubSkill.providers.twitter.description": "X (Twitter) es una plataforma de redes sociales para compartir actualizaciones en tiempo real, noticias y conectar con tu audiencia mediante publicaciones, respuestas y mensajes directos.",
   "tools.lobehubSkill.providers.twitter.readme": "Conéctate con X (Twitter) para publicar tuits, gestionar tu cronología e interactuar con tu audiencia. Crea contenido, programa publicaciones, monitorea menciones y fortalece tu presencia en redes sociales mediante IA conversacional.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel es una plataforma en la nube para desarrolladores frontend que ofrece alojamiento y funciones serverless para desplegar aplicaciones web fácilmente.",

locales/fa-IR/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "جستجوی الگوها...",
   "groupWizard.title": "ایجاد گروه",
   "groupWizard.useTemplate": "استفاده از الگو",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} مخزن انتخاب شده است",
-  "heteroAgent.cloudRepo.noRepos": "هیچ مخزنی تنظیم نشده است. آنها را در تنظیمات عامل اضافه کنید.",
-  "heteroAgent.cloudRepo.notSet": "هیچ مخزنی انتخاب نشده است",
-  "heteroAgent.cloudRepo.sectionTitle": "مخازن",
   "heteroAgent.fullAccess.label": "دسترسی کامل",
   "heteroAgent.fullAccess.tooltip": "Claude Code به‌صورت محلی با دسترسی کامل خواندن/نوشتن در پوشه کاری اجرا می‌شود. تغییر حالت‌های دسترسی فعلاً امکان‌پذیر نیست.",
   "heteroAgent.resumeReset.cwdChanged": "پوشه کاری تغییر کرده است. نشست قبلی Claude Code فقط از پوشه اصلی خود قابل ادامه است، بنابراین یک مکالمه جدید آغاز شد.",

locales/fa-IR/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "حذف گروهی",
   "blog": "وبلاگ محصول",
   "botIntegrationBanner.dismiss": "بستن",
-  "botIntegrationBanner.title": "با Lobe AI در پیام‌رسان‌های مورد علاقه‌تان گفتگو کنید",
+  "botIntegrationBanner.title": "افزودن کانال‌ها به LobeAI",
   "branching": "ایجاد زیرموضوع",
   "branchingDisable": "ویژگی «زیرموضوع» در حالت فعلی در دسترس نیست. برای استفاده از این ویژگی، لطفاً به حالت پایگاه داده Postgres/Pglite یا LobeHub Cloud تغییر دهید.",
   "branchingRequiresSavedTopic": "موضوع فعلی ذخیره نشده است، لطفاً ابتدا آن را ذخیره کنید تا بتوانید از ویژگی زیرموضوع استفاده کنید",

locales/fa-IR/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "نگه‌داشتن همه",
   "modifier.reject": "بازگرداندن",
   "modifier.rejectAll": "بازگرداندن همه",
-  "skillFrontmatter.edit": "ویرایش فراداده",
-  "skillFrontmatter.empty": "فراداده‌ای وجود ندارد",
-  "skillFrontmatter.invalid.descriptionInvalid": "توضیحات باید یک متن تک‌خطی باشد.",
-  "skillFrontmatter.invalid.descriptionRequired": "وارد کردن توضیحات الزامی است.",
-  "skillFrontmatter.invalid.mapping": "فراداده باید یک نگاشت YAML باشد.",
-  "skillFrontmatter.invalid.nameInvalid": "نام باید از حروف کوچک، اعداد و خط تیره استفاده کند.",
-  "skillFrontmatter.invalid.nameLocked": "نام باید به صورت {{name}} باقی بماند. در عوض بسته مهارت را تغییر نام دهید.",
-  "skillFrontmatter.invalid.nameRequired": "وارد کردن نام الزامی است.",
-  "skillFrontmatter.invalid.required": "فراداده الزامی است.",
-  "skillFrontmatter.invalid.syntax": "نحو YAML نامعتبر است.",
-  "skillFrontmatter.saveFailed": "فراداده ذخیره نشد. دوباره تلاش کنید یا به ویرایش ادامه دهید.",
-  "skillFrontmatter.title": "فراداده مهارت",
   "slash.compact": "فشرده‌سازی زمینه",
   "slash.h1": "سرفصل ۱",
   "slash.h2": "سرفصل ۲",

locales/fa-IR/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "یک حساب تلگرام دیگر قبلاً متصل شده است",
   "verify.confirm.title": "تأیید لینک",
   "verify.confirm.workspace": "فضای کاری: {{workspace}}",
-  "verify.error.alreadyConsumed": "این لینک قبلاً برای اتصال به یک حساب کاربری استفاده شده است. وارد حساب LobeHub خود شوید تا اتصال را مدیریت کنید، یا به ربات بازگردید و دوباره /start را ارسال کنید تا یک لینک جدید صادر شود.",
-  "verify.error.alreadyConsumedTitle": "این لینک قبلاً استفاده شده است",
   "verify.error.alreadyLinkedToOther": "این حساب قبلاً به یک حساب دیگر LobeHub لینک شده است. ابتدا وارد آن حساب شوید.",
   "verify.error.expired": "این لینک منقضی شده است. لطفاً به ربات بازگردید و دوباره دستور /start را ارسال کنید.",
   "verify.error.generic": "مشکلی پیش آمد. لطفاً دوباره امتحان کنید.",

locales/fa-IR/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "مدل جدید تولید ویدئو با ارتقاهای جامع در حرکت بدن، واقع‌گرایی فیزیکی و پیروی از دستورالعمل‌ها.",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: همان عملکرد M2.5 با استنتاج سریع‌تر.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku سریع‌ترین و فشرده‌ترین مدل Anthropic است که برای پاسخ‌های تقریباً فوری با عملکرد سریع و دقیق طراحی شده است.",
   "claude-3-opus-20240229.description": "Claude 3 Opus قدرتمندترین مدل Anthropic برای وظایف بسیار پیچیده است که در عملکرد، هوش، روانی و درک زبان برتری دارد.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet تعادل بین هوش و سرعت را برای بارهای کاری سازمانی برقرار می‌کند و با هزینه کمتر، بهره‌وری بالا و استقرار قابل اعتماد در مقیاس وسیع را ارائه می‌دهد.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 سریع‌ترین و هوشمندترین مدل هایکو Anthropic است که با سرعت فوق‌العاده و توانایی استدلال پیشرفته ارائه می‌شود.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 سریع‌ترین و هوشمندترین مدل هایکو Anthropic است، با سرعت فوق‌العاده و توانایی تفکر گسترده.",
   "claude-haiku-4-5.description": "Claude Haiku 4.5 از Anthropic — نسل جدید Haiku با استدلال و پردازش تصویری پیشرفته.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 سریع‌ترین و هوشمندترین مدل Haiku از Anthropic است که با سرعت برق‌آسا و توانایی استدلال پیشرفته ارائه می‌شود.",
   "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-1.description": "Claude Opus 4.1 از Anthropic — مدل استدلال سطح‌بالا با توانایی تحلیل عمیق.",
-  "claude-opus-4-20250514.description": "Claude Opus 4 قدرتمندترین مدل Anthropic برای وظایف بسیار پیچیده است که در عملکرد، هوش، روانی و فهم برتری دارد.",
+  "claude-opus-4-20250514.description": "Claude Opus 4 قدرتمندترین مدل Anthropic برای وظایف بسیار پیچیده است که در عملکرد، هوش، روانی و درک برتری دارد.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5 مدل پرچم‌دار Anthropic است که هوش برجسته را با عملکرد مقیاس‌پذیر ترکیب می‌کند و برای وظایف پیچیده‌ای که نیاز به پاسخ‌های باکیفیت و استدلال دارند، ایده‌آل است.",
   "claude-opus-4-5.description": "Claude Opus 4.5 از Anthropic — مدل پرچم‌دار با استدلال و کدنویسی سطح‌بالا.",
   "claude-opus-4-6.description": "Claude Opus 4.6 از Anthropic — مدل پرچم‌دار با پنجره زمینه ۱ میلیون و توانایی استدلال پیشرفته.",
@@ -334,7 +335,7 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 هوشمندترین مدل 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 می‌تواند پاسخ‌های تقریباً فوری یا تفکر مرحله‌به‌مرحله گسترده با فرآیند قابل مشاهده تولید کند.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4 هوشمندترین مدل Anthropic تا به امروز است که پاسخ‌های تقریباً فوری یا تفکر گام‌به‌گام گسترده با کنترل دقیق برای کاربران API ارائه می‌دهد.",
   "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5 هوشمندترین مدل Anthropic تا به امروز است.",
   "claude-sonnet-4-5.description": "Claude Sonnet 4.5 از Anthropic — نسخه بهبود‌یافته Sonnet با عملکرد بهتر در کدنویسی.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 از Anthropic — جدیدترین Sonnet با کدنویسی برتر و استفاده بهتر از ابزار.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) یک مدل نوآورانه با درک عمیق زبان و تعامل است.",
   "deepseek-ai/deepseek-v3.1-terminus.description": "DeepSeek V3.1 یک مدل استدلال نسل بعدی با توانایی استدلال پیچیده و زنجیره تفکر برای وظایف تحلیلی عمیق است.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2 یک مدل استدلال نسل بعدی با قابلیت‌های استدلال پیچیده‌تر و زنجیره‌ای از تفکر است.",
-  "deepseek-chat.description": "یک مدل متن‌باز جدید که توانایی‌های عمومی و کدنویسی را ترکیب می‌کند. این مدل گفتگوی عمومی و کدنویسی قوی را حفظ کرده و با هماهنگی بهتر ترجیحات، نوشتن و پیروی از دستورات را بهبود می‌بخشد.",
+  "deepseek-chat.description": "نام مستعار سازگار برای حالت غیرتفکری DeepSeek V4 Flash. برنامه‌ریزی شده برای توقف استفاده — به جای آن از DeepSeek V4 Flash استفاده کنید.",
   "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 دارد.",
@@ -430,7 +431,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 V4. برنامه‌ریزی شده برای حذف — به جای آن از deepseek-v4-flash استفاده کنید.",
+  "deepseek-reasoner.description": "نام مستعار سازگار برای حالت تفکری DeepSeek V4 Flash. برنامه‌ریزی شده برای توقف استفاده — به جای آن از DeepSeek V4 Flash استفاده کنید.",
   "deepseek-v2.description": "DeepSeek V2 یک مدل MoE کارآمد است که پردازش مقرون‌به‌صرفه را امکان‌پذیر می‌سازد.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B مدل متمرکز بر کدنویسی DeepSeek است که توانایی بالایی در تولید کد دارد.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324 یک مدل MoE با ۶۷۱ میلیارد پارامتر است که در برنامه‌نویسی، توانایی‌های فنی، درک زمینه و پردازش متون بلند عملکرد برجسته‌ای دارد.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 یک مدل تولید تصویر از ByteDance Seed است که از ورودی‌های متن و تصویر پشتیبانی می‌کند و تولید تصویر با کیفیت بالا و قابل کنترل را ارائه می‌دهد. این مدل تصاویر را از دستورات متنی تولید می‌کند.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 جدیدترین مدل چندوجهی تصویر ByteDance است که قابلیت‌های تبدیل متن به تصویر، تصویر به تصویر و تولید دسته‌ای تصاویر را ادغام می‌کند و توانایی‌های استدلال و دانش عمومی را نیز در بر می‌گیرد. در مقایسه با نسخه قبلی 4.0، کیفیت تولید به‌طور قابل‌توجهی بهبود یافته است، با سازگاری بهتر در ویرایش و ترکیب چند تصویر. کنترل دقیق‌تری بر جزئیات بصری ارائه می‌دهد، متن‌های کوچک و چهره‌های کوچک را به‌طور طبیعی‌تر تولید می‌کند و به هماهنگی بهتر در چیدمان و رنگ دست می‌یابد، که زیبایی کلی را افزایش می‌دهد.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite جدیدترین مدل تولید تصویر ByteDance است. برای اولین بار، قابلیت‌های بازیابی آنلاین را ادغام کرده است که به آن امکان می‌دهد اطلاعات وب لحظه‌ای را وارد کند و به‌موقع بودن تصاویر تولید شده را افزایش دهد. هوش مدل نیز ارتقا یافته است، که تفسیر دقیق دستورالعمل‌های پیچیده و محتوای بصری را امکان‌پذیر می‌کند. علاوه بر این، پوشش دانش جهانی، سازگاری مرجع و کیفیت تولید در سناریوهای حرفه‌ای بهبود یافته است، که نیازهای خلق بصری در سطح سازمانی را بهتر برآورده می‌کند.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 توسط ByteDance قدرتمندترین مدل تولید ویدئو است که از تولید ویدئو با مرجع چندوجهی، ویرایش ویدئو، گسترش ویدئو، متن به ویدئو و تصویر به ویدئو با صدای همگام‌سازی شده پشتیبانی می‌کند.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast توسط ByteDance همان قابلیت‌های Seedance 2.0 را با سرعت تولید بالاتر و قیمت رقابتی‌تر ارائه می‌دهد.",
   "emohaa.description": "Emohaa یک مدل سلامت روان با توانایی مشاوره حرفه‌ای است که به کاربران در درک مسائل احساسی کمک می‌کند.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B یک مدل سبک متن‌باز برای استقرار محلی و سفارشی‌سازی شده است.",
   "ernie-4.5-8k-preview.description": "پیش‌نمایش مدل با پنجره متنی ۸هزار توکن برای ارزیابی ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 یک مدل تولید تصویر از ByteDance Seed است که از ورودی‌های متنی و تصویری پشتیبانی می‌کند و تولید تصاویر با کیفیت بالا و قابل کنترل را ارائه می‌دهد. این مدل تصاویر را از درخواست‌های متنی تولید می‌کند.",
+  "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] یک مدل تولید تصویر با تمایل زیبایی‌شناسی به تصاویر طبیعی و واقع‌گرایانه‌تر است.",
@@ -527,8 +531,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 با قابلیت‌های برجسته در رندر متن چینی و سبک‌های بصری متنوع.",
+  "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-kontext-max.description": "تولید و ویرایش تصویر متنی-زمینه‌ای پیشرفته که متن و تصویر را برای نتایج دقیق و منسجم ترکیب می‌کند.",
@@ -567,10 +571,10 @@
   "gemini-3-flash-preview.description": "Gemini 3 Flash هوشمندترین مدل طراحی‌شده برای سرعت است که هوش پیشرفته را با قابلیت جست‌وجوی دقیق ترکیب می‌کند.",
   "gemini-3-flash.description": "Gemini 3 Flash از Google — مدل بسیار سریع با پشتیبانی ورودی چندوجهی.",
   "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-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) سریع‌ترین مدل تولید تصویر گوگل با پشتیبانی از تفکر، تولید و ویرایش تصویری مکالمه‌ای است.",
+  "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-3.1-pro.description": "Gemini 3.1 Pro از Google — مدل ممتاز چندوجهی با پنجره زمینه ۱ میلیون.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "با افتخار Grok 4 Fast را معرفی می‌کنیم، جدیدترین پیشرفت ما در مدل‌های استدلال مقرون‌به‌صرفه.",
   "grok-4.20-0309-non-reasoning.description": "نسخه بدون استدلال برای کاربردهای ساده.",
   "grok-4.20-0309-reasoning.description": "مدلی هوشمند و بسیار سریع که قبل از پاسخ استدلال می‌کند.",
+  "grok-4.20-beta-0309-non-reasoning.description": "یک نسخه غیرتفکری برای موارد استفاده ساده.",
+  "grok-4.20-beta-0309-reasoning.description": "مدلی هوشمند و فوق‌العاده سریع که قبل از پاسخ‌دهی استدلال می‌کند.",
   "grok-4.20-multi-agent-0309.description": "مجموعه‌ای از ۴ یا ۱۶ ایجنت که در پژوهش عملکرد عالی دارد. در حال حاضر از ابزارهای سمت کاربر پشتیبانی نمی‌کند و تنها ابزارهای سمت سرور xAI (مانند X Search و Web Search) و ابزارهای MCP از راه دور را پشتیبانی می‌کند.",
   "grok-4.3.description": "حقیقت‌جویانه‌ترین مدل زبان بزرگ در جهان",
-  "grok-4.description": "جدیدترین مدل پرچمدار Grok با عملکرد بی‌نظیر در زبان، ریاضیات و استدلال — یک مدل همه‌جانبه واقعی. در حال حاضر به grok-4-0709 اشاره دارد؛ به دلیل منابع محدود، قیمت آن موقتاً ۱۰٪ بالاتر از قیمت رسمی است و انتظار می‌رود به قیمت رسمی بازگردد.",
+  "grok-4.description": "جدیدترین و قوی‌ترین مدل پرچمدار ما که در NLP، ریاضیات و استدلال برتری دارد—یک مدل همه‌کاره ایده‌آل.",
   "grok-code-fast-1.description": "با افتخار grok-code-fast-1 را معرفی می‌کنیم، مدلی سریع و مقرون‌به‌صرفه برای استدلال که در برنامه‌نویسی عامل‌محور عملکرد درخشانی دارد.",
   "grok-imagine-image-pro.description": "تصاویر را از دستورات متنی تولید کنید، تصاویر موجود را با زبان طبیعی ویرایش کنید، یا تصاویر را از طریق مکالمات چندمرحله‌ای به‌طور مکرر اصلاح کنید.",
   "grok-imagine-image.description": "تصاویر را از دستورات متنی تولید کنید، تصاویر موجود را با زبان طبیعی ویرایش کنید، یا تصاویر را از طریق مکالمات چندمرحله‌ای به‌طور مکرر اصلاح کنید.",
@@ -1227,6 +1233,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 بالای ۸۰ دارد. در حال حاضر از زبان انگلیسی پشتیبانی می‌کند؛ انتشار کامل آن برای نوامبر ۲۰۲۴ با پشتیبانی زبانی گسترده‌تر و زمینه طولانی‌تر برنامه‌ریزی شده است.",

locales/fa-IR/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "ابزارها",
   "skillDetail.trustWarning": "فقط از کانکتورهایی استفاده کنید که توسط توسعه‌دهندگان مورد اعتماد شما ارائه شده‌اند. LobeHub کنترلی بر ابزارهایی که توسعه‌دهندگان ارائه می‌دهند ندارد و نمی‌تواند تضمین کند که این ابزارها طبق انتظار عمل می‌کنند یا تغییری نخواهند کرد.",
   "skillInstallBanner.dismiss": "بستن",
-  "skillInstallBanner.title": "برنامه‌های مورد علاقه‌تان را به Lobe AI وصل کنید",
+  "skillInstallBanner.title": "افزودن مهارت‌ها به Lobe AI",
   "store.actions.cancel": "لغو",
   "store.actions.configure": "پیکربندی",
   "store.actions.confirmUninstall": "حذف مهارت باعث پاک شدن پیکربندی آن می‌شود. ادامه می‌دهید؟",

locales/fa-IR/providers.json

@@ -33,6 +33,7 @@
   "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 را برای وظایف کدنویسی از طریق اشتراک با هزینه ثابت فراهم می‌کند.",

locales/fa-IR/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "روش احراز هویت",
   "heterogeneousStatus.auth.subscription": "اشتراک",
-  "heterogeneousStatus.cloud.githubDesc": "یک اعتبارنامه OAuth GitHub را انتخاب کنید تا به سندباکس اجازه دهید مخازن خصوصی شما را کلون کند.",
-  "heterogeneousStatus.cloud.githubLabel": "اتصال GitHub",
-  "heterogeneousStatus.cloud.githubNoCreds": "هیچ اعتبارنامه GitHub یافت نشد.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "یک اعتبارنامه GitHub انتخاب کنید...",
-  "heterogeneousStatus.cloud.manageCredentials": "مدیریت اعتبارنامه‌ها →",
-  "heterogeneousStatus.cloud.repoAdd": "افزودن",
-  "heterogeneousStatus.cloud.repoDesc": "مخازن را به لیست اضافه کنید. مخزن فعال را از نوار پایین در نمای چت تغییر دهید.",
-  "heterogeneousStatus.cloud.repoLabel": "مخازن",
-  "heterogeneousStatus.cloud.repoPlaceholder": "owner/repo یا https://github.com/owner/repo",
-  "heterogeneousStatus.cloud.tabLabel": "ابر",
-  "heterogeneousStatus.cloud.tokenCancel": "لغو",
-  "heterogeneousStatus.cloud.tokenChange": "تغییر",
-  "heterogeneousStatus.cloud.tokenDesc": "توکن OAuth Claude Code شما. پس از ارسال، به‌صورت امن در اعتبارنامه‌ها ذخیره می‌شود. دستور `claude setup-token` را در ترمینال خود اجرا کنید تا یک توکن ایجاد کنید.",
-  "heterogeneousStatus.cloud.tokenLabel": "توکن Claude Code",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "توکن OAuth خود را اینجا بچسبانید",
-  "heterogeneousStatus.cloud.tokenSave": "ذخیره",
   "heterogeneousStatus.command.edit": "ویرایش فرمان",
   "heterogeneousStatus.command.label": "فرمان اجرا",
   "heterogeneousStatus.command.placeholder": "نام فرمان یا مسیر کامل",
-  "heterogeneousStatus.desktop.tabLabel": "دسکتاپ",
   "heterogeneousStatus.detecting": "در حال شناسایی رابط خط فرمان {{name}} ...",
   "heterogeneousStatus.plan.label": "طرح",
   "heterogeneousStatus.redetect": "شناسایی دوباره",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "قدرت Linear را مستقیماً به دستیار هوش مصنوعی خود بیاورید. مسائل را ایجاد و به‌روزرسانی کرده، اسپرینت‌ها را مدیریت کنید، پیشرفت پروژه را پیگیری کرده و جریان کاری توسعه خود را از طریق مکالمه طبیعی بهینه نمایید.",
   "tools.lobehubSkill.providers.microsoft.description": "تقویم Outlook یک ابزار زمان‌بندی یکپارچه در Microsoft Outlook است که به کاربران امکان می‌دهد قرار ملاقات ایجاد کرده، جلسات را با دیگران سازمان‌دهی کرده و زمان و رویدادهای خود را به‌طور مؤثر مدیریت کنند.",
   "tools.lobehubSkill.providers.microsoft.readme": "با Outlook Calendar یکپارچه شوید تا رویدادهای خود را مشاهده، ایجاد و مدیریت کنید. جلسات را برنامه‌ریزی کرده، در دسترس بودن را بررسی کنید، یادآورها را تنظیم کرده و زمان خود را از طریق دستورات زبان طبیعی هماهنگ نمایید.",
-  "tools.lobehubSkill.providers.notion.description": "Notion یک برنامه همکاری، بهره‌وری و یادداشت‌برداری است.",
-  "tools.lobehubSkill.providers.notion.readme": "به Notion متصل شوید تا به فضای کاری خود دسترسی پیدا کنید و آن را مدیریت کنید. صفحات ایجاد کنید، محتوا جستجو کنید، پایگاه‌های داده را به‌روزرسانی کنید و پایگاه دانش خود را سازماندهی کنید—همه این‌ها از طریق مکالمه طبیعی با دستیار هوش مصنوعی شما.",
   "tools.lobehubSkill.providers.twitter.description": "X (توییتر) یک پلتفرم رسانه اجتماعی برای به‌اشتراک‌گذاری به‌روزرسانی‌های لحظه‌ای، اخبار و تعامل با مخاطبان از طریق پست‌ها، پاسخ‌ها و پیام‌های مستقیم است.",
   "tools.lobehubSkill.providers.twitter.readme": "به X (توییتر) متصل شوید تا توییت ارسال کرده، تایم‌لاین خود را مدیریت کرده و با مخاطبان خود تعامل داشته باشید. محتوا ایجاد کرده، پست‌ها را زمان‌بندی کنید، اشاره‌ها را پایش کرده و حضور خود در شبکه‌های اجتماعی را از طریق هوش مصنوعی مکالمه‌ای گسترش دهید.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel یک پلتفرم ابری برای توسعه‌دهندگان فرانت‌اند است که میزبانی و توابع بدون سرور را برای استقرار آسان برنامه‌های وب ارائه می‌دهد.",

locales/fr-FR/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "Rechercher des modèles...",
   "groupWizard.title": "Créer un groupe",
   "groupWizard.useTemplate": "Utiliser un modèle",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} dépôts sélectionnés",
-  "heteroAgent.cloudRepo.noRepos": "Aucun dépôt configuré. Ajoutez-les dans les paramètres de l'agent.",
-  "heteroAgent.cloudRepo.notSet": "Aucun dépôt sélectionné",
-  "heteroAgent.cloudRepo.sectionTitle": "Dépôts",
   "heteroAgent.fullAccess.label": "Accès complet",
   "heteroAgent.fullAccess.tooltip": "Claude Code s’exécute localement avec un accès complet en lecture/écriture au répertoire de travail. Le changement de mode d’autorisation n’est pas encore disponible.",
   "heteroAgent.resumeReset.cwdChanged": "Répertoire de travail modifié. La session précédente de Claude Code ne peut être reprise qu’à partir de son répertoire d’origine ; une nouvelle conversation a donc commencé.",

locales/fr-FR/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "Suppression en lot",
   "blog": "Blog produit",
   "botIntegrationBanner.dismiss": "Ignorer",
-  "botIntegrationBanner.title": "Discutez avec Lobe AI dans vos applications de messagerie favorites",
+  "botIntegrationBanner.title": "Ajouter des canaux à LobeAI",
   "branching": "Créer un sous-sujet",
   "branchingDisable": "La fonctionnalité \"Sous-sujet\" n'est pas disponible dans le mode actuel. Pour l'utiliser, passez en mode base de données Postgres/PGlite ou utilisez LobeHub Cloud.",
   "branchingRequiresSavedTopic": "Le sujet actuel n'est pas enregistré, veuillez l'enregistrer d'abord pour utiliser la fonction de sous-sujet",

locales/fr-FR/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "Tout conserver",
   "modifier.reject": "Annuler",
   "modifier.rejectAll": "Tout annuler",
-  "skillFrontmatter.edit": "Modifier les métadonnées",
-  "skillFrontmatter.empty": "Aucune métadonnée",
-  "skillFrontmatter.invalid.descriptionInvalid": "La description doit être un texte sur une seule ligne.",
-  "skillFrontmatter.invalid.descriptionRequired": "La description est requise.",
-  "skillFrontmatter.invalid.mapping": "Les métadonnées doivent être un mappage YAML.",
-  "skillFrontmatter.invalid.nameInvalid": "Le nom doit utiliser des lettres minuscules, des chiffres et des tirets.",
-  "skillFrontmatter.invalid.nameLocked": "Le nom doit rester {{name}}. Renommez plutôt le bundle de compétences.",
-  "skillFrontmatter.invalid.nameRequired": "Le nom est requis.",
-  "skillFrontmatter.invalid.required": "Les métadonnées sont requises.",
-  "skillFrontmatter.invalid.syntax": "Syntaxe YAML invalide.",
-  "skillFrontmatter.saveFailed": "Les métadonnées n'ont pas été enregistrées. Réessayez ou continuez à modifier.",
-  "skillFrontmatter.title": "Métadonnées de compétence",
   "slash.compact": "Compacter le contexte",
   "slash.h1": "Titre 1",
   "slash.h2": "Titre 2",

locales/fr-FR/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "Un autre compte Telegram est déjà lié",
   "verify.confirm.title": "Confirmer la liaison",
   "verify.confirm.workspace": "Espace de travail : {{workspace}}",
-  "verify.error.alreadyConsumed": "Ce lien a déjà été utilisé pour connecter un compte. Connectez-vous à ce compte LobeHub pour gérer la connexion, ou retournez au bot et envoyez /start à nouveau pour générer un nouveau lien.",
-  "verify.error.alreadyConsumedTitle": "Ce lien est déjà utilisé",
   "verify.error.alreadyLinkedToOther": "Ce compte est déjà lié à un autre compte LobeHub. Connectez-vous d'abord à ce compte.",
   "verify.error.expired": "Ce lien a expiré. Veuillez retourner au bot et envoyer /start à nouveau.",
   "verify.error.generic": "Une erreur s'est produite. Veuillez réessayer.",

locales/fr-FR/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "Nouveau modèle de génération vidéo avec des améliorations complètes dans les mouvements corporels, le réalisme physique et le suivi des instructions.",
   "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": "Capacités de programmation multilingues puissantes avec une inférence plus rapide et plus efficace.",
   "MiniMax-M2.1-highspeed.description": "Des capacités de programmation multilingues puissantes, offrant une expérience de programmation entièrement améliorée. 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-highspeed.description": "MiniMax M2.5 Highspeed : Même performance que M2.5 avec une inférence plus rapide.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku est le modèle le plus rapide et le plus compact d’Anthropic, conçu pour des réponses quasi instantanées avec des performances rapides et précises.",
   "claude-3-opus-20240229.description": "Claude 3 Opus est le modèle le plus puissant d’Anthropic pour les tâches complexes, excellent en performance, intelligence, fluidité et compréhension.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet équilibre intelligence et rapidité pour les charges de travail en entreprise, offrant une grande utilité à moindre coût et un déploiement fiable à grande échelle.",
-  "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 des capacités de raisonnement étendues.",
+  "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 réflexion étendue.",
   "claude-haiku-4-5.description": "Claude Haiku 4.5 par Anthropic — modèle Haiku de nouvelle génération avec un raisonnement et une vision améliorés.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 est le modèle Haiku le plus rapide et le plus intelligent d’Anthropic, avec une vitesse fulgurante et un raisonnement étendu.",
   "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 et le plus performant modèle d'Anthropic pour les tâches hautement complexes, excelling en performance, intelligence, fluidité et compréhension.",
+  "claude-opus-4-1-20250805.description": "Claude Opus 4.1 est le dernier modèle d'Anthropic, le plus performant pour les tâches hautement complexes, excelle en performance, intelligence, fluidité et compréhension.",
   "claude-opus-4-1.description": "Claude Opus 4.1 par Anthropic — modèle de raisonnement premium avec des capacités d'analyse approfondie.",
-  "claude-opus-4-20250514.description": "Claude Opus 4 est le modèle le plus puissant d'Anthropic pour les tâches hautement complexes, excelling 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 les 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-5.description": "Claude Opus 4.5 par Anthropic — modèle phare avec un raisonnement et un codage de premier ordre.",
   "claude-opus-4-6.description": "Claude Opus 4.6 par Anthropic — modèle phare avec une fenêtre de contexte de 1M et un raisonnement avancé.",
@@ -334,7 +335,7 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 est le modèle le plus intelligent d’Anthropic pour la création d’agents et le codage.",
   "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 peut produire des réponses quasi instantanées ou un raisonnement détaillé é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 réflexion 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-5.description": "Claude Sonnet 4.5 par Anthropic — Sonnet amélioré avec des performances de codage accrues.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 par Anthropic — dernier modèle Sonnet avec un codage supérieur et une utilisation d'outils avancée.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) est un modèle innovant offrant une compréhension linguistique approfondie et une interaction fluide.",
   "deepseek-ai/deepseek-v3.1-terminus.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-chat.description": "Un nouveau modèle open-source combinant des capacités générales et de codage. Il conserve le dialogue général du modèle de chat et les solides compétences en codage du modèle de programmation, avec un meilleur alignement des préférences. DeepSeek-V2.5 améliore également l'écriture et le suivi des instructions.",
+  "deepseek-chat.description": "Alias de compatibilité pour le mode non-réflexif de DeepSeek V4 Flash. Prévu pour être abandonné — utilisez DeepSeek V4 Flash à la place.",
   "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.",
@@ -430,7 +431,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": "Alias de compatibilité pour le mode de réflexion rapide de DeepSeek V4. Prévu pour être obsolète — utilisez deepseek-v4-flash à la place.",
+  "deepseek-reasoner.description": "Alias de compatibilité pour le mode réflexif de DeepSeek V4 Flash. Prévu pour être abandonné — utilisez DeepSeek V4 Flash à la place.",
   "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.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 est un modèle de génération d’image de ByteDance Seed, prenant en charge les entrées texte et image avec une génération d’image de haute qualité et hautement contrôlable. Il génère des images à partir d’invites textuelles.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 est le dernier modèle d'image multimodal de ByteDance, intégrant des capacités de génération de texte en image, d'image en image et de génération d'images par lots, tout en incorporant des compétences en raisonnement et en bon sens. Par rapport à la version précédente 4.0, il offre une qualité de génération nettement améliorée, avec une meilleure cohérence d'édition et une fusion multi-images. Il permet un contrôle plus précis des détails visuels, produisant des textes et des visages plus petits de manière plus naturelle, et atteint une mise en page et des couleurs plus harmonieuses, améliorant l'esthétique globale.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite est le dernier modèle de génération d'images de ByteDance. Pour la première fois, il intègre des capacités de recherche en ligne, lui permettant d'incorporer des informations web en temps réel et d'améliorer la pertinence des images générées. L'intelligence du modèle a également été améliorée, permettant une interprétation précise des instructions complexes et du contenu visuel. De plus, il offre une meilleure couverture des connaissances globales, une cohérence des références et une qualité de génération dans des scénarios professionnels, répondant mieux aux besoins de création visuelle au niveau des entreprises.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 de ByteDance est le modèle de génération vidéo le plus puissant, prenant en charge la génération de vidéos de référence multimodales, le montage vidéo, l'extension vidéo, la conversion texte en vidéo et image en vidéo avec audio synchronisé.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast de ByteDance offre les mêmes capacités que Seedance 2.0 avec des vitesses de génération plus rapides à un prix plus compétitif.",
   "emohaa.description": "Emohaa est un modèle de santé mentale doté de compétences professionnelles en conseil pour aider les utilisateurs à comprendre leurs problèmes émotionnels.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B est un modèle léger open source conçu pour un déploiement local et personnalisé.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview est un modèle de prévisualisation avec contexte 8K pour l’évaluation d’ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 est un modèle de génération d'images de ByteDance Seed, prenant en charge les entrées textuelles et visuelles avec une génération d'images hautement contrôlable et de haute qualité. Il génère des images à partir de descriptions textuelles.",
+  "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. Inclut 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.",
@@ -527,8 +531,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 qui prend en charge les modifications sémantiques et d'apparence, édite précisément le texte en chinois et en anglais, et permet des modifications de haute qualité telles que le transfert de style et la rotation d'objets.",
-  "fal-ai/qwen-image.description": "Un modèle puissant de génération d'images de l'équipe Qwen avec un rendu impressionnant du texte en chinois et des styles visuels variés.",
+  "fal-ai/qwen-image-edit.description": "Un modèle d'édition d'images professionnel 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": "Modèle open source de génération d’images destiné à la R&D, optimisé efficacement pour la recherche d’innovation non commerciale.",
   "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.",
@@ -570,7 +574,7 @@
   "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) 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-3.1-pro.description": "Gemini 3.1 Pro par Google — modèle multimodal premium avec une fenêtre contextuelle de 1M.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "Nous sommes ravis de présenter Grok 4 Fast, notre dernière avancée en matière de modèles de raisonnement économiques.",
   "grok-4.20-0309-non-reasoning.description": "Une variante sans raisonnement pour des cas d'utilisation simples.",
   "grok-4.20-0309-reasoning.description": "Modèle intelligent et ultra-rapide qui raisonne avant de répondre.",
+  "grok-4.20-beta-0309-non-reasoning.description": "Une variante non-réflexive pour des cas d'utilisation simples.",
+  "grok-4.20-beta-0309-reasoning.description": "Modèle intelligent et ultra-rapide qui réfléchit avant de répondre.",
   "grok-4.20-multi-agent-0309.description": "Une équipe de 4 ou 16 agents, excelle dans les cas d'utilisation de recherche. Ne prend actuellement pas en charge les outils côté client. Prend uniquement en charge les outils côté serveur xAI (par exemple X Search, outils de recherche Web) et les outils MCP distants.",
   "grok-4.3.description": "Le modèle de langage de grande taille le plus axé sur la vérité au monde",
-  "grok-4.description": "Dernier modèle phare Grok avec des performances inégalées en langage, mathématiques et raisonnement — un véritable polyvalent. Actuellement pointé vers grok-4-0709 ; en raison de ressources limitées, son prix est temporairement 10 % plus élevé que le tarif officiel et devrait revenir au prix officiel ultérieurement.",
+  "grok-4.description": "Notre modèle phare le plus récent et le plus puissant, excelle en PNL, mathématiques et raisonnement — un tout-en-un idéal.",
   "grok-code-fast-1.description": "Nous sommes ravis de lancer grok-code-fast-1, un modèle de raisonnement rapide et économique, excellent pour le codage agentique.",
   "grok-imagine-image-pro.description": "Générez des images à partir de prompts textuels, modifiez des images existantes avec un langage naturel ou affinez les images de manière itérative via des conversations multi-tours.",
   "grok-imagine-image.description": "Générez des images à partir de prompts textuels, modifiez des images existantes avec un langage naturel ou affinez les images de manière itérative via des conversations multi-tours.",
@@ -1227,6 +1233,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 conversion texte en vidéo, image en vidéo (première image, première+dernière image) et la génération audio synchronisée avec les visuels.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite par 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.",

locales/fr-FR/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "Outils",
   "skillDetail.trustWarning": "N'utilisez que des connecteurs provenant de développeurs de confiance. LobeHub ne contrôle pas les outils mis à disposition par les développeurs et ne peut garantir leur bon fonctionnement ni qu'ils ne seront pas modifiés.",
   "skillInstallBanner.dismiss": "Ignorer",
-  "skillInstallBanner.title": "Connectez vos applications favorites à Lobe AI",
+  "skillInstallBanner.title": "Ajouter des compétences à Lobe AI",
   "store.actions.cancel": "Annuler",
   "store.actions.configure": "Configurer",
   "store.actions.confirmUninstall": "La désinstallation effacera la configuration de la compétence. Continuer ?",

locales/fr-FR/providers.json

@@ -33,6 +33,7 @@
   "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.",

locales/fr-FR/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "Méthode d’authentification",
   "heterogeneousStatus.auth.subscription": "Abonnement",
-  "heterogeneousStatus.cloud.githubDesc": "Sélectionnez une autorisation OAuth GitHub pour permettre au sandbox de cloner vos dépôts privés.",
-  "heterogeneousStatus.cloud.githubLabel": "Connexion GitHub",
-  "heterogeneousStatus.cloud.githubNoCreds": "Aucune autorisation GitHub trouvée.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "Sélectionnez une autorisation GitHub...",
-  "heterogeneousStatus.cloud.manageCredentials": "Gérer les autorisations →",
-  "heterogeneousStatus.cloud.repoAdd": "Ajouter",
-  "heterogeneousStatus.cloud.repoDesc": "Ajoutez des dépôts à la liste. Changez celui actif depuis la barre inférieure dans la vue de chat.",
-  "heterogeneousStatus.cloud.repoLabel": "Dépôts",
-  "heterogeneousStatus.cloud.repoPlaceholder": "propriétaire/dépôt ou https://github.com/propriétaire/dépôt",
-  "heterogeneousStatus.cloud.tabLabel": "Cloud",
-  "heterogeneousStatus.cloud.tokenCancel": "Annuler",
-  "heterogeneousStatus.cloud.tokenChange": "Modifier",
-  "heterogeneousStatus.cloud.tokenDesc": "Votre jeton OAuth Claude Code. Sauvegardé de manière sécurisée dans les autorisations une fois soumis. Exécutez `claude setup-token` dans votre terminal pour en générer un.",
-  "heterogeneousStatus.cloud.tokenLabel": "Jeton Claude Code",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "Collez votre jeton OAuth ici",
-  "heterogeneousStatus.cloud.tokenSave": "Sauvegarder",
   "heterogeneousStatus.command.edit": "Modifier la commande",
   "heterogeneousStatus.command.label": "Commande de lancement",
   "heterogeneousStatus.command.placeholder": "Nom de la commande ou chemin absolu",
-  "heterogeneousStatus.desktop.tabLabel": "Bureau",
   "heterogeneousStatus.detecting": "Détection du CLI {{name}}…",
   "heterogeneousStatus.plan.label": "Forfait",
   "heterogeneousStatus.redetect": "Relancer la détection",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "Profitez de la puissance de Linear directement dans votre assistant IA. Créez et mettez à jour des tickets, gérez les sprints, suivez l'avancement des projets et optimisez votre flux de développement — le tout via une conversation naturelle.",
   "tools.lobehubSkill.providers.microsoft.description": "Outlook Calendar est un outil de planification intégré à Microsoft Outlook qui permet aux utilisateurs de créer des rendez-vous, organiser des réunions et gérer efficacement leur temps et leurs événements.",
   "tools.lobehubSkill.providers.microsoft.readme": "Intégrez Outlook Calendar pour consulter, créer et gérer vos événements en toute fluidité. Planifiez des réunions, vérifiez les disponibilités, définissez des rappels et organisez votre emploi du temps via des commandes en langage naturel.",
-  "tools.lobehubSkill.providers.notion.description": "Notion est une application collaborative de productivité et de prise de notes.",
-  "tools.lobehubSkill.providers.notion.readme": "Connectez-vous à Notion pour accéder et gérer votre espace de travail. Créez des pages, recherchez du contenu, mettez à jour des bases de données et organisez votre base de connaissances—tout cela par une conversation naturelle avec votre assistant IA.",
   "tools.lobehubSkill.providers.twitter.description": "X (Twitter) est une plateforme de médias sociaux permettant de partager des mises à jour en temps réel, des actualités et d’interagir avec votre audience via des publications, des réponses et des messages directs.",
   "tools.lobehubSkill.providers.twitter.readme": "Connectez-vous à X (Twitter) pour publier des tweets, gérer votre fil d’actualité et interagir avec votre audience. Créez du contenu, planifiez des publications, surveillez les mentions et développez votre présence sur les réseaux sociaux via l’IA conversationnelle.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel est une plateforme cloud pour les développeurs front-end, offrant hébergement et fonctions serverless pour déployer facilement des applications web.",

locales/it-IT/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "Cerca modelli...",
   "groupWizard.title": "Crea Gruppo",
   "groupWizard.useTemplate": "Usa Modello",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} repository selezionati",
-  "heteroAgent.cloudRepo.noRepos": "Nessun repository configurato. Aggiungili nelle impostazioni dell'agente.",
-  "heteroAgent.cloudRepo.notSet": "Nessun repository selezionato",
-  "heteroAgent.cloudRepo.sectionTitle": "Repository",
   "heteroAgent.fullAccess.label": "Accesso completo",
   "heteroAgent.fullAccess.tooltip": "Claude Code viene eseguito localmente con accesso completo in lettura/scrittura alla directory di lavoro. Il cambio delle modalità di autorizzazione non è ancora disponibile.",
   "heteroAgent.resumeReset.cwdChanged": "La directory di lavoro è stata modificata. Una sessione precedente di Claude Code può essere ripristinata solo dalla directory originale, quindi è iniziata una nuova conversazione.",

locales/it-IT/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "Eliminazione multipla",
   "blog": "Blog del prodotto",
   "botIntegrationBanner.dismiss": "Chiudi",
-  "botIntegrationBanner.title": "Parla con Lobe AI nelle tue app di messaggistica preferite",
+  "botIntegrationBanner.title": "Aggiungi canali a LobeAI",
   "branching": "Crea sottotema",
   "branchingDisable": "La funzione \"Sottotema\" non è disponibile nella modalità attuale. Per utilizzarla, passa alla modalità DB Postgres/PGlite o usa LobeHub Cloud.",
   "branchingRequiresSavedTopic": "Il tema attuale non è salvato, salvalo prima per usare la funzione sottotema",

locales/it-IT/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "Mantieni tutto",
   "modifier.reject": "Ripristina",
   "modifier.rejectAll": "Ripristina tutto",
-  "skillFrontmatter.edit": "Modifica i metadati",
-  "skillFrontmatter.empty": "Nessun metadato",
-  "skillFrontmatter.invalid.descriptionInvalid": "La descrizione deve essere un testo su una sola riga.",
-  "skillFrontmatter.invalid.descriptionRequired": "La descrizione è obbligatoria.",
-  "skillFrontmatter.invalid.mapping": "I metadati devono essere una mappatura YAML.",
-  "skillFrontmatter.invalid.nameInvalid": "Il nome deve utilizzare lettere minuscole, numeri e trattini.",
-  "skillFrontmatter.invalid.nameLocked": "Il nome deve rimanere {{name}}. Rinomina invece il pacchetto di abilità.",
-  "skillFrontmatter.invalid.nameRequired": "Il nome è obbligatorio.",
-  "skillFrontmatter.invalid.required": "I metadati sono obbligatori.",
-  "skillFrontmatter.invalid.syntax": "Sintassi YAML non valida.",
-  "skillFrontmatter.saveFailed": "I metadati non sono stati salvati. Riprova o continua a modificare.",
-  "skillFrontmatter.title": "Metadati dell'abilità",
   "slash.compact": "Compatta il contesto",
   "slash.h1": "Titolo 1",
   "slash.h2": "Titolo 2",

locales/it-IT/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "Un altro account Telegram è già collegato",
   "verify.confirm.title": "Conferma collegamento",
   "verify.confirm.workspace": "Workspace: {{workspace}}",
-  "verify.error.alreadyConsumed": "Questo link è già stato utilizzato per collegare un account. Accedi a quell'account LobeHub per gestire la connessione, oppure torna al bot e invia /start di nuovo per generare un nuovo link.",
-  "verify.error.alreadyConsumedTitle": "Questo link è già stato utilizzato",
   "verify.error.alreadyLinkedToOther": "Questo account è già collegato a un altro account LobeHub. Accedi prima a quell'account.",
   "verify.error.expired": "Questo collegamento è scaduto. Torna al bot e invia nuovamente /start.",
   "verify.error.generic": "Qualcosa è andato storto. Riprova.",

locales/it-IT/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "Nuovo modello di generazione video con aggiornamenti completi nei movimenti del corpo, realismo fisico e aderenza alle istruzioni.",
   "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 con inferenza più veloce ed efficiente.",
   "MiniMax-M2.1-highspeed.description": "Potenti capacità di programmazione multilingue, esperienza di programmazione completamente aggiornata. 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-highspeed.description": "MiniMax M2.5 Highspeed: Stesse prestazioni di M2.5 con inferenza più veloce.",
@@ -319,7 +320,7 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku è il modello più veloce e compatto di Anthropic, progettato per risposte quasi istantanee con prestazioni rapide e accurate.",
   "claude-3-opus-20240229.description": "Claude 3 Opus è il modello più potente di Anthropic per compiti altamente complessi, eccellendo in prestazioni, intelligenza, fluidità e comprensione.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet bilancia intelligenza e velocità per carichi di lavoro aziendali, offrendo alta utilità a costi inferiori e distribuzione affidabile su larga scala.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5 è il modello Haiku più veloce e intelligente di Anthropic, con velocità fulminea e ragionamento esteso.",
+  "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 di Anthropic — Haiku di nuova generazione con ragionamento e visione migliorati.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5 è il modello Haiku più veloce e intelligente di Anthropic, con velocità fulminea e capacità di ragionamento estese.",
   "claude-opus-4-1-20250805-thinking.description": "Claude Opus 4.1 Thinking è una variante avanzata in grado di mostrare il proprio processo di ragionamento.",
@@ -334,7 +335,7 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6 è il modello più intelligente di Anthropic per la creazione di agenti e la programmazione.",
   "claude-opus-4.6.description": "Claude Opus 4.6 è il modello più intelligente di Anthropic per la creazione 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 può produrre risposte quasi istantanee o ragionamenti estesi passo dopo passo con un 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 dopo 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-5.description": "Claude Sonnet 4.5 di Anthropic — Sonnet migliorato con prestazioni di codifica avanzate.",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 di Anthropic — ultimo Sonnet con codifica superiore e utilizzo di strumenti.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B) è un modello innovativo che offre una profonda comprensione linguistica e interazione.",
   "deepseek-ai/deepseek-v3.1-terminus.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-chat.description": "Un nuovo modello open-source che combina capacità generali e di codifica. Preserva il dialogo generale del modello di chat e la forte capacità di codifica del modello coder, con un migliore allineamento delle preferenze. DeepSeek-V2.5 migliora anche la scrittura e il seguire le istruzioni.",
+  "deepseek-chat.description": "Alias di compatibilità per la modalità non pensante di DeepSeek V4 Flash. Programmato per la deprecazione — utilizzare invece DeepSeek V4 Flash.",
   "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.",
@@ -430,7 +431,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": "Alias di compatibilità per la modalità di pensiero Flash di DeepSeek V4. Programmato per la deprecazione — utilizzare deepseek-v4-flash al suo posto.",
+  "deepseek-reasoner.description": "Alias di compatibilità per la modalità pensante di DeepSeek V4 Flash. Programmato per la deprecazione — utilizzare invece DeepSeek V4 Flash.",
   "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.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 è un modello di generazione di immagini di ByteDance Seed, che supporta input di testo e immagini con generazione di immagini di alta qualità e altamente controllabile. Genera immagini da prompt testuali.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5 è l'ultimo modello multimodale di ByteDance, che integra capacità di generazione da testo a immagine, immagine a immagine e generazione di immagini in batch, incorporando anche conoscenze di senso comune e capacità di ragionamento. Rispetto alla versione precedente 4.0, offre una qualità di generazione significativamente migliorata, con una maggiore coerenza nell'editing e nella fusione di più immagini. Offre un controllo più preciso sui dettagli visivi, producendo testi e volti piccoli in modo più naturale, e raggiunge una disposizione e una colorazione più armoniose, migliorando l'estetica complessiva.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite è l'ultimo modello di generazione di immagini di ByteDance. Per la prima volta, integra capacità di recupero online, consentendo di incorporare informazioni web in tempo reale e migliorare la tempestività delle immagini generate. L'intelligenza del modello è stata inoltre aggiornata, consentendo un'interpretazione precisa di istruzioni complesse e contenuti visivi. Inoltre, offre una copertura globale della conoscenza migliorata, una maggiore coerenza di riferimento e una qualità di generazione superiore in scenari professionali, soddisfacendo meglio le esigenze di creazione visiva a livello aziendale.",
+  "dreamina-seedance-2-0-260128.description": "Seedance 2.0 di ByteDance è il modello di generazione video più potente, supportando la generazione di video multimodali di riferimento, editing video, estensione video, testo-a-video e immagine-a-video con audio sincronizzato.",
+  "dreamina-seedance-2-0-fast-260128.description": "Seedance 2.0 Fast di ByteDance offre le stesse capacità di Seedance 2.0 con velocità di generazione più rapide a un prezzo più competitivo.",
   "emohaa.description": "Emohaa è un modello per la salute mentale con capacità di consulenza professionale per aiutare gli utenti a comprendere le problematiche emotive.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B è un modello open-source leggero per implementazioni locali e personalizzate.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview è un modello di anteprima con finestra contestuale da 8K per la valutazione di ERNIE 4.5.",
@@ -519,7 +522,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.description": "Seedream 4.0 è un modello di generazione di immagini di ByteDance Seed, che supporta input di testo e immagini con una generazione di immagini altamente controllabile e di alta qualità. Genera immagini da prompt testuali.",
+  "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 una 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.",
@@ -527,8 +531,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, modifica con precisione testi in cinese e inglese, e consente modifiche di alta qualità come trasferimento di stile e rotazione di oggetti.",
-  "fal-ai/qwen-image.description": "Un potente modello di generazione di immagini del team Qwen con un'impressionante resa del testo in cinese e stili visivi diversificati.",
+  "fal-ai/qwen-image-edit.description": "Un modello professionale di editing 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": "Modello open-source per la ricerca e sviluppo nella generazione di immagini, ottimizzato in modo efficiente per la ricerca innovativa non commerciale.",
   "flux-kontext-max.description": "Generazione ed editing di immagini contestuali all’avanguardia, combinando testo e immagini per risultati precisi e coerenti.",
@@ -570,7 +574,7 @@
   "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) è il modello di generazione di immagini nativo più veloce di Google con supporto al pensiero, generazione conversazionale di immagini ed editing.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2) offre qualità d'immagine a livello Pro a velocità Flash con supporto per la 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-3.1-pro.description": "Gemini 3.1 Pro di Google — modello multimodale premium con finestra di contesto da 1M.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "Siamo entusiasti di presentare Grok 4 Fast, il nostro ultimo progresso nei modelli di ragionamento a basso costo.",
   "grok-4.20-0309-non-reasoning.description": "Una variante senza ragionamento per casi d'uso semplici.",
   "grok-4.20-0309-reasoning.description": "Modello intelligente e velocissimo che ragiona prima di rispondere.",
+  "grok-4.20-beta-0309-non-reasoning.description": "Una variante non pensante per casi d'uso semplici.",
+  "grok-4.20-beta-0309-reasoning.description": "Modello intelligente e ultra veloce che ragiona prima di rispondere.",
   "grok-4.20-multi-agent-0309.description": "Un team di 4 o 16 agenti, eccelle nei casi d'uso di ricerca, non supporta attualmente strumenti client-side. Supporta solo strumenti server-side xAI (es. X Search, strumenti di ricerca web) e strumenti MCP remoti.",
   "grok-4.3.description": "Il modello linguistico di grandi dimensioni più orientato alla verità al mondo",
-  "grok-4.description": "Ultimo modello di punta Grok con prestazioni ineguagliabili in linguaggio, matematica e ragionamento — un vero tuttofare. Attualmente punta a grok-4-0709; a causa di risorse limitate, il prezzo è temporaneamente superiore del 10% rispetto al prezzo ufficiale e si prevede un ritorno al prezzo ufficiale in seguito.",
+  "grok-4.description": "Il nostro modello di punta più nuovo e potente, eccellente in NLP, matematica e ragionamento — un tuttofare ideale.",
   "grok-code-fast-1.description": "Siamo entusiasti di lanciare grok-code-fast-1, un modello di ragionamento veloce ed economico che eccelle nella programmazione agentica.",
   "grok-imagine-image-pro.description": "Genera immagini da prompt testuali, modifica immagini esistenti con linguaggio naturale o affina iterativamente le immagini attraverso conversazioni multi-turno.",
   "grok-imagine-image.description": "Genera immagini da prompt testuali, modifica immagini esistenti con linguaggio naturale o affina iterativamente le immagini attraverso conversazioni multi-turno.",
@@ -1227,6 +1233,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 testo-a-video, immagine-a-video (primo fotogramma, primo+ultimo fotogramma) e generazione audio sincronizzata con i visual.",
+  "seedream-5-0-260128.description": "ByteDance-Seedream-5.0-lite di BytePlus offre 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.",

locales/it-IT/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "Strumenti",
   "skillDetail.trustWarning": "Utilizza solo connettori di sviluppatori di cui ti fidi. LobeHub non controlla quali strumenti vengano resi disponibili dagli sviluppatori e non può garantire che funzionino come previsto o che non vengano modificati.",
   "skillInstallBanner.dismiss": "Chiudi",
-  "skillInstallBanner.title": "Collega le tue app preferite a Lobe AI",
+  "skillInstallBanner.title": "Aggiungi abilità a Lobe AI",
   "store.actions.cancel": "Annulla",
   "store.actions.configure": "Configura",
   "store.actions.confirmUninstall": "La disinstallazione rimuoverà la configurazione della Skill. Continuare?",

locales/it-IT/providers.json

@@ -33,6 +33,7 @@
   "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 di intelligenza artificiale 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.",

locales/it-IT/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "Metodo di autenticazione",
   "heterogeneousStatus.auth.subscription": "Abbonamento",
-  "heterogeneousStatus.cloud.githubDesc": "Seleziona una credenziale OAuth di GitHub per consentire al sandbox di clonare i tuoi repository privati.",
-  "heterogeneousStatus.cloud.githubLabel": "Connessione GitHub",
-  "heterogeneousStatus.cloud.githubNoCreds": "Nessuna credenziale GitHub trovata.",
-  "heterogeneousStatus.cloud.githubPlaceholder": "Seleziona una credenziale GitHub...",
-  "heterogeneousStatus.cloud.manageCredentials": "Gestisci Credenziali →",
-  "heterogeneousStatus.cloud.repoAdd": "Aggiungi",
-  "heterogeneousStatus.cloud.repoDesc": "Aggiungi repository all'elenco. Cambia quello attivo dalla barra inferiore nella vista chat.",
-  "heterogeneousStatus.cloud.repoLabel": "Repository",
-  "heterogeneousStatus.cloud.repoPlaceholder": "proprietario/repo o https://github.com/proprietario/repo",
-  "heterogeneousStatus.cloud.tabLabel": "Cloud",
-  "heterogeneousStatus.cloud.tokenCancel": "Annulla",
-  "heterogeneousStatus.cloud.tokenChange": "Modifica",
-  "heterogeneousStatus.cloud.tokenDesc": "Il tuo token OAuth di Claude Code. Salvato in modo sicuro nelle Credenziali una volta inviato. Esegui `claude setup-token` nel tuo terminale per generarne uno.",
-  "heterogeneousStatus.cloud.tokenLabel": "Token Claude Code",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "Incolla qui il tuo token OAuth",
-  "heterogeneousStatus.cloud.tokenSave": "Salva",
   "heterogeneousStatus.command.edit": "Modifica comando",
   "heterogeneousStatus.command.label": "Comando di avvio",
   "heterogeneousStatus.command.placeholder": "Nome del comando o percorso assoluto",
-  "heterogeneousStatus.desktop.tabLabel": "Desktop",
   "heterogeneousStatus.detecting": "Rilevamento della CLI di {{name}}...",
   "heterogeneousStatus.plan.label": "Piano",
   "heterogeneousStatus.redetect": "Rileva di nuovo",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "Porta la potenza di Linear direttamente nel tuo assistente IA. Crea e aggiorna issue, gestisci sprint, monitora l'avanzamento dei progetti e ottimizza il flusso di lavoro di sviluppo—tutto tramite conversazioni naturali.",
   "tools.lobehubSkill.providers.microsoft.description": "Outlook Calendar è uno strumento di pianificazione integrato in Microsoft Outlook che consente agli utenti di creare appuntamenti, organizzare riunioni e gestire efficacemente il proprio tempo.",
   "tools.lobehubSkill.providers.microsoft.readme": "Integra con Outlook Calendar per visualizzare, creare e gestire eventi senza interruzioni. Pianifica riunioni, controlla disponibilità, imposta promemoria e coordina il tuo tempo—tutto tramite comandi in linguaggio naturale.",
-  "tools.lobehubSkill.providers.notion.description": "Notion è un'applicazione collaborativa per la produttività e la gestione delle note.",
-  "tools.lobehubSkill.providers.notion.readme": "Connettiti a Notion per accedere e gestire il tuo spazio di lavoro. Crea pagine, cerca contenuti, aggiorna database e organizza la tua base di conoscenza—tutto attraverso una conversazione naturale con il tuo assistente AI.",
   "tools.lobehubSkill.providers.twitter.description": "X (Twitter) è una piattaforma di social media per condividere aggiornamenti in tempo reale, notizie e interagire con il tuo pubblico tramite post, risposte e messaggi diretti.",
   "tools.lobehubSkill.providers.twitter.readme": "Connettiti a X (Twitter) per pubblicare tweet, gestire la tua timeline e interagire con il tuo pubblico. Crea contenuti, programma post, monitora menzioni e costruisci la tua presenza sui social media tramite IA conversazionale.",
   "tools.lobehubSkill.providers.vercel.description": "Vercel è una piattaforma cloud per sviluppatori frontend, che offre hosting e funzioni serverless per distribuire applicazioni web con facilità.",

locales/ja-JP/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "テンプレートを検索…",
   "groupWizard.title": "グループを作成",
   "groupWizard.useTemplate": "テンプレートを使用",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}} 個のリポジトリが選択されました",
-  "heteroAgent.cloudRepo.noRepos": "リポジトリが設定されていません。エージェント設定で追加してください。",
-  "heteroAgent.cloudRepo.notSet": "リポジトリが選択されていません",
-  "heteroAgent.cloudRepo.sectionTitle": "リポジトリ",
   "heteroAgent.fullAccess.label": "フルアクセス",
   "heteroAgent.fullAccess.tooltip": "Claude Code はローカルで動作し、作業ディレクトリへの読み書きが可能です。権限モードの切り替えはまだ利用できません。",
   "heteroAgent.resumeReset.cwdChanged": "作業ディレクトリが変更されました。以前の Claude Code セッションは元のディレクトリからのみ再開できるため、新しい会話が開始されました。",

locales/ja-JP/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "一括削除",
   "blog": "製品ブログ",
   "botIntegrationBanner.dismiss": "閉じる",
-  "botIntegrationBanner.title": "お気に入りのメッセージアプリで Lobe AI と会話",
+  "botIntegrationBanner.title": "LobeAI にチャネルを追加",
   "branching": "サブトピックを作成",
   "branchingDisable": "現在のモードでは「サブトピック」機能は利用できません。この機能を使用するには、Postgres/Pglite DB モードに切り替えるか、LobeHub Cloud をご利用ください",
   "branchingRequiresSavedTopic": "現在のトピックが保存されていません。保存後にサブトピック機能を使用できます",

locales/ja-JP/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "すべて承諾する",
   "modifier.reject": "取り消し",
   "modifier.rejectAll": "すべてを取り消す",
-  "skillFrontmatter.edit": "メタデータを編集",
-  "skillFrontmatter.empty": "メタデータがありません",
-  "skillFrontmatter.invalid.descriptionInvalid": "説明は1行のテキストである必要があります。",
-  "skillFrontmatter.invalid.descriptionRequired": "説明は必須です。",
-  "skillFrontmatter.invalid.mapping": "FrontmatterはYAMLマッピングである必要があります。",
-  "skillFrontmatter.invalid.nameInvalid": "名前は小文字の英字、数字、ハイフンを使用する必要があります。",
-  "skillFrontmatter.invalid.nameLocked": "名前は{{name}}のままである必要があります。代わりにスキルバンドルの名前を変更してください。",
-  "skillFrontmatter.invalid.nameRequired": "名前は必須です。",
-  "skillFrontmatter.invalid.required": "Frontmatterは必須です。",
-  "skillFrontmatter.invalid.syntax": "無効なYAML構文です。",
-  "skillFrontmatter.saveFailed": "メタデータが保存されませんでした。再試行するか、編集を続けてください。",
-  "skillFrontmatter.title": "スキルメタデータ",
   "slash.compact": "コンテキストを圧縮",
   "slash.h1": "見出し1",
   "slash.h2": "見出し2",

locales/ja-JP/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "別のTelegramアカウントがすでにリンクされています",
   "verify.confirm.title": "リンクを確認",
   "verify.confirm.workspace": "ワークスペース: {{workspace}}",
-  "verify.error.alreadyConsumed": "このリンクはすでにアカウントを接続するために使用されています。そのLobeHubアカウントにサインインして接続を管理するか、ボットに戻って「/start」を送信し、新しいリンクを発行してください。",
-  "verify.error.alreadyConsumedTitle": "このリンクはすでに使用されています",
   "verify.error.alreadyLinkedToOther": "このアカウントは別の LobeHub アカウントにすでにリンクされています。最初にそのアカウントにサインインしてください。",
   "verify.error.expired": "このリンクは期限切れです。ボットに戻り、/start を再度送信してください。",
   "verify.error.generic": "問題が発生しました。もう一度お試しください。",

locales/ja-JP/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "身体動作、物理的リアリズム、指示追従性において全面的にアップグレードされた新しいビデオ生成モデル。",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: M2.5と同等の性能で推論速度が向上。",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haikuは、Anthropicの最速かつ最小のモデルで、即時応答と高速かつ正確な性能を実現するよう設計されています。",
   "claude-3-opus-20240229.description": "Claude 3 Opusは、Anthropicの最も強力なモデルで、非常に複雑なタスクにおいて卓越した性能、知性、流暢さ、理解力を発揮します。",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnetは、知性と速度のバランスを取り、エンタープライズ向けのワークロードにおいて高い実用性とコスト効率、信頼性のある大規模展開を実現します。",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5は、Anthropicの最速かつ最も賢いHaikuモデルで、驚異的なスピードと高度な推論能力を備えています。",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5は、Anthropicの最速かつ最も知的なHaikuモデルで、驚異的な速度と高度な思考能力を備えています。",
   "claude-haiku-4-5.description": "Claude Haiku 4.5 by Anthropic — 次世代Haikuモデルで、推論能力とビジョンが強化されています。",
   "claude-haiku-4.5.description": "Claude Haiku 4.5は、Anthropicの最速かつ最も賢いHaikuモデルで、驚異的なスピードと高度な推論能力を備えています。",
   "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-1-20250805.description": "Claude Opus 4.1は、Anthropicの最新かつ最も高性能なモデルで、非常に複雑なタスクにおいて卓越したパフォーマンス、知性、流暢さ、理解力を発揮します。",
   "claude-opus-4-1.description": "Claude Opus 4.1 by Anthropic — 深い分析能力を備えたプレミアム推論モデル。",
-  "claude-opus-4-20250514.description": "Claude Opus 4は、Anthropicの最も強力なモデルで、非常に複雑なタスクにおいて卓越した性能、知性、流暢さ、理解力を発揮します。",
+  "claude-opus-4-20250514.description": "Claude Opus 4は、Anthropicの最も強力なモデルで、非常に複雑なタスクにおいて卓越したパフォーマンス、知性、流暢さ、理解力を発揮します。",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5は、Anthropicのフラッグシップモデルで、卓越した知性とスケーラブルな性能を兼ね備え、最高品質の応答と推論が求められる複雑なタスクに最適です。",
   "claude-opus-4-5.description": "Claude Opus 4.5 by Anthropic — 最高レベルの推論とコーディング能力を備えたフラッグシップモデル。",
   "claude-opus-4-6.description": "Claude Opus 4.6 by Anthropic — 1Mコンテキストウィンドウを備えたフラッグシップモデルで、高度な推論能力を提供します。",
@@ -334,8 +335,8 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6は、エージェント構築やコーディングにおいて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は、瞬時の応答や、プロセスを可視化した段階的な思考を提供することができます。",
-  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5は、これまでで最も知的なAnthropicモデルです。",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4は、Anthropicのこれまでで最も知的なモデルで、APIユーザー向けに即時応答や詳細なステップバイステップの思考を提供します。",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5は、Anthropicのこれまでで最も知的なモデルです。",
   "claude-sonnet-4-5.description": "Claude Sonnet 4.5 by Anthropic — コーディング性能が向上した改良版Sonnet。",
   "claude-sonnet-4-6.description": "Claude Sonnet 4.6 by Anthropic — 最新のSonnetモデルで、優れたコーディングとツール使用能力を備えています。",
   "claude-sonnet-4.5.description": "Claude Sonnet 4.5は、これまでで最も知的なAnthropicのモデルです。",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat（67B）は、深い言語理解と対話能力を提供する革新的なモデルです。",
   "deepseek-ai/deepseek-v3.1-terminus.description": "DeepSeek V3.1 は次世代の推論モデルで、複雑な推論と連想思考に優れ、深い分析タスクに対応します。",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2は次世代推論モデルで、複雑な推論と連鎖的思考能力が強化されています。",
-  "deepseek-chat.description": "一般的な対話能力とコーディング能力を組み合わせた新しいオープンソースモデルです。チャットモデルの一般的な対話能力と、コーダーモデルの強力なコーディング能力を維持しながら、より良い嗜好調整を実現しています。DeepSeek-V2.5は、文章作成や指示の追従能力も向上しています。",
+  "deepseek-chat.description": "DeepSeek V4 Flash非思考モードの互換性エイリアス。廃止予定—代わりにDeepSeek V4 Flashを使用してください。",
   "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 に匹敵する性能を発揮します。",
@@ -430,7 +431,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 V4 Flash思考モードの互換性エイリアスです。廃止予定のため、代わりにdeepseek-v4-flashを使用してください。",
+  "deepseek-reasoner.description": "DeepSeek V4 Flash思考モードの互換性エイリアス。廃止予定—代わりにDeepSeek V4 Flashを使用してください。",
   "deepseek-v2.description": "DeepSeek V2は、コスト効率の高い処理を実現する効率的なMoEモデルです。",
   "deepseek-v2:236b.description": "DeepSeek V2 236Bは、コード生成に特化したDeepSeekのモデルで、強力なコード生成能力を持ちます。",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324は、671BパラメータのMoEモデルで、プログラミングや技術的能力、文脈理解、長文処理において優れた性能を発揮します。",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0 は ByteDance Seed による画像生成モデルで、テキストと画像入力に対応し、高品質かつ制御性の高い画像生成を実現します。テキストプロンプトから画像を生成します。",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5はByteDanceの最新マルチモーダル画像モデルで、テキストから画像生成、画像間変換、バッチ画像生成機能を統合し、常識と推論能力を組み込んでいます。前バージョン4.0と比較して、生成品質が大幅に向上し、編集の一貫性や複数画像の融合が改善されています。視覚的な詳細の制御がより正確になり、小さなテキストや顔を自然に生成し、レイアウトや色彩の調和が向上し、全体的な美観が強化されています。",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-liteはByteDanceの最新画像生成モデルです。初めてオンライン検索機能を統合し、リアルタイムのウェブ情報を取り入れることで生成画像のタイムリー性を向上させています。モデルの知能もアップグレードされ、複雑な指示や視覚コンテンツを正確に解釈できるようになりました。また、専門的なシナリオでのグローバルな知識カバレッジ、一貫性、生成品質が向上し、企業レベルの視覚制作ニーズにより適合しています。",
+  "dreamina-seedance-2-0-260128.description": "ByteDanceのSeedance 2.0は、マルチモーダル参照ビデオ生成、ビデオ編集、ビデオ拡張、テキストからビデオ、画像からビデオへの同期音声付き生成をサポートする最も強力なビデオ生成モデルです。",
+  "dreamina-seedance-2-0-fast-260128.description": "ByteDanceのSeedance 2.0 Fastは、Seedance 2.0と同じ機能を提供しながら、より高速な生成速度と競争力のある価格を実現しています。",
   "emohaa.description": "Emohaa は、専門的なカウンセリング能力を備えたメンタルヘルスモデルで、ユーザーが感情的な問題を理解するのを支援します。",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B は、ローカルおよびカスタマイズ展開に適した軽量なオープンソースモデルです。",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview は、ERNIE 4.5 の評価用に設計された 8K コンテキストプレビューモデルです。",
@@ -519,7 +522,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.description": "Seedream 4.0は、ByteDance Seedによる画像生成モデルで、テキストと画像入力をサポートし、高度に制御可能で高品質な画像生成を実現します。テキストプロンプトから画像を生成します。",
+  "fal-ai/bytedance/seedream/v4.5.description": "ByteDance Seedチームが開発したSeedream 4.5は、マルチイメージ編集と構成をサポートします。被写体の一貫性向上、正確な指示の追従、空間的論理の理解、美的表現、ポスターレイアウト、ロゴデザイン、高精度なテキスト画像レンダリングを特徴としています。",
+  "fal-ai/bytedance/seedream/v4.description": "ByteDance Seedが開発したSeedream 4.0は、プロンプトからの高品質で制御可能な画像生成をサポートするテキストおよび画像入力対応モデルです。",
   "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] は、よりリアルで自然な画像を生成する美的バイアスを持つ画像生成モデルです。",
@@ -527,8 +531,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チームによる強力な画像生成モデルで、中国語のテキストレンダリングや多様なビジュアルスタイルに優れています。",
+  "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-kontext-max.description": "最先端のコンテキスト画像生成・編集モデルで、テキストと画像を組み合わせて精密かつ一貫性のある結果を生成します。",
@@ -567,10 +571,10 @@
   "gemini-3-flash-preview.description": "Gemini 3 Flash は、最先端の知能と優れた検索基盤を融合し、スピードに特化した最もスマートなモデルです。",
   "gemini-3-flash.description": "Gemini 3 Flash by Google — 超高速モデルでマルチモーダル入力をサポートします。",
   "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-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）は、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-3.1-pro.description": "Gemini 3.1 Pro by Google — 1Mコンテキストウィンドウを備えたプレミアムマルチモーダルモデル。",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "Grok 4 Fast をリリースしました。コスト効率の高い推論モデルにおける最新の進展です。",
   "grok-4.20-0309-non-reasoning.description": "単純なユースケース向けの非推論バリアント。",
   "grok-4.20-0309-reasoning.description": "応答前に推論する知的で超高速なモデル。",
+  "grok-4.20-beta-0309-non-reasoning.description": "シンプルなユースケース向けの非思考型バリアント",
+  "grok-4.20-beta-0309-reasoning.description": "応答前に推論を行う、知的で非常に高速なモデル",
   "grok-4.20-multi-agent-0309.description": "4または16のエージェントチーム。研究ユースケースに優れています。現在、クライアントサイドツールはサポートしていません。xAIサーバーサイドツール（例：X Search、Web Searchツール）およびリモートMCPツールのみをサポートします。",
   "grok-4.3.description": "世界で最も真実を追求する大規模言語モデル",
-  "grok-4.description": "最新のGrokフラッグシップモデルで、言語、数学、推論において比類のない性能を発揮する真のオールラウンダーです。現在はgrok-4-0709を指しており、リソースの制限により一時的に公式価格より10%高く設定されていますが、後に公式価格に戻る予定です。",
+  "grok-4.description": "NLP、数学、推論において卓越した性能を発揮する、最新かつ最強のフラッグシップモデル。万能型として理想的です。",
   "grok-code-fast-1.description": "grok-code-fast-1 をリリースできることを嬉しく思います。このモデルは、高速かつコスト効率に優れた推論モデルで、エージェント型コーディングにおいて卓越した性能を発揮します。",
   "grok-imagine-image-pro.description": "テキストプロンプトから画像を生成し、自然言語で既存の画像を編集したり、マルチターン会話を通じて画像を反復的に改良します。",
   "grok-imagine-image.description": "テキストプロンプトから画像を生成し、自然言語で既存の画像を編集したり、マルチターン会話を通じて画像を反復的に改良します。",
@@ -1227,6 +1233,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": "ByteDanceのSeedance 1.5 Proは、テキストからビデオ、画像からビデオ（最初のフレーム、最初+最後のフレーム）、および視覚と同期した音声生成をサポートします。",
+  "seedream-5-0-260128.description": "BytePlusのByteDance-Seedream-5.0-liteは、リアルタイム情報のためのウェブ検索強化生成、複雑なプロンプト解釈の向上、プロフェッショナルなビジュアル作成のための参照一貫性の向上を特徴としています。",
   "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月の正式リリースでは対応言語とコンテキスト長が拡張される予定です。",

locales/ja-JP/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "ツール",
   "skillDetail.trustWarning": "信頼できる開発者のコネクタのみを使用してください。LobeHub は、開発者が提供するツールを管理しておらず、それらが意図したとおりに動作することや、変更されないことを保証できません。",
   "skillInstallBanner.dismiss": "閉じる",
-  "skillInstallBanner.title": "お気に入りのアプリを Lobe AI に接続",
+  "skillInstallBanner.title": "Lobe AI にスキルを追加",
   "store.actions.cancel": "インストールをキャンセル",
   "store.actions.configure": "設定",
   "store.actions.confirmUninstall": "このスキルをアンインストールすると設定も削除されます。操作を確認してください",

locales/ja-JP/providers.json

@@ -33,6 +33,7 @@
   "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モデルへのアクセスを提供します。",

locales/ja-JP/setting.json

@@ -291,26 +291,9 @@
   "heterogeneousStatus.auth.api": "API",
   "heterogeneousStatus.auth.label": "認証方法",
   "heterogeneousStatus.auth.subscription": "サブスクリプション",
-  "heterogeneousStatus.cloud.githubDesc": "サンドボックスがプライベートリポジトリをクローンできるようにするため、GitHub OAuth資格情報を選択してください。",
-  "heterogeneousStatus.cloud.githubLabel": "GitHub接続",
-  "heterogeneousStatus.cloud.githubNoCreds": "GitHub資格情報が見つかりません。",
-  "heterogeneousStatus.cloud.githubPlaceholder": "GitHub資格情報を選択...",
-  "heterogeneousStatus.cloud.manageCredentials": "資格情報を管理 →",
-  "heterogeneousStatus.cloud.repoAdd": "追加",
-  "heterogeneousStatus.cloud.repoDesc": "リポジトリをリストに追加します。チャットビューの下部バーからアクティブなリポジトリを切り替えられます。",
-  "heterogeneousStatus.cloud.repoLabel": "リポジトリ",
-  "heterogeneousStatus.cloud.repoPlaceholder": "owner/repo または https://github.com/owner/repo",
-  "heterogeneousStatus.cloud.tabLabel": "クラウド",
-  "heterogeneousStatus.cloud.tokenCancel": "キャンセル",
-  "heterogeneousStatus.cloud.tokenChange": "変更",
-  "heterogeneousStatus.cloud.tokenDesc": "Claude Code OAuthトークンです。送信後、資格情報に安全に保存されます。ターミナルで`claude setup-token`を実行して生成してください。",
-  "heterogeneousStatus.cloud.tokenLabel": "Claude Codeトークン",
-  "heterogeneousStatus.cloud.tokenPlaceholder": "ここにOAuthトークンを貼り付けてください",
-  "heterogeneousStatus.cloud.tokenSave": "保存",
   "heterogeneousStatus.command.edit": "コマンドを編集",
   "heterogeneousStatus.command.label": "起動コマンド",
   "heterogeneousStatus.command.placeholder": "コマンド名または絶対パス",
-  "heterogeneousStatus.desktop.tabLabel": "デスクトップ",
   "heterogeneousStatus.detecting": "{{name}} CLI を検出しています…",
   "heterogeneousStatus.plan.label": "プラン",
   "heterogeneousStatus.redetect": "再検出",
@@ -1062,8 +1045,6 @@
   "tools.lobehubSkill.providers.linear.readme": "Linearの機能をAIアシスタントに統合します。イシューの作成・更新、スプリントの管理、プロジェクト進捗の追跡、自然な会話による開発ワークフローの最適化が可能です。",
   "tools.lobehubSkill.providers.microsoft.description": "Outlook カレンダーは、Microsoft Outlookに統合されたスケジューリングツールで、予定の作成、他者との会議の調整、時間とイベントの効果的な管理が可能です。",
   "tools.lobehubSkill.providers.microsoft.readme": "Outlookカレンダーと連携してイベントの表示、作成、管理をシームレスに行います。会議のスケジューリング、空き時間の確認、リマインダーの設定、自然言語による時間調整が可能です。",
-  "tools.lobehubSkill.providers.notion.description": "Notionは、共同作業型の生産性向上およびメモ作成アプリケーションです。",
-  "tools.lobehubSkill.providers.notion.readme": "Notionに接続してワークスペースにアクセスし、管理します。ページの作成、コンテンツの検索、データベースの更新、ナレッジベースの整理を、AIアシスタントとの自然な会話を通じて行えます。",
   "tools.lobehubSkill.providers.twitter.description": "X（旧Twitter）は、リアルタイムの更新、ニュースの共有、投稿・返信・DMを通じてオーディエンスと交流できるソーシャルメディアプラットフォームです。",
   "tools.lobehubSkill.providers.twitter.readme": "X（旧Twitter）と接続してツイートの投稿、タイムラインの管理、オーディエンスとの交流を行います。コンテンツの作成、投稿のスケジューリング、メンションの監視、会話型AIによるSNS運用が可能です。",
   "tools.lobehubSkill.providers.vercel.description": "Vercel はフロントエンド開発者向けのクラウドプラットフォームで、Web アプリケーションを簡単にデプロイできるホスティングやサーバーレス機能を提供します。",

locales/ko-KR/chat.json

@@ -184,10 +184,6 @@
   "groupWizard.searchTemplates": "템플릿 검색…",
   "groupWizard.title": "그룹 만들기",
   "groupWizard.useTemplate": "템플릿 사용",
-  "heteroAgent.cloudRepo.multiSelected": "{{count}}개의 저장소가 선택되었습니다",
-  "heteroAgent.cloudRepo.noRepos": "구성된 저장소가 없습니다. 에이전트 설정에서 추가하세요.",
-  "heteroAgent.cloudRepo.notSet": "선택된 저장소가 없습니다",
-  "heteroAgent.cloudRepo.sectionTitle": "저장소",
   "heteroAgent.fullAccess.label": "전체 권한",
   "heteroAgent.fullAccess.tooltip": "Claude Code는 작업 디렉터리에 대한 전체 읽기/쓰기 권한으로 로컬에서 실행됩니다. 권한 모드 전환은 아직 지원되지 않습니다.",
   "heteroAgent.resumeReset.cwdChanged": "작업 디렉터리가 변경되었습니다. 이전 Claude Code 세션은 원래 디렉터리에서만 재개할 수 있으므로 새 대화가 시작되었습니다.",

locales/ko-KR/common.json

@@ -29,7 +29,7 @@
   "batchDelete": "일괄 삭제",
   "blog": "제품 블로그",
   "botIntegrationBanner.dismiss": "닫기",
-  "botIntegrationBanner.title": "즐겨 쓰는 메신저 앱에서 Lobe AI와 대화하세요",
+  "botIntegrationBanner.title": "LobeAI에 채널 추가",
   "branching": "하위 주제 생성",
   "branchingDisable": "현재 모드에서는 '하위 주제' 기능을 사용할 수 없습니다. 이 기능을 사용하려면 Postgres/Pglite DB 모드로 전환하거나 LobeHub Cloud를 이용해 주세요",
   "branchingRequiresSavedTopic": "현재 주제가 저장되지 않았습니다. 저장 후 하위 주제 기능을 사용할 수 있습니다",

locales/ko-KR/editor.json

@@ -40,18 +40,6 @@
   "modifier.acceptAll": "모두 수락",
   "modifier.reject": "취소",
   "modifier.rejectAll": "모두 취소",
-  "skillFrontmatter.edit": "메타데이터 편집",
-  "skillFrontmatter.empty": "메타데이터 없음",
-  "skillFrontmatter.invalid.descriptionInvalid": "설명은 단일 행 텍스트여야 합니다.",
-  "skillFrontmatter.invalid.descriptionRequired": "설명이 필요합니다.",
-  "skillFrontmatter.invalid.mapping": "Frontmatter는 YAML 매핑이어야 합니다.",
-  "skillFrontmatter.invalid.nameInvalid": "이름은 소문자, 숫자, 하이픈만 사용할 수 있습니다.",
-  "skillFrontmatter.invalid.nameLocked": "이름은 {{name}}로 유지해야 합니다. 대신 스킬 번들을 이름 변경하세요.",
-  "skillFrontmatter.invalid.nameRequired": "이름이 필요합니다.",
-  "skillFrontmatter.invalid.required": "Frontmatter가 필요합니다.",
-  "skillFrontmatter.invalid.syntax": "잘못된 YAML 구문입니다.",
-  "skillFrontmatter.saveFailed": "메타데이터가 저장되지 않았습니다. 다시 시도하거나 계속 편집하세요.",
-  "skillFrontmatter.title": "스킬 메타데이터",
   "slash.compact": "컨텍스트 압축",
   "slash.h1": "제목 1",
   "slash.h2": "제목 2",

locales/ko-KR/messenger.json

@@ -89,8 +89,6 @@
   "verify.confirm.relink.title": "다른 Telegram 계정이 이미 연결되어 있습니다",
   "verify.confirm.title": "연결 확인",
   "verify.confirm.workspace": "워크스페이스: {{workspace}}",
-  "verify.error.alreadyConsumed": "이 링크는 이미 계정을 연결하는 데 사용되었습니다. 해당 LobeHub 계정에 로그인하여 연결을 관리하거나, 봇으로 돌아가 /start를 다시 보내 새 링크를 발급받으세요.",
-  "verify.error.alreadyConsumedTitle": "이 링크는 이미 사용되었습니다",
   "verify.error.alreadyLinkedToOther": "이 계정은 이미 다른 LobeHub 계정에 연결되어 있습니다. 먼저 해당 계정에 로그인하세요.",
   "verify.error.expired": "이 링크가 만료되었습니다. 봇으로 돌아가 /start를 다시 전송하세요.",
   "verify.error.generic": "문제가 발생했습니다. 다시 시도하세요.",

locales/ko-KR/models.json

@@ -106,6 +106,7 @@
   "MiniMax-Hailuo-2.3.description": "신규 비디오 생성 모델로 신체 움직임, 물리적 사실성, 지침 준수에서 전반적인 업그레이드 제공.",
   "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-highspeed.description": "MiniMax M2.5 Highspeed: M2.5와 동일한 성능을 제공하며 추론 속도가 더 빠릅니다.",
@@ -319,13 +320,13 @@
   "claude-3-haiku-20240307.description": "Claude 3 Haiku는 Anthropic의 가장 빠르고 컴팩트한 모델로, 빠르고 정확한 성능으로 즉각적인 응답을 위해 설계되었습니다.",
   "claude-3-opus-20240229.description": "Claude 3 Opus는 Anthropic의 가장 강력한 모델로, 고난도 작업에서 뛰어난 성능, 지능, 유창성, 이해력을 자랑합니다.",
   "claude-3-sonnet-20240229.description": "Claude 3 Sonnet은 엔터프라이즈 워크로드를 위한 지능과 속도의 균형을 제공하며, 낮은 비용으로 높은 효용성과 안정적인 대규모 배포를 지원합니다.",
-  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5는 Anthropic의 가장 빠르고 똑똑한 Haiku 모델로, 번개 같은 속도와 확장된 추론 능력을 자랑합니다.",
+  "claude-haiku-4-5-20251001.description": "Claude Haiku 4.5는 Anthropic의 가장 빠르고 지능적인 Haiku 모델로, 번개 같은 속도와 확장된 사고력을 제공합니다.",
   "claude-haiku-4-5.description": "Anthropic의 Claude Haiku 4.5 — 향상된 추론 및 비전을 갖춘 차세대 Haiku.",
   "claude-haiku-4.5.description": "Claude Haiku 4.5는 Anthropic의 가장 빠르고 똑똑한 Haiku 모델로, 번개 같은 속도와 확장된 추론 능력을 자랑합니다.",
   "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-1-20250805.description": "Claude Opus 4.1은 Anthropic의 최신 모델로, 매우 복잡한 작업에서 뛰어난 성능, 지능, 유창함, 이해력을 자랑합니다.",
   "claude-opus-4-1.description": "Anthropic의 Claude Opus 4.1 — 심층 분석 기능을 갖춘 프리미엄 추론 모델.",
-  "claude-opus-4-20250514.description": "Claude Opus 4는 Anthropic의 가장 강력한 모델로, 매우 복잡한 작업에서 뛰어난 성능, 지능, 유창성, 이해력을 자랑합니다.",
+  "claude-opus-4-20250514.description": "Claude Opus 4는 Anthropic의 가장 강력한 모델로, 매우 복잡한 작업에서 뛰어난 성능, 지능, 유창함, 이해력을 자랑합니다.",
   "claude-opus-4-5-20251101.description": "Claude Opus 4.5는 Anthropic의 플래그십 모델로, 탁월한 지능과 확장 가능한 성능을 결합하여 최고 품질의 응답과 추론이 필요한 복잡한 작업에 이상적입니다.",
   "claude-opus-4-5.description": "Anthropic의 Claude Opus 4.5 — 최고 수준의 추론 및 코딩을 갖춘 플래그십 모델.",
   "claude-opus-4-6.description": "Anthropic의 Claude Opus 4.6 — 고급 추론을 갖춘 1M 컨텍스트 윈도우 플래그십.",
@@ -334,8 +335,8 @@
   "claude-opus-4.6-fast.description": "Claude Opus 4.6은 에이전트 구축과 코딩을 위한 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는 거의 즉각적인 응답을 생성하거나 가시적인 과정을 통해 단계별 사고를 확장할 수 있습니다.",
-  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5는 현재까지 Anthropic의 가장 지능적인 모델입니다.",
+  "claude-sonnet-4-20250514.description": "Claude Sonnet 4는 Anthropic의 가장 지능적인 모델로, API 사용자에게 세밀한 제어를 통해 즉각적인 응답 또는 단계별 사고를 제공합니다.",
+  "claude-sonnet-4-5-20250929.description": "Claude Sonnet 4.5는 Anthropic의 가장 지능적인 모델입니다.",
   "claude-sonnet-4-5.description": "Anthropic의 Claude Sonnet 4.5 — 향상된 코딩 성능을 갖춘 개선된 Sonnet.",
   "claude-sonnet-4-6.description": "Anthropic의 Claude Sonnet 4.6 — 우수한 코딩 및 도구 사용을 갖춘 최신 Sonnet.",
   "claude-sonnet-4.5.description": "Claude Sonnet 4.5는 지금까지의 Anthropic 모델 중 가장 지능적인 모델입니다.",
@@ -408,7 +409,7 @@
   "deepseek-ai/deepseek-llm-67b-chat.description": "DeepSeek LLM Chat (67B)은 심층 언어 이해와 상호작용을 제공하는 혁신적인 모델입니다.",
   "deepseek-ai/deepseek-v3.1-terminus.description": "DeepSeek V3.1은 복잡한 추론과 연쇄적 사고(chain-of-thought)에 강한 차세대 추론 모델로, 심층 분석 작업에 적합합니다.",
   "deepseek-ai/deepseek-v3.2.description": "DeepSeek V3.2는 복잡한 추론과 연쇄 사고 능력이 강화된 차세대 추론 모델입니다.",
-  "deepseek-chat.description": "일반 대화 능력과 코딩 능력을 결합한 새로운 오픈소스 모델입니다. 이 모델은 대화 모델의 일반적인 대화 능력과 코더 모델의 강력한 코딩 능력을 유지하며, 더 나은 선호도 정렬을 제공합니다. DeepSeek-V2.5는 또한 글쓰기와 지시 따르기 능력을 향상시켰습니다.",
+  "deepseek-chat.description": "DeepSeek V4 Flash 비사고 모드의 호환성 별칭입니다. 사용 중단 예정 — DeepSeek V4 Flash를 대신 사용하세요.",
   "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 코드 모델입니다.",
@@ -430,7 +431,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 V4 Flash 사고 모드의 호환성 별칭입니다. 사용 중단 예정 — 대신 deepseek-v4-flash를 사용하세요.",
+  "deepseek-reasoner.description": "DeepSeek V4 Flash 사고 모드의 호환성 별칭입니다. 사용 중단 예정 — DeepSeek V4 Flash를 대신 사용하세요.",
   "deepseek-v2.description": "DeepSeek V2는 비용 효율적인 처리를 위한 고효율 MoE 모델입니다.",
   "deepseek-v2:236b.description": "DeepSeek V2 236B는 코드 생성에 강점을 가진 DeepSeek의 코드 특화 모델입니다.",
   "deepseek-v3-0324.description": "DeepSeek-V3-0324는 671B 파라미터의 MoE 모델로, 프로그래밍 및 기술 역량, 문맥 이해, 장문 처리에서 뛰어난 성능을 보입니다.",
@@ -495,6 +496,8 @@
   "doubao-seedream-4-0-250828.description": "Seedream 4.0은 ByteDance Seed의 이미지 생성 모델로, 텍스트 및 이미지 입력을 지원하며, 고품질의 이미지 생성과 높은 제어력을 제공합니다. 텍스트 프롬프트로부터 이미지를 생성합니다.",
   "doubao-seedream-4-5-251128.description": "Seedream 4.5는 ByteDance의 최신 멀티모달 이미지 모델로, 텍스트-이미지, 이미지-이미지, 배치 이미지 생성 기능을 통합하며 상식과 추론 능력을 포함합니다. 이전 4.0 버전에 비해 생성 품질이 크게 향상되었으며, 편집 일관성과 다중 이미지 융합이 개선되었습니다. 시각적 세부 사항에 대한 더 정밀한 제어를 제공하며, 작은 텍스트와 작은 얼굴을 더 자연스럽게 생성하고 레이아웃과 색상이 더 조화롭게 되어 전체적인 미학을 향상시킵니다.",
   "doubao-seedream-5-0-260128.description": "Doubao-Seedream-5.0-lite는 ByteDance의 최신 이미지 생성 모델로, 처음으로 온라인 검색 기능을 통합하여 실시간 웹 정보를 포함하고 생성된 이미지의 시의성을 향상시킵니다. 모델의 지능도 업그레이드되어 복잡한 지시와 시각적 콘텐츠를 정확히 해석할 수 있습니다. 또한 전문적인 시나리오에서 글로벌 지식 범위, 참조 일관성, 생성 품질이 개선되어 기업 수준의 시각적 창작 요구를 더 잘 충족시킵니다.",
+  "dreamina-seedance-2-0-260128.description": "ByteDance의 Seedance 2.0은 가장 강력한 비디오 생성 모델로, 다중 모달 참조 비디오 생성, 비디오 편집, 비디오 확장, 텍스트-비디오 및 이미지-비디오를 동기화된 오디오와 함께 지원합니다.",
+  "dreamina-seedance-2-0-fast-260128.description": "ByteDance의 Seedance 2.0 Fast는 Seedance 2.0과 동일한 기능을 제공하며, 더 빠른 생성 속도와 경쟁력 있는 가격을 자랑합니다.",
   "emohaa.description": "Emohaa는 전문 상담 능력을 갖춘 정신 건강 모델로, 사용자가 감정 문제를 이해하도록 돕습니다.",
   "ernie-4.5-0.3b.description": "ERNIE 4.5 0.3B는 로컬 및 맞춤형 배포를 위한 오픈소스 경량 모델입니다.",
   "ernie-4.5-8k-preview.description": "ERNIE 4.5 8K Preview는 ERNIE 4.5의 8K 컨텍스트 프리뷰 모델로, 평가용으로 사용됩니다.",
@@ -519,7 +522,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.description": "Seedream 4.0은 ByteDance Seed의 이미지 생성 모델로, 텍스트와 이미지 입력을 지원하며 매우 제어 가능하고 고품질의 이미지를 생성합니다. 텍스트 프롬프트로 이미지를 생성합니다.",
+  "fal-ai/bytedance/seedream/v4.5.description": "ByteDance Seed 팀이 개발한 Seedream 4.5는 다중 이미지 편집 및 합성을 지원합니다. 향상된 주제 일관성, 정확한 지침 준수, 공간 논리 이해, 미적 표현, 포스터 레이아웃 및 로고 디자인과 고정밀 텍스트-이미지 렌더링 기능을 제공합니다.",
+  "fal-ai/bytedance/seedream/v4.description": "ByteDance Seed가 개발한 Seedream 4.0은 텍스트 및 이미지 입력을 지원하며, 프롬프트를 통해 고품질 이미지를 매우 제어 가능하게 생성합니다.",
   "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]는 보다 사실적이고 자연스러운 이미지 스타일에 중점을 둔 이미지 생성 모델입니다.",
@@ -527,8 +531,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 팀의 강력한 이미지 생성 모델로, 인상적인 중국어 텍스트 렌더링과 다양한 시각적 스타일을 제공합니다.",
+  "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": "비상업적 혁신 연구를 위해 효율적으로 최적화된 오픈소스 R&D 이미지 생성 모델입니다.",
   "flux-kontext-max.description": "최첨단 문맥 기반 이미지 생성 및 편집 모델로, 텍스트와 이미지를 결합하여 정밀하고 일관된 결과를 생성합니다.",
@@ -567,10 +571,10 @@
   "gemini-3-flash-preview.description": "Gemini 3 Flash는 속도를 위해 설계된 가장 스마트한 모델로, 최첨단 지능과 뛰어난 검색 기반을 결합합니다.",
   "gemini-3-flash.description": "Google의 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-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)는 Google의 가장 빠른 네이티브 이미지 생성 모델로, 사고 지원, 대화형 이미지 생성 및 편집을 제공합니다.",
+  "gemini-3.1-flash-image-preview:image.description": "Gemini 3.1 Flash Image (Nano Banana 2)는 Flash 속도로 Pro 수준의 이미지 품질을 제공하며, 다중 모달 채팅을 지원합니다.",
   "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-3.1-pro.description": "Google의 Gemini 3.1 Pro — 1M 컨텍스트 윈도우를 갖춘 프리미엄 멀티모달 모델.",
@@ -736,9 +740,11 @@
   "grok-4-fast-reasoning.description": "Grok 4 Fast는 비용 효율적인 추론 모델 분야에서의 최신 성과로, 출시를 기쁘게 생각합니다.",
   "grok-4.20-0309-non-reasoning.description": "간단한 사용 사례를 위한 비추론 변형",
   "grok-4.20-0309-reasoning.description": "응답 전에 추론하는 지능적이고 매우 빠른 모델",
+  "grok-4.20-beta-0309-non-reasoning.description": "간단한 사용 사례를 위한 비사고 변형 모델입니다.",
+  "grok-4.20-beta-0309-reasoning.description": "응답 전에 사고하는 지능적이고 매우 빠른 모델입니다.",
   "grok-4.20-multi-agent-0309.description": "4명 또는 16명의 에이전트 팀, 연구 사용 사례에서 뛰어남, 현재 클라이언트 측 도구를 지원하지 않음. xAI 서버 측 도구(예: X Search, Web Search 도구) 및 원격 MCP 도구만 지원.",
   "grok-4.3.description": "세계에서 가장 진실을 추구하는 대규모 언어 모델",
-  "grok-4.description": "언어, 수학, 추론에서 타의 추종을 불허하는 성능을 자랑하는 최신 Grok 플래그십 모델 — 진정한 만능 모델입니다. 현재 grok-4-0709를 가리키며, 제한된 자원으로 인해 공식 가격보다 임시로 10% 높게 책정되었으며, 이후 공식 가격으로 복귀할 예정입니다.",
+  "grok-4.description": "최신 및 가장 강력한 플래그십 모델로, NLP, 수학 및 사고에서 뛰어난 성능을 발휘하며 이상적인 다재다능 모델입니다.",
   "grok-code-fast-1.description": "에이전트 기반 코딩에 특화된 빠르고 비용 효율적인 추론 모델 grok-code-fast-1을 출시하게 되어 기쁩니다.",
   "grok-imagine-image-pro.description": "텍스트 프롬프트에서 이미지를 생성하거나 자연어로 기존 이미지를 편집하거나 다중 턴 대화를 통해 이미지를 반복적으로 개선합니다.",
   "grok-imagine-image.description": "텍스트 프롬프트에서 이미지를 생성하거나 자연어로 기존 이미지를 편집하거나 다중 턴 대화를 통해 이미지를 반복적으로 개선합니다.",
@@ -1227,6 +1233,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": "ByteDance의 Seedance 1.5 Pro는 텍스트-비디오, 이미지-비디오(첫 프레임, 첫+마지막 프레임) 및 시각과 동기화된 오디오 생성을 지원합니다.",
+  "seedream-5-0-260128.description": "BytePlus의 ByteDance-Seedream-5.0-lite는 실시간 정보를 위한 웹 검색 증강 생성, 복잡한 프롬프트 해석 향상, 전문적인 시각적 창작을 위한 참조 일관성 개선을 제공합니다.",
   "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월 전체 릴리스 시 더 많은 언어와 긴 컨텍스트를 지원할 예정입니다.",

locales/ko-KR/plugin.json

@@ -681,7 +681,7 @@
   "skillDetail.tools": "도구",
   "skillDetail.trustWarning": "신뢰할 수 있는 개발자의 커넥터만 사용하세요. LobeHub은 개발자가 제공하는 도구를 통제하지 않으며, 해당 도구가 의도한 대로 작동하거나 변경되지 않을 것이라는 보장을 할 수 없습니다.",
   "skillInstallBanner.dismiss": "닫기",
-  "skillInstallBanner.title": "즐겨 쓰는 앱을 Lobe AI에 연결하세요",
+  "skillInstallBanner.title": "Lobe AI에 스킬 추가",
   "store.actions.cancel": "설치 취소",
   "store.actions.configure": "구성",
   "store.actions.confirmUninstall": "이 기능을 제거하려고 합니다. 제거 시 설정 정보도 함께 삭제됩니다. 계속하시겠습니까?",

locales/ko-KR/providers.json

@@ -33,6 +33,7 @@
   "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 모델에 접근하여 코딩 작업을 수행할 수 있습니다.",