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,715 @@
/**
* OllamaAdapter 独立测试
*
* 覆盖契约:
* - NDJSON 流式解析(thinking/content/tool_calls/done usage
* - 工具参数坏 JSON 自愈(_truncatedArguments
* - pullModel 进度回调 / 取消信号 / 非 JSON 行跳过
* - probeCapabilities / showModel / listModels / getVersion / listRunning
* - 图片 URL → base64 下载、data URI 剥前缀、失败降级
*/
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 { OllamaAdapter } from '../ollama.adapter';
import type { MetonaRequest } from '../../types';
import { MetonaStreamEventType } from '../../types';
const mockFetch = vi.fn();
function makeAdapter(model = 'qwen3', overrides: Record<string, unknown> = {}): OllamaAdapter {
return new OllamaAdapter({
provider: 'ollama',
baseURL: 'http://localhost:11434',
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: true },
...overrides,
};
}
function mockNDJSON(lines: unknown[]): void {
const payload = lines.map((l) => JSON.stringify(l)).join('\n') + '\n';
const body = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(new TextEncoder().encode(payload));
controller.close();
},
});
mockFetch.mockResolvedValue(new Response(body, { status: 200 }));
}
async function collectStream(
adapter: OllamaAdapter,
request: MetonaRequest,
): Promise<
Array<{
type: string;
delta?: string;
usage?: Record<string, unknown>;
toolCall?: Record<string, unknown>;
}>
> {
const events: Array<{
type: string;
delta?: string;
usage?: Record<string, unknown>;
toolCall?: Record<string, unknown>;
}> = [];
for await (const ev of adapter.sendStream(request)) {
events.push({
type: ev.type,
delta: ev.delta,
usage: ev.usage as Record<string, unknown> | undefined,
toolCall: ev.toolCall as Record<string, unknown> | undefined,
});
}
return events;
}
beforeEach(() => {
mockFetch.mockReset();
vi.stubGlobal('fetch', mockFetch);
});
afterEach(() => {
vi.unstubAllGlobals();
});
// ===== NDJSON 流式解析 =====
describe('OllamaAdapter — NDJSON 流式解析', () => {
it('thinking + content 逐行产出 REASONING_DELTA / TEXT_DELTA', async () => {
const adapter = makeAdapter();
mockNDJSON([
{ model: 'qwen3', message: { role: 'assistant', thinking: '思考一' } },
{ model: 'qwen3', message: { role: 'assistant', content: '正文一' } },
{ model: 'qwen3', message: { role: 'assistant', thinking: '思考二' } },
{ model: 'qwen3', message: { role: 'assistant', content: '正文二' } },
{
model: 'qwen3',
message: { role: 'assistant', content: '' },
done: true,
done_reason: 'stop',
prompt_eval_count: 3,
eval_count: 2,
},
]);
const events = await collectStream(adapter, makeRequest());
const reasoning = events.filter((e) => e.type === MetonaStreamEventType.REASONING_DELTA);
expect(reasoning.map((e) => e.delta)).toEqual(['思考一', '思考二']);
const text = events.filter((e) => e.type === MetonaStreamEventType.TEXT_DELTA);
expect(text.map((e) => e.delta)).toEqual(['正文一', '正文二']);
});
it('tool_calls 整块返回 → TOOL_CALL_COMPLETE(字符串 arguments 解析)', async () => {
const adapter = makeAdapter();
mockNDJSON([
{
model: 'qwen3',
message: {
role: 'assistant',
content: '',
tool_calls: [
{ function: { name: 'read_file', arguments: '{"path":"a.txt"}' } },
{ function: { name: 'list_dir', arguments: '{"path":"."}' } },
],
},
},
{
model: 'qwen3',
message: { role: 'assistant', content: '' },
done: true,
done_reason: 'stop',
prompt_eval_count: 1,
eval_count: 1,
},
]);
const events = await collectStream(adapter, makeRequest());
const completes = events.filter((e) => e.type === MetonaStreamEventType.TOOL_CALL_COMPLETE);
expect(completes).toHaveLength(2);
expect(completes[0].toolCall!.name).toBe('read_file');
expect(completes[0].toolCall!.args).toEqual({ path: 'a.txt' });
expect(completes[1].toolCall!.name).toBe('list_dir');
expect(completes[1].toolCall!.id).toMatch(/^tc_/);
});
it('done chunk → USAGEprompt_eval_count/eval_count+ DONE', async () => {
const adapter = makeAdapter();
mockNDJSON([
{ model: 'qwen3', message: { role: 'assistant', content: 'x' } },
{
model: 'qwen3',
message: { role: 'assistant', content: '' },
done: true,
done_reason: 'stop',
prompt_eval_count: 11,
eval_count: 7,
},
]);
const events = await collectStream(adapter, makeRequest());
const usage = events.find((e) => e.type === MetonaStreamEventType.USAGE)?.usage;
expect(usage).toMatchObject({ inputTokens: 11, outputTokens: 7, totalTokens: 18 });
expect(events[events.length - 1].type).toBe(MetonaStreamEventType.DONE);
});
it('坏 NDJSON 行被跳过不中断流(记录警告)', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue(
new Response(
new ReadableStream<Uint8Array>({
start(controller) {
const encoder = new TextEncoder();
controller.enqueue(encoder.encode('{bad json\n'));
controller.enqueue(
encoder.encode(
JSON.stringify({ model: 'm', message: { role: 'assistant', content: 'ok' } }) +
'\n',
),
);
controller.enqueue(
encoder.encode(
JSON.stringify({
model: 'm',
message: { role: 'assistant', content: '' },
done: true,
}) + '\n',
),
);
controller.close();
},
}),
{ status: 200 },
),
);
const events = await collectStream(adapter, makeRequest());
expect(
events.some((e) => e.type === MetonaStreamEventType.TEXT_DELTA && e.delta === 'ok'),
).toBe(true);
expect(events[events.length - 1].type).toBe(MetonaStreamEventType.DONE);
});
it('流断开(无 done 行)→ 补发 DONE 防止挂起', async () => {
const adapter = makeAdapter();
mockNDJSON([{ model: 'm', message: { role: 'assistant', content: 'partial' } }]);
const events = await collectStream(adapter, makeRequest());
expect(events[events.length - 1].type).toBe(MetonaStreamEventType.DONE);
});
it('工具参数坏 JSON → _truncatedArguments 自愈,且同 chunk 后续 done 仍处理', async () => {
const adapter = makeAdapter();
mockNDJSON([
{
model: 'qwen3',
message: {
role: 'assistant',
tool_calls: [{ function: { name: 'write', arguments: '{"path":"a","cont' } }],
},
},
{
model: 'qwen3',
message: { role: 'assistant', content: '' },
done: true,
done_reason: 'stop',
prompt_eval_count: 5,
eval_count: 1,
},
]);
const events = await collectStream(adapter, makeRequest());
const completes = events.filter((e) => e.type === MetonaStreamEventType.TOOL_CALL_COMPLETE);
expect(completes).toHaveLength(1);
const args = completes[0].toolCall!.args as Record<string, unknown>;
expect(args._truncatedArguments).toBe(true);
expect(String(args._truncatedReason)).toContain('truncated');
// done/USAGE 未被吞
expect(events.some((e) => e.type === MetonaStreamEventType.USAGE)).toBe(true);
expect(events[events.length - 1].type).toBe(MetonaStreamEventType.DONE);
});
it('工具参数为对象类型 → 原样保留', async () => {
const adapter = makeAdapter();
mockNDJSON([
{
model: 'm',
message: {
role: 'assistant',
tool_calls: [{ function: { name: 'f', arguments: { a: 1 } } }],
},
},
{ model: 'm', message: { role: 'assistant', content: '' }, done: true, done_reason: 'stop' },
]);
const events = await collectStream(adapter, makeRequest());
const complete = events.find((e) => e.type === MetonaStreamEventType.TOOL_CALL_COMPLETE);
expect(complete?.toolCall?.args).toEqual({ a: 1 });
});
});
// ===== 非流式 send 响应 =====
describe('OllamaAdapter — 非流式 send', () => {
function mockJsonResponse(body: unknown): void {
mockFetch.mockResolvedValue({
ok: true,
status: 200,
json: async () => body,
} as unknown as Response);
}
it('send 组装 MetonaResponse(含 perfStats / done_reason 映射)', async () => {
const adapter = makeAdapter();
mockJsonResponse({
model: 'qwen3',
message: { role: 'assistant', content: 'answer', thinking: 'trace' },
done: true,
done_reason: 'stop',
prompt_eval_count: 4,
eval_count: 3,
load_duration: 1_000_000,
eval_duration: 2_000_000_000,
});
const res = await adapter.send(makeRequest({ params: { stream: false } }));
expect(res.content).toBe('answer');
expect(res.reasoningContent).toBe('trace');
expect(res.usage.totalTokens).toBe(7);
expect(res.finishReason).toBe('stop');
expect(res.meta.perfStats).toMatchObject({
loadDurationMs: 1,
evalDurationMs: 2000,
});
});
it('done_reason=length → LENGTH finishReason', async () => {
const adapter = makeAdapter();
mockJsonResponse({
message: { role: 'assistant', content: 'cut' },
done: true,
done_reason: 'length',
prompt_eval_count: 1,
eval_count: 100,
});
const res = await adapter.send(makeRequest());
expect(res.finishReason).toBe('length');
});
it('message.tool_calls 存在 → TOOL_CALLS finishReasondone_reason 无关)', async () => {
const adapter = makeAdapter();
mockJsonResponse({
message: {
role: 'assistant',
content: '',
tool_calls: [{ function: { name: 'f', arguments: '{"a":1}' } }],
},
done: true,
done_reason: 'stop',
prompt_eval_count: 0,
eval_count: 0,
});
const res = await adapter.send(makeRequest());
expect(res.finishReason).toBe('tool_calls');
expect(res.toolCalls).toHaveLength(1);
});
it('非流式坏参 → _truncatedArguments 自愈', async () => {
const adapter = makeAdapter();
mockJsonResponse({
message: {
role: 'assistant',
content: '',
tool_calls: [{ function: { name: 'f', arguments: '{bad' } }],
},
done: true,
done_reason: 'tool_calls',
prompt_eval_count: 0,
eval_count: 0,
});
const res = await adapter.send(makeRequest());
const args = res.toolCalls![0].args as Record<string, unknown>;
expect(args._truncatedArguments).toBe(true);
});
it('HTTP 错误 → throwHttpError 携带 status', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({
ok: false,
status: 500,
statusText: 'Internal Server Error',
text: async () => 'oops',
} as unknown as Response);
const err = await adapter.send(makeRequest()).catch((e: unknown) => e);
expect((err as Error & { status?: number }).status).toBe(500);
});
});
// ===== pullModel =====
describe('OllamaAdapter — pullModel 进度 / 取消', () => {
it('进度逐行回调(status/completed/total),结束后 resolve', async () => {
const adapter = makeAdapter();
const lines = [
{ status: 'pulling manifest' },
{ status: 'downloading', completed: 50, total: 100 },
{ status: 'downloading', completed: 100, total: 100 },
{ status: 'success', completed: 100, total: 100 },
];
const body = new ReadableStream<Uint8Array>({
start(controller) {
const encoder = new TextEncoder();
for (const l of lines) controller.enqueue(encoder.encode(JSON.stringify(l) + '\n'));
controller.close();
},
});
mockFetch.mockResolvedValue(new Response(body, { status: 200 }));
const progress: Array<Record<string, unknown>> = [];
await adapter.pullModel('qwen3:8b', (p) => progress.push(p as Record<string, unknown>));
expect(progress).toHaveLength(4);
expect(progress[1]).toEqual({ status: 'downloading', completed: 50, total: 100 });
expect(mockFetch).toHaveBeenCalledWith(
'http://localhost:11434/api/pull',
expect.objectContaining({ body: JSON.stringify({ model: 'qwen3:8b', stream: true }) }),
);
});
it('非 JSON 行(进度提示)被跳过不中断', async () => {
const adapter = makeAdapter();
const body = new ReadableStream<Uint8Array>({
start(controller) {
const encoder = new TextEncoder();
controller.enqueue(encoder.encode('some text line\n'));
controller.enqueue(encoder.encode(JSON.stringify({ status: 'success' }) + '\n'));
controller.close();
},
});
mockFetch.mockResolvedValue(new Response(body, { status: 200 }));
const progress: Array<Record<string, unknown>> = [];
await adapter.pullModel('m', (p) => progress.push(p as Record<string, unknown>));
expect(progress).toEqual([{ status: 'success' }]);
});
it('取消信号中止底层 fetchsignal 透传)', async () => {
const adapter = makeAdapter();
const controller = new AbortController();
const signalSpy = vi.fn();
mockFetch.mockImplementation((_url: string, init: RequestInit) => {
init.signal?.addEventListener('abort', signalSpy);
return new Promise<Response>((_r, rej) => {
init.signal?.addEventListener('abort', () =>
rej(new DOMException('aborted', 'AbortError')),
);
});
});
const promise = adapter.pullModel('qwen3:8b', undefined, controller.signal);
controller.abort();
await expect(promise).rejects.toMatchObject({ name: 'AbortError' });
expect(signalSpy).toHaveBeenCalled();
});
it('HTTP 非 2xx → 抛 Ollama pull error', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({ ok: false, status: 404, body: null } as unknown as Response);
await expect(adapter.pullModel('nope')).rejects.toThrow('Ollama pull error: 404');
});
});
// ===== probeCapabilities / showModel / listModels =====
describe('OllamaAdapter — 能力探测', () => {
it('probeCapabilities 从 capabilities[] 解析三能力', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({
ok: true,
status: 200,
json: async () => ({
parameters: '',
template: '',
capabilities: ['tools', 'vision', 'thinking'],
}),
} as unknown as Response);
const caps = await adapter.probeCapabilities('qwen3');
expect(caps).toEqual({ supportsTools: true, supportsVision: true, supportsThinking: true });
});
it('capabilities 为空数组(showModel 缺省 [])→ 三能力全 false(非 null', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({
ok: true,
status: 200,
json: async () => ({ parameters: '', template: '' }),
} as unknown as Response);
expect(await adapter.probeCapabilities('qwen3')).toEqual({
supportsTools: false,
supportsVision: false,
supportsThinking: false,
});
});
it('showModel 失败 → probeCapabilities 返回 null(调用方回退保守 true', async () => {
const adapter = makeAdapter();
mockFetch.mockRejectedValue(new Error('down'));
expect(await adapter.probeCapabilities('qwen3')).toBeNull();
});
it('showModel 非 2xx → null', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({ ok: false, status: 500 } as unknown as Response);
expect(await adapter.showModel('m')).toBeNull();
});
it('showModel 网络异常 → null(不抛出)', async () => {
const adapter = makeAdapter();
mockFetch.mockRejectedValue(new Error('ECONNREFUSED'));
expect(await adapter.showModel('m')).toBeNull();
});
it('listModels/api/tags 成功 → 逐模型探测并组装元信息', async () => {
// 构造时的 fire-and-forget /api/show 探测会先消费第一个 mock → 先给良性响应
mockFetch
.mockResolvedValueOnce({
ok: true,
status: 200,
json: async () => ({ parameters: '' }),
} as unknown as Response)
.mockResolvedValueOnce({
ok: true,
status: 200,
json: async () => ({
models: [
{
name: 'qwen3',
size: 123,
details: { family: 'qwen', parameter_size: '8B', quantization_level: 'Q4' },
},
],
}),
} as unknown as Response)
.mockResolvedValue({
ok: true,
status: 200,
json: async () => ({ parameters: '', template: '', capabilities: ['tools', 'vision'] }),
} as unknown as Response);
const adapter = makeAdapter();
const models = await adapter.listModels();
expect(models).toHaveLength(1);
expect(models[0]).toMatchObject({
id: 'qwen3',
supportsToolCalling: true,
supportsVision: true,
supportsThinking: false,
});
expect(models[0].description).toContain('qwen / 8B / Q4');
});
it('listModelsAPI 失败 → 降级 supportedModels', async () => {
const adapter = makeAdapter();
mockFetch.mockRejectedValue(new Error('network'));
const models = await adapter.listModels();
expect(models.map((m) => m.id)).toEqual([
'qwen3:latest',
'gemma3:latest',
'deepseek-r1:latest',
]);
});
it('getVersion 成功返回版本号;失败返回 unknown', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({
ok: true,
status: 200,
json: async () => ({ version: '0.5.1' }),
} as unknown as Response);
expect(await adapter.getVersion()).toBe('0.5.1');
mockFetch.mockReset();
mockFetch.mockRejectedValue(new Error('down'));
expect(await adapter.getVersion()).toBe('unknown');
});
it('listRunning 映射运行中模型;失败返回空数组', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue({
ok: true,
status: 200,
json: async () => ({
models: [{ name: 'qwen3', size: 100, size_vram: 90, context_length: 4096 }],
}),
} as unknown as Response);
const running = await adapter.listRunning();
expect(running[0]).toEqual({ name: 'qwen3', size: 100, sizeVram: 90, contextLength: 4096 });
mockFetch.mockReset();
mockFetch.mockRejectedValue(new Error('down'));
expect(await adapter.listRunning()).toEqual([]);
});
});
// ===== 图片 URL → base64 =====
describe('OllamaAdapter — 图片归一化', () => {
function okChatResponse(): Response {
return {
ok: true,
status: 200,
json: async () => ({
message: { role: 'assistant', content: 'ok' },
done: true,
done_reason: 'stop',
}),
} as unknown as Response;
}
function lastBody(): Record<string, unknown> {
const calls = mockFetch.mock.calls;
const chatCall = calls.find(([url]) => String(url).includes('/api/chat')) as [
string,
RequestInit,
];
return JSON.parse(String(chatCall[1].body));
}
it('http URL 图片下载为纯 base64(无 data: 前缀)', async () => {
const adapter = makeAdapter();
const imageBytes = new TextEncoder().encode('IMG-BYTES');
mockFetch
.mockResolvedValueOnce({
ok: true,
status: 200,
arrayBuffer: async () => imageBytes.buffer,
} as unknown as Response)
.mockResolvedValue(okChatResponse());
await adapter.send(
makeRequest({
messages: [
{
role: 'user',
content: '看图',
images: [{ url: 'https://example.com/pic.png' }],
timestamp: Date.now(),
},
],
}),
);
const body = lastBody();
const userMsg = (body.messages as Array<Record<string, unknown>>).find(
(m) => m.role === 'user',
);
expect(userMsg!.images).toEqual([Buffer.from('IMG-BYTES').toString('base64')]);
});
it('http URL 下载失败 → 图片被忽略(空数组/不发送),请求不阻断', async () => {
const adapter = makeAdapter();
mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED')).mockResolvedValue(okChatResponse());
const res = await adapter.send(
makeRequest({
messages: [
{
role: 'user',
content: '看图',
images: [{ url: 'https://example.com/pic.png' }],
timestamp: Date.now(),
},
],
}),
);
expect(res.content).toBe('ok');
});
it('data URI 图片剥前缀;纯 base64 原样保留', async () => {
const adapter = makeAdapter();
mockFetch.mockResolvedValue(okChatResponse());
await adapter.send(
makeRequest({
messages: [
{
role: 'user',
content: '看图',
images: [
{ url: 'data:image/png;base64,AAAABBBB' },
{ url: 'iVBORw0KGgo', detail: 'high' },
],
timestamp: Date.now(),
},
],
}),
);
const body = lastBody();
const userMsg = (body.messages as Array<Record<string, unknown>>).find(
(m) => m.role === 'user',
);
expect(userMsg!.images).toEqual(['AAAABBBB', 'iVBORw0KGgo']);
});
it('HTTP 下载响应非 2xx → 图片降级忽略', async () => {
const adapter = makeAdapter();
mockFetch
.mockResolvedValueOnce({ ok: false, status: 404 } as unknown as Response)
.mockResolvedValue(okChatResponse());
await adapter.send(
makeRequest({
messages: [
{
role: 'user',
content: '看图',
images: [{ url: 'https://example.com/missing.png' }],
timestamp: Date.now(),
},
],
}),
);
const body = lastBody();
const userMsg = (body.messages as Array<Record<string, unknown>>).find(
(m) => m.role === 'user',
);
expect(userMsg!.images).toEqual([]);
});
});
// ===== getContextWindow =====
describe('OllamaAdapter — getContextWindow', () => {
it('未探测到时返回默认 4096', () => {
const adapter = makeAdapter();
expect(adapter.getContextWindow()).toBe(4096);
});
it('探测到 num_ctx 后返回实测值(机会主义缓存收敛)', async () => {
// 需在构造前就位:构造时的 fire-and-forget 探测消费首个 fetch
mockFetch.mockResolvedValue({
ok: true,
status: 200,
json: async () => ({ parameters: 'num_ctx 32768', template: '', capabilities: [] }),
} as unknown as Response);
const adapter = makeAdapter();
// 等待构造时的探测完成并写入缓存
await vi.waitFor(() => expect(adapter.getContextWindow()).toBe(32768));
});
it('探测失败(网络错误)→ 保持默认 4096', async () => {
mockFetch.mockRejectedValue(new Error('down'));
const adapter = makeAdapter();
await new Promise((r) => setTimeout(r, 20));
expect(adapter.getContextWindow()).toBe(4096);
});
});