feat: v0.7.4 时序语义修正 · 防线实效补漏 · 全量测试翻倍 — 2406 用例 + jsdom 组件测试全量回归
CI / 类型检查 + Lint + 单元测试 (push) Failing after 6m27s
CI / 产物编译验证 (push) Successful in 9m57s
CI / 全量测试 (Electron ABI) (push) Failing after 5m19s

P1 修复面收口:
- 超时三态区分(aborted→USER_INTERRUPT / ETIMEDOUT→TIMEOUT / 其余→ERROR),
  根治"真实网络超时被误报为用户中断"
- 流空闲超时统一(SSE/Ollama/Anthropic 读循环 60s 无数据抛 504 进重试通道)
- 同会话并发 sendMessage 防重入(isRunning 守卫)+ 会话存在性预检 +
  前置调用移入 try(ERROR+DONE 双事件保证,根治 isStreaming 假死)
- 清空审计后 resetChainCache(根治 verifyChain 误报 TAMPERED)
- DONE 不再提前清理 TRACE(TERMINATED 统一收尾,补全最终迭代录制)
- IME 合成回车不发送(普通 Enter + Cmd/Ctrl+Enter 双分支)+ handleSend 闭包修复

P2 安全纵深:
- preload 移除原始 electronAPI 暴露(渲染层零使用,关掉 XSS invoke 任意通道单点风险)
- CORS 同源回显根治(仅当前浏览页面 Origin,did-navigate 同步)
- MEMORY.md 命令保护正则扩展(括号/$/反引号/< 重定向边界 + 前导路径)
- write_file append TOCTOU 统一(open 后 realpath 校验,新文件分支补漏)
- 敏感键归一化(authKey 驼峰/连字符命中)+ MCP headers 鉴权值加密落库
- ReDoS 检测共享化(search_files/file_editor 统一拦截)
- run_tests/lint_code 升风险 + 需确认 + npx --no-install(执行边界对齐 run_command)
- MCP/SearXNG/llm.baseURL/updateFeedUrl 配置类 URL 高危目标校验(IPv6 去括号 +
  十六进制映射解析 + 尾点剥离)

P3 架构还债:
- temperature/maxTokens 热生效(引擎/编排器/SubAgent 三处接线)+ setBatch 单事务落盘
- SessionRecorder flush 竞态根治(flushPromise 等待 + 超限内联落盘 + stopRecording async)
- 内存收口(lastConsolidationBySession LRU / subTraces 清理 / 会话删除 disposeEngine)
- i18n 全量收口(28 组件 + 353 key 双字典,状态标签改渲染时函数)
- 死代码清理(updateTraceStep/HEADER_HEIGHT/void preA/失实注释)
- 斜杠菜单 MUI 化 + 删除逻辑收敛 resetSessionState + Blob URL 统一释放 +
  用户消息"仅保存"落库(saveMessage 透传前端 id 修复 id 错位)

P4 能力演进:
- 死循环检测拆分(驻留前置 + 乒乓后置带进度信号,合法交替不误报)
- run-lock 30s 超时强制 abort(旧 run 卡死不无限排队)
- RETRY 双通道 stream_reset(前端按 run 归属精确清空,根治重试文本重复)
- FTS5 trigram 中文子串搜索(迁移 9 版本化 SCHEMA_VERSION=2,≤2 字符 LIKE 回退)
- getContextWindow 兜底 1M→128K(未知模型防 413)

测试:
- 855 → 2406 用例(+1551,2.8 倍):服务层 +325(含 MemoryManager 51 新用例)、
  工具实体 +483、IPC/适配器 +390(含 OpenAI/Anthropic/Ollama 独立套件)、
  纯函数表格化 +330;引入 jsdom + @testing-library(14 组件测试文件 249 用例)
- 修复 R1(saveMessage id 透传)/ R2(stream_reset 精确归属)两个回归缺陷
- 遗留低危项清零:git-tools 顺序耦合 / web-fetch 真实时间退避 / slo 内存断言 /
  mcp-security 多余 skipIf / deepseek-balance 命名误导 / 组件 mock 注入脆弱性

版本: 0.7.4; README 同步(工具风险表/版本徽章); 依赖: 移除 @electron-toolkit/preload,
新增 jsdom/@testing-library(devDependencies 不打包)

回归: typecheck 双端 0 错误; ESLint 0/0; Electron ABI 全量 2406/2406 零跳过;
系统 Node 2110 通过 296 跳过(better-sqlite3 ABI)
This commit is contained in:
2026-08-30 19:19:07 +08:00
parent ebe45482b0
commit 99d0c54129
137 changed files with 25190 additions and 1792 deletions
@@ -0,0 +1,417 @@
/**
* OpenAIAdapter 独立测试(v0.6.4 P3-1 收敛后差异点)
*
* OpenAIAdapter 继承 OpenAICompatibleAdapter,本文件锁定 OpenAI 独有契约:
* - 推理模型(o 系列 / gpt-5)字段路由:reasoning_effort / max_completion_tokens
* - 推理模型拒图:ModelCapabilityErrorstatus=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'],
['max', 'high'], // max 归一 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 参数路由', () => {
it.each([
['o3-mini', 63_488, 63_488, 'max_completion_tokens'],
['o3-mini', 200_000, 100_000, 'max_completion_tokens'], // 上限 100000
['gpt-4o', 63_488, 16_384, 'max_tokens'],
['gpt-4.1', 63_488, 32_768, '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 → 默认 32768thinking 场景安全值)', async () => {
const adapter = makeAdapter('o3-mini');
mockFetch.mockResolvedValue(okResponse());
await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
expect(lastBody().max_completion_tokens).toBe(32_768);
});
it('非推理模型未配置 maxTokens → 默认模型上限', async () => {
const adapter = makeAdapter('gpt-4o');
mockFetch.mockResolvedValue(okResponse());
await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
expect(lastBody().max_tokens).toBe(16_384);
});
});
// ===== 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 不传 temperatureo 系列不支持)', 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 回退链', () => {
it('gpt-4.1 返回 1M 上下文', () => {
expect(makeAdapter('gpt-4.1').getContextWindow()).toBe(1_000_000);
});
it('o3-mini 返回 200K', () => {
expect(makeAdapter('o3-mini').getContextWindow()).toBe(200_000);
});
it('未知模型 → 兜底 128Kv0.7.4 P4-5 从 1M 降级)', () => {
expect(makeAdapter('unknown-model-x').getContextWindow()).toBe(128_000);
});
it('config.contextWindow 显式配置优先', () => {
const adapter = makeAdapter('gpt-4o', { contextWindow: 64_000 });
expect(adapter.getContextWindow()).toBe(64_000);
});
});
// ===== 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);
expect(models[0]).toMatchObject({ id: 'gpt-4o', contextWindow: 128_000 });
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 返回 MetonaResponsecontent/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();
});
});