MailUI4Agents/plugins/dsh-mail-bridge/test/model-scope.test.mjs

/**
 * 模型范围与降级尝试的测试。
 *
 * 最要紧的一条：范围为空时必须返回 `[undefined]`（试一次平台默认）而不是 `[]`。
 * 返回空数组会让调用方一次都不试，等于「管理员没配」就把 Agent 彻底哑掉。
 *
 *   node --test 'test/*.test.mjs'
 */

import { test } from 'node:test';
import assert from 'node:assert/strict';
import {
  snapshotOpencodeModels,
  snapshotDshModels,
  modelAttemptOrder,
  renderFailureReport,
  MAX_CATALOG,
} from '../lib/model-scope.js';

// ─── opencode 目录 ───

const ocConfig = {
  providers: [
    {
      id: 'llmsproxy',
      models: {
        AUTO: { name: 'AUTO (smart routing)' },
        'claude-sonnet-4-6': { name: 'claude-sonnet-4-6' },
      },
    },
    { id: 'huawei', models: { 'deepseek-v4-flash': { name: 'dpkv4' } } },
  ],
};

test('opencode 目录拍平 provider × model', () => {
  const got = snapshotOpencodeModels(ocConfig);
  assert.equal(got.length, 3);
  assert.deepEqual(got[0], {
    provider: 'llmsproxy',
    model: 'AUTO',
    display_name: 'AUTO (smart routing)',
  });
});

test('models 是对象而非数组（键是 model id）', () => {
  // 实测 opencode 的 /config/providers 返回 { models: { "AUTO": {...} } }。
  // 当成数组处理会得到零条目而不是报错。
  const got = snapshotOpencodeModels(ocConfig);
  assert.ok(got.some(m => m.model === 'claude-sonnet-4-6'));
});

test('无 id 的 provider 被跳过', () => {
  const got = snapshotOpencodeModels({
    providers: [{ models: { a: {} } }, { id: 'ok', models: { b: {} } }],
  });
  assert.equal(got.length, 1);
  assert.equal(got[0].provider, 'ok');
});

test('缺 name 时 display_name 为空串而不是 undefined', () => {
  const got = snapshotOpencodeModels({ providers: [{ id: 'p', models: { m: {} } }] });
  assert.equal(got[0].display_name, '');
});

test('opencode 目录容错：结构缺失不崩', () => {
  assert.deepEqual(snapshotOpencodeModels(undefined), []);
  assert.deepEqual(snapshotOpencodeModels({}), []);
  assert.deepEqual(snapshotOpencodeModels({ providers: 'oops' }), []);
  assert.deepEqual(snapshotOpencodeModels({ providers: [{ id: 'p', models: null }] }), []);
});

// ─── DSH 目录 ───

test('DSH 目录用 provider + id', () => {
  const got = snapshotDshModels([
    { provider: 'llmsproxy', id: 'AUTO', name: 'AUTO' },
    { provider: 'deepseek', id: 'chat', name: 'DeepSeek Chat' },
  ]);
  assert.equal(got.length, 2);
  assert.deepEqual(got[1], { provider: 'deepseek', model: 'chat', display_name: 'DeepSeek Chat' });
});

test('DSH 目录跳过缺 provider 或 id 的条目', () => {
  const got = snapshotDshModels([
    { provider: '', id: 'x' },
    { provider: 'p', id: '' },
    { provider: 'p', id: 'ok' },
  ]);
  assert.equal(got.length, 1);
  assert.equal(got[0].model, 'ok');
});

test('重复的 provider/model 组合去重', () => {
  const got = snapshotDshModels([
    { provider: 'p', id: 'm', name: '第一次' },
    { provider: 'p', id: 'm', name: '第二次' },
  ]);
  assert.equal(got.length, 1);
  assert.equal(got[0].display_name, '第一次');
});

test('目录截断到 MAX_CATALOG', () => {
  const many = Array.from({ length: MAX_CATALOG + 20 }, (_, i) => ({
    provider: 'p', id: `m${i}`, name: `M${i}`,
  }));
  assert.equal(snapshotDshModels(many).length, MAX_CATALOG);
});

// ─── modelAttemptOrder ───

test('管理员划定范围时按 rank 顺序尝试', () => {
  const got = modelAttemptOrder(
    [{ provider: 'a', model: '1' }, { provider: 'b', model: '2' }],
    { provider: 'env', model: 'x' }
  );
  assert.deepEqual(got, [
    { provider: 'a', model: '1' },
    { provider: 'b', model: '2' },
  ]);
});

test('不变量：范围为空时返回 [undefined] 而不是 []', () => {
  // 返回空数组会让调用方一次都不试 —— 「管理员没配」的正确含义是不限定，
  // 不是「一个都不许用」。后者等于让 Agent 彻底哑掉。
  const got = modelAttemptOrder([], undefined);
  assert.equal(got.length, 1, `应有一次尝试，实际 ${got.length}`);
  assert.equal(got[0], undefined, 'undefined 表示交给平台自己选');
});

test('范围为空但有环境变量时用环境变量', () => {
  const got = modelAttemptOrder([], { provider: 'llmsproxy', model: 'AUTO' });
  assert.deepEqual(got, [{ provider: 'llmsproxy', model: 'AUTO' }]);
});

test('不变量：范围优先于环境变量', () => {
  // 范围是运行时可改的策略，环境变量是部署时的兜底。
  // 反过来的话管理员在配置页改了范围却不生效，得去改 service 文件重启。
  const got = modelAttemptOrder(
    [{ provider: 'chosen', model: 'm' }],
    { provider: 'env', model: 'x' }
  );
  assert.equal(got.length, 1);
  assert.equal(got[0].provider, 'chosen');
});

test('过滤掉范围里字段不全的项', () => {
  const got = modelAttemptOrder(
    [{ provider: 'a', model: '' }, { provider: '', model: '1' }, { provider: 'ok', model: 'm' }],
    undefined
  );
  assert.deepEqual(got, [{ provider: 'ok', model: 'm' }]);
});

test('环境变量只给一半时不采用', () => {
  assert.deepEqual(modelAttemptOrder([], { provider: 'p' }), [undefined]);
  assert.deepEqual(modelAttemptOrder([], { model: 'm' }), [undefined]);
});

test('modelAttemptOrder 容错非数组', () => {
  assert.deepEqual(modelAttemptOrder(undefined, undefined), [undefined]);
  assert.deepEqual(modelAttemptOrder('oops', undefined), [undefined]);
});

// ─── renderFailureReport ───

test('失败报告列出每次尝试的路由与原因', () => {
  const got = renderFailureReport(
    [
      { provider: 'llmsproxy', model: 'AUTO', error: '429 Too Many Requests' },
      { provider: 'huawei', model: 'dpk', error: 'connect ECONNREFUSED' },
    ],
    '缓存选型'
  );
  assert.match(got, /缓存选型/);
  assert.match(got, /已尝试 2 个/);
  assert.match(got, /llmsproxy\/AUTO/);
  assert.match(got, /429 Too Many Requests/);
  assert.match(got, /huawei\/dpk/);
  assert.match(got, /ECONNREFUSED/);
});

test('没有路由信息时标为平台默认模型', () => {
  const got = renderFailureReport([{ error: 'boom' }], '主题');
  assert.match(got, /平台默认模型/);
});

test('失败报告给出可操作的下一步', () => {
  // 只报错误不说怎么办，收信的人只能来问。
  const got = renderFailureReport([{ error: 'x' }], '主题');
  assert.match(got, /配置页/);
});

test('多行报错缩进后不破坏 Markdown 排版', () => {
  const got = renderFailureReport([{ error: 'line1\nline2' }], '主题');
  // 第二行也要带缩进，否则会脱离代码块、其中的字符被当作 Markdown 解析
  assert.match(got, /    line1\n    line2/);
});

test('空主题有兜底', () => {
  assert.match(renderFailureReport([{ error: 'x' }], ''), /\(无主题\)/);
  assert.match(renderFailureReport([{ error: 'x' }], undefined), /\(无主题\)/);
});

test('renderFailureReport 容错非数组', () => {
  const got = renderFailureReport(undefined, '主题');
  assert.match(got, /已尝试 0 个/);
});