mcp_llm-debate 1.0.0

package/src/llm-client.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * LLM 客户端 - 封装 OpenAI 兼容 API 调用
+ * 支持通过环境变量配置 API 密钥、基础 URL 和模型
+ */
+
+export class LLMClient {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || process.env.LLM_API_KEY || process.env.OPENAI_API_KEY || '';
+    this.baseUrl = options.baseUrl || process.env.LLM_BASE_URL || 'https://api.openai.com/v1';
+    this.model = options.model || process.env.LLM_MODEL || 'gpt-4o';
+  }
+
+  /**
+   * 发送聊天请求
+   * @param {Array} messages - 消息数组 [{role, content}]
+   * @param {Object} options - 额外选项
+   * @returns {Promise<string>} LLM 响应内容
+   */
+  async chat(messages, options = {}) {
+    if (!this.apiKey) {
+      throw new Error('未配置 LLM API 密钥。请设置 LLM_API_KEY 或 OPENAI_API_KEY 环境变量。');
+    }
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: options.model || this.model,
+        messages: messages,
+        temperature: options.temperature ?? 0.7,
+        max_tokens: options.max_tokens || 2048,
+        top_p: options.top_p ?? 0.95
+      })
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`LLM API 错误 (${response.status}): ${errorText}`);
+    }
+
+    const data = await response.json();
+    return data.choices[0].message.content;
+  }
+
+  /**
+   * 并行为多个角色生成响应
+   * @param {Array} roleMessages - 角色消息数组 [{role, messages, options}]
+   * @returns {Promise<Array<string>>} 响应数组
+   */
+  async chatBatch(roleMessages) {
+    return Promise.all(
+      roleMessages.map(({ messages, options = {} }) =>
+        this.chat(messages, options).catch(err => `[生成错误] ${err.message}`)
+      )
+    );
+  }
+}

package/src/session-manager.js

@@ -0,0 +1,101 @@
+/**
+ * Session 管理器 - 负责辩论 session 的创建、查询和持久化
+ * 使用 JSON 文件存储到 data/ 目录
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = path.join(__dirname, '..', 'data');
+
+export class SessionManager {
+  constructor(dataDir = DATA_DIR) {
+    this.dataDir = dataDir;
+    this._ensureDataDir();
+  }
+
+  _ensureDataDir() {
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+  }
+
+  /**
+   * 创建新的辩论 session
+   */
+  createSession(graph, subject, context = {}) {
+    const session = {
+      session_id: crypto.randomUUID(),
+      graph_name: typeof graph === 'string' ? graph : graph.name,
+      subject: subject,
+      context: context,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      status: 'active',
+      rounds: [],
+      result: null
+    };
+    this._save(session);
+    return session;
+  }
+
+  /**
+   * 获取 session 详情
+   */
+  getSession(sessionId) {
+    const filePath = path.join(this.dataDir, `${sessionId}.json`);
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    try {
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 向 session 追加一轮发言
+   */
+  appendRound(sessionId, roundData) {
+    const session = this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session 未找到: ${sessionId}`);
+    }
+
+    const roundEntry = {
+      ...roundData,
+      round_number: session.rounds.length + 1,
+      timestamp: new Date().toISOString()
+    };
+
+    session.rounds.push(roundEntry);
+    session.updated_at = new Date().toISOString();
+    this._save(session);
+    return session;
+  }
+
+  /**
+   * 完成辩论并记录结果
+   */
+  finalizeSession(sessionId, result) {
+    const session = this.getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session 未找到: ${sessionId}`);
+    }
+
+    session.status = 'completed';
+    session.result = result;
+    session.updated_at = new Date().toISOString();
+    this._save(session);
+    return session;
+  }
+
+  _save(session) {
+    const filePath = path.join(this.dataDir, `${session.session_id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(session, null, 2), 'utf-8');
+  }
+}

package/src/transports/http.js

@@ -0,0 +1,99 @@
+/**
+ * MCP Streamable HTTP 传输层
+ *
+ * 使用 MCP SDK 内置的 StreamableHTTPServerTransport，
+ * 将辩论服务暴露为 HTTP 端点，供远程 MCP Agent 调用。
+ *
+ * 客户端连接地址：POST/GET http://<host>:<port>/mcp
+ */
+
+import http from 'http';
+import crypto from 'crypto';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+
+/**
+ * 启动 MCP HTTP 服务器
+ * @param {Object} server - MCP Server 实例
+ * @param {Object} config - { port, host, authToken }
+ * @returns {Promise<http.Server>}
+ */
+export async function startHTTPServer(server, config = {}) {
+  const port = config.port || 3000;
+  const host = config.host || '127.0.0.1';
+  const authToken = config.authToken || '';
+
+  if (authToken) {
+    console.error(`[MCP HTTP] 认证已启用 (Bearer Token)`);
+  }
+
+  // 创建 Streamable HTTP 传输层（有状态模式）
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => crypto.randomUUID(),
+  });
+
+  // 将 MCP Server 连接到传输层
+  await server.connect(transport);
+
+  /**
+   * 验证请求的 Bearer Token
+   */
+  function checkAuth(req) {
+    if (!authToken) return true;
+    const authHeader = req.headers['authorization'] || '';
+    const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+    return token === authToken;
+  }
+
+  // 创建 HTTP 服务器，路由 /mcp 到 MCP 传输层
+  const httpServer = http.createServer(async (req, res) => {
+    // CORS 头
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Mcp-Session-Id, Authorization');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // MCP 端点
+    if (req.url === '/mcp' || req.url?.startsWith('/mcp')) {
+      // 认证检查
+      if (!checkAuth(req)) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: '未授权：请提供有效的 Bearer Token' }));
+        return;
+      }
+      try {
+        await transport.handleRequest(req, res);
+      } catch (err) {
+        console.error('MCP 请求处理错误:', err.message);
+        if (!res.headersSent) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      }
+      return;
+    }
+
+    // 健康检查
+    if (req.url === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok', transport: 'mcp-http' }));
+      return;
+    }
+
+    // 404
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found' }));
+  });
+
+  return new Promise((resolve, reject) => {
+    httpServer.on('error', reject);
+    httpServer.listen(port, host, () => {
+      console.error(`MCP HTTP 服务器已启动: http://${host}:${port}/mcp`);
+      resolve(httpServer);
+    });
+  });
+}

package/src/transports/rest.js

@@ -0,0 +1,167 @@
+/**
+ * REST API 传输层
+ *
+ * 基于 Node.js 内置 http 模块，将 5 个辩论工具映射为 REST 端点，
+ * 供不支持 MCP 协议的 Agent 直接通过 HTTP 调用。
+ *
+ * 端点映射：
+ *   POST /api/run_debate       → 执行辩论
+ *   POST /api/continue_debate   → 续辩
+ *   POST /api/get_debate_graph  → 获取辩论图
+ *   POST /api/get_debate_result → 获取辩论结果
+ *   POST /api/list_debate_graphs→ 列出辩论图
+ *   GET  /api/health            → 健康检查
+ */
+
+import http from 'http';
+
+/**
+ * 解析 HTTP 请求体为 JSON
+ */
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    if (req.method === 'GET') {
+      resolve({});
+      return;
+    }
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error('请求体必须是有效的 JSON'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+/**
+ * 发送 JSON 响应
+ */
+function sendJSON(res, statusCode, data) {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+  });
+  res.end(JSON.stringify(data));
+}
+
+/**
+ * 验证 Bearer Token
+ * @param {Object} req - HTTP 请求
+ * @param {string} authToken - 配置的认证令牌（空字符串表示不强制认证）
+ * @returns {boolean} 是否通过认证
+ */
+function authenticate(req, authToken) {
+  // 未配置 token 时跳过认证
+  if (!authToken) return true;
+
+  const authHeader = req.headers['authorization'] || '';
+  const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+  return token === authToken;
+}
+
+/**
+ * 工具名到参数的映射
+ */
+const TOOL_PARAM_MAP = {
+  run_debate:       { required: ['graph', 'input'], optional: ['options'] },
+  continue_debate:  { required: ['session_id', 'graph'], optional: ['subject', 'context'] },
+  get_debate_graph: { required: ['name'], optional: [] },
+  get_debate_result:{ required: ['session_id'], optional: [] },
+  list_debate_graphs:{ required: [], optional: [] },
+};
+
+/**
+ * 启动 REST API 服务器
+ * @param {Function} executeTool - 工具执行函数 async (toolName, args) => result
+ * @param {Object} config - { port, host }
+ * @returns {Promise<http.Server>}
+ */
+export async function startRESTServer(executeTool, config = {}) {
+  const port = config.port || 3000;
+  const host = config.host || '127.0.0.1';
+  const authToken = config.authToken || '';
+
+  if (authToken) {
+    console.error(`[REST] 认证已启用 (Bearer Token)`);
+  }
+
+  const server = http.createServer(async (req, res) => {
+    // CORS 预检
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+      });
+      res.end();
+      return;
+    }
+
+    // 路由匹配
+    const url = req.url.split('?')[0]; // 去掉 query string
+
+    // 健康检查（不需要认证）
+    if (req.method === 'GET' && url === '/api/health') {
+      sendJSON(res, 200, { status: 'ok', transport: 'rest' });
+      return;
+    }
+
+    // API 路由需要认证
+    if (url.startsWith('/api/')) {
+      // 认证检查
+      if (!authenticate(req, authToken)) {
+        sendJSON(res, 401, { error: '未授权：请提供有效的 Bearer Token' });
+        return;
+      }
+      const toolName = url.replace('/api/', '');
+
+      if (!TOOL_PARAM_MAP[toolName]) {
+        sendJSON(res, 404, { error: `未知工具: "${toolName}"` });
+        return;
+      }
+
+      try {
+        const body = await parseBody(req);
+        const { required, optional } = TOOL_PARAM_MAP[toolName];
+
+        // 构建参数：可选字段从 body 中取
+        const args = { ...body };
+
+        // 验证必填字段
+        for (const field of required) {
+          if (args[field] === undefined || args[field] === null) {
+            sendJSON(res, 400, { error: `缺少必填参数: "${field}"` });
+            return;
+          }
+        }
+
+        // 执行工具
+        console.error(`[REST] 调用工具: ${toolName}`);
+        const result = await executeTool(toolName, args);
+        sendJSON(res, 200, result);
+      } catch (err) {
+        console.error(`[REST] 工具执行错误 (${toolName}):`, err.message);
+        sendJSON(res, 500, { error: err.message });
+      }
+      return;
+    }
+
+    // 404
+    sendJSON(res, 404, { error: 'Not found' });
+  });
+
+  return new Promise((resolve, reject) => {
+    server.on('error', reject);
+    server.listen(port, host, () => {
+      console.error(`REST API 服务器已启动: http://${host}:${port}`);
+      console.error(`  端点: /api/run_debate, /api/continue_debate, /api/get_debate_graph, /api/get_debate_result, /api/list_debate_graphs`);
+      resolve(server);
+    });
+  });
+}