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

import { createServer, type Server } from 'node:http';
import { mkdtempSync, readFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import type { CodexProviderSpec, CodexRuntime } from './codexRuntime';
import { chatRouter } from './chatRouter/routerService';
import {
  applyProvider,
  baseUrlHint,
  describeDroppedKeys,
  normalizeBaseUrl,
  probeEndpoint,
  toProviderSpec,
} from './providerService';
import type { ApplyProviderInput } from './types';

/** applyProvider 会往 getCodexDataDir() 落 provider.json；挪到临时目录，绝不碰客户端真实数据目录 */
vi.mock('./codexHome', async (importOriginal) => {
  const actual = await importOriginal<typeof import('./codexHome')>();
  // 目录只能算一次：providerFile() 每次都会调 getCodexDataDir()，给出不同路径就写不进同一处
  const dir = mkdtempSync(join(tmpdir(), 'zsjz-provider-test-'));
  return { ...actual, getCodexDataDir: () => dir };
});

let server: Server;
let port = 0;
let responsesStatus = 404;
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('/responses')
        ? responsesStatus
        : 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('空闲窗口必须显著大于 Codex 默认的 300 秒，且不写等于默认值的无效项', () => {
    const spec = toProviderSpec({ modelId: 'm', baseUrl: 'http://10.66.66.66:8080/v1' });
    expect(spec.extra).toMatchObject({
      request_max_retries: 0,
      stream_max_retries: 0,
      // Codex 默认 300_000（model-provider-info/src/lib.rs:29）；写 300_000 等于没写
      stream_idle_timeout_ms: 1_800_000,
    });
    expect(spec.extra).toBeTypeOf('object');
    // supports_websockets 的 serde 默认就是 false，用 -c 声明的 provider 根本不走 WS，
    // 写进默认值只会让下一位误以为这里防住了什么（15 秒那条说法来自 websocket 握手超时）
    expect(spec.extra).not.toHaveProperty('supports_websockets');
  });

  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('只探 Responses 路由存在性，请求体不带 input（不能触发推理）', async () => {
    responsesStatus = 400;
    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');
    const body = JSON.parse(lastRequest.body ?? '{}') as Record<string, unknown>;
    expect(body.model).toBe('qwen3-max');
    // 一旦带上 input，单槽本地服务就会真的开始生成，实测一次要 14 秒
    expect(body.input).toBeUndefined();
  });

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

  it('没有 Responses 但有 Chat → chat-only，说明将由内置路由层桥接对接', async () => {
    responsesStatus = 404;
    chatStatus = 400;
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'x' });
    expect(result.protocol).toBe('chat-only');
    expect(result.detail).toMatch(/没有 \/responses/);
    expect(result.detail).toMatch(/路由层/);
  });

  it('两条路由都没有 → unsupported', async () => {
    responsesStatus = 404;
    chatStatus = 404;
    const result = await probeEndpoint({ baseUrl: base(), modelId: 'x' });
    expect(result.protocol).toBe('unsupported');
  });

  it('端点不可达时报错带上是哪个地址', 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(/不可达/);
    expect(result.detail).toContain('http://127.0.0.1:1/v1/responses');
  });
});

/**
 * 客户端真正走的是 applyProvider：探端点 → 把 spec 交给运行时重启子进程。
 * 这里用假运行时把「交给 Codex 的最终参数」钉死 —— 真机 smoke 用的是手搓 spec，覆盖不到这一段。
 */
describe('applyProvider 交给运行时的 spec', () => {
  class StubRuntime {
    spec: CodexProviderSpec | null | undefined;
    calls = 0;

    async applyProvider(spec: CodexProviderSpec | null): Promise<void> {
      this.calls += 1;
      this.spec = spec;
    }
  }

  it('Codex 直连上游真实地址，并带上有效的重试/空闲窗口参数', async () => {
    responsesStatus = 400;
    const stub = new StubRuntime();
    const upstream = `http://127.0.0.1:${port}/v1`;
    const applied = await applyProvider(stub as unknown as CodexRuntime, {
      modelId: 'qwen',
      name: '自部署 Qwen',
      baseUrl: upstream,
      modelRecordId: 7,
    });
    const spec = stub.spec;
    expect(spec).not.toBeNull();
    expect(spec?.id).toBe('zsjz');
    expect(spec?.model).toBe('qwen');
    // 不做任何翻译：Codex 连的就是模型记录里那个地址
    expect(spec?.baseUrl).toBe(upstream);
    expect(spec?.extra).toMatchObject({
      request_max_retries: 0,
      stream_max_retries: 0,
      stream_idle_timeout_ms: 1_800_000,
    });
    expect(applied).toMatchObject({ model: 'qwen', modelRecordId: '7', baseUrl: upstream, bridged: false });
  });

  it('落盘 model-catalog.json 并把路径挂到 spec，目录条目带 slug 与 instructions_template', async () => {
    responsesStatus = 400;
    const stub = new StubRuntime();
    await applyProvider(stub as unknown as CodexRuntime, {
      modelId: 'qwen',
      name: '自部署 Qwen',
      baseUrl: `http://127.0.0.1:${port}/v1`,
    });
    const spec = stub.spec;
    expect(spec?.modelCatalogPath).toBeTruthy();

    const catalog = JSON.parse(readFileSync(spec!.modelCatalogPath!, 'utf8')) as {
      models: Array<Record<string, unknown>>;
    };
    expect(catalog.models).toHaveLength(1);
    const entry = catalog.models[0] as Record<string, unknown> & {
      slug: string;
      display_name: string;
      model_messages: { instructions_template: string };
    };
    // slug 必须与应用的 model 一致，codex 靠它命中元数据（used_fallback 归零、警告消失）
    expect(entry.slug).toBe('qwen');
    expect(entry.display_name).toBe('自部署 Qwen');
    // 0.155.1 校验：目录模型缺 instructions_template 会在启动时报错
    expect(entry.model_messages.instructions_template.length).toBeGreaterThan(1000);
  });

  it('端点只会 Chat 时起路由层桥接：spec 指向本地路由，落盘保留上游真实地址', async () => {
    responsesStatus = 404;
    chatStatus = 400;
    const stub = new StubRuntime();
    const upstream = `http://127.0.0.1:${port}/v1`;
    const applied = await applyProvider(stub as unknown as CodexRuntime, {
      modelId: 'qwen',
      baseUrl: upstream,
      modelRecordId: 9,
    });
    const spec = stub.spec;
    expect(spec).not.toBeNull();
    // codex 的 base_url 是本地路由地址（127.0.0.1 随机端口 + /v1），绝不是上游地址
    expect(spec?.baseUrl).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/v1$/u);
    expect(spec?.baseUrl).not.toBe(upstream);
    // 落盘快照保存真实上游地址与 bridged 标记，供页面与 modelApplied 比对
    expect(applied.bridged).toBe(true);
    expect(applied.baseUrl).toBe(upstream);
    // 目录文件的 slug 仍是上游模型 id，桥接不改变模型名
    expect(stub.spec?.modelCatalogPath).toBeTruthy();
  });

  it('路由层桥接应用失败时回滚停掉路由', async () => {
    responsesStatus = 404;
    chatStatus = 400;
    class FailingRuntime {
      calls = 0;
      async applyProvider(): Promise<void> {
        this.calls += 1;
        throw new Error('runtime boom');
      }
    }
    await expect(
      applyProvider(new FailingRuntime() as unknown as CodexRuntime, {
        modelId: 'qwen',
        baseUrl: `http://127.0.0.1:${port}/v1`,
      }),
    ).rejects.toThrow('runtime boom');
    expect(chatRouter.running).toBe(false);
  });
});