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 responsesStatus = 404;
let chatStatus = 404;
let ollamaVersion: string | null = null;
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');
      if (req.url === '/api/version') {
        if (ollamaVersion === null) {
          res.writeHead(404).end('{}');
        } else {
          res.writeHead(200).end(JSON.stringify({ version: ollamaVersion }));
        }
        return;
      }
      const status = req.url?.endsWith('/chat/completions') ? chatStatus : responsesStatus;
      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',
  providerType: 'DASHSCOPE',
  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.builtinProvider ?? null).toBeNull();
    expect(spec.httpHeaders).toEqual({ 'X-DashScope-WorkSpace': 'ws-1' });
    // config 里只放行白名单键，temperature 必须被丢掉
    expect(spec.extra).toEqual({ request_max_retries: 3 });
  });

  it('OLLAMA 走 Codex 内置 provider，不需要 baseUrl 与 key', () => {
    const spec = toProviderSpec({ modelId: 'qwen3:8b', providerType: 'OLLAMA' });
    expect(spec).toMatchObject({ id: null, builtinProvider: 'ollama', model: 'qwen3:8b' });
    expect(spec.baseUrl).toBeNull();
  });

  it('远端 Ollama 必须保留并补齐 base_url，不能退回 localhost:11434', () => {
    expect(
      toProviderSpec({ modelId: 'qwen', providerType: 'OLLAMA', baseUrl: 'http://10.66.66.66:8080' }).baseUrl,
    ).toBe('http://10.66.66.66:8080/v1');
    expect(
      toProviderSpec({ modelId: 'qwen', providerType: 'OLLAMA', baseUrl: 'http://host:11434/v1/' }).baseUrl,
    ).toBe('http://host:11434/v1');
  });

  it('可显式指定内置 provider（lmstudio）', () => {
    const spec = toProviderSpec({ modelId: 'local-model', builtinProvider: 'lmstudio' });
    expect(spec.builtinProvider).toBe('lmstudio');
  });

  it('缺 modelId 或非内置 provider 缺 baseUrl 时报错', () => {
    expect(() => toProviderSpec({ modelId: '  ' })).toThrow(/modelId/);
    expect(() => toProviderSpec({ modelId: 'gpt', providerType: 'OPENAI' })).toThrow(/baseUrl/);
  });

  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).toEqual({
      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('用真实模型名探 /responses，带上 api key', async () => {
    responsesStatus = 401;
    const result = await probeEndpoint({
      baseUrl: `${base()}/`,
      modelId: 'qwen3-max',
      apiKey: 'sk-test-key',
    });
    expect(result.protocol).toBe('responses');
    expect(lastRequest.url).toBe('/v1/responses');
    expect(lastRequest.auth).toBe('Bearer sk-test-key');
    expect(JSON.parse(lastRequest.body ?? '{}').model).toBe('qwen3-max');
  });

  it('401/400/2xx 判为 responses 直通', async () => {
    for (const status of [401, 400, 200]) {
      responsesStatus = status;
      const result = await probeEndpoint({ baseUrl: base(), modelId: 'x' });
      expect(result).toMatchObject({ protocol: 'responses', responsesStatus: status });
    }
  });

  it('双协议 404 判 unsupported', async () => {
    responsesStatus = 404;
    chatStatus = 404;
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'x', providerType: 'OPENAI' });
    expect(result.protocol).toBe('unsupported');
    expect(result.detail).toMatch(/无法对接/);
  });

  it('responses 404 + chat 存在判 chat-only', async () => {
    responsesStatus = 404;
    chatStatus = 200;
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'x', providerType: 'VLLM' });
    expect(result).toMatchObject({ protocol: 'chat-only', responsesStatus: 404, chatStatus: 200 });
    expect(result.detail).toMatch(/chat\/completions/);
  });

  it('Ollama ≥ 0.13.3：/responses 404 只是模型未拉取，判 responses', async () => {
    responsesStatus = 404;
    chatStatus = 404;
    ollamaVersion = '0.13.3';
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'qwen3:8b', providerType: 'OLLAMA' });
    expect(result).toMatchObject({ protocol: 'responses', ollamaVersion: '0.13.3', ollamaNeedsUpgrade: false });
    expect(result.detail).toMatch(/ollama pull/);
  });

  it('Ollama < 0.13.3：判 chat-only 并标记需要升级', async () => {
    responsesStatus = 404;
    chatStatus = 200;
    ollamaVersion = '0.12.9';
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'qwen3:8b', providerType: 'OLLAMA' });
    expect(result).toMatchObject({ protocol: 'chat-only', ollamaVersion: '0.12.9', ollamaNeedsUpgrade: true });
    expect(result.detail).toMatch(/低于 0\.13\.3/);
    ollamaVersion = null;
  });

  it('端点不可达判 unreachable', async () => {
    const result = await probeEndpoint({ baseUrl: 'http://127.0.0.1:1/v1', modelId: 'x' });
    expect(result.protocol).toBe('unreachable');
    expect(result.responsesStatus).toBeNull();
    expect(result.detail).toMatch(/不可达/);
  });
});