feat: v0.8.0 流语义补全 · 会话可靠 · 恢复力 — finish_reason 全链路贯通根治"思考中停止" · 2445 用例全量回归
CI / 类型检查 + Lint + 单元测试 (push) Failing after 9m16s
CI / 全量测试 (Electron ABI) (push) Failing after 6m4s
CI / 产物编译验证 (push) Successful in 11m1s

P0 会话可靠性收口(根治"模型思考着会话就停止"):
- P0-1 finish_reason 全链路贯通:DONE 事件与 IterationStep 新增 finishReason,OpenAI 共享 SSE / Anthropic message_delta.stop_reason / Ollama done_reason 三路采集,TRACE 层弃用硬编码 'stop' 记录真值
- P0-2 空响应守卫 + 降级重试:零产出流→可重试错误走退避;思考耗尽输出预算(reasoning-only + length)→自动关闭思考降级重试一次;仍失败→OUTPUT_LENGTH_EXCEEDED 结构化错误 + 故障转移;附带根治 abort 恰逢零工具调用轮被 COMPLETED 抢占的真实缺陷
- P0-3 思考×能力×预算三对齐:DeepSeek/MiMo/Agnes/Ollama 四家 supportsThinking=false 强制不发思考参数;小输出预算告警;设置页联动提示
- P0-4 渲染层可见性:截断/空完成/友好错误三类提示,i18n 全部出层
- P0-5 回归四件套:reasoning-only 终止判定、集成级空闲超时、504 引擎重试归类、思考中 abort→USER_INTERRUPT、P4-2 强制收尾路径

FEAT-1:LLM 设置新增「最大输出上限」——Provider 支持矩阵显隐 + 模型上限钳制提示 + 超限保存警告 + llm.maxTokens 热生效

P1 修复面收口:
- 渲染层三缺陷根治:后台会话回放缓冲(2000 条/4MB 有界 + agent:getReplayState + 事件总线)+ abort 双层自愈 + sendMessage 收尾兜底 + 中断卡片清扫
- 工具 abort 信号全覆盖:web_search/web_fetch/http_request/code_search/git 系列/delegate_task 全部接入引擎中断;web_search 时间预算收敛(720s→≤240s);移除伪造 ToolExecutionContext 与死代码
- 安全:本地 Pinned CONNECT 代理根治浏览器通道 DNS rebinding(校验期 IP pinning,可注入 resolver 表测);配置 URL 域名解析深校验(DeepCheckSoftFailure 软失败);SSE 空 error 帧防御修复;Ollama generate/embed AbortSignal.any 合并
- 缺陷清单:UTF-16 BOM 读取、tmp 同毫秒碰撞(nanoid 后缀)、code_search JS 回退参数对称(case_sensitive/前后文独立)、list_directory include_node_modules、崩溃自愈退避(60s 窗 ≥3 次停 reload)、MemoryViewer/Sidebar i18n 收口

P2 能力演进:
- 会话回收站:SCHEMA_VERSION 3 + 迁移 10(deleted_at,存在性守卫),软删除/恢复/彻底删除/30 天自动清理(启动+24h),searchMessages 聚合剔除,Sidebar 回收站面板
- 会话回放播放器:sessions:listRecordings/readRecording(白名单+目录边界+20MB 上限),SessionReplayPlayer 时间轴/步进/变速,Trace 面板入口
- electron-updater 自动更新:双轨(手动 feed 比对保留),生产环境启动静默检查 + update:status 广播 + app:updateInstall + LogsSettings UpdatePanel + builder publish 配置
- @ 文件提及:workspace.listFiles/readFileClip(边界/512KB/NUL 拒绝/MEMORY.md 保护),ChatInput Fuse 联想+键盘导航+附件管线注入
- MCP Resources/Prompts 发现:可选能力 try/catch 降级,mcp:listServerContents,MCPSettings 展开视图
- 文档对齐:内部 API 标准 HTML(Adapter 清单补 MiMo/已实现注记/STREAM_RESET/DONE.finishReason/ repetition_truncation 映射);README v0.8.0 亮点表

P3 测试基建:
- 新增 4 个测试文件:engine-stream-contract(6)、engine-stream-reliability(4:集成空闲超时/504 重试/思考中 abort/P4-2 强制收尾)、thinking-capability-gate(7)、pinned-proxy(9,含深校验 5)、session-trash(5,DB 域)、use-agent-stream hook 级(5)、agent.test 回放缓冲(2)
- 契约更新:orchestrator 被中断 SubAgent success=false(abort 优先级修复语义)、SSE 空 error 帧、UTF-16 正常读取、DeepSeek 未配置思考显式 disabled、迁移矩阵 v2→3
- 弱断言根治:registry WEBP 单向断言、hooks-contracts 自比恒真、memory 空 token 补强

全量验证:typecheck 0 错误 / lint 0 问题 / 系统 Node 2144 通过(301 DB 用例按 ABI 跳过)/ Electron ABI 2445/2445 全量通过 0 跳过
This commit is contained in:
2026-09-05 20:06:26 +08:00
parent 99d0c54129
commit 5b9d4d19b3
78 changed files with 5128 additions and 411 deletions
@@ -0,0 +1,243 @@
/**
* v0.8.0 P0-5 回归测试(第二批):流可靠性四件套的剩余项。
*
* 1. parseSSEStream 集成级空闲超时:挂死 ReadableStream → 60s 无数据 →
* SseUpstreamError(504)P1-2 防线的集成真实性,此前仅纯函数层覆盖);
* 2. SseUpstreamError(504) 经引擎 isRetryableError 归类 → 退避重试后成功;
* 3. REASONING_DELTA 持续输出中 abort → USER_INTERRUPT"思考中点停止"场景);
* 4. 引擎 P4-2:上一 run 卡死(不响应 abort)→ 新 run 等待 30s → 强制 abort
* → 再等 5s → 抛错(防"会话永久排队")。
*/
import { describe, it, expect, vi, afterEach } from 'vitest';
import { parseSSEStream, SseUpstreamError } from '../../adapters/shared/sse-stream';
import { AgentLoopEngine } from '../engine';
import type { MetonaRequest, MetonaStreamEvent, IMetonaProviderAdapter } from '../../types';
import { MetonaStreamEventType } from '../../types';
const SYSTEM_PROMPT = {
roleDefinition: 'test',
outputConstraints: '',
safetyGuidelines: '',
};
afterEach(() => {
vi.useRealTimers();
});
// ===== 1. 集成级空闲超时 =====
describe('parseSSEStream integrated idle timeout (P0-5 #2)', () => {
function makeHungBody(): ReadableStream<Uint8Array> {
return {
getReader: () => ({
// 永不 resolve 的 read —— 模拟"服务器保活但不再推数据"
read: () => new Promise<never>(() => {}),
releaseLock: () => {},
}),
} as unknown as ReadableStream<Uint8Array>;
}
it('挂死流 60s 无数据 → SseUpstreamError(504)', async () => {
vi.useFakeTimers();
const iterator = parseSSEStream(makeHungBody(), 'r', 's', 1);
let thrown: unknown = null;
const firstRead = iterator.next().catch((e: unknown) => {
thrown = e;
return { done: true, value: undefined } as const;
});
// 推进 61sIDLE_TIMEOUT_MS=60_000 触发 idle controller → read() 竞速失败
await vi.advanceTimersByTimeAsync(61_000);
await firstRead;
expect(thrown).toBeInstanceOf(SseUpstreamError);
expect((thrown as SseUpstreamError).status).toBe(504);
expect((thrown as Error).message).toContain('idle timeout');
});
});
// ===== 2. SseUpstreamError(504) → 引擎重试 =====
describe('engine: SseUpstreamError(504) retry classification (P0-5 #3)', () => {
it('504 首败 → 退避重试 → 第二次流成功 → COMPLETED', async () => {
let call = 0;
const adapter = {
providerId: 'mock' as const,
supportedModels: ['m'],
supportsToolCalling: true,
supportsThinking: true,
getContextWindow: () => 128_000,
async send(): Promise<unknown> {
throw new Error('not used');
},
async *sendStream(_r: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
call++;
if (call === 1) {
throw new SseUpstreamError('Stream idle timeout after 60000ms (no data received)', {
status: 504,
});
}
yield {
type: MetonaStreamEventType.TEXT_DELTA,
requestId: 'r',
sessionId: 's',
iteration: 1,
seq: 0,
timestamp: Date.now(),
delta: 'recovered',
};
yield {
type: MetonaStreamEventType.DONE,
requestId: 'r',
sessionId: 's',
iteration: 1,
seq: 1,
timestamp: Date.now(),
finishReason: 'stop',
};
},
} as unknown as IMetonaProviderAdapter;
const engine = new AgentLoopEngine(
{ maxIterations: 3, totalTimeoutMs: 15_000, retryCount: 2, contextWindow: 128_000 },
adapter,
);
const events: MetonaStreamEvent[] = [];
engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
const output = await engine.runStream(
{ role: 'user', content: 'hi', timestamp: Date.now() },
's1',
[],
SYSTEM_PROMPT,
);
expect(output.terminationReason).toBe('completed');
expect(output.finalAnswer).toBe('recovered');
expect(call).toBe(2);
// 重试经过 RETRY 事件(引擎消费后向渲染层转 STREAM_RESET
expect(events.some((e) => e.type === MetonaStreamEventType.STREAM_RESET)).toBe(true);
});
});
// ===== 3. REASONING_DELTA 中途 abort =====
describe('engine: abort during reasoning stream (P0-5 #4)', () => {
it('思考增量持续输出中 abort → USER_INTERRUPT,迟到 reasoning 不再产出事件', async () => {
const adapter = {
providerId: 'mock' as const,
supportedModels: ['m'],
supportsToolCalling: true,
supportsThinking: true,
getContextWindow: () => 128_000,
async send(): Promise<unknown> {
throw new Error('not used');
},
// 持续每 10ms 推送一个 reasoning delta,直到 abort 或 500 个(挂起)
async *sendStream(_r: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
for (let i = 0; i < 500; i++) {
if (_r.params.thinkingEnabled === false) return;
yield {
type: MetonaStreamEventType.REASONING_DELTA,
requestId: 'r',
sessionId: 's',
iteration: 1,
seq: i,
timestamp: Date.now(),
delta: `t${i};`,
};
await new Promise((r) => setTimeout(r, 10));
}
yield {
type: MetonaStreamEventType.DONE,
requestId: 'r',
sessionId: 's',
iteration: 1,
seq: 999,
timestamp: Date.now(),
};
},
} as unknown as IMetonaProviderAdapter;
const engine = new AgentLoopEngine(
{ maxIterations: 3, totalTimeoutMs: 30_000, retryCount: 0, contextWindow: 128_000 },
adapter,
);
const events: MetonaStreamEvent[] = [];
engine.on('streamEvent', (e: MetonaStreamEvent) => events.push(e));
const run = engine.runStream(
{ role: 'user', content: 'hi', timestamp: Date.now() },
's1',
[],
SYSTEM_PROMPT,
);
// 等待至少 3 个 reasoning delta 到达(确认流确实在思考态输出中)
await new Promise((r) => setTimeout(r, 80));
expect(
events.filter((e) => e.type === MetonaStreamEventType.REASONING_DELTA).length,
).toBeGreaterThanOrEqual(3);
engine.abort();
const output = await run;
expect(output.terminationReason).toBe('user_interrupt');
const lastReasoningIdx = events
.map((e) => e.type)
.lastIndexOf(MetonaStreamEventType.REASONING_DELTA);
const doneIdx = events.findIndex((e) => e.type === MetonaStreamEventType.DONE);
// abort 生效后不再有迟到 reasoning(abort 尾巴过滤在引擎侧)
expect(lastReasoningIdx).toBeLessThan(doneIdx);
}, 15_000);
});
// ===== 4. P4-2: 上一 run 卡死 → 30s 强制 abort + 5s 再等待 → 抛错 =====
describe('engine: stuck previous run force-abort path (P4-2)', () => {
it('上一 run 不响应 abort → 新 run 30s 超时强制 abort → 5s 后仍卡 → 抛错', async () => {
vi.useFakeTimers();
let released = false;
const stuckAdapter = {
providerId: 'mock' as const,
supportedModels: ['m'],
supportsToolCalling: true,
supportsThinking: true,
getContextWindow: () => 128_000,
async send(): Promise<unknown> {
throw new Error('not used');
},
// 第一次 run:永远挂起且不响应 abort(模拟卡死的底层 fetch);
// 挂起生成器无 yield 属场景定义(require-yield 由下行指令豁免)
// eslint-disable-next-line require-yield
async *sendStream(): AsyncIterable<MetonaStreamEvent> {
while (!released) {
await new Promise(() => {});
}
return;
},
} as unknown as IMetonaProviderAdapter;
const engine = new AgentLoopEngine(
{ maxIterations: 3, totalTimeoutMs: 600_000, retryCount: 0, contextWindow: 128_000 },
stuckAdapter,
);
const firstRun = engine.runStream(
{ role: 'user', content: 'first', timestamp: Date.now() },
's1',
[],
SYSTEM_PROMPT,
);
firstRun.catch(() => {});
// 新消息进入 → 等待上一 run 结束(30s 超时)→ 强制 abort → 5s 再等待 → 抛错
const secondRun = engine.runStream(
{ role: 'user', content: 'second', timestamp: Date.now() },
's1',
[],
SYSTEM_PROMPT,
);
const expectation = expect(secondRun).rejects.toThrow(/Previous run did not finish/i);
// 驱动 30s 等待超时 + 5s 强制 abort 等待
await vi.advanceTimersByTimeAsync(30_500);
await vi.advanceTimersByTimeAsync(5_500);
// 清理:放行挂死流,让 firstRun 收敛
released = true;
await expectation;
}, 20_000);
});