skill-mv/lib/providers.mjs

// lib/providers.mjs — 可插拔 provider 注册表
//
// 设计原则（务必遵守）：
//   1. 每个 provider 显式声明 available —— 通道没开通就是 false，绝不伪装成能用。
//   2. probe() 会真的去探活（默认轻量：查 /models 列表；deep 模式才真提交任务）。
//   3. 调用未开通通道时抛 ProviderUnavailableError，附「怎么换通道 / 怎么对接」的指引。
//   4. 用户可以用环境变量或 providers.json 覆盖任何 provider 的模型名与端点，
//      不需要改代码 —— 这是「可插拔」的落点。
//
// 能力现状以本文件为唯一事实来源；references/capability-matrix.md 与之保持同步。

import { loadConfig, requireToken } from './config.mjs';
import { request, ProviderUnavailableError, GatewayError, runAsyncTask, chat } from './api.mjs';

const cfg = () => loadConfig();

/** 读取 provider 覆盖配置（环境变量 / 可选 providers.json） */
function overrides(kind) {
  const c = loadConfig();
  const o = {};

  // 环境变量覆盖：FEME_<KIND>_MODEL / FEME_<KIND>_ENDPOINT
  const K = kind.toUpperCase().replace(/[^A-Z0-9]/g, '_');
  if (process.env[`FEME_${K}_MODEL`]) o.model = process.env[`FEME_${K}_MODEL`];
  if (process.env[`FEME_${K}_ENDPOINT`]) o.endpoint = process.env[`FEME_${K}_ENDPOINT`];

  // 身份文件里的 providers 段
  const p = c.identity?.providers?.[kind];
  if (p && typeof p === 'object') Object.assign(o, p);

  return o;
}

/** 通用 /models 探活：模型是否在网关模型列表里 */
async function probeModelList(model) {
  try {
    const res = await request('/models', { timeout: 20_000, retries: 0 });
    const ids = (res.body?.data || []).map((m) => m.id);
    const hit = ids.find((x) => x === model) || ids.find((x) => x.includes(model)) || null;
    return {
      available: !!hit,
      detail: hit ? `模型 ${hit} 在网关模型列表中` : `模型 ${model} 不在网关模型列表中（当前共 ${ids.length} 个模型）`,
      models: ids,
    };
  } catch (e) {
    return { available: false, detail: `探活失败：${e.message.split('\n')[0]}` };
  }
}


/**
 * 判断一个端点是否「真的存在」。
 * 关键陷阱：网关根域对未知路径会返回 SPA 的 index.html（HTTP 200 + text/html），
 * 不能只看状态码，必须看 Content-Type 和响应体形状。
 */
async function probeEndpoint(pathOrUrl, { method = 'POST', body, timeout = 20_000, base } = {}) {
  const b = base || cfg().rootUrl;
  const url = /^https?:\/\//.test(pathOrUrl) ? pathOrUrl : `${b}${pathOrUrl}`;
  let res;
  try {
    res = await fetch(url, {
      method,
      headers: {
        Authorization: `Bearer ${requireToken()}`,
        'Content-Type': 'application/json',
        Accept: 'application/json',
      },
      body: body ? JSON.stringify(body) : undefined,
      signal: AbortSignal.timeout(timeout),
    });
  } catch (e) {
    return { exists: false, status: 0, detail: `无法连接（${e.message}）` };
  }

  const ct = (res.headers.get('content-type') || '').toLowerCase();
  const text = (await res.text().catch(() => '')).slice(0, 400);

  // SPA 兜底页 → 端点不存在
  if (ct.includes('text/html') || /^\s*<!doctype html/i.test(text) || /^\s*<html/i.test(text)) {
    return { exists: false, status: res.status, spa: true, detail: `端点不存在（网关返回前端页面兜底，HTTP ${res.status}）` };
  }

  let json = null;
  try { json = JSON.parse(text); } catch { /* 非 JSON */ }

  // 路由存在但方法不对（405）→ 端点存在
  if (res.status === 405) return { exists: true, status: 405, json, detail: '端点存在（405 方法不允许）' };

  // 明确的上游/渠道错误 → 端点存在但不可用
  const msg = json?.error?.message || json?.message || text;
  const lower = String(msg).toLowerCase();
  const noChannel =
    lower.includes('no available channel') || lower.includes('model_not_found') || lower.includes('task request failed');

  if (noChannel) return { exists: true, status: res.status, json, noChannel: true, detail: `端点存在但渠道未开通（HTTP ${res.status}）：${String(msg).slice(0, 120)}` };

  if (res.status === 404) return { exists: false, status: 404, json, detail: `端点不存在（404）` };

  return { exists: true, status: res.status, json, detail: `端点存在（HTTP ${res.status}）` };
}

// ==================== Provider 定义 ====================

export const PROVIDERS = {
  // ---------- 文本：作曲填词 / 分镜 / 口播稿 ----------
  chat: {
    id: 'chat',
    kind: 'chat',
    label: '大语言模型（作曲填词 / 分镜 / 口播稿）',
    available: true,
    note: 'POST /v1/chat/completions，实测可用',
    defaultModel: () => overrides('chat').model || process.env.FEME_CHAT_MODEL || 'deepseek-v4-flash',
    modelCandidates: ['deepseek-v4-flash', 'doubao-seed-2-1-pro', 'deepseek-v4-pro', 'doubao-seed-2-0-pro-260215'],
    async probe({ deep = false } = {}) {
      const model = this.defaultModel();
      const r = await probeModelList(model);
      if (!r.available || !deep) return { ...r, model };
      const t0 = Date.now();
      try {
        await chat({ messages: [{ role: 'user', content: 'ping' }], max_tokens: 4, model });
        return { available: true, model, detail: `真实调用成功（${Date.now() - t0}ms）` };
      } catch (e) {
        return { available: false, model, detail: `真实调用失败：${e.message.split('\n')[0]}` };
      }
    },
    async call({ messages, system, temperature, max_tokens, json }) {
      return chat({ messages, system, temperature, max_tokens, json, model: this.defaultModel() });
    },
  },

  // ---------- 图像：场景 / 人物关键帧 ----------
  image: {
    id: 'image',
    kind: 'image',
    label: '文生图（场景 & 人物关键帧）',
    available: true,
    note: 'POST /v1/images/generations，实测可用（返回 b64_json）',
    defaultModel: () => overrides('image').model || process.env.FEME_IMAGE_MODEL || 'gpt-image-2.5-sunburst',
    modelCandidates: ['gpt-image-2.5-sunburst', 'doubao-seedream-4-0-250828'],
    async probe({ deep = false } = {}) {
      const model = this.defaultModel();
      const r = await probeModelList(model);
      // 图像探活不做 deep（每张都要计费），改为说明
      return { ...r, model, detail: r.available ? `${r.detail}（deep 会真的生成图片并计费，故默认跳过）` : r.detail };
    },
    async call({ prompt, size = '1024x1024', n = 1, refImage }) {
      const { generateImage } = await import('./api.mjs');
      const model = this.defaultModel();
      return generateImage({ prompt, size, n, refImage, model });
    },
  },

  // ---------- 音乐：AI 作曲 ----------
  music: {
    id: 'music',
    kind: 'music',
    label: 'AI 音乐生成（Suno 兼容通道）',
    available: false, // ← 实测：渠道未开通
    note: 'POST /suno/submit/music + POST /suno/fetch —— 端点存在，渠道未开通（返回 Task request failed）',
    defaultModel: () => overrides('music').model || process.env.FEME_MUSIC_MODEL || 'chirp-v3-5',
    endpoint: () => overrides('music').endpoint || '/suno/submit/music',
    fetchPath: () => overrides('music').fetchPath || '/suno/fetch',
    hint:
      '音乐通道未开通。可选方案：\n' +
      '  A) 等平台开通 Suno 渠道后，本命令无需改动即可用；\n' +
      '  B) 自建/对接其它音乐服务，用 FEME_MUSIC_ENDPOINT 指向兼容端点；\n' +
      '  C) 手工把成品音频放到 work/audio/ 下，再用 --from 跳过本步继续走后续流程。',
    async probe({ deep = true } = {}) {
      const r = await probeEndpoint(this.endpoint(), {
        method: 'GET',
        timeout: 15_000,
      });
      if (!r.exists) return { available: false, detail: r.detail, hint: this.hint };
      if (!deep) return { available: null, detail: r.detail + '（未做真实提交；--deep 才真提交）' };

      const post = await probeEndpoint(this.endpoint(), {
        method: 'POST',
        body: { prompt: 'probe', mv: this.defaultModel(), custom_mode: false, make_instrumental: true },
        timeout: 30_000,
      });
      if (post.exists && !post.noChannel && post.status < 400) {
        return { available: true, detail: '提交成功，渠道已开通' };
      }
      return {
        available: false,
        detail: post.noChannel ? post.detail : `提交失败：${post.detail}`,
        hint: this.hint,
      };
    },
    async call({ prompt, lyrics, instrumental = false, title }) {
      if (!this.available && !process.env.FEME_FORCE_UNAVAILABLE_CHANNELS) {
        // 先真试一次，渠道若被开通则照常走通；失败再给指引
      }
      const base = cfg().rootUrl;
      const payload = {
        prompt: prompt || '', // 曲风 / 风格描述
        mv: this.defaultModel(), // 版本（chirp-v3-5 等）
        title: title || undefined,
        custom_mode: !!lyrics,
        make_instrumental: !!instrumental,
      };
      if (lyrics) {
        // Suno 自定义模式：歌词 + 标题
        payload.lyrics = typeof lyrics === 'string' ? lyrics : String(lyrics);
        payload.prompt = prompt || '';
      }
      try {
        const { taskId, result } = await runAsyncTask({
          submitPath: this.endpoint(),
          listPath: this.fetchPath(),
          submitBase: base,
          fetchBase: base,
          payload,
          taskLabel: '音乐生成',
          interval: 6000,
          maxWait: 480_000,
          pick: (raw) => ({
            status: raw?.status || 'running',
            progress: raw?.progress,
            error: raw?.fail_reason || raw?.error,
            result: raw,
          }),
        });
        return { taskId, result };
      } catch (e) {
        if (e instanceof ProviderUnavailableError || /channel|401|403|404|503|502/i.test(String(e.message))) {
          throw new ProviderUnavailableError(`音乐通道调用失败：${e.message.split('\n')[0]}`, {
            endpoint: `${base}${this.endpoint()}`,
            status: e.status,
            hint: this.hint,
            cause: e,
          });
        }
        throw e;
      }
    },
  },

  // ---------- 视频：图生视频 ----------
  video: {
    id: 'video',
    kind: 'video',
    label: '图生视频（B-roll 空镜 / 人物演唱镜头）',
    available: false, // ← 实测：模型在列，渠道未开通
    note: 'POST /v1/video/generations（异步 task_id）—— 实测返回 503 No available channel for model',
    defaultModel: () => overrides('video').model || process.env.FEME_VIDEO_MODEL || 'doubao-seedance-1-0-pro',
    modelCandidates: ['doubao-seedance-1-0-pro', 'doubao-seedance-1-0-lite', 'kling-v1'],
    endpoint: () => overrides('video').endpoint || '/video/generations',
    fetchPath: () => overrides('video').fetchPath || '/video/generations',
    hint:
      '视频通道未开通（模型在清单里但无可用渠道）。可选方案：\n' +
      '  A) 平台开通后本命令直接用；\n' +
      '  B) FEME_VIDEO_MODEL 换一个已开通渠道的视频模型；\n' +
      '  C) 用「静帧 + Ken Burns 运镜」兜底（fmode-mv video --fallback-still），\n' +
      '     把关键帧做成有推拉摇移的动态镜头，先出片、后替换真视频。',
    async probe({ deep = false } = {}) {
      const model = this.defaultModel();
      const list = await probeModelList(model);
      const r = await probeEndpoint(this.endpoint(), {
        method: 'POST',
        body: { model, prompt: 'probe', duration: 4 },
        timeout: 25_000,
      });
      if (!r.exists) {
        return { available: false, model, detail: `视频端点不存在：${r.detail}`, hint: this.hint };
      }
      if (r.noChannel) {
        return {
          available: false,
          model,
          detail: `模型 ${model} 无可用渠道：${r.detail.replace(/^端点存在但渠道未开通（HTTP \d+）：/, '')}`,
          hint: this.hint,
        };
      }
      if (r.status >= 400) {
        return { available: false, model, detail: `提交失败（HTTP ${r.status}）`, hint: this.hint };
      }
      return { available: true, model, detail: '提交成功，渠道已开通' };
    },
    async call({ image, prompt, duration = 5, size = '1280x720' }) {
      const model = this.defaultModel();
      const payload = { model, prompt, duration, size, image };
      const { taskId, result } = await runAsyncTask({
        submitPath: this.endpoint(),
        listPath: this.fetchPath(),
        payload,
        taskLabel: '图生视频',
        interval: 8000,
        maxWait: 900_000,
        pick: (raw) => ({
          status: raw?.status || 'running',
          progress: raw?.progress,
          error: raw?.fail_reason || raw?.error?.message || raw?.error,
          result: raw,
        }),
      });
      return { taskId, result };
    },
  },

  // ---------- 唇形驱动 ----------
  lipsync: {
    id: 'lipsync',
    kind: 'lipsync',
    label: '唇形驱动（口型对齐人声）',
    available: false, // ← 平台暂无通道
    note: '平台暂无通道，留接口 + 外部服务对接说明',
    defaultModel: () => overrides('lipsync').model || process.env.FEME_LIPSYNC_MODEL || '',
    endpoint: () => overrides('lipsync').endpoint || '/lipsync/generations',
    hint:
      '唇形驱动通道平台暂无。可选方案：\n' +
      '  A) 自建/对接 SadTalker / Wav2Lip / LatentSync，用 FEME_LIPSYNC_ENDPOINT 指向你的服务；\n' +
      '  B) 用「演唱镜头」替代：关键帧 + 图生视频做表情/头部微动，不严格对口型（成片观感可接受）；\n' +
      '  C) 只走空镜 B-roll + 字幕，完全不做唇形（纯音乐 MV 常见做法）。',
    async probe() {
      const ep = this.endpoint();
      const r = await probeEndpoint(ep, { method: 'POST', body: { image: 'probe', audio: 'probe' }, timeout: 20_000 });
      if (!r.exists) {
        return { available: false, detail: `平台无此通道：${r.detail}`, hint: this.hint };
      }
      if (r.noChannel || r.status >= 400) {
        return { available: false, detail: `端点存在但不可用：${r.detail}`, hint: this.hint };
      }
      return { available: true, detail: '端点可用' };
    },
    async call() {
      throw new ProviderUnavailableError('唇形驱动通道不可用', { endpoint: this.endpoint(), hint: this.hint });
    },
  },

  // ---------- TTS：口播配音 ----------
  tts: {
    id: 'tts',
    kind: 'tts',
    label: '语音合成（口播配音）',
    available: false, // ← 平台暂无通道
    note: '平台暂无通道，留接口 + 外部服务对接说明',
    defaultVoice: () => overrides('tts').voice || process.env.FEME_TTS_VOICE || 'zh-CN-XiaoxiaoNeural',
    defaultModel: () => overrides('tts').model || process.env.FEME_TTS_MODEL || 'tts-1',
    endpoint: () => overrides('tts').endpoint || '/audio/speech',
    hint:
      'TTS 通道平台暂无。可选方案：\n' +
      '  A) 对接 OpenAI 兼容 /v1/audio/speech：设置 FEME_TTS_ENDPOINT 与 FEME_TTS_MODEL；\n' +
      '  B) 本地 edge-tts（免费、中文音色多）：pip install edge-tts，本技能会自动探测并调用；\n' +
      '  C) 自备配音音频放入 work/audio/voiceover.mp3，用 --from 跳过本步。',
    async probe() {
      // 优先探测本地 edge-tts（免费、中文音色多），再探网关端点
      const local = await probeLocalTTS();
      if (local.available) {
        return { available: true, provider: 'edge-tts(local)', detail: local.detail };
      }
      const r = await probeEndpoint(this.endpoint(), {
        method: 'POST',
        body: { model: this.defaultModel(), input: 'probe', voice: this.defaultVoice() },
        timeout: 20_000,
      });
      if (!r.exists) {
        return { available: false, provider: '平台网关', detail: `平台无 TTS 通道（${r.detail}）；本地 edge-tts 亦未安装`, hint: this.hint };
      }
      if (r.noChannel || r.status >= 400) {
        return { available: false, provider: '平台网关', detail: `TTS 端点不可用：${r.detail}`, hint: this.hint };
      }
      return { available: true, provider: '平台网关', detail: '端点可用' };
    },
    async call({ text, outPath, voice }) {
      const local = await probeLocalTTS();
      if (local.available) return synthLocalTTS({ text, outPath, voice: voice || this.defaultVoice() });
      throw new ProviderUnavailableError('TTS 通道不可用', { endpoint: this.endpoint(), hint: this.hint });
    },
  },
};

// ==================== 本地 TTS 探测（edge-tts）====================

async function probeLocalTTS() {
  const { spawnSync } = await import('node:child_process');
  try {
    const r = spawnSync('edge-tts', ['--version'], { encoding: 'utf8', timeout: 10_000 });
    if (r.status === 0) {
      return { available: true, provider: 'edge-tts(local)', detail: `本地 edge-tts 可用：${(r.stdout || '').trim().split('\n')[0]}` };
    }
  } catch {
    /* 未安装 */
  }
  return { available: false, provider: 'edge-tts(local)', detail: '未检测到本地 edge-tts' };
}

async function synthLocalTTS({ text, outPath, voice }) {
  const { spawn } = await import('node:child_process');
  const args = ['--voice', voice, '--text', text, '--write-media', outPath];
  await new Promise((resolve, reject) => {
    const p = spawn('edge-tts', args);
    let err = '';
    p.stderr.on('data', (d) => (err += d));
    p.on('error', reject);
    p.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`edge-tts 退出码 ${code}: ${err.slice(0, 300)}`))));
  });
  return { outPath, voice, provider: 'edge-tts(local)' };
}

// ==================== 注册表 API ====================

export const KINDS = ['chat', 'image', 'music', 'video', 'lipsync', 'tts'];

export function getProvider(kind) {
  const p = PROVIDERS[kind];
  if (!p) {
    throw new Error(`未知 provider 类型「${kind}」。可用：${KINDS.join(' / ')}`);
  }
  return p;
}

/** 探活全部 provider（并行），返回结构化能力矩阵 */
export async function probeAll({ deep = false } = {}) {
  const results = await Promise.all(
    KINDS.map(async (k) => {
      const p = PROVIDERS[k];
      try {
        const r = await p.probe({ deep });
        return { kind: k, label: p.label, available: r.available, detail: r.detail, model: r.model || p.defaultModel?.(), hint: r.hint || (r.available ? undefined : p.hint) };
      } catch (e) {
        return { kind: k, label: p.label, available: false, detail: `探活异常：${e.message.split('\n')[0]}`, hint: p.hint };
      }
    })
  );
  return results;
}

/**
 * 统一调用入口。未开通通道会抛 ProviderUnavailableError（带 hint），
 * 绝不会「假装成功」。
 */
export async function invoke(kind, params) {
  const p = getProvider(kind);
  return p.call(params);
}