protocol-proxy 2.8.3 → 2.10.1

package/lib/config-store.js

@@ -148,13 +148,14 @@ function normalizeConfig(config) {
     ...config,
     providers: providers.map(normalizeProvider),
     proxies: proxies.map(normalizeProxy),
+    mcpServers: config?.mcpServers && typeof config.mcpServers === 'object' ? config.mcpServers : {},
   };
 }
 
 function loadConfig() {
   try {
     if (!fs.existsSync(CONFIG_PATH)) {
-      configCache = { providers: [], proxies: [], settings: {} };
+      configCache = { providers: [], proxies: [], settings: {}, mcpServers: {} };
       return configCache;
     }
     const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
@@ -165,7 +166,7 @@ function loadConfig() {
     return configCache;
   } catch (err) {
     console.error('加载配置失败:', err.message);
-    return configCache || { providers: [], proxies: [], settings: {} };
+    return configCache || { providers: [], proxies: [], settings: {}, mcpServers: {} };
   }
 }
 
@@ -353,6 +354,43 @@ function removeProxy(id) {
   return removed;
 }
 
+// --- MCP Server CRUD ---
+
+function getMcpServers() {
+  const config = loadConfig();
+  return config.mcpServers || {};
+}
+
+function getMcpServer(name) {
+  const servers = getMcpServers();
+  return servers[name] || null;
+}
+
+function addMcpServer(name, serverConfig) {
+  const config = loadConfig();
+  if (!config.mcpServers) config.mcpServers = {};
+  if (config.mcpServers[name]) return null;
+  config.mcpServers[name] = serverConfig;
+  saveConfig(config);
+  return serverConfig;
+}
+
+function updateMcpServer(name, updates) {
+  const config = loadConfig();
+  if (!config.mcpServers || !config.mcpServers[name]) return null;
+  config.mcpServers[name] = { ...config.mcpServers[name], ...updates };
+  saveConfig(config);
+  return config.mcpServers[name];
+}
+
+function removeMcpServer(name) {
+  const config = loadConfig();
+  if (!config.mcpServers || !config.mcpServers[name]) return false;
+  delete config.mcpServers[name];
+  saveConfig(config);
+  return true;
+}
+
 module.exports = {
   loadConfig,
   saveConfig,
@@ -373,4 +411,9 @@ module.exports = {
   removeProxy,
   normalizeRoutingStrategy,
   normalizeProviderPool,
+  getMcpServers,
+  getMcpServer,
+  addMcpServer,
+  updateMcpServer,
+  removeMcpServer,
 };

package/lib/conversation-store.js

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DATA_DIR = path.join(os.homedir(), '.protocol-proxy', 'conversations');
+
+// 内存缓存：conversationId → { id, proxyId, messages, createdAt, lastActivity }
+let conversations = {};
+
+// debounce 写入：500ms 内同一 conv 只写一次
+const pendingWrites = new Map(); // convId → timer
+
+function scheduleSave(conv) {
+  if (pendingWrites.has(conv.id)) clearTimeout(pendingWrites.get(conv.id));
+  pendingWrites.set(conv.id, setTimeout(() => {
+    pendingWrites.delete(conv.id);
+    fs.writeFile(path.join(DATA_DIR, conv.id + '.json'), JSON.stringify(conv), 'utf8', () => {});
+  }, 500));
+}
+
+function saveImmediate(conv) {
+  if (pendingWrites.has(conv.id)) {
+    clearTimeout(pendingWrites.get(conv.id));
+    pendingWrites.delete(conv.id);
+  }
+  try {
+    fs.writeFileSync(path.join(DATA_DIR, conv.id + '.json'), JSON.stringify(conv), 'utf8');
+  } catch {}
+}
+
+function flushAll() {
+  for (const [id, timer] of pendingWrites) {
+    clearTimeout(timer);
+    const conv = conversations[id];
+    if (conv) {
+      try { fs.writeFileSync(path.join(DATA_DIR, id + '.json'), JSON.stringify(conv), 'utf8'); } catch {}
+    }
+  }
+  pendingWrites.clear();
+}
+
+function init() {
+  if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+  }
+  try {
+    const files = fs.readdirSync(DATA_DIR).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(DATA_DIR, file), 'utf8'));
+        if (data.id) conversations[data.id] = data;
+      } catch {}
+    }
+  } catch {}
+}
+
+function get(id) {
+  return conversations[id] || null;
+}
+
+function create(proxyId, maxConversations) {
+  // 超过最大会话数时删除最早的
+  if (maxConversations > 0) {
+    const all = list();
+    while (all.length >= maxConversations) {
+      const oldest = all.shift(); // list() 已按 lastActivity 升序
+      remove(oldest.id);
+    }
+  }
+  const id = 'conv-' + Date.now() + '-' + Math.random().toString(36).slice(2, 8);
+  const conv = { id, proxyId, messages: [], createdAt: Date.now(), lastActivity: Date.now() };
+  conversations[id] = conv;
+  saveImmediate(conv); // 新建立即写入
+  return conv;
+}
+
+function touch(conv) {
+  conv.lastActivity = Date.now();
+  scheduleSave(conv); // debounce 异步写入
+}
+
+function remove(id) {
+  delete conversations[id];
+  if (pendingWrites.has(id)) { clearTimeout(pendingWrites.get(id)); pendingWrites.delete(id); }
+  fs.unlink(path.join(DATA_DIR, id + '.json'), () => {});
+}
+
+// 返回会话列表（按 lastActivity 升序，不含 messages），用于前端展示
+function list() {
+  return Object.values(conversations)
+    .map(c => ({
+      id: c.id,
+      proxyId: c.proxyId,
+      createdAt: c.createdAt,
+      lastActivity: c.lastActivity,
+      messageCount: (c.messages || []).length,
+      // 取第一条 user 消息作为标题预览
+      preview: ((c.messages || []).find(m => m.role === 'user')?.content || '').slice(0, 60),
+    }))
+    .sort((a, b) => a.lastActivity - b.lastActivity);
+}
+
+// 进程退出时确保所有 debounce 中的数据落盘
+process.on('exit', flushAll);
+process.on('SIGINT', () => { flushAll(); process.exit(0); });
+process.on('SIGTERM', () => { flushAll(); process.exit(0); });
+
+module.exports = { init, get, create, touch, remove, list, flushAll };

package/lib/mcp-client.js

@@ -0,0 +1,423 @@
+const { Client } = require('@modelcontextprotocol/sdk/client');
+const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+const { StreamableHTTPClientTransport } = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+const { SSEClientTransport } = require('@modelcontextprotocol/sdk/client/sse.js');
+const crypto = require('crypto');
+const configStore = require('./config-store');
+
+const CALL_TIMEOUT = 30000;
+const INITIALIZE_TIMEOUT = 60000;  // 首次连接需要下载依赖，延长超时
+const LIST_TOOLS_TIMEOUT = 30000;
+const MAX_RECONNECT_ATTEMPTS = 10;
+const BASE_RECONNECT_DELAY = 5000;
+const MAX_RECONNECT_DELAY = 60000;
+
+// Map<name, { client, transport, config, status, tools, lastError, reconnectTimer, reconnectAttempts }>
+const servers = new Map();
+let onUpdateCallback = null;
+let _defsCache = null;
+let _handlerCache = null;
+
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, '_').replace(/-/g, '_');
+}
+
+function notifyUpdate(name) {
+  _defsCache = null;
+  _handlerCache = null;
+  const entry = servers.get(name);
+  if (onUpdateCallback && entry) {
+    onUpdateCallback(name, {
+      status: entry.status,
+      toolCount: entry.tools.length,
+      lastError: entry.lastError,
+    });
+  }
+}
+
+function createTransport(name, config) {
+  if (config.url) {
+    const url = new URL(config.url);
+    const opts = {};
+    if (config.headers && Object.keys(config.headers).length) {
+      opts.requestInit = { headers: config.headers };
+    }
+    // 检测 SSE 端点（高德等使用 /sse 路径的服务）
+    if (config.url.includes('/sse')) {
+      console.log(`[mcp] ${name} 使用 SSE 传输模式`);
+      return new SSEClientTransport(url, opts);
+    }
+    return new StreamableHTTPClientTransport(url, opts);
+  }
+  if (config.command) {
+    return new StdioClientTransport({
+      command: config.command,
+      args: config.args || [],
+      env: config.env ? { ...process.env, ...config.env } : undefined,
+      cwd: config.cwd || undefined,
+    });
+  }
+  throw new Error('MCP 服务器配置需要 command（本地进程）或 url（远程 HTTP）');
+}
+
+async function connectServer(name, config) {
+  let entry = servers.get(name);
+  if (entry) {
+    // 清理旧连接
+    if (entry.reconnectTimer) {
+      clearTimeout(entry.reconnectTimer);
+      entry.reconnectTimer = null;
+    }
+    try {
+      if (entry.client) await entry.client.close().catch(() => {});
+    } catch (closeErr) { console.warn(`[mcp] 关闭旧连接 ${name} 失败: ${closeErr.message}`); }
+  }
+
+  entry = {
+    client: null,
+    transport: null,
+    config,
+    status: 'connecting',
+    tools: [],
+    lastError: null,
+    lastConnected: null,
+    reconnectTimer: null,
+    reconnectAttempts: 0,
+    configHash: null,
+  };
+  servers.set(name, entry);
+  notifyUpdate(name);
+
+  const connectWithRetry = async (transport, client, retries = 1) => {
+    const errors = [];
+    for (let i = 0; i <= retries; i++) {
+      try {
+        if (i > 0) console.log(`[mcp] ${name} 正在重连（第 ${i} 次）...`);
+        await Promise.race([
+          client.connect(transport),
+          new Promise((_, rej) => setTimeout(() => rej(new Error(`握手超时（${INITIALIZE_TIMEOUT / 1000}s）`)), INITIALIZE_TIMEOUT))
+        ]);
+        return true;
+      } catch (err) {
+        errors.push(err.message);
+        // 如果是 stdio 模式且首次超时，可能是正在下载依赖，给一次重试机会
+        if (config.command && i < retries && err.message.includes('超时')) {
+          console.log(`[mcp] ${name} 首次连接超时，可能是正在下载依赖，将重试...`);
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw new Error(errors.join('; '));
+  };
+
+  try {
+    const transport = createTransport(name, config);
+    const client = new Client(
+      { name: 'protocol-proxy', version: '1.0.0' },
+      { capabilities: {} }
+    );
+
+    await connectWithRetry(transport, client, 1);
+
+    // 列出工具
+    let allTools = [];
+    let cursor;
+    do {
+      try {
+        const result = await Promise.race([
+          client.listTools(cursor ? { cursor } : undefined),
+          new Promise((_, rej) => setTimeout(() => rej(new Error(`列出工具超时（${LIST_TOOLS_TIMEOUT / 1000}s）`)), LIST_TOOLS_TIMEOUT))
+        ]);
+        allTools = allTools.concat(result.tools || []);
+        cursor = result.nextCursor;
+      } catch (err) {
+        throw new Error(`列出工具失败: ${err.message}`);
+      }
+    } while (cursor);
+
+    entry.client = client;
+    entry.transport = transport;
+    entry.tools = allTools;
+    entry.status = 'connected';
+    entry.lastConnected = new Date();
+    entry.lastError = null;
+    entry.reconnectAttempts = 0;
+    entry.configHash = configHashFn(config);
+
+    console.log(`[mcp] 已连接 ${name}: ${allTools.length} 个工具`);
+    notifyUpdate(name);
+    return allTools;
+  } catch (err) {
+    entry.status = 'error';
+    entry.lastError = err.message;
+    console.error(`[mcp] 连接 ${name} 失败: ${err.message}`);
+    notifyUpdate(name);
+    throw err;
+  }
+}
+
+async function disconnectServer(name) {
+  const entry = servers.get(name);
+  if (!entry) return;
+
+  if (entry.reconnectTimer) {
+    clearTimeout(entry.reconnectTimer);
+    entry.reconnectTimer = null;
+  }
+
+  try {
+    if (entry.client) await entry.client.close().catch(() => {});
+  } catch (closeErr) { console.warn(`[mcp] 断开 ${name} 时关闭连接失败: ${closeErr.message}`); }
+
+  entry.status = 'disconnected';
+  entry.client = null;
+  entry.transport = null;
+  entry.tools = [];
+  console.log(`[mcp] 已断开 ${name}`);
+  notifyUpdate(name);
+}
+
+async function reconnectServer(name) {
+  const entry = servers.get(name);
+  if (!entry) return;
+  const config = entry.config;
+  entry.reconnectAttempts = 0;
+  await disconnectServer(name);
+  await connectServer(name, config);
+}
+
+function scheduleReconnect(name) {
+  const entry = servers.get(name);
+  if (!entry || entry.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) return;
+
+  if (entry.reconnectTimer) {
+    clearTimeout(entry.reconnectTimer);
+    entry.reconnectTimer = null;
+  }
+
+  const delay = Math.min(BASE_RECONNECT_DELAY * Math.pow(2, entry.reconnectAttempts), MAX_RECONNECT_DELAY);
+  entry.reconnectTimer = setTimeout(async () => {
+    entry.reconnectAttempts++;
+    try {
+      await connectServer(name, entry.config);
+    } catch {
+      scheduleReconnect(name);
+    }
+  }, delay);
+  console.log(`[mcp] ${name} 将在 ${Math.round(delay / 1000)}s 后重连 (第 ${entry.reconnectAttempts + 1} 次)`);
+}
+
+async function callTool(serverName, toolName, args) {
+  const entry = servers.get(serverName);
+  if (!entry || entry.status !== 'connected' || !entry.client) {
+    return { error: `MCP 服务 "${serverName}" 未连接` };
+  }
+
+  try {
+    const controller = new AbortController();
+    const callTimeout = entry.config.toolCallTimeoutMs || CALL_TIMEOUT;
+    const timer = setTimeout(() => controller.abort(), callTimeout);
+
+    let result;
+    try {
+      result = await entry.client.callTool({ name: toolName, arguments: args }, undefined, { signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+
+    if (result.isError) {
+      const text = (result.content || []).map(c => c.text || JSON.stringify(c)).join('\n');
+      return { error: text || 'MCP 工具执行失败' };
+    }
+
+    const text = (result.content || []).map(c => {
+      if (c.type === 'text') return c.text;
+      return JSON.stringify(c);
+    }).join('\n');
+
+    try { return JSON.parse(text); } catch { return { result: text }; }
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      const timeout = entry.config.toolCallTimeoutMs || CALL_TIMEOUT;
+      return { error: `MCP 工具调用超时 (${timeout / 1000}s)` };
+    }
+    // 连接断开时尝试重连
+    if (entry.status === 'connected') {
+      entry.status = 'error';
+      entry.lastError = err.message;
+      notifyUpdate(serverName);
+      scheduleReconnect(serverName);
+    }
+    return { error: `MCP 工具调用失败: ${err.message}` };
+  }
+}
+
+function fixSchemaType(schema) {
+  if (!schema || typeof schema !== 'object') return schema;
+  // 修复非法的类型值
+  if (schema.type === 'bool') schema.type = 'boolean';
+  // 修复 properties 中每个属性的 type
+  if (schema.properties && typeof schema.properties === 'object') {
+    for (const key of Object.keys(schema.properties)) {
+      const prop = schema.properties[key];
+      if (prop && prop.type === 'bool') prop.type = 'boolean';
+      // 递归修复嵌套属性
+      if (prop && prop.properties) fixSchemaType(prop);
+      // 修复 items
+      if (prop && prop.items && prop.items.type === 'bool') prop.items.type = 'boolean';
+    }
+  }
+  return schema;
+}
+
+function getToolDefinitions() {
+  if (_defsCache) return _defsCache;
+  const defs = [];
+  for (const [serverName, entry] of servers) {
+    if (entry.status !== 'connected') continue;
+    const prefix = `mcp__${sanitizeName(serverName)}__`;
+    for (const tool of entry.tools) {
+      const rawSchema = tool.inputSchema || {};
+      const schema = fixSchemaType(JSON.parse(JSON.stringify(rawSchema)));  // 深拷贝避免修改原对象
+      defs.push({
+        type: 'function',
+        function: {
+          name: `${prefix}${tool.name}`,
+          description: `[MCP:${serverName}] ${tool.description || tool.name}`,
+          parameters: {
+            type: schema.type || 'object',
+            properties: schema.properties || {},
+            required: schema.required || [],
+          },
+        },
+      });
+    }
+  }
+  _defsCache = defs;
+  return defs;
+}
+
+function getToolHandlerMap() {
+  if (_handlerCache) return _handlerCache;
+  const map = {};
+  for (const [serverName, entry] of servers) {
+    if (entry.status !== 'connected') continue;
+    const prefix = `mcp__${sanitizeName(serverName)}__`;
+    for (const tool of entry.tools) {
+      const fullName = `${prefix}${tool.name}`;
+      const sn = serverName;
+      const tn = tool.name;
+      map[fullName] = (args) => callTool(sn, tn, args);
+    }
+  }
+  _handlerCache = map;
+  return map;
+}
+
+function getStatus() {
+  return Array.from(servers.entries()).map(([name, entry]) => ({
+    name,
+    status: entry.status,
+    tools: entry.tools.map(t => ({ name: t.name, description: t.description || '' })),
+    lastError: entry.lastError,
+    lastConnected: entry.lastConnected,
+    transport: entry.config?.url ? 'http' : 'stdio',
+  }));
+}
+
+function getServerStatus(name) {
+  const entry = servers.get(name);
+  return entry ? entry.status : null;
+}
+
+function refreshTools() {
+  _defsCache = null;
+  _handlerCache = null;
+  return {
+    definitions: getToolDefinitions(),
+    handlers: getToolHandlerMap(),
+  };
+}
+
+function configHashFn(config) {
+  return crypto.createHash('md5').update(JSON.stringify(config)).digest('hex');
+}
+
+async function reconnectIfChanged(name, newConfig) {
+  const entry = servers.get(name);
+  if (!entry) {
+    await connectServer(name, newConfig);
+    return { changed: true };
+  }
+  const newHash = configHashFn(newConfig);
+  if (entry.configHash && entry.configHash === newHash) {
+    console.log(`[mcp] ${name} 配置未变更，跳过重连`);
+    return { changed: false };
+  }
+  await reconnectServer(name);
+  return { changed: true };
+}
+
+async function init({ onUpdate } = {}) {
+  onUpdateCallback = onUpdate || null;
+
+  const mcpServers = configStore.getMcpServers();
+  const names = Object.keys(mcpServers);
+
+  if (names.length === 0) {
+    console.log('[mcp] 未配置 MCP 服务器');
+    return;
+  }
+
+  console.log(`[mcp] 正在连接 ${names.length} 个 MCP 服务器...`);
+
+  const results = await Promise.allSettled(
+    names.map(name => {
+      const config = mcpServers[name];
+      if (config.enabled === false) {
+        servers.set(name, {
+          client: null, transport: null, config, status: 'disconnected',
+          tools: [], lastError: null, lastConnected: null,
+          reconnectTimer: null, reconnectAttempts: 0, configHash: null,
+        });
+        return Promise.resolve();
+      }
+      return connectServer(name, config).catch(() => {});
+    })
+  );
+
+  const connected = results.filter(r => r.status === 'fulfilled' && r.value).length;
+  console.log(`[mcp] 初始化完成: ${connected}/${names.length} 已连接`);
+}
+
+async function shutdown() {
+  for (const [name, entry] of servers) {
+    if (entry.reconnectTimer) {
+      clearTimeout(entry.reconnectTimer);
+      entry.reconnectTimer = null;
+    }
+    try {
+      if (entry.client) await entry.client.close().catch(() => {});
+    } catch (closeErr) { console.warn(`[mcp] 关闭 ${name} 失败: ${closeErr.message}`); }
+  }
+  servers.clear();
+  _defsCache = null;
+  _handlerCache = null;
+  console.log('[mcp] 已关闭所有 MCP 连接');
+}
+
+module.exports = {
+  init,
+  connectServer,
+  disconnectServer,
+  reconnectServer,
+  reconnectIfChanged,
+  callTool,
+  getToolDefinitions,
+  getToolHandlerMap,
+  getStatus,
+  getServerStatus,
+  refreshTools,
+  shutdown,
+};

package/lib/prompt-builder.js

@@ -0,0 +1,94 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const INSTRUCTIONS_PATH = path.join(os.homedir(), '.protocol-proxy', 'instructions.md');
+const MAX_INSTRUCTIONS_CHARS = 4000;
+
+/**
+ * 读取用户自定义指令文件
+ * 不存在时返回空字符串
+ */
+function loadUserInstructions() {
+  try {
+    if (!fs.existsSync(INSTRUCTIONS_PATH)) return '';
+    const content = fs.readFileSync(INSTRUCTIONS_PATH, 'utf8').trim();
+    if (!content) return '';
+    const truncated = content.length > MAX_INSTRUCTIONS_CHARS
+      ? content.slice(0, MAX_INSTRUCTIONS_CHARS) + '\n...(已截断)'
+      : content;
+    return `用户自定义指令：\n${truncated}`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * 构建技能段落
+ */
+function buildSkillsSection(skillStore) {
+  const skills = skillStore.getAvailableForChat();
+  const skillList = skills.length
+    ? skills.map(s => `- /${s.name}: ${s.description}`).join('\n')
+    : '（暂无可用技能）';
+  return `可用技能（当用户输入 /技能名 时，调用 invoke_skill 获取指令并遵循执行）：\n${skillList}`;
+}
+
+/**
+ * 构建 MCP 工具段落
+ */
+function buildMcpSection(mcpClient) {
+  const mcpStatus = mcpClient.getStatus();
+  const connected = mcpStatus.filter(s => s.status === 'connected' && s.tools.length);
+  const degraded = mcpStatus.filter(s => s.status !== 'connected');
+
+  let out = connected.length
+    ? connected.map(s => `- [${s.name}] ${s.tools.map(t => t.name + (t.description ? ': ' + t.description : '')).join(', ')}`).join('\n')
+    : '（暂无已连接的 MCP 服务）';
+
+  if (degraded.length) {
+    out += '\n\n⚠️ 以下 MCP 服务当前不可用，相关工具无法使用：\n'
+      + degraded.map(s => `- ${s.name}（${s.status}${s.lastError ? ': ' + s.lastError : ''}）`).join('\n');
+  }
+
+  return `MCP 外部工具（通过 MCP 协议接入的第三方工具，名称以 mcp__ 开头）：\n${out}`;
+}
+
+/**
+ * 组装完整系统提示词
+ * 工具信息由 TOOL_DEFINITIONS 通过 API tools 参数单独传递，不在提示词中重复
+ * @param {Object} opts
+ * @param {Object} opts.skillStore - skillStore 模块
+ * @param {Object} opts.mcpClient - mcpClient 模块
+ */
+function buildSystemPrompt({ skillStore, mcpClient }) {
+  const now = new Date().toLocaleString('zh-CN', { hour12: false });
+
+  const sections = [
+    // 角色声明
+    `你是 Protocol Proxy 的智能助手，帮助管理员管理和运维代理系统。当前时间：${now}`,
+
+    // 行为规则
+    `规则：\n- 当用户询问系统状态、代理、供应商、日志、用量等运维相关问题时，调用工具获取实时数据后再回答\n- 当用户需要创建、修改、删除供应商或代理时，使用对应的管理工具直接操作\n- 当用户需要查看或修改文件、执行命令时，使用对应的文件和命令工具\n- 当用户只是打招呼、闲聊、或询问与系统无关的问题时，直接回答，不要调用工具\n- 不要凭空猜测系统状态，需要数据时必须调用工具\n- 执行写操作或危险命令前，先告知用户将要做什么并确认`,
+
+    // 职责
+    `你的职责：\n1. 回答关于代理配置和运行状态的问题\n2. 分析日志，指出异常和可能原因\n3. 根据数据给出优化建议（负载均衡、模型选择、故障切换策略）\n4. 帮助用户管理供应商、代理、MCP 服务器和技能\n5. 用自然语言解释技术问题\n6. 如果发现问题，给出具体的修复步骤`,
+
+    // 用户自定义指令（可选）
+    loadUserInstructions(),
+
+    // 技能列表
+    buildSkillsSection(skillStore),
+
+    // MCP 工具列表
+    buildMcpSection(mcpClient),
+
+    // 结束语
+    '请用中文回答，保持专业且易懂。',
+  ];
+
+  // 过滤空段落，用双换行拼接
+  return sections.filter(Boolean).join('\n\n');
+}
+
+module.exports = { buildSystemPrompt };