@geminilight/mindos 0.6.56 → 0.6.57

package/app/hooks/useEditorImageUpload.ts

@@ -0,0 +1,113 @@
+/**
+ * Hook for uploading images to the .media/ directory in the editor.
+ *
+ * Unlike useImageUpload (for chat image attachments), this hook uploads
+ * images to the knowledge base's .media/ directory and returns file paths
+ * suitable for use in markdown `![alt](path)` syntax.
+ *
+ * Usage:
+ *   const { uploadToMedia, isUploading } = useEditorImageUpload();
+ *   const paths = await uploadToMedia([file1, file2]);
+ *   // paths = ['/.media/2026-04-07_abc123.png', ...]
+ */
+
+import { useState, useCallback } from 'react';
+
+const MAX_IMAGE_SIZE = 10 * 1024 * 1024; // 10 MB per image
+const ALLOWED_IMAGE_TYPES = new Set([
+  'image/png',
+  'image/jpeg',
+  'image/gif',
+  'image/webp',
+  'image/svg+xml',
+  'image/bmp',
+  'image/x-icon',
+  'image/vnd.microsoft.icon',
+]);
+
+/**
+ * Generates a unique filename: YYYY-MM-DD_randomhash.ext
+ */
+function generateImageFileName(originalName: string): string {
+  const ext = originalName.split('.').pop()?.toLowerCase() || 'png';
+  const timestamp = new Date().toISOString().split('T')[0];
+  const randomHash = Math.random().toString(36).slice(2, 10);
+  return `${timestamp}_${randomHash}.${ext}`;
+}
+
+/** Converts a File to base64 string (without data URL prefix). */
+async function fileToBase64(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result as string;
+      resolve(result.split(',')[1]); // Strip "data:image/...;base64," prefix
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+
+export function useEditorImageUpload() {
+  const [isUploading, setIsUploading] = useState(false);
+
+  const uploadToMedia = useCallback(async (files: File[]): Promise<string[]> => {
+    setIsUploading(true);
+
+    try {
+      // Filter valid images
+      const validFiles: Array<{ base64: string; newName: string }> = [];
+      const skippedReasons: string[] = [];
+
+      for (const file of files) {
+        if (!ALLOWED_IMAGE_TYPES.has(file.type)) {
+          skippedReasons.push(`${file.name}: unsupported format`);
+          continue;
+        }
+        if (file.size > MAX_IMAGE_SIZE) {
+          skippedReasons.push(`${file.name}: exceeds 10MB limit`);
+          continue;
+        }
+
+        const base64 = await fileToBase64(file);
+        const newName = generateImageFileName(file.name);
+        validFiles.push({ base64, newName });
+      }
+
+      if (validFiles.length === 0) {
+        throw new Error(skippedReasons.length > 0
+          ? skippedReasons.join('; ')
+          : 'No valid images to upload');
+      }
+
+      const response = await fetch('/api/file/import', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          files: validFiles.map((img) => ({
+            name: img.newName,
+            content: img.base64,
+            encoding: 'base64',
+          })),
+          targetSpace: '.media',
+          organize: false,  // Don't trigger AI organize for media files
+          conflict: 'rename',
+        }),
+      });
+
+      if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || `Upload failed: ${response.statusText}`);
+      }
+
+      const result = await response.json();
+      return (result.created ?? []).map(
+        (item: { path: string }) => `/${item.path}`,
+      );
+    } finally {
+      setIsUploading(false);
+    }
+  }, []);
+
+  return { uploadToMedia, isUploading };
+}

package/app/lib/agent/model.ts

@@ -84,6 +84,12 @@ function resolveModel(providerId: ProviderId, modelName: string, baseUrl: string
     };
   }
 
+  // 2.5. Apply preset fixedBaseUrl when registry lookup succeeded but needs endpoint override
+  // (zai-cn: domestic endpoint, deepseek: fixed baseUrl, ollama: localhost)
+  if (preset.fixedBaseUrl && !hasCustomBase) {
+    model = { ...model, baseUrl: preset.fixedBaseUrl };
+  }
+
   // 3. Apply user's custom baseUrl
   if (hasCustomBase) {
     model = { ...model, baseUrl };
@@ -93,7 +99,7 @@ function resolveModel(providerId: ProviderId, modelName: string, baseUrl: string
     }
   }
 
-  // 4. For deepseek or any custom endpoint, apply conservative compat
+  // 4. For deepseek/zai-cn/ollama or any custom endpoint, apply conservative compat
   if (hasCustomBase || preset.fixedBaseUrl) {
     model = {
       ...model,

package/app/lib/agent/providers.ts

@@ -16,8 +16,8 @@ import {
 export type ProviderId =
   | 'anthropic' | 'openai' | 'google' | 'groq'
   | 'xai' | 'openrouter' | 'mistral' | 'deepseek'
-  | 'zai' | 'kimi-coding'
-  | 'cerebras' | 'minimax' | 'huggingface'
+  | 'zai' | 'zai-cn' | 'kimi-coding'
+  | 'cerebras' | 'minimax' | 'minimax-cn' | 'huggingface'
   | 'ollama';
 
 /**
@@ -135,13 +135,26 @@ export const PROVIDER_PRESETS: Record<ProviderId, ProviderPreset> = {
   zai: {
     id: 'zai',
     name: 'ZhipuAI (GLM)',
-    nameZh: '智谱 AI (GLM)',
+    nameZh: '智谱 AI (GLM 国际版)',
     defaultModel: 'glm-4-plus',
     supportsBaseUrl: false,
     supportsThinking: true,
     supportsListModels: false,
     category: 'more',
   },
+  'zai-cn': {
+    id: 'zai-cn',
+    name: 'ZhipuAI (GLM China)',
+    nameZh: '智谱 AI (GLM 国内版)',
+    defaultModel: 'glm-4-plus',
+    piProviderOverride: 'zai' as KnownProvider,
+    fixedBaseUrl: 'https://open.bigmodel.cn/api/coding/paas/v4',
+    supportsBaseUrl: false,
+    supportsThinking: true,
+    supportsListModels: false,
+    signupUrl: 'https://open.bigmodel.cn/',
+    category: 'more',
+  },
   'kimi-coding': {
     id: 'kimi-coding',
     name: 'Kimi Coding',
@@ -165,10 +178,20 @@ export const PROVIDER_PRESETS: Record<ProviderId, ProviderPreset> = {
   minimax: {
     id: 'minimax',
     name: 'MiniMax',
-    nameZh: 'MiniMax',
-    defaultModel: 'MiniMax-M1',
+    nameZh: 'MiniMax (国际版)',
+    defaultModel: 'MiniMax-M2.5',
     supportsBaseUrl: false,
-    supportsThinking: false,
+    supportsThinking: true,
+    supportsListModels: false,
+    category: 'more',
+  },
+  'minimax-cn': {
+    id: 'minimax-cn',
+    name: 'MiniMax (China)',
+    nameZh: 'MiniMax (国内版)',
+    defaultModel: 'MiniMax-M2.5',
+    supportsBaseUrl: false,
+    supportsThinking: true,
     supportsListModels: false,
     category: 'more',
   },
@@ -288,8 +311,10 @@ const PI_ENV_MAP: Record<string, string> = {
   xai: 'XAI_API_KEY',
   openrouter: 'OPENROUTER_API_KEY',
   zai: 'ZAI_API_KEY',
+  'zai-cn': 'ZAI_API_KEY',
   mistral: 'MISTRAL_API_KEY',
   minimax: 'MINIMAX_API_KEY',
+  'minimax-cn': 'MINIMAX_API_KEY',
   huggingface: 'HF_TOKEN',
   'kimi-coding': 'KIMI_API_KEY',
 };

package/app/lib/core/organize.ts

@@ -14,7 +14,7 @@ const STOP_WORDS = new Set([
   'readme', 'instruction', 'md',
 ]);
 
-const SKIP_DIRS = new Set(['.git', 'node_modules', '.next', '.DS_Store']);
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.next', '.DS_Store', '.media', 'mcp']);
 
 function extractKeywords(filePath: string): string[] {
   const stem = path.basename(filePath, path.extname(filePath));

package/app/lib/core/tree.ts

@@ -3,7 +3,7 @@ import fsp from 'fs/promises';
 import path from 'path';
 import type { FileNode } from './types';
 
-const DEFAULT_IGNORED_DIRS = new Set(['.git', 'node_modules', 'app', '.next', '.DS_Store', 'mcp']);
+const DEFAULT_IGNORED_DIRS = new Set(['.git', 'node_modules', 'app', '.next', '.DS_Store', 'mcp', '.media']);
 const DEFAULT_ALLOWED_EXTENSIONS = new Set([
   '.md', '.csv', '.pdf',
   '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico',

package/app/lib/custom-agents.ts

@@ -0,0 +1,279 @@
+/**
+ * Custom Agent registration: types, slugify, defaults inference, and persistence.
+ *
+ * CustomAgentDef is stored in config.json.customAgents[].
+ * At runtime, toAgentDef() converts it into the standard AgentDef that all
+ * downstream detection / snippet / UI code already understands.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { expandHome, MCP_AGENTS } from './mcp-agents';
+import type { AgentDef } from './mcp-agents';
+import { readSettings, writeSettings } from './settings';
+
+/* ─── Types ─── */
+
+export interface CustomAgentDef {
+  name: string;
+  key: string;
+  baseDir: string;
+  global: string;
+  project?: string | null;
+  configKey: string;
+  format: 'json' | 'toml';
+  preferredTransport: 'stdio' | 'http';
+  presenceDirs: string[];
+  presenceCli?: string;
+  globalNestedKey?: string;
+}
+
+export interface DetectResult {
+  exists: boolean;
+  detectedConfig?: string;
+  detectedFormat?: 'json' | 'toml';
+  detectedConfigKey?: string;
+  hasSkillsDir: boolean;
+  suggestedName?: string;
+}
+
+/* ─── Slugify ─── */
+
+export function slugify(name: string): string {
+  const slug = name
+    .toLowerCase()
+    .replace(/[^\x20-\x7E]/g, '')
+    .replace(/[_\s]+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-|-$/g, '');
+
+  return slug || '';
+}
+
+/**
+ * Generate a unique key from a name, avoiding collisions with built-in
+ * and existing custom agents.
+ */
+export function generateUniqueKey(
+  name: string,
+  existingKeys: Set<string>,
+): string {
+  let base = slugify(name);
+
+  if (!base) {
+    let n = 1;
+    while (existingKeys.has(`custom-${n}`)) n++;
+    return `custom-${n}`;
+  }
+
+  if (!existingKeys.has(base)) return base;
+
+  let n = 2;
+  while (existingKeys.has(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+
+/* ─── Defaults Inference ─── */
+
+export function inferDefaults(name: string, baseDir: string): Omit<CustomAgentDef, 'key'> {
+  const dir = baseDir.endsWith('/') ? baseDir : baseDir + '/';
+  return {
+    name,
+    baseDir: dir,
+    global: dir + 'mcp.json',
+    project: null,
+    configKey: 'mcpServers',
+    format: 'json',
+    preferredTransport: 'stdio',
+    presenceDirs: [dir],
+  };
+}
+
+/* ─── Auto-detection ─── */
+
+export function detectBaseDir(baseDir: string): DetectResult {
+  const expanded = expandHome(baseDir);
+
+  if (!fs.existsSync(expanded)) {
+    const dirName = path.basename(expanded.replace(/\/$/, ''));
+    return {
+      exists: false,
+      hasSkillsDir: false,
+      suggestedName: dirName.charAt(0).toUpperCase() + dirName.slice(1),
+    };
+  }
+
+  const result: DetectResult = {
+    exists: true,
+    hasSkillsDir: false,
+  };
+
+  const dirName = path.basename(expanded.replace(/\/$/, ''));
+  result.suggestedName = dirName.charAt(0).toUpperCase() + dirName.slice(1);
+
+  // Check for skills/ subdirectory
+  result.hasSkillsDir = fs.existsSync(path.join(expanded, 'skills'));
+
+  // Scan top-level files (max 20)
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(expanded).slice(0, 20);
+  } catch {
+    return result;
+  }
+
+  // Try JSON files first
+  for (const entry of entries) {
+    if (!entry.endsWith('.json')) continue;
+    const filePath = path.join(expanded, entry);
+    try {
+      const stat = fs.statSync(filePath);
+      if (!stat.isFile() || stat.size > 1_000_000) continue;
+      const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      if (raw && typeof raw === 'object') {
+        if ('mcpServers' in raw) {
+          result.detectedConfig = baseDir.endsWith('/') ? baseDir + entry : baseDir + '/' + entry;
+          result.detectedFormat = 'json';
+          result.detectedConfigKey = 'mcpServers';
+          return result;
+        }
+        if ('servers' in raw) {
+          result.detectedConfig = baseDir.endsWith('/') ? baseDir + entry : baseDir + '/' + entry;
+          result.detectedFormat = 'json';
+          result.detectedConfigKey = 'servers';
+          return result;
+        }
+      }
+    } catch { /* skip unparseable files */ }
+  }
+
+  // Try TOML files
+  for (const entry of entries) {
+    if (!entry.endsWith('.toml')) continue;
+    const filePath = path.join(expanded, entry);
+    try {
+      const stat = fs.statSync(filePath);
+      if (!stat.isFile() || stat.size > 1_000_000) continue;
+      const lines = fs.readFileSync(filePath, 'utf-8').split('\n').slice(0, 50);
+      for (const line of lines) {
+        if (/^\s*\[mcp_servers/i.test(line) || /^\s*\[mcpServers/i.test(line)) {
+          const lower = line.toLowerCase();
+          const key = lower.includes('mcp_servers') ? 'mcp_servers' : 'mcpServers';
+          result.detectedConfig = baseDir.endsWith('/') ? baseDir + entry : baseDir + '/' + entry;
+          result.detectedFormat = 'toml';
+          result.detectedConfigKey = key;
+          return result;
+        }
+      }
+    } catch { /* skip */ }
+  }
+
+  return result;
+}
+
+/* ─── AgentDef Conversion ─── */
+
+/**
+ * Convert a CustomAgentDef into the standard AgentDef that all downstream
+ * code (detectInstalled, generateSnippet, etc.) expects.
+ *
+ * Note: AgentDef.key is the *config key* (e.g. "mcpServers"), not the agent identifier.
+ * The agent identifier is the key in the MCP_AGENTS record, which comes from CustomAgentDef.key.
+ */
+export function toAgentDef(custom: CustomAgentDef): AgentDef {
+  return {
+    name: custom.name,
+    project: custom.project ?? null,
+    global: custom.global,
+    key: custom.configKey,
+    preferredTransport: custom.preferredTransport,
+    format: custom.format,
+    globalNestedKey: custom.globalNestedKey,
+    presenceCli: custom.presenceCli,
+    presenceDirs: custom.presenceDirs,
+  };
+}
+
+/* ─── Persistence ─── */
+
+export function loadCustomAgents(): CustomAgentDef[] {
+  try {
+    const settings = readSettings();
+    const raw = settings.customAgents;
+    if (!Array.isArray(raw)) return [];
+    return raw.filter(
+      (item): item is CustomAgentDef => {
+        if (item == null || typeof item !== 'object') return false;
+        const obj = item as unknown as Record<string, unknown>;
+        return typeof obj.name === 'string' && typeof obj.key === 'string' && typeof obj.baseDir === 'string';
+      },
+    );
+  } catch {
+    console.warn('[custom-agents] Failed to parse, using empty list');
+    return [];
+  }
+}
+
+export function saveCustomAgents(agents: CustomAgentDef[]): void {
+  const settings = readSettings();
+  settings.customAgents = agents;
+  writeSettings(settings);
+}
+
+/* ─── Merged Registry ─── */
+
+/**
+ * Returns all agents (built-in + custom) as a Record<agentId, AgentDef>.
+ * Built-in agents take priority on key collision.
+ */
+export function getAllAgents(): Record<string, AgentDef> {
+  const result: Record<string, AgentDef> = { ...MCP_AGENTS };
+  const customs = loadCustomAgents();
+
+  for (const custom of customs) {
+    if (custom.key in result) continue; // built-in priority
+    result[custom.key] = toAgentDef(custom);
+  }
+
+  return result;
+}
+
+/* ─── Validation ─── */
+
+export function validateCustomAgentInput(input: {
+  name?: string;
+  baseDir?: string;
+  key?: string;
+}, existingKeys: Set<string>, isEdit = false): string | null {
+  if (!input.name || !input.name.trim()) {
+    return 'Agent name is required';
+  }
+
+  if (!input.baseDir || !input.baseDir.trim()) {
+    return 'Config directory is required';
+  }
+
+  const dir = input.baseDir.trim();
+  if (!dir.startsWith('~/') && !dir.startsWith('/')) {
+    if (process.platform === 'win32' && /^[A-Z]:\\/i.test(dir)) {
+      // Windows absolute path — OK
+    } else {
+      return 'Must be an absolute path (e.g. ~/.qclaw/)';
+    }
+  }
+
+  if (!isEdit) {
+    const key = input.key || slugify(input.name.trim());
+    if (!key) return 'Cannot generate a valid key from this name';
+    if (key in MCP_AGENTS) {
+      const builtIn = MCP_AGENTS[key];
+      return `Conflicts with built-in agent "${builtIn.name}"`;
+    }
+    if (existingKeys.has(key)) {
+      return `An agent with key "${key}" already exists`;
+    }
+  }
+
+  return null;
+}

package/app/lib/fs.ts

@@ -49,7 +49,7 @@ export function getMindRoot(): string {
   return effectiveSopRoot();
 }
 
-const IGNORED_DIRS = new Set(['.git', 'node_modules', 'app', '.next', '.DS_Store']);
+const IGNORED_DIRS = new Set(['.git', 'node_modules', 'app', '.next', '.DS_Store', '.media', 'mcp']);
 const ALLOWED_EXTENSIONS = new Set([
   '.md', '.csv', '.json', '.pdf',
   '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico',

package/app/lib/i18n/modules/panels.ts

@@ -313,6 +313,54 @@ export const panelsEn = {
       recentActivity: 'Recent Activity',
       viewAll: 'View all',
       showLess: 'Show less',
+      addCustomAgent: 'Add your own agent',
+      addCustomAgentTitle: 'Add Custom Agent',
+      editCustomAgentTitle: (name: string) => `Edit ${name}`,
+      customAgentName: 'Agent Name',
+      customAgentNamePlaceholder: 'e.g. QCLaw, WorkBuddy',
+      customAgentDir: 'Config Directory',
+      customAgentDirPlaceholder: '~/.qclaw/',
+      customAgentDirHint: 'Common: ~/.xxx/ or ~/Library/Application Support/',
+      customAgentKeyPreview: (key: string) => `Key: ${key}`,
+      customAgentContinue: 'Continue',
+      customAgentDetecting: 'Detecting...',
+      customAgentDirFound: 'Directory found',
+      customAgentDirNotFound: 'Not found yet — agent will appear when installed',
+      customAgentDetectTimeout: 'Detection timed out, using defaults',
+      customAgentDetectedTitle: 'Detected Configuration',
+      customAgentDefaultTitle: 'Default Configuration',
+      customAgentConfigLabel: 'MCP Config',
+      customAgentFormatLabel: 'Format',
+      customAgentTransportLabel: 'Transport',
+      customAgentSkillsLabel: 'Skills',
+      customAgentSkillsFound: (n: number) => `${n} found`,
+      customAgentCustomize: 'Customize these settings',
+      customAgentAdd: 'Add Agent',
+      customAgentAdding: 'Adding...',
+      customAgentSave: 'Save Changes',
+      customAgentSaving: 'Saving...',
+      customAgentRetry: 'Retry',
+      customAgentAdded: (name: string) => `${name} added`,
+      customAgentUpdated: (name: string) => `${name} updated`,
+      customAgentRemoved: (name: string) => `${name} removed`,
+      customAgentRemoveTitle: (name: string) => `Remove "${name}"?`,
+      customAgentRemoveMessage: 'This removes the agent from MindOS. No files will be deleted on disk.',
+      customAgentRemoveConfirm: 'Remove',
+      customAgentConfigPath: 'MCP Config File Path',
+      customAgentConfigKey: 'Config Key',
+      customAgentFormat: 'Format',
+      customAgentTransport: 'Transport',
+      customAgentProjectConfig: 'Project Config (optional)',
+      customAgentCliBinary: 'CLI Binary (optional)',
+      customAgentCliBinaryPlaceholder: 'e.g. qclaw',
+      customAgentEdit: 'Edit',
+      customAgentRemove: 'Remove',
+      customAgentCancel: 'Cancel',
+      customAgentNetworkError: 'Network error. Please try again.',
+      customAgentFailedSave: 'Failed to save',
+      customAgentFailedRemove: 'Failed to remove',
+      customAgentKeyConflict: (key: string) => `An agent with key "${key}" already exists`,
+      customAgentBuiltinConflict: (name: string) => `Conflicts with built-in agent "${name}"`,
     },
     mcp: {
       title: 'MCP Connections',
@@ -949,6 +997,54 @@ export const panelsZh = {
       recentActivity: '最近活动',
       viewAll: '查看全部',
       showLess: '收起',
+      addCustomAgent: '添加自定义 Agent',
+      addCustomAgentTitle: '添加自定义 Agent',
+      editCustomAgentTitle: (name: string) => `编辑 ${name}`,
+      customAgentName: 'Agent 名称',
+      customAgentNamePlaceholder: '例如 QCLaw、WorkBuddy',
+      customAgentDir: '配置目录',
+      customAgentDirPlaceholder: '~/.qclaw/',
+      customAgentDirHint: '常见路径：~/.xxx/ 或 ~/Library/Application Support/',
+      customAgentKeyPreview: (key: string) => `标识符：${key}`,
+      customAgentContinue: '继续',
+      customAgentDetecting: '检测中...',
+      customAgentDirFound: '目录已找到',
+      customAgentDirNotFound: '目录尚未创建，安装后将自动检测',
+      customAgentDetectTimeout: '检测超时，使用默认配置',
+      customAgentDetectedTitle: '检测到的配置',
+      customAgentDefaultTitle: '默认配置',
+      customAgentConfigLabel: 'MCP 配置',
+      customAgentFormatLabel: '格式',
+      customAgentTransportLabel: '传输协议',
+      customAgentSkillsLabel: '技能',
+      customAgentSkillsFound: (n: number) => `发现 ${n} 个`,
+      customAgentCustomize: '自定义配置',
+      customAgentAdd: '添加 Agent',
+      customAgentAdding: '添加中...',
+      customAgentSave: '保存更改',
+      customAgentSaving: '保存中...',
+      customAgentRetry: '重试',
+      customAgentAdded: (name: string) => `${name} 已添加`,
+      customAgentUpdated: (name: string) => `${name} 已更新`,
+      customAgentRemoved: (name: string) => `${name} 已移除`,
+      customAgentRemoveTitle: (name: string) => `移除「${name}」？`,
+      customAgentRemoveMessage: '这将从 MindOS 中移除该 Agent，不会删除磁盘上的任何文件。',
+      customAgentRemoveConfirm: '移除',
+      customAgentConfigPath: 'MCP 配置文件路径',
+      customAgentConfigKey: '配置键名',
+      customAgentFormat: '格式',
+      customAgentTransport: '传输协议',
+      customAgentProjectConfig: '项目配置路径（可选）',
+      customAgentCliBinary: 'CLI 命令名（可选）',
+      customAgentCliBinaryPlaceholder: '例如 qclaw',
+      customAgentEdit: '编辑',
+      customAgentRemove: '移除',
+      customAgentCancel: '取消',
+      customAgentNetworkError: '网络错误，请重试。',
+      customAgentFailedSave: '保存失败',
+      customAgentFailedRemove: '移除失败',
+      customAgentKeyConflict: (key: string) => `已存在标识为 "${key}" 的 Agent`,
+      customAgentBuiltinConflict: (name: string) => `与内置 Agent "${name}" 冲突`,
     },
     mcp: {
       title: 'MCP 连接',

package/app/lib/image.ts

@@ -0,0 +1,47 @@
+/**
+ * Image path resolution utilities for Markdown.
+ *
+ * Converts markdown image paths (e.g., `![alt](/.media/image.png)`) to API URLs
+ * that can be served by `/api/file/raw?path=...`
+ */
+
+/**
+ * Checks if a path is an absolute path (starts with `/`).
+ */
+function isAbsolutePath(path: string): boolean {
+  return path.startsWith('/');
+}
+
+/**
+ * Checks if a path is a URL (starts with protocol like http://, https://, file://).
+ */
+function isUrl(path: string): boolean {
+  return /^(https?|file):\/\//.test(path);
+}
+
+/**
+ * Resolves an image path to a URL for the API endpoint.
+ *
+ * Rules:
+ * - Absolute paths (start with `/`) → `/api/file/raw?path=...` (strip leading slash)
+ * - URLs (http/https/file) → return as-is
+ * - Relative paths → return as-is (browser handles relative URLs)
+ *
+ * @param imagePath - The image path from markdown syntax
+ * @returns The resolved URL or path
+ */
+export function resolveImagePath(imagePath: string): string {
+  // Already a URL
+  if (isUrl(imagePath)) {
+    return imagePath;
+  }
+
+  // Absolute path like `/.media/image.png` or `/path/to/image.png`
+  if (isAbsolutePath(imagePath)) {
+    const cleanPath = imagePath.slice(1); // Remove leading `/`
+    return `/api/file/raw?path=${encodeURIComponent(cleanPath)}`;
+  }
+
+  // Relative path — return as-is for browser to resolve
+  return imagePath;
+}