zsjz-ai/ai-electron/electron/service/codex/providerService.test.ts

import { createServer, type Server } from 'node:http';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import {
  baseUrlHint,
  describeDroppedKeys,
  normalizeBaseUrl,
  probeEndpoint,
  toProviderSpec,
} from './providerService';
import type { ApplyProviderInput } from './types';

let server: Server;
let port = 0;
let chatStatus = 404;
let lastRequest: { url: string | null; auth: string | null; body: string | null } = { url: null, auth: null, body: null };

beforeAll(async () => {
  server = createServer((req, res) => {
    const chunks: Buffer[] = [];
    req.on('data', (chunk: Buffer) => chunks.push(chunk));
    req.on('end', () => {
      lastRequest = {
        url: req.url ?? null,
        auth: req.headers.authorization ?? null,
        body: Buffer.concat(chunks).toString('utf8') || null,
      };
      res.setHeader('content-type', 'application/json');
      const status = req.url?.endsWith('/chat/completions') ? chatStatus : 404;
      res.writeHead(status).end(JSON.stringify({ status }));
    });
  });
  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
  const address = server.address();
  port = typeof address === 'object' && address ? address.port : 0;
});

afterAll(async () => {
  await new Promise<void>((resolve) => server.close(() => resolve()));
});

const openaiLike: ApplyProviderInput = {
  modelId: 'qwen3-max',
  name: '通义千问',
  baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1/',
  apiKey: 'sk-test-key',
  headersJson: JSON.stringify({ 'X-DashScope-WorkSpace': 'ws-1' }),
  config: JSON.stringify({ request_max_retries: 3, temperature: 0.2 }),
};

describe('normalizeBaseUrl / baseUrlHint', () => {
  it('去掉尾部斜杠，空值返回 null', () => {
    expect(normalizeBaseUrl('https://x.com/v1///')).toBe('https://x.com/v1');
    expect(normalizeBaseUrl('   ')).toBeNull();
    expect(normalizeBaseUrl(null)).toBeNull();
  });

  it('缺版本段时给非阻断提示', () => {
    expect(baseUrlHint('https://x.com')).toMatch(/v1/);
    expect(baseUrlHint('https://x.com/v1')).toBeNull();
    expect(baseUrlHint('ftp://x.com/v1')).toMatch(/http/);
    expect(baseUrlHint(null)).toMatch(/未配置/);
  });
});

describe('toProviderSpec', () => {
  it('OpenAI 兼容端点：写 model_providers.zsjz，key 只留给 env', () => {
    const spec = toProviderSpec(openaiLike);
    expect(spec).toMatchObject({
      id: 'zsjz',
      model: 'qwen3-max',
      baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
      apiKey: 'sk-test-key',
      envKey: 'ZSJZ_CODEX_API_KEY',
    });
    expect(spec.httpHeaders).toEqual({ 'X-DashScope-WorkSpace': 'ws-1' });
    // config 里只放行白名单键，temperature 必须被丢掉
    expect(spec.extra).toMatchObject({ request_max_retries: 3 });
    expect(spec.extra).not.toHaveProperty('temperature');
  });

  it('地址原样使用，尾部斜杠规整；没配 key 就不写 env_key', () => {
    const spec = toProviderSpec({ modelId: 'qwen', baseUrl: 'http://10.66.66.66:8080/v1/' });
    expect(spec).toMatchObject({ id: 'zsjz', model: 'qwen', baseUrl: 'http://10.66.66.66:8080/v1' });
    expect(spec.apiKey ?? null).toBeNull();
  });

  it('自部署端点默认关掉重试放大、放宽空闲超时、不走 websocket', () => {
    const spec = toProviderSpec({ modelId: 'm', baseUrl: 'http://10.66.66.66:8080/v1' });
    // 单槽推理上一次 prefill 要几分钟，Codex 默认 5 次重试 = 同样几分钟的活儿重复五遍
    expect(spec.extra).toMatchObject({
      request_max_retries: 0,
      stream_max_retries: 0,
      stream_idle_timeout_ms: 300_000,
      supports_websockets: false,
    });
  });

  it('模型管理 config 里显式写的值优先于默认', () => {
    const spec = toProviderSpec({
      modelId: 'm',
      baseUrl: 'http://x/v1',
      config: { stream_idle_timeout_ms: 5_000, stream_max_retries: 3 },
    });
    expect(spec.extra).toMatchObject({
      stream_idle_timeout_ms: 5_000,
      stream_max_retries: 3,
      request_max_retries: 0,
    });
  });
  it('缺 modelId 或缺 baseUrl 直接报错，不做任何地址兜底', () => {
    expect(() => toProviderSpec({ modelId: '  ' })).toThrow(/modelId/);
    expect(() => toProviderSpec({ modelId: 'gpt' })).toThrow(/base_url/);
    expect(() => toProviderSpec({ modelId: 'gpt', baseUrl: '   ' })).toThrow(/base_url/);
  });

  it('headersJson 与 config 支持对象或 JSON 字符串，非法 JSON 忽略', () => {
    expect(toProviderSpec({ ...openaiLike, headersJson: { A: '1' } }).httpHeaders).toEqual({ A: '1' });
    expect(toProviderSpec({ ...openaiLike, headersJson: '{bad json' }).httpHeaders).toBeNull();
    expect(toProviderSpec({ ...openaiLike, config: { stream_max_retries: 5 } }).extra).toMatchObject({
      stream_max_retries: 5,
    });
  });

  it('describeDroppedKeys 报告被丢弃的非白名单键', () => {
    expect(describeDroppedKeys(openaiLike)).toEqual(['temperature']);
    expect(describeDroppedKeys({ modelId: 'x' })).toEqual([]);
  });
});

describe('probeEndpoint', () => {
  const base = () => `http://127.0.0.1:${port}/v1`;

  it('只探 Chat 路由存在性，请求体不带 messages（不能触发推理）', async () => {
    chatStatus = 400;
    const result = await probeEndpoint({
      baseUrl: `${base()}/`,
      modelId: 'qwen3-max',
      apiKey: 'sk-test-key',
    });
    expect(result.protocol).toBe('chat');
    expect(lastRequest.url).toBe('/v1/chat/completions');
    expect(lastRequest.auth).toBe('Bearer sk-test-key');
    const body = JSON.parse(lastRequest.body ?? '{}') as Record<string, unknown>;
    expect(body.model).toBe('qwen3-max');
    // 一旦带上 messages，单槽本地服务就会真的开始生成，实测一次要 14 秒
    expect(body.messages).toBeUndefined();
  });

  it('2xx 与 4xx 只要有路由就判 chat 可用', async () => {
    for (const status of [200, 400, 401]) {
      chatStatus = status;
      const result = await probeEndpoint({ baseUrl: base(), modelId: 'x' });
      expect(result).toMatchObject({ protocol: 'chat', chatStatus: status });
    }
  });

  it('没有 Chat 路由判 unsupported', async () => {
    chatStatus = 404;
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'x' });
    expect(result.protocol).toBe('unsupported');
    expect(result.detail).toMatch(/没有 \/chat\/completions/);
  });

  it('端点不可达时报错带上是哪个地址', async () => {
    const result = await probeEndpoint({ baseUrl: 'http://127.0.0.1:1/v1', modelId: 'x' });
    expect(result.protocol).toBe('unreachable');
    expect(result.chatStatus).toBeNull();
    expect(result.detail).toMatch(/不可达/);
    expect(result.detail).toContain('http://127.0.0.1:1/v1/chat/completions');
  });
});