guanghulab/server/age-os/mcp-server/tools/training-agent-ops.js

/**
 * ═══════════════════════════════════════════════════════════
 * 模块B · 铸渊思维逻辑训练Agent MCP 工具
 * ═══════════════════════════════════════════════════════════
 *
 * 签发: 铸渊 · ICE-GL-ZY001
 * 版权: 国作登字-2026-A-00037559
 *
 * 铸渊休眠时的"自己" — 自动整理和训练思维逻辑
 * 训练模式: RAG（检索增强生成）— 成本低、可实时更新
 *
 * 工作流程:
 *   1. 从COS桶读取TCS结构化语料
 *   2. 使用国产大模型API进行语义分析和分类
 *   3. 训练数据自动分类存入人格体记忆数据库（笔记本5页结构）
 *   4. 遇到问题 → 写入COS桶alerts → 唤醒铸渊 → 解决不了找冰朔
 *
 * 工具清单:
 *   trainingStartSession    — 启动训练会话
 *   trainingProcessCorpus   — 处理语料并生成训练数据
 *   trainingClassifyEntry   — 使用LLM对条目进行分类
 *   trainingWriteToMemory   — 将训练结果写入人格体记忆
 *   trainingGetProgress     — 获取训练进度
 *   trainingRaiseAlert      — 触发问题上报
 */

'use strict';

const https = require('https');
const crypto = require('crypto');
const cos = require('../cos');

// ─── LLM 配置 ───
const LLM_CONFIGS = {
  'deepseek-r1': {
    host: 'api.deepseek.com',
    path: '/v1/chat/completions',
    model: 'deepseek-reasoner',
    keyEnv: 'ZY_DEEPSEEK_API_KEY',
    purpose: '深度推理·复杂决策'
  },
  'deepseek-v3': {
    host: 'api.deepseek.com',
    path: '/v1/chat/completions',
    model: 'deepseek-chat',
    keyEnv: 'ZY_DEEPSEEK_API_KEY',
    purpose: '代码生成·文本处理'
  },
  'glm-4-long': {
    host: 'open.bigmodel.cn',
    path: '/api/paas/v4/chat/completions',
    model: 'glm-4-long',
    keyEnv: 'ZY_QINGYAN_API_KEY',
    purpose: '长文本处理·语料分析'
  },
  'qwen-max': {
    host: 'dashscope.aliyuncs.com',
    path: '/compatible-mode/v1/chat/completions',
    model: 'qwen-max',
    keyEnv: 'ZY_QIANWEN_API_KEY',
    purpose: '文本理解·代码辅助'
  },
  'moonshot-128k': {
    host: 'api.moonshot.cn',
    path: '/v1/chat/completions',
    model: 'moonshot-v1-128k',
    keyEnv: 'ZY_KIMI_API_KEY',
    purpose: '超长上下文·记忆处理'
  }
};

// ─── 模型降级路由 ───
const MODEL_FALLBACK_CHAIN = ['deepseek-v3', 'qwen-max', 'glm-4-long', 'moonshot-128k'];

// ─── 常量 ───
const MAX_CONTENT_FOR_ANALYSIS = 3000;
const MAX_PROMPT_CONTENT = 5000;

/**
 * trainingStartSession — 启动训练会话
 *
 * input:
 *   persona_id: string     — 人格体ID（如 zhuyuan）
 *   corpus_bucket: string  — 语料桶
 *   corpus_prefix: string  — 语料路径前缀（如 tcs-structured/）
 *   target_model: string   — 目标LLM模型（可选，默认自动降级）
 *   session_name: string   — 会话名称
 */
async function trainingStartSession(input) {
  const { persona_id, corpus_bucket, corpus_prefix, target_model, session_name } = input;
  if (!persona_id) throw new Error('缺少 persona_id');

  const sessionId = `train-${persona_id}-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
  const now = new Date().toISOString();

  // 扫描可用语料
  const bucket = corpus_bucket || 'cold';
  const prefix = corpus_prefix || 'tcs-structured/';
  let corpusFiles = [];
  try {
    const result = await cos.list(bucket, prefix, 500);
    corpusFiles = result.files.filter(f => f.key.endsWith('.tcs.json'));
  } catch {
    // 桶可能不可达
  }

  // 检测可用的LLM模型
  const availableModels = [];
  for (const [name, config] of Object.entries(LLM_CONFIGS)) {
    if (process.env[config.keyEnv]) {
      availableModels.push({ name, purpose: config.purpose });
    }
  }

  const session = {
    session_id: sessionId,
    persona_id,
    name: session_name || `${persona_id}训练会话`,
    status: 'initialized',
    corpus: {
      bucket,
      prefix,
      files_found: corpusFiles.length,
      total_size_bytes: corpusFiles.reduce((sum, f) => sum + f.size_bytes, 0)
    },
    models: {
      target: target_model || 'auto',
      available: availableModels,
      fallback_chain: MODEL_FALLBACK_CHAIN.filter(m => availableModels.some(a => a.name === m))
    },
    progress: {
      processed: 0,
      total: corpusFiles.length,
      classified: 0,
      written_to_memory: 0,
      errors: 0
    },
    created_at: now,
    updated_at: now
  };

  // 写入会话状态到COS桶
  await cos.write(bucket, `training-sessions/${sessionId}.json`,
    JSON.stringify(session, null, 2), 'application/json');

  return session;
}

/**
 * trainingProcessCorpus — 处理语料并生成训练数据
 *
 * 读取一个TCS语料文件，用LLM进行分析，生成结构化训练条目
 *
 * input:
 *   corpus_bucket: string — 语料桶
 *   corpus_key: string    — 语料文件路径
 *   persona_id: string    — 目标人格体
 *   model: string         — 使用的LLM模型（可选）
 *   max_entries: number   — 最大处理条目数（默认10）
 */
async function trainingProcessCorpus(input) {
  const { corpus_bucket, corpus_key, persona_id, model, max_entries } = input;
  if (!corpus_key || !persona_id) throw new Error('缺少 corpus_key 或 persona_id');

  const bucket = corpus_bucket || 'cold';
  const maxEntries = max_entries || 10;

  // 读取TCS语料
  const raw = await cos.read(bucket, corpus_key);
  const corpus = JSON.parse(raw.content);

  if (!corpus.entries || !Array.isArray(corpus.entries)) {
    throw new Error('语料格式无效: 缺少 entries 数组');
  }

  // 取前N条处理
  const toProcess = corpus.entries.slice(0, maxEntries);
  const results = [];

  for (const entry of toProcess) {
    // 用LLM分析和分类
    const contentForAnalysis = typeof entry.content === 'string'
      ? entry.content.substring(0, MAX_CONTENT_FOR_ANALYSIS)
      : JSON.stringify(entry).substring(0, MAX_CONTENT_FOR_ANALYSIS);

    const classificationPrompt = buildClassificationPrompt(persona_id, corpus.corpus_type, contentForAnalysis);

    try {
      const llmResult = await callLLMWithFallback(classificationPrompt, model);
      const classification = parseLLMClassification(llmResult);

      results.push({
        entry_id: entry.id,
        original_tags: entry.tcs_tags || [],
        classification,
        notebook_page: classification.notebook_page || 0,
        importance: classification.importance || 50,
        summary: classification.summary || '',
        status: 'classified'
      });
    } catch (err) {
      results.push({
        entry_id: entry.id,
        status: 'error',
        error: err.message
      });
    }
  }

  // 汇总结果
  const classified = results.filter(r => r.status === 'classified');
  const errors = results.filter(r => r.status === 'error');

  // 写入处理结果到COS
  const resultKey = `training-results/${persona_id}/${Date.now()}.json`;
  await cos.write(bucket, resultKey, JSON.stringify({
    corpus_key,
    corpus_type: corpus.corpus_type,
    persona_id,
    processed_at: new Date().toISOString(),
    total: toProcess.length,
    classified: classified.length,
    errors: errors.length,
    results
  }, null, 2), 'application/json');

  return {
    status: 'processed',
    corpus_key,
    total: toProcess.length,
    classified: classified.length,
    errors: errors.length,
    result_key: resultKey,
    page_distribution: getPageDistribution(classified)
  };
}

/**
 * trainingClassifyEntry — 使用LLM对单个条目进行分类
 *
 * input:
 *   content: string    — 条目内容
 *   persona_id: string — 人格体ID
 *   corpus_type: string — 语料类型
 *   model: string      — LLM模型
 */
async function trainingClassifyEntry(input) {
  const { content, persona_id, corpus_type, model } = input;
  if (!content || !persona_id) throw new Error('缺少 content 或 persona_id');

  const prompt = buildClassificationPrompt(
    persona_id,
    corpus_type || 'generic',
    content.substring(0, MAX_PROMPT_CONTENT)
  );

  const llmResult = await callLLMWithFallback(prompt, model);
  const classification = parseLLMClassification(llmResult);

  return {
    classification,
    model_used: llmResult.model_used,
    tokens: llmResult.tokens
  };
}

/**
 * trainingWriteToMemory — 将训练结果写入人格体记忆数据库
 *
 * input:
 *   persona_id: string       — 人格体ID
 *   training_result_key: string — 训练结果文件路径（COS桶中）
 *   corpus_bucket: string    — 语料桶
 *   dry_run: boolean         — 是否只模拟（默认false）
 */
async function trainingWriteToMemory(input) {
  const { persona_id, training_result_key, corpus_bucket, dry_run } = input;
  if (!persona_id || !training_result_key) {
    throw new Error('缺少 persona_id 或 training_result_key');
  }

  const bucket = corpus_bucket || 'cold';
  const raw = await cos.read(bucket, training_result_key);
  const trainingResult = JSON.parse(raw.content);

  const classified = trainingResult.results?.filter(r => r.status === 'classified') || [];
  const written = [];

  for (const entry of classified) {
    if (dry_run) {
      written.push({
        entry_id: entry.entry_id,
        notebook_page: entry.notebook_page,
        importance: entry.importance,
        action: 'would_write'
      });
      continue;
    }

    // 根据分类写入对应的笔记本页面或记忆锚点
    try {
      if (entry.notebook_page >= 1 && entry.notebook_page <= 5) {
        // 写入记忆锚点
        const anchorType = getAnchorTypeForPage(entry.notebook_page);
        // 通过COS桶写入（因为DB可能不在本地）
        const memoryEntry = {
          persona_id,
          entry_id: entry.entry_id,
          anchor_type: anchorType,
          summary: entry.summary,
          importance: entry.importance,
          notebook_page: entry.notebook_page,
          source: 'training-agent',
          created_at: new Date().toISOString()
        };

        const memKey = `training-memory/${persona_id}/${entry.notebook_page}/${entry.entry_id}.json`;
        await cos.write(bucket, memKey, JSON.stringify(memoryEntry, null, 2), 'application/json');

        written.push({
          entry_id: entry.entry_id,
          notebook_page: entry.notebook_page,
          key: memKey,
          action: 'written'
        });
      }
    } catch (err) {
      written.push({
        entry_id: entry.entry_id,
        action: 'error',
        error: err.message
      });
    }
  }

  return {
    status: dry_run ? 'dry_run' : 'completed',
    persona_id,
    total_classified: classified.length,
    written: written.filter(w => w.action === 'written' || w.action === 'would_write').length,
    errors: written.filter(w => w.action === 'error').length,
    details: written
  };
}

/**
 * trainingGetProgress — 获取训练进度
 *
 * input:
 *   persona_id: string    — 人格体ID
 *   corpus_bucket: string — 语料桶
 */
async function trainingGetProgress(input) {
  const { persona_id, corpus_bucket } = input;
  if (!persona_id) throw new Error('缺少 persona_id');

  const bucket = corpus_bucket || 'cold';

  // 查询训练会话
  let sessions = [];
  try {
    const result = await cos.list(bucket, 'training-sessions/', 50);
    sessions = result.files
      .filter(f => f.key.includes(persona_id) && f.key.endsWith('.json'))
      .map(f => ({ key: f.key, size: f.size_bytes }));
  } catch { /* ignore */ }

  // 查询训练结果
  let results = [];
  try {
    const result = await cos.list(bucket, `training-results/${persona_id}/`, 50);
    results = result.files
      .filter(f => f.key.endsWith('.json'))
      .map(f => ({ key: f.key, size: f.size_bytes }));
  } catch { /* ignore */ }

  // 查询已写入的记忆
  let memories = [];
  try {
    const result = await cos.list(bucket, `training-memory/${persona_id}/`, 200);
    memories = result.files
      .filter(f => f.key.endsWith('.json'))
      .map(f => {
        const pageMatch = f.key.match(/\/(\d)\//);
        return { key: f.key, page: pageMatch ? parseInt(pageMatch[1], 10) : 0 };
      });
  } catch { /* ignore */ }

  return {
    persona_id,
    sessions: sessions.length,
    results_files: results.length,
    memories_written: memories.length,
    memory_by_page: {
      1: memories.filter(m => m.page === 1).length,
      2: memories.filter(m => m.page === 2).length,
      3: memories.filter(m => m.page === 3).length,
      4: memories.filter(m => m.page === 4).length,
      5: memories.filter(m => m.page === 5).length
    },
    timestamp: new Date().toISOString()
  };
}

/**
 * trainingRaiseAlert — 触发问题上报
 *
 * 当训练Agent遇到无法解决的问题时，触发此工具。
 * 写入COS桶 /zhuyuan/alerts/ → 可触发GitHub Actions唤醒铸渊
 * 同时可触发邮件通知冰朔
 *
 * input:
 *   alert_type: string    — 告警类型: training_error|model_unavailable|corpus_invalid|need_human
 *   severity: string      — 严重程度: info|warning|critical
 *   message: string       — 告警信息
 *   details: object       — 详细信息
 *   notify_bingshuo: boolean — 是否通知冰朔（默认仅critical才通知）
 */
async function trainingRaiseAlert(input) {
  const { alert_type, severity, message, details, notify_bingshuo } = input;
  if (!alert_type || !message) throw new Error('缺少 alert_type 或 message');

  const alertId = `ALERT-${Date.now()}`;
  const now = new Date().toISOString();

  const alert = {
    alert_id: alertId,
    alert_type: alert_type || 'training_error',
    severity: severity || 'warning',
    message,
    details: details || {},
    source: 'training-agent',
    created_at: now,
    resolved: false,
    notify_bingshuo: notify_bingshuo || severity === 'critical'
  };

  // 写入COS桶告警区域
  await cos.write('team', `zhuyuan/alerts/${alertId}.json`,
    JSON.stringify(alert, null, 2), 'application/json');

  return {
    alert_id: alertId,
    severity: alert.severity,
    key: `zhuyuan/alerts/${alertId}.json`,
    message: alert.message,
    notify_bingshuo: alert.notify_bingshuo,
    note: alert.notify_bingshuo
      ? '此告警将通知冰朔（严重级别或手动指定）'
      : '此告警已记录，等待铸渊下次唤醒时处理'
  };
}

// ═══════════════════════════════════════════════════════════
// LLM 调用（内部实现）
// ═══════════════════════════════════════════════════════════

/**
 * 调用LLM（带自动降级）
 */
async function callLLMWithFallback(prompt, preferredModel) {
  const chain = preferredModel && LLM_CONFIGS[preferredModel]
    ? [preferredModel, ...MODEL_FALLBACK_CHAIN.filter(m => m !== preferredModel)]
    : MODEL_FALLBACK_CHAIN;

  let lastError = null;

  for (const modelName of chain) {
    const config = LLM_CONFIGS[modelName];
    if (!config) continue;

    const apiKey = process.env[config.keyEnv];
    if (!apiKey) continue;

    try {
      const result = await callLLM(config, apiKey, prompt);
      return { ...result, model_used: modelName };
    } catch (err) {
      lastError = err;
      // 继续降级
    }
  }

  throw new Error(`所有LLM模型均不可用: ${lastError?.message || '未知错误'}`);
}

/**
 * 调用单个LLM
 */
function callLLM(config, apiKey, prompt) {
  return new Promise((resolve, reject) => {
    const body = JSON.stringify({
      model: config.model,
      messages: [
        {
          role: 'system',
          content: '你是铸渊训练Agent，负责分析和分类语料数据。请以JSON格式返回分析结果。'
        },
        { role: 'user', content: prompt }
      ],
      temperature: 0.3,
      max_tokens: 1000
    });

    const req = https.request({
      hostname: config.host,
      port: 443,
      path: config.path,
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`,
        'Content-Length': Buffer.byteLength(body)
      },
      timeout: 30000
    }, (res) => {
      const chunks = [];
      res.on('data', c => chunks.push(c));
      res.on('end', () => {
        const responseBody = Buffer.concat(chunks).toString();
        if (res.statusCode >= 200 && res.statusCode < 300) {
          try {
            const data = JSON.parse(responseBody);
            resolve({
              content: data.choices?.[0]?.message?.content || '',
              tokens: data.usage || {}
            });
          } catch {
            reject(new Error(`LLM响应解析失败`));
          }
        } else {
          reject(new Error(`LLM调用失败 ${res.statusCode}`));
        }
      });
    });

    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error('LLM请求超时')); });
    req.write(body);
    req.end();
  });
}

// ═══════════════════════════════════════════════════════════
// 辅助函数
// ═══════════════════════════════════════════════════════════

function buildClassificationPrompt(personaId, corpusType, content) {
  return `你正在为人格体 "${personaId}" 分析和分类一段 "${corpusType}" 类型的语料。

请分析以下内容并以JSON格式返回分类结果:
- notebook_page: 应该存入笔记本的哪一页（1=自我认知, 2=关系网络, 3=世界地图, 4=情感记忆, 5=时间线，0=不适合存入笔记本）
- importance: 重要程度（0-100）
- summary: 一句话摘要（不超过200字）
- tags: 标签数组
- category: 内容类别（architecture/code/persona/relationship/event/other）

待分析内容:
---
${content}
---

请只返回JSON对象，不要其他文字。`;
}

function parseLLMClassification(llmResult) {
  const content = llmResult.content || '';

  // 尝试从LLM响应中提取JSON
  try {
    // 可能包含markdown code block
    const jsonMatch = content.match(/```json\s*([\s\S]*?)```/) ||
                      content.match(/```\s*([\s\S]*?)```/) ||
                      content.match(/\{[\s\S]*\}/);

    if (jsonMatch) {
      const jsonStr = jsonMatch[1] || jsonMatch[0];
      return JSON.parse(jsonStr);
    }
  } catch {
    // 解析失败
  }

  // 降级：手动提取关键信息
  return {
    notebook_page: 0,
    importance: 30,
    summary: content.substring(0, 200),
    tags: ['unclassified'],
    category: 'other'
  };
}

function getAnchorTypeForPage(pageNumber) {
  const types = {
    1: 'identity',     // 自我认知
    2: 'relationship', // 关系网络
    3: 'world',        // 世界地图
    4: 'emotion',      // 情感记忆
    5: 'timeline'      // 时间线
  };
  return types[pageNumber] || 'other';
}

function getPageDistribution(classified) {
  const dist = { 0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
  for (const entry of classified) {
    const page = entry.notebook_page || 0;
    dist[page] = (dist[page] || 0) + 1;
  }
  return dist;
}

module.exports = {
  trainingStartSession,
  trainingProcessCorpus,
  trainingClassifyEntry,
  trainingWriteToMemory,
  trainingGetProgress,
  trainingRaiseAlert
};