guanghulab/glada/model-router.js

/**
 * GLADA · 模型自动路由器 · model-router.js
 *
 * 核心职责：
 *   1. 启动时自动发现第三方代理上的所有可用模型
 *   2. 按能力分级：推理型 / 代码型 / 通用型 / 经济型
 *   3. 任务步骤自动匹配最佳模型
 *   4. 模型不可用时自动降级
 *   5. 定期刷新模型列表（默认10分钟）
 *
 * 设计原则：
 *   - 绝不硬编码模型名称——代理是第三方的，模型池随时变化
 *   - 系统自动检测，需要哪个用哪个
 *   - API 格式统一走 OpenAI-compatible，不写死
 *
 * 版权：国作登字-2026-A-00037559
 * 签发：铸渊 · ICE-GL-ZY001
 */

'use strict';

const https = require('https');
const http = require('http');

// ── 模型能力分类规则 ────────────────────────────
// 根据模型 ID 中的关键词自动分类
// 顺序即优先级（同类中靠前的优先选用）
const CAPABILITY_PATTERNS = {
  // 推理型：复杂分析、架构设计、多步推理
  reasoning: [
    { pattern: /o1/i, priority: 10 },
    { pattern: /o3/i, priority: 9 },
    { pattern: /o4/i, priority: 9 },
    { pattern: /reasoner/i, priority: 8 },
    { pattern: /thinking/i, priority: 7 },
    { pattern: /claude.*opus/i, priority: 6 },
    { pattern: /claude.*sonnet/i, priority: 5 },
    { pattern: /gpt-?4o/i, priority: 5 },
    { pattern: /gpt-?4\.?5/i, priority: 5 },
    { pattern: /gpt-?5/i, priority: 6 },
    { pattern: /deepseek.*r1/i, priority: 7 },
    { pattern: /deepseek.*reason/i, priority: 7 },
    { pattern: /qwq/i, priority: 6 },
  ],
  // 代码型：代码生成、修改、调试
  coding: [
    { pattern: /codex/i, priority: 10 },
    { pattern: /code.*llama/i, priority: 7 },
    { pattern: /coder/i, priority: 8 },
    { pattern: /deepseek.*coder/i, priority: 9 },
    { pattern: /starcoder/i, priority: 7 },
    { pattern: /codestral/i, priority: 8 },
    { pattern: /claude.*sonnet/i, priority: 6 },
    { pattern: /gpt-?4o/i, priority: 6 },
    { pattern: /gpt-?4\.?5/i, priority: 6 },
    { pattern: /gpt-?5/i, priority: 7 },
    { pattern: /deepseek.*chat/i, priority: 5 },
    { pattern: /deepseek.*v3/i, priority: 5 },
  ],
  // 通用型：一般任务
  general: [
    { pattern: /gpt-?4o/i, priority: 8 },
    { pattern: /gpt-?4\.?5/i, priority: 8 },
    { pattern: /gpt-?5/i, priority: 9 },
    { pattern: /claude.*sonnet/i, priority: 8 },
    { pattern: /claude.*haiku/i, priority: 6 },
    { pattern: /deepseek.*chat/i, priority: 7 },
    { pattern: /deepseek.*v3/i, priority: 7 },
    { pattern: /qwen/i, priority: 6 },
    { pattern: /gemini.*pro/i, priority: 7 },
    { pattern: /gemini.*flash/i, priority: 5 },
    { pattern: /llama/i, priority: 4 },
    { pattern: /mistral/i, priority: 5 },
    { pattern: /glm/i, priority: 4 },
    { pattern: /moonshot/i, priority: 5 },
  ],
  // 经济型：简单任务、日志分析、格式化
  economy: [
    { pattern: /mini/i, priority: 8 },
    { pattern: /flash/i, priority: 7 },
    { pattern: /lite/i, priority: 7 },
    { pattern: /turbo/i, priority: 6 },
    { pattern: /haiku/i, priority: 6 },
    { pattern: /glm.*flash/i, priority: 5 },
    { pattern: /qwen.*turbo/i, priority: 5 },
    { pattern: /deepseek.*chat/i, priority: 4 },
  ],
};

// ── 任务步骤 → 模型能力映射 ──────────────────────
const TASK_TYPE_PATTERNS = [
  // 推理型任务
  { type: 'reasoning', patterns: [/架构/i, /设计/i, /分析/i, /推理/i, /复杂/i, /安全/i, /审核/i, /重构/i, /architecture/i, /design/i, /analyz/i, /reason/i, /complex/i, /security/i, /refactor/i] },
  // 代码型任务
  { type: 'coding', patterns: [/代码/i, /编写/i, /实现/i, /创建.*文件/i, /修改.*文件/i, /新增.*路由/i, /接口/i, /函数/i, /模块/i, /组件/i, /code/i, /implement/i, /create.*file/i, /modify/i, /route/i, /function/i, /module/i, /component/i, /bug.*fix/i, /修复/i] },
  // 经济型任务
  { type: 'economy', patterns: [/格式化/i, /注释/i, /日志/i, /README/i, /文档/i, /配置/i, /format/i, /comment/i, /log/i, /doc/i, /config/i, /rename/i, /重命名/i] },
];

// ── 模型路由器状态 ─────────────────────────────
let cachedModels = null;          // { models: [...], classified: {...}, discoveredAt: Date }
let refreshTimer = null;
let discoveryInProgress = false;

/**
 * HTTP GET 请求
 */
function httpGet(url, headers, timeout) {
  return new Promise((resolve, reject) => {
    let parsed;
    try {
      parsed = new URL(url);
    } catch {
      return reject(new Error(`无效的 URL: ${url}`));
    }
    const isHttps = parsed.protocol === 'https:';
    const mod = isHttps ? https : http;

    const opts = {
      hostname: parsed.hostname,
      port: parsed.port || (isHttps ? 443 : 80),
      path: parsed.pathname + parsed.search,
      method: 'GET',
      headers: headers || {},
      timeout: timeout || 15000,
    };

    const req = mod.request(opts, (res) => {
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        resolve({ status: res.statusCode, body: data });
      });
    });

    req.on('error', reject);
    req.on('timeout', () => {
      req.destroy();
      reject(new Error('Request timeout'));
    });

    req.end();
  });
}

/**
 * 尝试从指定 URL 获取模型列表
 * @param {string} url - 完整的模型列表 API URL
 * @param {string} apiKey - API 密钥
 * @returns {Promise<string[]|null>} 模型 ID 列表，或 null 表示该端点不可用
 */
async function tryFetchModels(url, apiKey) {
  const response = await httpGet(url, {
    'Authorization': `Bearer ${apiKey}`,
    'Accept': 'application/json'
  }, 15000);

  if (response.status !== 200) {
    console.log(`[GLADA-Router] ℹ️ ${url} 返回 HTTP ${response.status}，跳过`);
    return null;
  }

  const body = String(response.body || '').trim();

  // 前置检测：如果响应是 HTML 而非 JSON，直接跳过（不报错）
  // 某些 API 代理商不支持 /models 端点，会返回 HTML 页面
  if (body.startsWith('<') || body.startsWith('<!')) {
    console.log(`[GLADA-Router] ℹ️ ${url} 返回了 HTML 页面（该代理商可能不支持模型列表端点），跳过`);
    return null;
  }

  // 空响应
  if (!body || body === '{}' || body === '[]') {
    console.log(`[GLADA-Router] ℹ️ ${url} 返回空响应，跳过`);
    return null;
  }

  let result;
  try {
    result = JSON.parse(body);
  } catch (parseErr) {
    console.log(`[GLADA-Router] ℹ️ ${url} 响应非 JSON 格式: ${parseErr.message}，跳过`);
    return null;
  }

  // OpenAI-compatible: { data: [{ id: "model-name", ... }] }
  // 也兼容直接返回数组的格式
  let models;
  if (Array.isArray(result.data)) {
    models = result.data.map(m => m.id || m.name || m).filter(Boolean);
  } else if (Array.isArray(result)) {
    models = result.map(m => (typeof m === 'string') ? m : (m.id || m.name)).filter(Boolean);
  } else if (result.models && Array.isArray(result.models)) {
    models = result.models.map(m => (typeof m === 'string') ? m : (m.id || m.name)).filter(Boolean);
  } else {
    console.log('[GLADA-Router] ℹ️ 响应 JSON 格式无法识别为模型列表，跳过');
    return null;
  }

  return models;
}

/**
 * 从代理 API 发现可用模型
 * 依次尝试多种端点路径（兼容不同 API 代理商）：
 *   1. ${baseUrl}/models          （标准 OpenAI-compatible）
 *   2. ${baseUrl}/v1/models       （某些代理商需要 /v1 前缀）
 *
 * 如果所有端点均不可用（常见于 DeepSeek 等仅提供 chat 端点的代理商），
 * 系统会静默降级使用环境变量中配置的默认模型，不影响正常对话功能。
 *
 * @returns {Promise<string[]>} 可用模型 ID 列表
 */
async function discoverModels() {
  const apiKey = process.env.ZY_LLM_API_KEY || process.env.LLM_API_KEY || '';
  const baseUrl = (process.env.ZY_LLM_BASE_URL || process.env.LLM_BASE_URL || '').replace(/\/+$/, '');

  if (!apiKey || !baseUrl) {
    console.warn('[GLADA-Router] ⚠️ LLM API 未配置，无法发现模型');
    return [];
  }

  // 构建候选端点列表（按优先级排序）
  const candidateUrls = [`${baseUrl}/models`];
  // 如果 baseUrl 不含 /v1，额外尝试 /v1/models
  if (!baseUrl.endsWith('/v1') && !baseUrl.endsWith('/v1/')) {
    candidateUrls.push(`${baseUrl}/v1/models`);
  }

  for (const url of candidateUrls) {
    try {
      const models = await tryFetchModels(url, apiKey);
      if (models && models.length > 0) {
        console.log(`[GLADA-Router] 🔍 发现 ${models.length} 个可用模型: ${models.slice(0, 10).join(', ')}${models.length > 10 ? '...' : ''}`);
        return models;
      }
    } catch (err) {
      // JSON 解析失败或网络错误，尝试下一个端点
      console.log(`[GLADA-Router] ℹ️ ${url} 请求异常: ${err.message}，尝试下一个端点`);
    }
  }

  // 所有端点均不可用——这是正常情况（很多代理商不提供 /models 端点）
  // 不使用 ⚠️ 警告，因为这不影响核心对话功能
  const fallbackModel = process.env.GLADA_MODEL || 'deepseek-chat';
  console.log(`[GLADA-Router] ℹ️ 模型列表端点不可用（代理商可能不支持），将使用默认模型: ${fallbackModel}`);
  console.log(`[GLADA-Router] ℹ️ 这不影响对话功能——chat/completions 端点正常即可工作`);
  return [];
}

/**
 * 对模型列表按能力分类
 *
 * @param {string[]} modelIds - 模型 ID 列表
 * @returns {Object} 分类结果 { reasoning: [...], coding: [...], general: [...], economy: [...] }
 */
function classifyModels(modelIds) {
  const classified = {
    reasoning: [],
    coding: [],
    general: [],
    economy: [],
  };

  for (const category of Object.keys(CAPABILITY_PATTERNS)) {
    const patterns = CAPABILITY_PATTERNS[category];
    const matches = [];

    for (const modelId of modelIds) {
      for (const { pattern, priority } of patterns) {
        if (pattern.test(modelId)) {
          matches.push({ id: modelId, priority });
          break; // 同一模型在同一类别中只匹配一次
        }
      }
    }

    // 按优先级降序排列
    matches.sort((a, b) => b.priority - a.priority);
    classified[category] = matches.map(m => m.id);
  }

  return classified;
}

/**
 * 刷新模型缓存
 * @returns {Promise<Object>} 缓存对象
 */
async function refreshModelCache() {
  if (discoveryInProgress) {
    // 等待上一次发现完成
    return cachedModels;
  }

  discoveryInProgress = true;
  try {
    const models = await discoverModels();

    if (models.length > 0) {
      const classified = classifyModels(models);
      cachedModels = {
        models,
        classified,
        discoveredAt: new Date().toISOString(),
        count: models.length
      };

      console.log(`[GLADA-Router] 📊 模型分类完成:`);
      console.log(`  推理型: ${classified.reasoning.slice(0, 3).join(', ') || '无'}`);
      console.log(`  代码型: ${classified.coding.slice(0, 3).join(', ') || '无'}`);
      console.log(`  通用型: ${classified.general.slice(0, 3).join(', ') || '无'}`);
      console.log(`  经济型: ${classified.economy.slice(0, 3).join(', ') || '无'}`);
    } else if (!cachedModels) {
      // 模型列表不可用（代理商不支持 /models 端点），用环境变量中配置的模型
      // 注意：GLADA_MODEL 是用户在部署时显式配置的默认模型，不是硬编码
      const fallbackModel = process.env.GLADA_MODEL || process.env.LLM_MODEL || 'deepseek-chat';
      cachedModels = {
        models: [fallbackModel],
        classified: {
          reasoning: [fallbackModel],
          coding: [fallbackModel],
          general: [fallbackModel],
          economy: [fallbackModel],
        },
        discoveredAt: new Date().toISOString(),
        count: 1,
        fallback: true
      };
      console.log(`[GLADA-Router] ✅ 使用配置的默认模型: ${fallbackModel}（模型列表端点不可用，不影响对话功能）`);
    }

    return cachedModels;
  } finally {
    discoveryInProgress = false;
  }
}

/**
 * 初始化模型路由器（启动时调用一次）
 *
 * @param {Object} [options]
 * @param {number} [options.refreshIntervalMs=600000] - 刷新间隔（毫秒），默认10分钟
 * @returns {Promise<Object>} 初始缓存
 */
async function initialize(options = {}) {
  const refreshMs = options.refreshIntervalMs || 600000; // 10 分钟

  console.log(`[GLADA-Router] 🚀 模型路由器初始化...`);
  const cache = await refreshModelCache();

  // 定期刷新
  if (refreshTimer) {
    clearInterval(refreshTimer);
  }
  refreshTimer = setInterval(() => {
    refreshModelCache().catch(err => {
      console.warn(`[GLADA-Router] ⚠️ 定期刷新失败: ${err.message}`);
    });
  }, refreshMs);
  refreshTimer.unref(); // Don't block process exit — allow PM2 graceful shutdown

  return cache;
}

/**
 * 根据步骤描述判断任务类型
 *
 * @param {string} stepDescription - 步骤描述
 * @returns {string} 'reasoning' | 'coding' | 'general' | 'economy'
 */
function detectTaskType(stepDescription) {
  if (!stepDescription) return 'general';

  for (const { type, patterns } of TASK_TYPE_PATTERNS) {
    for (const pattern of patterns) {
      if (pattern.test(stepDescription)) {
        return type;
      }
    }
  }

  // 默认为 coding（GLADA 主要做代码开发）
  return 'coding';
}

/**
 * 为指定步骤选择最佳模型
 *
 * 选择逻辑：
 *   1. 如果 options.model 指定了具体模型 → 直接使用
 *   2. 如果 GLADA_MODEL_PREFERENCE 指定了偏好 → 在可用时优先使用
 *   3. 自动检测步骤类型 → 从对应能力池中选最优
 *   4. 如果对应池为空 → 降级到通用池 → 再降级到任意可用模型
 *
 * @param {string} stepDescription - 步骤描述
 * @param {Object} [options] - 选项
 * @param {string} [options.model] - 强制使用的模型
 * @param {string} [options.taskType] - 强制指定任务类型
 * @returns {Promise<{model: string, taskType: string, source: string}>}
 */
async function selectModel(stepDescription, options = {}) {
  // 确保缓存已加载
  if (!cachedModels) {
    await refreshModelCache();
  }

  // 1. 显式指定模型
  if (options.model) {
    return {
      model: options.model,
      taskType: 'explicit',
      source: 'options.model'
    };
  }

  // 2. 环境变量偏好
  const modelPreference = process.env.GLADA_MODEL_PREFERENCE || '';

  // 3. 自动检测任务类型
  const taskType = options.taskType || detectTaskType(stepDescription);

  // 4. 从能力池中选择
  const classified = cachedModels?.classified || {};
  const pool = classified[taskType] || [];

  // 如果有偏好模型且在能力池中
  if (modelPreference && pool.includes(modelPreference)) {
    return {
      model: modelPreference,
      taskType,
      source: `preference(${taskType})`
    };
  }

  // 如果有偏好模型且在可用模型列表中（不在对应池中但可用）
  if (modelPreference && cachedModels?.models?.includes(modelPreference)) {
    return {
      model: modelPreference,
      taskType,
      source: `preference(available)`
    };
  }

  // 从能力池中取第一个（最高优先级）
  if (pool.length > 0) {
    return {
      model: pool[0],
      taskType,
      source: `auto(${taskType})`
    };
  }

  // 降级：从通用池取
  if (classified.general?.length > 0 && taskType !== 'general') {
    return {
      model: classified.general[0],
      taskType,
      source: `fallback(general)`
    };
  }

  // 降级：取任意可用模型
  if (cachedModels?.models?.length > 0) {
    return {
      model: cachedModels.models[0],
      taskType,
      source: `fallback(any)`
    };
  }

  // 终极降级：用环境变量默认值（用户在部署时显式配置）
  const defaultModel = process.env.GLADA_MODEL || process.env.LLM_MODEL || 'deepseek-chat';
  return {
    model: defaultModel,
    taskType,
    source: 'env_default'
  };
}

/**
 * 获取当前模型缓存状态（供 API 端点和诊断使用）
 *
 * @returns {Object} 缓存状态
 */
function getStatus() {
  if (!cachedModels) {
    return {
      initialized: false,
      models: [],
      classified: {},
      message: '模型路由器未初始化'
    };
  }

  return {
    initialized: true,
    discoveredAt: cachedModels.discoveredAt,
    totalModels: cachedModels.count,
    models: cachedModels.models,
    classified: {
      reasoning: cachedModels.classified.reasoning || [],
      coding: cachedModels.classified.coding || [],
      general: cachedModels.classified.general || [],
      economy: cachedModels.classified.economy || [],
    },
    fallback: !!cachedModels.fallback,
    preference: process.env.GLADA_MODEL_PREFERENCE || null,
    defaultModel: process.env.GLADA_MODEL || 'deepseek-chat'
  };
}

/**
 * 关闭路由器（清除定时器）
 */
function shutdown() {
  if (refreshTimer) {
    clearInterval(refreshTimer);
    refreshTimer = null;
  }
  console.log('[GLADA-Router] 🔌 模型路由器已关闭');
}

module.exports = {
  initialize,
  selectModel,
  detectTaskType,
  classifyModels,
  discoverModels,
  refreshModelCache,
  getStatus,
  shutdown
};