416 lines
15 KiB
TypeScript
416 lines
15 KiB
TypeScript
/**
|
||
* OpenAIAdapter 独立测试（v0.6.4 P3-1 收敛后差异点）
|
||
*
|
||
* OpenAIAdapter 继承 OpenAICompatibleAdapter，本文件锁定 OpenAI 独有契约：
|
||
* - 推理模型（o 系列 / gpt-5）字段路由：reasoning_effort / max_completion_tokens
|
||
* - 推理模型拒图：ModelCapabilityError（status=400）
|
||
* - 非推理模型 temperature / max_tokens 路由
|
||
* - gpt-4.1 1M 上下文窗口（getContextWindow 回退链）
|
||
* - listModels 动态 /models 合并与降级
|
||
*/
|
||
|
||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
||
|
||
vi.mock('electron-log', () => ({
|
||
default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
|
||
}));
|
||
|
||
import { OpenAIAdapter } from '../openai.adapter';
|
||
import { ModelCapabilityError } from '../shared/openai-compatible-base';
|
||
import type { MetonaRequest } from '../../types';
|
||
|
||
const mockFetch = vi.fn();
|
||
|
||
function makeAdapter(model: string, overrides: Record<string, unknown> = {}): OpenAIAdapter {
|
||
return new OpenAIAdapter({
|
||
provider: 'openai',
|
||
baseURL: 'https://api.openai.com/v1',
|
||
apiKey: 'sk-test',
|
||
defaultModel: model,
|
||
...overrides,
|
||
});
|
||
}
|
||
|
||
function makeRequest(overrides?: Partial<MetonaRequest>): MetonaRequest {
|
||
return {
|
||
meta: {
|
||
sessionId: 's1',
|
||
iteration: 1,
|
||
requestId: 'r1',
|
||
timestamp: Date.now(),
|
||
agentVersion: 'test',
|
||
},
|
||
systemPrompt: {
|
||
roleDefinition: 'You are Metona.',
|
||
outputConstraints: '',
|
||
safetyGuidelines: '',
|
||
},
|
||
messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
|
||
params: { maxTokens: 4096, temperature: 0, stream: false },
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function okResponse(
|
||
body: Record<string, unknown> = { choices: [{ message: { content: 'ok' } }] },
|
||
): Response {
|
||
return {
|
||
ok: true,
|
||
status: 200,
|
||
json: async () => body,
|
||
} as unknown as Response;
|
||
}
|
||
|
||
function lastBody(): Record<string, unknown> {
|
||
const call = mockFetch.mock.calls[mockFetch.mock.calls.length - 1] as [string, RequestInit];
|
||
return JSON.parse(String(call[1].body));
|
||
}
|
||
|
||
beforeEach(() => {
|
||
mockFetch.mockReset();
|
||
vi.stubGlobal('fetch', mockFetch);
|
||
});
|
||
|
||
afterEach(() => {
|
||
vi.unstubAllGlobals();
|
||
});
|
||
|
||
// ===== reasoning_effort 映射 =====
|
||
|
||
describe('OpenAIAdapter — 推理模型 reasoning_effort', () => {
|
||
it.each([
|
||
['low', 'low'],
|
||
['medium', 'medium'],
|
||
['high', 'high'],
|
||
['xhigh', 'high'], // v0.8.3: OpenAI 档位封顶 high，xhigh 就近降档
|
||
['max', 'high'], // max 归一 high
|
||
['true', 'high'], // v0.8.3: 模型默认档归一 high
|
||
] as const)('o3-mini effort=%s → reasoning_effort=%s', async (effort, expected) => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({
|
||
params: {
|
||
maxTokens: 4096,
|
||
temperature: 0,
|
||
stream: false,
|
||
thinkingEnabled: true,
|
||
thinkingEffort: effort,
|
||
},
|
||
}),
|
||
);
|
||
expect(lastBody().reasoning_effort).toBe(expected);
|
||
});
|
||
|
||
it('o3-mini thinking 关闭 → 不传 reasoning_effort（可关闭服务端默认思考）', async () => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({
|
||
params: { maxTokens: 4096, temperature: 0, stream: false, thinkingEnabled: false },
|
||
}),
|
||
);
|
||
expect(lastBody().reasoning_effort).toBeUndefined();
|
||
});
|
||
|
||
it('o3-mini thinking 未配置 → 不传 reasoning_effort', async () => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(makeRequest({ params: { maxTokens: 4096, temperature: 0, stream: false } }));
|
||
expect(lastBody().reasoning_effort).toBeUndefined();
|
||
});
|
||
|
||
it('o3-mini thinking 未配置 effort → 缺省 high', async () => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({
|
||
params: { maxTokens: 4096, temperature: 0, stream: false, thinkingEnabled: true },
|
||
}),
|
||
);
|
||
expect(lastBody().reasoning_effort).toBe('high');
|
||
});
|
||
|
||
it('非推理模型 gpt-4o 即使 thinkingEnabled=true 也不传 reasoning_effort（忽略思考参数）', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({
|
||
params: { maxTokens: 4096, temperature: 0.3, stream: false, thinkingEnabled: true },
|
||
}),
|
||
);
|
||
expect(lastBody().reasoning_effort).toBeUndefined();
|
||
// 非推理模型仍传 temperature
|
||
expect(lastBody().temperature).toBe(0.3);
|
||
});
|
||
});
|
||
|
||
// ===== 推理模型拒图 =====
|
||
|
||
describe('OpenAIAdapter — 推理模型拒图（ModelCapabilityError）', () => {
|
||
it.each(['o3-mini', 'o1', 'gpt-5.1'])(
|
||
'%s 带图片 → 抛 ModelCapabilityError(status=400)',
|
||
async (model) => {
|
||
const adapter = makeAdapter(model);
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
const request = makeRequest({
|
||
messages: [
|
||
{
|
||
role: 'user',
|
||
content: '看图',
|
||
images: [{ url: 'data:image/png;base64,AAA' }],
|
||
timestamp: Date.now(),
|
||
},
|
||
],
|
||
});
|
||
const err = await adapter.send(request).catch((e: unknown) => e);
|
||
expect(err).toBeInstanceOf(ModelCapabilityError);
|
||
expect((err as ModelCapabilityError).status).toBe(400);
|
||
expect((err as Error).message).toContain('does not support');
|
||
// 拒图不发出网络请求
|
||
expect(mockFetch).not.toHaveBeenCalled();
|
||
},
|
||
);
|
||
|
||
it('o3-mini 无图片 → 正常发送（不误拒）', async () => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(makeRequest());
|
||
expect(mockFetch).toHaveBeenCalledTimes(1);
|
||
});
|
||
|
||
it('非推理模型 gpt-4o 带图片 → 正常发送（多模态允许）', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({
|
||
messages: [
|
||
{
|
||
role: 'user',
|
||
content: '看图',
|
||
images: [{ url: 'data:image/png;base64,AAA' }],
|
||
timestamp: Date.now(),
|
||
},
|
||
],
|
||
}),
|
||
);
|
||
expect(mockFetch).toHaveBeenCalledTimes(1);
|
||
const body = lastBody();
|
||
// 图片转为 image_url parts
|
||
const userMsg = (body.messages as Array<Record<string, unknown>>)[1];
|
||
expect(userMsg.content).toEqual([
|
||
{ type: 'text', text: '看图' },
|
||
{ type: 'image_url', image_url: { url: 'data:image/png;base64,AAA' } },
|
||
]);
|
||
});
|
||
});
|
||
|
||
// ===== max_completion_tokens / max_tokens 路由 =====
|
||
|
||
describe('OpenAIAdapter — token 参数路由（v0.8.1：原样透传，无模型钳制）', () => {
|
||
it.each([
|
||
['o3-mini', 63_488, 63_488, 'max_completion_tokens'],
|
||
['o3-mini', 200_000, 200_000, 'max_completion_tokens'], // 超过任何旧元信息上限 → 原样
|
||
['gpt-4o', 63_488, 63_488, 'max_tokens'],
|
||
['gpt-4.1', 63_488, 63_488, 'max_tokens'],
|
||
] as const)('%s maxTokens=%d → %s=%d', async (model, requested, expected, field) => {
|
||
const adapter = makeAdapter(model);
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({ params: { maxTokens: requested, temperature: 0, stream: false } }),
|
||
);
|
||
const body = lastBody();
|
||
expect(body[field]).toBe(expected);
|
||
// 另一个字段不出现
|
||
const other = field === 'max_completion_tokens' ? 'max_tokens' : 'max_completion_tokens';
|
||
expect(body[other]).toBeUndefined();
|
||
});
|
||
|
||
it('o3-mini 未配置 maxTokens → 不下发 max_completion_tokens（无写死兜底）', async () => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
|
||
expect(lastBody().max_completion_tokens).toBeUndefined();
|
||
});
|
||
|
||
it('非推理模型未配置 maxTokens → 不下发 max_tokens（无写死兜底）', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
|
||
expect(lastBody().max_tokens).toBeUndefined();
|
||
});
|
||
});
|
||
|
||
// ===== temperature 传递 =====
|
||
|
||
describe('OpenAIAdapter — temperature 路由', () => {
|
||
it('非推理模型 temperature 逐值透传', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
for (const t of [0, 0.7, 1.0]) {
|
||
await adapter.send(
|
||
makeRequest({ params: { maxTokens: 4096, temperature: t, stream: false } }),
|
||
);
|
||
}
|
||
expect(lastBody().temperature).toBe(1.0);
|
||
const bodies = mockFetch.mock.calls.map((c) => JSON.parse(String((c[1] as RequestInit).body)));
|
||
expect(bodies.map((b) => b.temperature)).toEqual([0, 0.7, 1.0]);
|
||
});
|
||
|
||
it('推理模型 o3-mini 不传 temperature（o 系列不支持）', async () => {
|
||
const adapter = makeAdapter('o3-mini');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({ params: { maxTokens: 4096, temperature: 0.7, stream: false } }),
|
||
);
|
||
expect(lastBody().temperature).toBeUndefined();
|
||
});
|
||
|
||
it('gpt-5 系列同样不传 temperature（推理家族）', async () => {
|
||
const adapter = makeAdapter('gpt-5');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({ params: { maxTokens: 4096, temperature: 0.5, stream: false } }),
|
||
);
|
||
expect(lastBody().temperature).toBeUndefined();
|
||
expect(lastBody().max_completion_tokens).toBe(4096);
|
||
});
|
||
});
|
||
|
||
// ===== getContextWindow 回退链 =====
|
||
|
||
describe('OpenAIAdapter — getContextWindow（v0.8.1：唯一来源是设置面板配置）', () => {
|
||
it('config.contextWindow 显式配置（llm.contextWindow 注入）返回配置值', () => {
|
||
const adapter = makeAdapter('gpt-4o', { contextWindow: 64_000 });
|
||
expect(adapter.getContextWindow()).toBe(64_000);
|
||
});
|
||
|
||
it('未配置（任意模型，含已知/未知）→ 返回 0（引擎跳过压缩判定，无写死兜底）', () => {
|
||
expect(makeAdapter('gpt-4.1').getContextWindow()).toBe(0);
|
||
expect(makeAdapter('o3-mini').getContextWindow()).toBe(0);
|
||
expect(makeAdapter('unknown-model-x').getContextWindow()).toBe(0);
|
||
});
|
||
});
|
||
|
||
// ===== listModels =====
|
||
|
||
describe('OpenAIAdapter — listModels 动态发现与降级', () => {
|
||
it('API 成功 → 合并本地元信息（已知模型带 name，未知模型裸 id）', async () => {
|
||
mockFetch.mockResolvedValue(okResponse({ data: [{ id: 'gpt-4o' }, { id: 'custom-model' }] }));
|
||
const models = await makeAdapter('gpt-4o').listModels();
|
||
expect(models).toHaveLength(2);
|
||
// v0.8.1: 元信息不再承载窗口/上限数值
|
||
expect(models[0]).toMatchObject({ id: 'gpt-4o', name: 'GPT-4o' });
|
||
expect(models[0].contextWindow).toBeUndefined();
|
||
expect(models[1]).toEqual({ id: 'custom-model' });
|
||
// /models 请求头携带 Bearer
|
||
const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
|
||
expect((init.headers as Record<string, string>).Authorization).toBe('Bearer sk-test');
|
||
});
|
||
|
||
it('API 失败 → 降级到 supportedModels（带元信息）', async () => {
|
||
mockFetch.mockRejectedValue(new Error('network'));
|
||
const models = await makeAdapter('gpt-4o').listModels();
|
||
expect(models.map((m) => m.id)).toEqual(['gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'o3-mini']);
|
||
});
|
||
|
||
it('API 返回空 data → 降级到 supportedModels', async () => {
|
||
mockFetch.mockResolvedValue(okResponse({ data: [] }));
|
||
const models = await makeAdapter('gpt-4o').listModels();
|
||
expect(models).toHaveLength(4);
|
||
});
|
||
|
||
it('healthCheck 基于 listModels 成功返回 true', async () => {
|
||
mockFetch.mockResolvedValue(okResponse({ data: [{ id: 'gpt-4o' }] }));
|
||
expect(await makeAdapter('gpt-4o').healthCheck()).toBe(true);
|
||
});
|
||
});
|
||
|
||
// ===== 非流式响应组装 =====
|
||
|
||
describe('OpenAIAdapter — 非流式响应组装', () => {
|
||
it('send 返回 MetonaResponse（content/usage/finishReason 映射）', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(
|
||
okResponse({
|
||
id: 'cmpl-1',
|
||
model: 'gpt-4o',
|
||
choices: [{ message: { content: 'hello' }, finish_reason: 'stop' }],
|
||
usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
|
||
}),
|
||
);
|
||
const res = await adapter.send(makeRequest());
|
||
expect(res.content).toBe('hello');
|
||
expect(res.finishReason).toBe('stop');
|
||
expect(res.usage.totalTokens).toBe(15);
|
||
expect(res.meta.provider).toBe('openai');
|
||
});
|
||
|
||
it('HTTP 非 2xx → 抛出带 status 的 Error', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue({
|
||
ok: false,
|
||
status: 429,
|
||
statusText: 'Too Many Requests',
|
||
text: async () => '{"error":{"message":"rate limited"}}',
|
||
} as unknown as Response);
|
||
const err = await adapter.send(makeRequest()).catch((e: unknown) => e);
|
||
expect((err as Error & { status?: number }).status).toBe(429);
|
||
});
|
||
|
||
it('content_filter 错误体 → ContentFilterError 实例', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue({
|
||
ok: false,
|
||
status: 400,
|
||
statusText: 'Bad Request',
|
||
text: async () => '{"error":{"code":"content_filter","message":"blocked"}}',
|
||
} as unknown as Response);
|
||
const err = await adapter.send(makeRequest()).catch((e: unknown) => e);
|
||
expect((err as { name: string }).name).toBe('ContentFilterError');
|
||
});
|
||
|
||
it('sendStream 走 SSE 解析（[DONE] 结束）', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
const payload =
|
||
'data: {"choices":[{"delta":{"content":"hi"}}]}\n\n' +
|
||
'data: {"choices":[{"delta":{"content":""},"finish_reason":"stop"}]}\n\n' +
|
||
'data: [DONE]\n\n';
|
||
const body = new ReadableStream<Uint8Array>({
|
||
start(controller) {
|
||
controller.enqueue(new TextEncoder().encode(payload));
|
||
controller.close();
|
||
},
|
||
});
|
||
mockFetch.mockResolvedValue(new Response(body, { status: 200 }));
|
||
const events: string[] = [];
|
||
for await (const ev of adapter.sendStream(makeRequest({ params: { stream: true } }))) {
|
||
events.push(ev.type);
|
||
}
|
||
expect(events[0]).toBe('text_delta');
|
||
expect(events[events.length - 1]).toBe('done');
|
||
});
|
||
});
|
||
|
||
// ===== stop 序列 =====
|
||
|
||
describe('OpenAIAdapter — stop 序列透传', () => {
|
||
it('stopSequences 透传为 stop 数组（o 系列已知边界透传）', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(
|
||
makeRequest({
|
||
params: { maxTokens: 4096, temperature: 0, stream: false, stopSequences: ['END'] },
|
||
}),
|
||
);
|
||
expect(lastBody().stop).toEqual(['END']);
|
||
});
|
||
|
||
it('未配置 stopSequences 不发送 stop', async () => {
|
||
const adapter = makeAdapter('gpt-4o');
|
||
mockFetch.mockResolvedValue(okResponse());
|
||
await adapter.send(makeRequest());
|
||
expect(lastBody().stop).toBeUndefined();
|
||
});
|
||
});
|