@hugesb/dsh-stream-agent 0.3.1 → 0.3.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +125 -0
- package/README.en.md +3 -3
- package/README.md +3 -3
- package/dist/entry/loop.js +332 -21
- package/dist/entry/mock-provider.js +20 -7
- package/dist/kernel/parser.js +488 -39
- package/dist/kernel/render.js +25 -3
- package/dist/version.js +1 -1
- package/package.json +2 -2
- package/scripts/release.mjs +20 -7
- package/scripts/repair-session-logs.mjs +105 -10
- package/src/entry/loop.ts +332 -21
- package/src/entry/mock-provider.ts +20 -7
- package/src/kernel/parser.ts +488 -39
- package/src/kernel/render.ts +25 -3
- package/src/version.ts +1 -1
- package/test/host-conformance.test.ts +418 -0
- package/test/kernel/parser.test.ts +3 -2
- package/test/v032-conflict.test.ts +191 -0
- package/test/v032-truncation.test.ts +291 -0
|
@@ -0,0 +1,191 @@
|
|
|
1
|
+
// test/v032-conflict.test.ts —— v0.3.2 宿主契约冲突回归(真机 session-8f22c7a0,2026-11-20 23:31)
|
|
2
|
+
//
|
|
3
|
+
// "修复"后截断仍发生——对照 GitHub deepseek-harness 源码(packages/llm/llm/src/index.ts
|
|
4
|
+
// 的 forAdapter 与 packages/llm/llm-deepseek/src/serialize.ts)找到的**四个独立因素**:
|
|
5
|
+
// W1 崩溃主因:宿主 LlmRuntime.forAdapter 对请求里的每条 assistant 消息读
|
|
6
|
+
// `message.source.replayState`(master 无防护)——并行修复新增的"正文落追加区"
|
|
7
|
+
// 用 role:'assistant' 但不带 source,正文首次落史后的下一请求必崩
|
|
8
|
+
// (TypeError: Cannot read properties of undefined (reading 'replayState')),
|
|
9
|
+
// 流以 error finish 收场 → 回合 blocked。本回归:assistant 线格式消息必须带 source。
|
|
10
|
+
// W2 nudge 一次性预算误杀生产性回合:nudge 在"写文件步"被消耗后,任何后续
|
|
11
|
+
// 无注入步骤直接 nudgeExhausted → blocked。本回归:nudge 后继续产出不中断,
|
|
12
|
+
// 零产出才收束(C3 语义不变)。
|
|
13
|
+
// W3 XML 实体未解码:模型把 `command="... "EXIT=1""` 的实体原样传给
|
|
14
|
+
// PowerShell → 命令报错,白烧一步。本回归:属性值实体解码。
|
|
15
|
+
// W4 DSML 内联属性 invoke 走 body 模式吞包装残片:闭合标签到流末才露出。
|
|
16
|
+
// 本回归:内联属性 + parameter 混合形态整体缓冲,命令属性齐全、残片不进正文。
|
|
17
|
+
|
|
18
|
+
import { test } from 'node:test';
|
|
19
|
+
import assert from 'node:assert/strict';
|
|
20
|
+
import { mkdtempSync, rmSync } from 'node:fs';
|
|
21
|
+
import { tmpdir } from 'node:os';
|
|
22
|
+
import { join } from 'node:path';
|
|
23
|
+
|
|
24
|
+
import { SingleStreamDriver, normalizeStreamShim } from '../src/entry/loop.ts';
|
|
25
|
+
import type {
|
|
26
|
+
DriverPorts,
|
|
27
|
+
StreamChunkLike,
|
|
28
|
+
StreamRequestOptions,
|
|
29
|
+
ToolBatchInputLike,
|
|
30
|
+
ToolBatchResultLike,
|
|
31
|
+
} from '../src/entry/loop.ts';
|
|
32
|
+
import { TfStreamParser } from '../src/kernel/parser.ts';
|
|
33
|
+
import type { ParserEvent, TfCommand } from '../src/kernel/parser.ts';
|
|
34
|
+
import { createMockModel } from '../src/entry/mock-provider.ts';
|
|
35
|
+
|
|
36
|
+
// ---------------------------------------------------------------- 设施
|
|
37
|
+
|
|
38
|
+
type ChunkGen = AsyncGenerator<StreamChunkLike, void, undefined>;
|
|
39
|
+
|
|
40
|
+
async function* scriptedStream(chunks: readonly StreamChunkLike[]): ChunkGen {
|
|
41
|
+
for (const chunk of chunks) yield chunk;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
function textDelta(text: string, index = 1): StreamChunkLike {
|
|
45
|
+
return { type: 'text-delta', index, text } as StreamChunkLike;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
function finishStop(): StreamChunkLike {
|
|
49
|
+
return { type: 'finish', reason: { kind: 'stop' } } as StreamChunkLike;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
interface Harness {
|
|
53
|
+
driver: SingleStreamDriver;
|
|
54
|
+
/** 逐请求的线格式消息(原样引用,供 source 断言) */
|
|
55
|
+
wireRequests: StreamRequestOptions['messages'][];
|
|
56
|
+
sandboxDir: string;
|
|
57
|
+
cleanup: () => void;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function makeHarness(responses: ReadonlyArray<readonly StreamChunkLike[]>, task: string): Harness {
|
|
61
|
+
const sandboxDir = mkdtempSync(join(tmpdir(), 'tf-v032c-'));
|
|
62
|
+
const wireRequests: StreamRequestOptions['messages'][] = [];
|
|
63
|
+
let call = 0;
|
|
64
|
+
const ports: DriverPorts = {
|
|
65
|
+
stream: (options) => {
|
|
66
|
+
wireRequests.push(options.messages);
|
|
67
|
+
const chunks = responses[Math.min(call, responses.length - 1)]!;
|
|
68
|
+
call += 1;
|
|
69
|
+
return normalizeStreamShim(scriptedStream(chunks));
|
|
70
|
+
},
|
|
71
|
+
executeTools: async (input: ToolBatchInputLike): Promise<ToolBatchResultLike> => {
|
|
72
|
+
const results = [];
|
|
73
|
+
for (const callItem of input.calls) {
|
|
74
|
+
results.push({ callId: callItem.id, result: { content: [{ type: 'text', text: `ok:${callItem.name}` }], isError: false } });
|
|
75
|
+
}
|
|
76
|
+
return { results };
|
|
77
|
+
},
|
|
78
|
+
};
|
|
79
|
+
const driver = new SingleStreamDriver(ports, { provider: 'mock-provider', model: 'mock-model', streamIdleTimeoutMs: 30_000 });
|
|
80
|
+
driver.pushUserTask(task);
|
|
81
|
+
return { driver, wireRequests, sandboxDir, cleanup: () => rmSync(sandboxDir, { recursive: true, force: true }) };
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
// ---------------------------------------------------------------- W1 崩溃主因
|
|
85
|
+
|
|
86
|
+
test('W1. assistant 线格式消息必须携带 source(宿主 forAdapter 契约;缺失即流崩溃)', async () => {
|
|
87
|
+
const responses: ReadonlyArray<readonly StreamChunkLike[]> = [
|
|
88
|
+
[
|
|
89
|
+
textDelta('我先写文件。\n'),
|
|
90
|
+
textDelta('<tf-write path="a.txt" id="w1">x</tf-write>\n'),
|
|
91
|
+
finishStop(),
|
|
92
|
+
],
|
|
93
|
+
[
|
|
94
|
+
textDelta('写完了,收尾:a.txt 内容为 x,任务完成。\n'),
|
|
95
|
+
textDelta('<tf-final id="f1" summary="a.txt 已写入(内容 x),任务完成。"/>\n'),
|
|
96
|
+
finishStop(),
|
|
97
|
+
],
|
|
98
|
+
];
|
|
99
|
+
const harness = makeHarness(responses, '写 a.txt 后收尾。');
|
|
100
|
+
try {
|
|
101
|
+
const reason = await harness.driver.runTurn();
|
|
102
|
+
assert.equal(reason.kind, 'completed', `应收敛:${JSON.stringify(reason)}`);
|
|
103
|
+
assert.ok(harness.wireRequests.length >= 2);
|
|
104
|
+
// 请求 1:无任何 assistant 消息(正文尚未落史)
|
|
105
|
+
for (const message of harness.wireRequests[0]!) {
|
|
106
|
+
assert.notEqual(message.role, 'assistant', '请求 1 不应有 assistant 历史');
|
|
107
|
+
}
|
|
108
|
+
// 请求 2:正文已落史 → assistant 消息必须带完整 source(缺了宿主 forAdapter 即崩)
|
|
109
|
+
const assistants = harness.wireRequests[1]!.filter((m) => m.role === 'assistant');
|
|
110
|
+
assert.ok(assistants.length >= 1, '请求 2 应有落史的 assistant 消息');
|
|
111
|
+
for (const message of assistants) {
|
|
112
|
+
assert.notEqual(message.source, undefined, 'assistant 线消息缺 source → 宿主 forAdapter 崩溃(真机 seq 121)');
|
|
113
|
+
assert.equal(message.source!.kind, 'model');
|
|
114
|
+
assert.equal(message.source!.provider, 'mock-provider');
|
|
115
|
+
assert.equal(message.source!.model, 'mock-model');
|
|
116
|
+
}
|
|
117
|
+
} finally {
|
|
118
|
+
harness.cleanup();
|
|
119
|
+
}
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
// ---------------------------------------------------------------- W2 nudge 进度
|
|
123
|
+
|
|
124
|
+
test('W2. nudge 后继续产出不中断:写文件步不被 nudgeExhausted 误杀(零产出才收束)', async () => {
|
|
125
|
+
const responses: ReadonlyArray<readonly StreamChunkLike[]> = [
|
|
126
|
+
[
|
|
127
|
+
textDelta('写第一个文件。\n'),
|
|
128
|
+
textDelta('<tf-write path="a.txt" id="w1">x</tf-write>\n'),
|
|
129
|
+
finishStop(),
|
|
130
|
+
],
|
|
131
|
+
[
|
|
132
|
+
textDelta('写第二个文件。\n'),
|
|
133
|
+
textDelta('<tf-write path="b.txt" id="w2">y</tf-write>\n'),
|
|
134
|
+
finishStop(),
|
|
135
|
+
],
|
|
136
|
+
[
|
|
137
|
+
textDelta('两个文件都写完了:a.txt=x,b.txt=y,任务完成。\n'),
|
|
138
|
+
textDelta('<tf-final id="f1" summary="a.txt=x、b.txt=y 已写入,任务完成。"/>\n'),
|
|
139
|
+
finishStop(),
|
|
140
|
+
],
|
|
141
|
+
];
|
|
142
|
+
const harness = makeHarness(responses, '写两个文件后收尾。');
|
|
143
|
+
try {
|
|
144
|
+
const reason = await harness.driver.runTurn();
|
|
145
|
+
assert.equal(reason.kind, 'completed', `nudge 后继续产出不得中断(旧语义在请求 2 后即 blocked):${JSON.stringify(reason)}`);
|
|
146
|
+
assert.equal(harness.wireRequests.length, 3, `三步三请求,实际 ${harness.wireRequests.length}`);
|
|
147
|
+
} finally {
|
|
148
|
+
harness.cleanup();
|
|
149
|
+
}
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
// ---------------------------------------------------------------- W3 实体解码
|
|
153
|
+
|
|
154
|
+
function commandsOf(events: ParserEvent[]): TfCommand[] {
|
|
155
|
+
return events.filter((e) => e.type === 'command').map((e) => (e as { command: TfCommand }).command);
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
test('W3. 属性值 XML 实体解码:" 进 PowerShell 前还原为引号(真机 step 5 selfcheck 报错)', () => {
|
|
159
|
+
const parser = new TfStreamParser();
|
|
160
|
+
const events = parser.feed('<tf-bash id="b4" cmd="python selfcheck.py; Write-Output "EXIT=$LASTEXITCODE""/>');
|
|
161
|
+
events.push(...parser.end());
|
|
162
|
+
const cmds = commandsOf(events);
|
|
163
|
+
assert.equal(cmds.length, 1, `命令应解析:${JSON.stringify(events)}`);
|
|
164
|
+
assert.equal(cmds[0]!.attrs['cmd'], 'python selfcheck.py; Write-Output "EXIT=$LASTEXITCODE"');
|
|
165
|
+
// & 单遍解码不二次展开:&quot; → "(不变成 ")
|
|
166
|
+
const parser2 = new TfStreamParser();
|
|
167
|
+
const events2 = parser2.feed('<tf-bash id="b" cmd="echo &quot;x&quot;"/>');
|
|
168
|
+
events2.push(...parser2.end());
|
|
169
|
+
const cmds2 = commandsOf(events2);
|
|
170
|
+
assert.equal(cmds2[0]!.attrs['cmd'], 'echo "x"');
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
// ---------------------------------------------------------------- W4 DSML 内联属性
|
|
174
|
+
|
|
175
|
+
test('W4. DSML 内联属性 + parameter 混合形态:整体缓冲,命令属性齐全,包装残片不进正文', () => {
|
|
176
|
+
const parser = new TfStreamParser();
|
|
177
|
+
const events: ParserEvent[] = [];
|
|
178
|
+
events.push(...parser.feed('<||DSML|| invoke name="tf-read" id="r1">\n'));
|
|
179
|
+
events.push(...parser.feed('<||DSML|| parameter name="path">README.md</||DSML|| parameter>\n'));
|
|
180
|
+
events.push(...parser.feed('</||DSML|| invoke>\n'));
|
|
181
|
+
events.push(...parser.feed('</||DSML|| calls>\n'));
|
|
182
|
+
events.push(...parser.end());
|
|
183
|
+
const cmds = commandsOf(events);
|
|
184
|
+
assert.equal(cmds.length, 1, `命令应解析(旧实现走 body 模式吞残片):${JSON.stringify(events.map((e) => e.type))}`);
|
|
185
|
+
assert.equal(cmds[0]!.name, 'tf-read');
|
|
186
|
+
assert.equal(cmds[0]!.id, 'r1', '内联属性保留(id 提升为命令身份)');
|
|
187
|
+
assert.equal(cmds[0]!.attrs['path'], 'README.md', 'parameter 归集');
|
|
188
|
+
const prose = events.filter((e) => e.type === 'text').map((e) => (e as { text: string }).text).join('');
|
|
189
|
+
assert.ok(!prose.includes('DSML'), '包装残片不得进正文');
|
|
190
|
+
assert.ok(!prose.includes('README.md'), '参数值不得进正文');
|
|
191
|
+
});
|
|
@@ -0,0 +1,291 @@
|
|
|
1
|
+
// test/v032-truncation.test.ts —— v0.3.2 会话中途截断修复(真机 session-e4b9a89c)
|
|
2
|
+
//
|
|
3
|
+
// 覆盖四条根因(取证见 CHANGELOG 0.3.2):
|
|
4
|
+
// T1 DSML 参数式调用被当噪声:`invoke` + `parameter` 子标签形态下,命令丢失、
|
|
5
|
+
// 参数值(README.md / r10 / 命令行)作为 prose 漏进正文 —— 用户侧就是"截断的正文"。
|
|
6
|
+
// T2 请求之间无会话记忆:上一步的 assistant 正文 / 命令 / 结果不进追加区,
|
|
7
|
+
// 观测只注入一次;第 3 个请求起模型只看到 system + 任务 + 句柄目录行
|
|
8
|
+
// (真机原话 "The history is truncated")。
|
|
9
|
+
// T3 非正文命令的配对开标签(少写 '/')吞掉后续整段输出。
|
|
10
|
+
// T4 max-tokens / 块未闭合的截断没有任何续写事由:回合"安静地"结束在半截输出上。
|
|
11
|
+
//
|
|
12
|
+
// 断言全部对着**线格式请求**(wireRequests)与**落盘事件**,不看内部字段。
|
|
13
|
+
|
|
14
|
+
import { test } from 'node:test';
|
|
15
|
+
import assert from 'node:assert/strict';
|
|
16
|
+
import { mkdtempSync, rmSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
|
|
17
|
+
import { tmpdir } from 'node:os';
|
|
18
|
+
import { join } from 'node:path';
|
|
19
|
+
|
|
20
|
+
import { SingleStreamDriver, createSessionEventWriter } from '../src/entry/loop.ts';
|
|
21
|
+
import type {
|
|
22
|
+
DriverPorts,
|
|
23
|
+
StreamChunkLike,
|
|
24
|
+
StreamDriverConfig,
|
|
25
|
+
ToolBatchInputLike,
|
|
26
|
+
ToolBatchResultLike,
|
|
27
|
+
} from '../src/entry/loop.ts';
|
|
28
|
+
import { TfStreamParser } from '../src/kernel/parser.ts';
|
|
29
|
+
import type { ParserEvent, TfCommand } from '../src/kernel/parser.ts';
|
|
30
|
+
|
|
31
|
+
// ---------------------------------------------------------------- 解析器设施
|
|
32
|
+
|
|
33
|
+
function commandsOf(events: ParserEvent[]): TfCommand[] {
|
|
34
|
+
return events.filter((e) => e.type === 'command').map((e) => (e as { command: TfCommand }).command);
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
function proseOf(events: ParserEvent[]): string {
|
|
38
|
+
return events.filter((e) => e.type === 'text').map((e) => (e as { text: string }).text).join('');
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
function feedAll(parser: TfStreamParser, deltas: string[]): ParserEvent[] {
|
|
42
|
+
const out: ParserEvent[] = [];
|
|
43
|
+
for (const delta of deltas) out.push(...parser.feed(delta));
|
|
44
|
+
out.push(...parser.end());
|
|
45
|
+
return out;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
// ---------------------------------------------------------------- 驱动器设施
|
|
49
|
+
|
|
50
|
+
type ChunkGen = AsyncGenerator<StreamChunkLike, void, undefined>;
|
|
51
|
+
|
|
52
|
+
async function* scriptedStream(chunks: readonly StreamChunkLike[]): ChunkGen {
|
|
53
|
+
for (const chunk of chunks) yield chunk;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
function textDelta(text: string, index = 1): StreamChunkLike {
|
|
57
|
+
return { type: 'text-delta', index, text } as StreamChunkLike;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function finish(kind: 'stop' | 'max-tokens'): StreamChunkLike {
|
|
61
|
+
return { type: 'finish', reason: { kind } } as StreamChunkLike;
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
interface DriverHarness {
|
|
65
|
+
driver: SingleStreamDriver;
|
|
66
|
+
/** 逐请求的线格式消息文本(每条 message 一项) */
|
|
67
|
+
requests: string[][];
|
|
68
|
+
sandboxDir: string;
|
|
69
|
+
cleanup: () => void;
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
function createExecutor(sandboxDir: string) {
|
|
73
|
+
return async (input: ToolBatchInputLike): Promise<ToolBatchResultLike> => {
|
|
74
|
+
const results: ToolBatchResultLike['results'] = [];
|
|
75
|
+
for (const call of input.calls) {
|
|
76
|
+
let args: Record<string, unknown> = {};
|
|
77
|
+
try {
|
|
78
|
+
args = JSON.parse(call.arguments) as Record<string, unknown>;
|
|
79
|
+
} catch {
|
|
80
|
+
results.push({ callId: call.id, result: { content: [{ type: 'text', text: 'bad json' }], isError: true } });
|
|
81
|
+
continue;
|
|
82
|
+
}
|
|
83
|
+
if (call.name === 'write') {
|
|
84
|
+
const filePath = String(args['file_path'] ?? '');
|
|
85
|
+
const abs = join(sandboxDir, filePath);
|
|
86
|
+
mkdirSync(join(abs, '..'), { recursive: true });
|
|
87
|
+
writeFileSync(abs, String(args['content'] ?? ''), 'utf8');
|
|
88
|
+
results.push({ callId: call.id, result: { content: [{ type: 'text', text: `written ${filePath}` }], isError: false } });
|
|
89
|
+
} else if (call.name === 'read') {
|
|
90
|
+
const abs = join(sandboxDir, String(args['file_path'] ?? ''));
|
|
91
|
+
results.push({ callId: call.id, result: { content: [{ type: 'text', text: readFileSync(abs, 'utf8') }], isError: false } });
|
|
92
|
+
} else {
|
|
93
|
+
results.push({ callId: call.id, result: { content: [{ type: 'text', text: `echo:${String(args['command'] ?? '')}` }], isError: false } });
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
return { results, additionalContexts: [], concluded: false };
|
|
97
|
+
};
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
function makeHarness(responses: ReadonlyArray<readonly StreamChunkLike[]>, task: string, config?: Partial<StreamDriverConfig>): DriverHarness {
|
|
101
|
+
const sandboxDir = mkdtempSync(join(tmpdir(), 'tf-v032-'));
|
|
102
|
+
const requests: string[][] = [];
|
|
103
|
+
let call = 0;
|
|
104
|
+
const ports: DriverPorts = {
|
|
105
|
+
stream: (options) => {
|
|
106
|
+
requests.push(options.messages.map((m) => m.content.map((b) => b.text).join('')));
|
|
107
|
+
const chunks = responses[Math.min(call, responses.length - 1)]!;
|
|
108
|
+
call += 1;
|
|
109
|
+
return {
|
|
110
|
+
[Symbol.asyncIterator]: () => scriptedStream(chunks),
|
|
111
|
+
} as AsyncIterable<StreamChunkLike>;
|
|
112
|
+
},
|
|
113
|
+
executeTools: createExecutor(sandboxDir),
|
|
114
|
+
};
|
|
115
|
+
const driver = new SingleStreamDriver(ports, {
|
|
116
|
+
provider: 'mock',
|
|
117
|
+
model: 'mock-v032',
|
|
118
|
+
...config,
|
|
119
|
+
});
|
|
120
|
+
driver.pushUserTask(task);
|
|
121
|
+
return { driver, requests, sandboxDir, cleanup: () => rmSync(sandboxDir, { recursive: true, force: true }) };
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
/** 某个请求的全部消息文本(拼成一段便于 includes 断言)。 */
|
|
125
|
+
function promptOf(harness: DriverHarness, index: number): string {
|
|
126
|
+
return (harness.requests[index] ?? []).join('\n');
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
// ---------------------------------------------------------------- T1 解析器
|
|
130
|
+
|
|
131
|
+
test('T1. DSML 参数式子标签:命令照常发出,参数值不再作为 prose 泄漏', () => {
|
|
132
|
+
const parser = new TfStreamParser();
|
|
133
|
+
const events = feedAll(parser, [
|
|
134
|
+
'我先读取 README。\n',
|
|
135
|
+
'<||DSML|| calls>\n',
|
|
136
|
+
'<||DSML|| invoke name="tf-read">\n',
|
|
137
|
+
'<||DSML|| parameter name="path" string="true">README.md</||DSML|| parameter>\n',
|
|
138
|
+
'<||DSML|| parameter name="id" string="true">r10</||DSML|| parameter>\n',
|
|
139
|
+
'</||DSML|| invoke>\n',
|
|
140
|
+
'</||DSML|| calls>\n',
|
|
141
|
+
]);
|
|
142
|
+
const cmds = commandsOf(events);
|
|
143
|
+
assert.equal(cmds.length, 1);
|
|
144
|
+
assert.equal(cmds[0]!.name, 'tf-read');
|
|
145
|
+
assert.equal(cmds[0]!.attrs['path'], 'README.md');
|
|
146
|
+
assert.equal(cmds[0]!.id, 'r10');
|
|
147
|
+
const prose = proseOf(events);
|
|
148
|
+
assert.ok(prose.includes('我先读取 README。'));
|
|
149
|
+
assert.ok(!prose.includes('README.md'), '参数值不得进正文(真机残片 "README.md r10")');
|
|
150
|
+
assert.ok(!prose.includes('r10'), 'id 不得进正文');
|
|
151
|
+
assert.ok(!prose.includes('DSML'), 'DSML 标签不得进正文');
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
test('T1b. DSML 参数式跨 chunk(逐字符)+ 正文参数(tf-write content)', () => {
|
|
155
|
+
const text = '<||DSML|| invoke name="tf-write">\n'
|
|
156
|
+
+ '<||DSML|| parameter name="path">a.txt</||DSML|| parameter>\n'
|
|
157
|
+
+ '<||DSML|| parameter name="content">line1\nline2</||DSML|| parameter>\n'
|
|
158
|
+
+ '</||DSML|| invoke>';
|
|
159
|
+
const parser = new TfStreamParser();
|
|
160
|
+
const events = feedAll(parser, [...text]);
|
|
161
|
+
const cmds = commandsOf(events);
|
|
162
|
+
assert.equal(cmds.length, 1);
|
|
163
|
+
assert.equal(cmds[0]!.name, 'tf-write');
|
|
164
|
+
assert.equal(cmds[0]!.attrs['path'], 'a.txt');
|
|
165
|
+
assert.equal(cmds[0]!.body, 'line1\nline2');
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
test('T1c. DSML 块未闭合:非正文命令能救则救;正文命令不写半截', () => {
|
|
169
|
+
const nonBody = new TfStreamParser();
|
|
170
|
+
const rescued = feedAll(nonBody, [
|
|
171
|
+
'<||DSML|| invoke name="tf-bash">\n',
|
|
172
|
+
'<||DSML|| parameter name="cmd">Get-ChildItem</||DSML|| parameter>',
|
|
173
|
+
]);
|
|
174
|
+
const bash = commandsOf(rescued);
|
|
175
|
+
assert.equal(bash.length, 1);
|
|
176
|
+
assert.equal(bash[0]!.attrs['cmd'], 'Get-ChildItem');
|
|
177
|
+
assert.ok(rescued.some((e) => e.type === 'truncated'));
|
|
178
|
+
|
|
179
|
+
const body = new TfStreamParser();
|
|
180
|
+
const dropped = feedAll(body, [
|
|
181
|
+
'<||DSML|| invoke name="tf-write">\n',
|
|
182
|
+
'<||DSML|| parameter name="path">a.txt</||DSML|| parameter>\n',
|
|
183
|
+
'<||DSML|| parameter name="content">半截内容',
|
|
184
|
+
]);
|
|
185
|
+
assert.equal(commandsOf(dropped).length, 0, '未闭合的正文命令不得执行(避免写半截文件)');
|
|
186
|
+
assert.ok(dropped.some((e) => e.type === 'truncated'));
|
|
187
|
+
});
|
|
188
|
+
|
|
189
|
+
// ---------------------------------------------------------------- T3 解析器
|
|
190
|
+
|
|
191
|
+
test('T3. 非正文命令少了 "/" 不吞后续输出:命令照发、后续命令照解析', () => {
|
|
192
|
+
const parser = new TfStreamParser();
|
|
193
|
+
const events = feedAll(parser, [
|
|
194
|
+
'<tf-read path="README.md" id="r10">\n接下来是说明文本。\n<tf-final id="f1" summary="完成"/>',
|
|
195
|
+
]);
|
|
196
|
+
const cmds = commandsOf(events);
|
|
197
|
+
assert.deepEqual(cmds.map((c) => c.id), ['r10', 'f1']);
|
|
198
|
+
assert.ok(proseOf(events).includes('接下来是说明文本。'), '被误当正文的文本归还 prose');
|
|
199
|
+
});
|
|
200
|
+
|
|
201
|
+
test('T3b. 流末尾仍未闭合的非正文命令:命令照发,剩余文本不丢', () => {
|
|
202
|
+
const parser = new TfStreamParser();
|
|
203
|
+
const events = feedAll(parser, ['前文<tf-read path="a.md" id="r1">\n后面没有闭合']);
|
|
204
|
+
const cmds = commandsOf(events);
|
|
205
|
+
assert.equal(cmds.length, 1);
|
|
206
|
+
assert.equal(cmds[0]!.id, 'r1');
|
|
207
|
+
const prose = proseOf(events);
|
|
208
|
+
assert.ok(prose.includes('前文'));
|
|
209
|
+
assert.ok(prose.includes('后面没有闭合'));
|
|
210
|
+
});
|
|
211
|
+
|
|
212
|
+
// ---------------------------------------------------------------- T2 驱动器
|
|
213
|
+
|
|
214
|
+
test('T2. 第 3 个请求仍能看到第 1 步的观测内容与命令摘要(历史不再蒸发)', async () => {
|
|
215
|
+
const harness = makeHarness([
|
|
216
|
+
[textDelta('先读 a.txt。\n'), textDelta('<tf-read path="a.txt" id="r1"/>'), finish('stop')],
|
|
217
|
+
[textDelta('再执行一条命令。\n'), textDelta('<tf-bash cmd="echo hi" id="b1"/>'), finish('stop')],
|
|
218
|
+
[textDelta('<tf-final id="f1" summary="两步都完成"/>'), finish('stop')],
|
|
219
|
+
], '历史保留任务');
|
|
220
|
+
try {
|
|
221
|
+
mkdirSync(harness.sandboxDir, { recursive: true });
|
|
222
|
+
writeFileSync(join(harness.sandboxDir, 'a.txt'), 'AAAA-READ-CONTENT', 'utf8');
|
|
223
|
+
const reason = await harness.driver.runTurn();
|
|
224
|
+
assert.equal(reason.kind, 'completed');
|
|
225
|
+
assert.equal(harness.requests.length, 3);
|
|
226
|
+
|
|
227
|
+
assert.ok(harness.requests[1]!.join('\n').includes('AAAA-READ-CONTENT'), '第 2 请求带首读观测');
|
|
228
|
+
assert.ok(harness.requests[1]!.join('\n').includes('[tf-stream:step step=1'), '第 2 请求带第 1 步摘要');
|
|
229
|
+
|
|
230
|
+
// 回归点:0.3.1 在第 3 个请求里已经看不到 AAAA-READ-CONTENT(观测只注入一次)。
|
|
231
|
+
assert.ok(promptOf(harness, 2).includes('AAAA-READ-CONTENT'), '第 3 请求仍能看到第 1 步的读取内容');
|
|
232
|
+
assert.ok(promptOf(harness, 2).includes('[tf-stream:step step=1'), '第 1 步摘要持久');
|
|
233
|
+
assert.ok(promptOf(harness, 2).includes('[tf-stream:step step=2'), '第 2 步摘要已追加');
|
|
234
|
+
|
|
235
|
+
// 前缀单调:后一请求的前 N 条消息必须与前一请求逐条一致(只追加,不重写历史)
|
|
236
|
+
const prev = harness.requests[1]!;
|
|
237
|
+
const next = harness.requests[2]!;
|
|
238
|
+
assert.ok(next.length > prev.length, '第 3 请求应比第 2 请求更长');
|
|
239
|
+
for (let i = 0; i < prev.length; i++) {
|
|
240
|
+
assert.equal(next[i], prev[i], `第 ${i} 条消息必须逐字节不变(前缀单调)`);
|
|
241
|
+
}
|
|
242
|
+
} finally {
|
|
243
|
+
harness.cleanup();
|
|
244
|
+
}
|
|
245
|
+
});
|
|
246
|
+
|
|
247
|
+
// ---------------------------------------------------------------- T4 驱动器
|
|
248
|
+
|
|
249
|
+
test('T4. max-tokens 截断未闭合的 tf-write:强制续写,模型重发后落盘完整内容', async () => {
|
|
250
|
+
const harness = makeHarness([
|
|
251
|
+
[textDelta('开始写文件。\n'), textDelta('<tf-write path="out.txt" id="w1">\n第一段\n第二'), finish('max-tokens')],
|
|
252
|
+
[
|
|
253
|
+
textDelta('<tf-write path="out.txt" id="w2">完整内容\n</tf-write>'),
|
|
254
|
+
textDelta('<tf-final id="f2" summary="已写入 out.txt"/>'),
|
|
255
|
+
finish('stop'),
|
|
256
|
+
],
|
|
257
|
+
], '截断续写任务');
|
|
258
|
+
try {
|
|
259
|
+
const reason = await harness.driver.runTurn();
|
|
260
|
+
assert.equal(reason.kind, 'completed');
|
|
261
|
+
assert.equal(harness.requests.length, 2, '截断后必须重入一次续写请求');
|
|
262
|
+
assert.ok(promptOf(harness, 1).includes('[tf-stream:truncated'), '续写请求带截断说明');
|
|
263
|
+
assert.ok(promptOf(harness, 1).includes('unclosed-command-body:tf-write'), '说明里带截断原因');
|
|
264
|
+
assert.equal(readFileSync(join(harness.sandboxDir, 'out.txt'), 'utf8'), '完整内容\n');
|
|
265
|
+
const faults = harness.driver.snapshot().records.filter((r) => r.kind === 'fault' && r.fault === 'output-truncated');
|
|
266
|
+
assert.equal(faults.length, 1, '截断续写记账一次');
|
|
267
|
+
} finally {
|
|
268
|
+
harness.cleanup();
|
|
269
|
+
}
|
|
270
|
+
});
|
|
271
|
+
|
|
272
|
+
// ---------------------------------------------------------------- 计划快照
|
|
273
|
+
|
|
274
|
+
test('T5. 计划门槛拒绝 tf-final 时,注入里带计划项原文(模型不必凭记忆猜)', async () => {
|
|
275
|
+
const harness = makeHarness([
|
|
276
|
+
[
|
|
277
|
+
textDelta('<tf-plan id="p1">\n- [a1] 写出 receipt_tools/model.py\n</tf-plan>'),
|
|
278
|
+
textDelta('<tf-final id="f1" summary="做完了"/>'),
|
|
279
|
+
finish('stop'),
|
|
280
|
+
],
|
|
281
|
+
[textDelta('<tf-final id="f2" summary="真的做完了"/>'), finish('stop')],
|
|
282
|
+
], '计划快照任务', { maxReentries: 2 });
|
|
283
|
+
try {
|
|
284
|
+
const reason = await harness.driver.runTurn();
|
|
285
|
+
assert.equal(reason.kind, 'blocked', '验收项未验证不放行');
|
|
286
|
+
assert.ok(promptOf(harness, 1).includes('写出 receipt_tools/model.py'), '拒绝注入必须带计划项原文');
|
|
287
|
+
assert.ok(promptOf(harness, 1).includes('当前计划'), '明确标注计划快照');
|
|
288
|
+
} finally {
|
|
289
|
+
harness.cleanup();
|
|
290
|
+
}
|
|
291
|
+
});
|