hansjone/dsh-im-ops
1
0
Fork 0
mirror of https://github.com/hansjone/dsh-im-ops.git synced 2026-10-09 06:30:45 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix(qq): prevent turn feed message spam

Browse source
This commit is contained in:
xmanrui 2026-08-24 00:48:21 +08:00
parent 6ea048b277
commit ade50210f0
10 changed files with 382 additions and 213 deletions
Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -52,7 +52,7 @@ Connect IM bots to DeepSeek Harness by scanning a QR code, using an App Manifest
| 微信 | 使用微信扫码绑定机器人 | 腾讯 iLink 长轮询收发消息 |
| 钉钉 | 扫码创建机器人，或使用 Client ID + Client Secret 手动绑定 | 钉钉 Stream 长连接；通过 AI Card 流式显示回答 |
| 企业微信 | 使用企业微信 App 扫码创建智能机器人，或使用 Bot ID + Secret 手动绑定 | 官方 WebSocket 长连接；原生显示“正在思考中”、工具执行进度和流式回答 |
| QQ | 使用手机 QQ 扫码创建机器人，或使用 AppID + AppSecret 手动绑定 | WebSocket 长连接；私聊显示“正在输入”和流式回答，群聊被 @ 后回复 |
| QQ | 使用手机 QQ 扫码创建机器人，或使用 AppID + AppSecret 手动绑定 | WebSocket 长连接；私聊显示“正在输入”并以单条 Markdown 回复，群聊被 @ 后只发送最终答案 |
| Slack | 使用预置 App Manifest 创建应用，再填写 Bot Token（`xoxb-`）和 App Token（`xapp-`） | Socket Mode 长连接；私聊直接回复，频道被 @ 后响应，优先使用官方流式消息 API |
| Telegram | 使用 @BotFather 生成的 Bot Token | Bot API 长轮询；默认私聊直接响应、群聊被提及或回复时响应，也可为每个机器人独立启用私聊白名单安全模式；通过编辑消息流式显示回答 |
| Discord | 使用 Developer Portal 生成的 Bot Token | Gateway v10 长连接；私信直接回复，服务器频道被提及时响应，通过编辑消息流式显示回答 |

288
lib/index.js
View file

File diff suppressed because one or more lines are too long

57
src/channels/qq/markdown-reply.mjs
View file

@ -1,9 +1,21 @@
// QQ markdown 回复投递：长文按代码块/表格边界切分，以 msg_type=2 发送，
// QQ markdown 回复投递：长文尽量按结构边界切分，以 msg_type=2 发送，
// 平台拒绝 markdown 时逐条回退纯文本。
const DEFAULT_CHUNK_LIMIT = 4_500;
const CODE_FENCE_OPEN = /^```/;
const GFM_TABLE_LINE = /^\|.+\|$/;
const PASSIVE_REPLY_LIMIT = Object.freeze({ c2c: 4, group: 5 });
const PARTIAL_REPLY_NOTICE = '回答较长，后续内容未能通过 QQ 完整发送，请回复“继续”。';
function safeSliceIndex(value, limit) {
let index = Math.min(limit, value.length);
const before = value.charCodeAt(index - 1);
const after = value.charCodeAt(index);
if (before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF) {
index -= 1;
}
return Math.max(1, index);
}
/**
* 按换行边界切分 Markdown 文本：
@ -44,8 +56,9 @@ export function chunkMarkdownText(text, limit = DEFAULT_CHUNK_LIMIT) {
}
let remaining = block;
while (remaining.length > bound) {
chunks.push(remaining.slice(0, bound));
remaining = remaining.slice(bound);
const index = safeSliceIndex(remaining, bound);
chunks.push(remaining.slice(0, index));
remaining = remaining.slice(index);
}
current = remaining;
};
@ -65,8 +78,9 @@ export function chunkMarkdownText(text, limit = DEFAULT_CHUNK_LIMIT) {
chunks.push(current);
current = '';
}
chunks.push(remaining.slice(0, bound));
remaining = remaining.slice(bound);
const index = safeSliceIndex(remaining, bound);
chunks.push(remaining.slice(0, index));
remaining = remaining.slice(index);
}
appendBlock(remaining);
};
@ -115,11 +129,32 @@ function nextMsgSeq() {
export async function sendMarkdownReply(bot, target, text, { logger } = {}) {
const chunks = chunkMarkdownText(text);
const results = [];
for (const chunk of chunks) {
const passiveLimit = target?.msgId ? PASSIVE_REPLY_LIMIT[target.scope] : null;
const overflow = passiveLimit !== null && chunks.length > passiveLimit;
const passiveContentCount = overflow ? passiveLimit - 1 : chunks.length;
const proactiveTarget = target?.msgId
? { scope: target.scope, targetId: target.targetId }
: target;
let partialNoticeSent = false;
const sendPartialNotice = async () => {
if (partialNoticeSent || !target?.msgId) return;
partialNoticeSent = true;
try {
results.push(await bot.sendText(target, PARTIAL_REPLY_NOTICE));
} catch (error) {
logger?.warn?.('[dsh-im:qq] unable to send partial reply notice:', error);
}
};
for (const [index, chunk] of chunks.entries()) {
const deliveryTarget = overflow && index >= passiveContentCount
? proactiveTarget
: target;
if (typeof bot?.send === 'function') {
try {
results.push(await bot.send({
target,
target: deliveryTarget,
msgType: 2,
markdown: { content: chunk },
extra: { msg_seq: nextMsgSeq() },
@ -129,7 +164,13 @@ export async function sendMarkdownReply(bot, target, text, { logger } = {}) {
logger?.warn?.('[dsh-im:qq] markdown delivery failed; retrying as plain text:', error);
}
}
results.push(await bot.sendText(target, chunk));
try {
results.push(await bot.sendText(deliveryTarget, chunk));
} catch (error) {
if (results.length === 0) throw error;
await sendPartialNotice();
break;
}
}
return results;
}

92
src/channels/qq/qq-bridge.mjs
View file

@ -592,6 +592,7 @@ export class QqHarnessBridge {
const text = promptMessage.content;
const hasImages = hasInboundImages(promptMessage);
const hasFiles = hasInboundFiles(promptMessage);
let stream = null;
try {
if (!text && !hasImages && !hasFiles) {
await this.#bot.sendText(target, '目前支持文字、图片和文件消息。');
@ -644,16 +645,17 @@ export class QqHarnessBridge {
const content = hasImages
? await promptContentForMessage(promptMessage, { signal: this.#signal })
: undefined;
// 过程流：把一次 Turn 的中间过程逐条推送给用户——
// 模型说明文本、每个 Tool call、失败的工具错误详情，最后是完整回答。
let pendingStepText = null;
const pushNotice = async (text) => {
// QQ C2C keeps one stream bubble. Progress is collected but never submitted:
// some clients reject replacing an already visible stream frame, which would
// otherwise leave a stale progress bubble plus a separate fallback answer.
if (message.kind === 'c2c' && target?.msgId && typeof this.#bot.openStream === 'function') {
try {
await this.#bot.sendText(target, text);
stream = this.#bot.openStream({ target });
} catch (error) {
this.#logger.warn?.('[dsh-im:qq] unable to send a turn progress notice:', error);
this.#logger.warn?.('[dsh-im:qq] unable to start a QQ stream; using markdown fallback:', error);
}
};
}
const toolErrors = [];
let answer;
let artifacts = [];
try {
@ -668,25 +670,13 @@ export class QqHarnessBridge {
timeoutMs: this.#replyTimeoutMs,
signal: this.#signal,
control: { owner: this, key },
onUpdate: async (update) => {
if (update.type === 'text') {
// 当前 step 的累积文本：暂存，等下一个工具或结束时一次性推送。
pendingStepText = update.text;
return;
}
if (update.type === 'tool') {
// 工具调用本身不推送：agent 任务工具调用频繁，逐条推送会刷屏；
// 它只作为边界把上一段说明文本定稿推送。失败时随错误详情带出工具名。
if (nonEmptyString(pendingStepText)) {
await pushNotice(pendingStepText.trim());
}
pendingStepText = null;
return;
}
progressMode: 'all',
onUpdate: (update) => {
if (update.error) {
const label = nonEmptyString(update.toolName)
? `Tool call ${update.toolName}` : 'Tool call';
await pushNotice(`${label}\nError: ${update.error}`);
const text = `${label}\nError: ${update.error}`;
toolErrors.push(text);
}
},
onInteraction: (interaction) => this.#handleInteraction(interaction, {
@ -707,22 +697,42 @@ export class QqHarnessBridge {
}
this.#signal?.throwIfAborted();
const answerText = answerTextForDelivery(answer, artifacts);
// 结束前仍有一段未推送的说明文本（且不是最终回答本身）时补发。
if (nonEmptyString(pendingStepText) && pendingStepText.trim() !== answerText.trim()) {
await pushNotice(pendingStepText.trim());
}
const displayAnswer = answerText;
const displayAnswer = toolErrors.length > 0
? `${answerText}\n\n---\n\n${toolErrors.join('\n\n')}`
: answerText;
let textReceipt = null;
let textSendError = null;
try {
const deliveries = await sendMarkdownReply(this.#bot, target, displayAnswer, {
logger: this.#logger,
});
textReceipt = createDeliveryReceipt({
deliveryId: messageId,
presentation: 'qq-text',
providerMessageIds: deliveries.flatMap((delivery) => providerMessageIdsFor(delivery)),
});
let streamFinished = false;
if (stream) {
try {
await stream.update(displayAnswer);
streamFinished = true;
textReceipt = createDeliveryReceipt({
deliveryId: messageId,
presentation: 'qq-text',
providerMessageIds: providerMessageIdsFor(stream),
});
try {
await stream.complete();
} catch (error) {
this.#logger.warn?.('[dsh-im:qq] QQ stream completion failed after visible final content:', error);
}
} catch (error) {
stream.cancel?.();
this.#logger.warn?.('[dsh-im:qq] QQ stream update failed; using markdown fallback:', error);
}
}
if (!streamFinished) {
const deliveries = await sendMarkdownReply(this.#bot, target, displayAnswer, {
logger: this.#logger,
});
textReceipt = createDeliveryReceipt({
deliveryId: messageId,
presentation: 'qq-text',
providerMessageIds: deliveries.flatMap((delivery) => providerMessageIdsFor(delivery)),
});
}
} catch (error) {
textSendError = error;
this.#logger.warn?.('[dsh-im:qq] final text delivery failed; continuing with result files:', error);
@ -741,6 +751,11 @@ export class QqHarnessBridge {
return delivery.receipt;
} catch (error) {
if (error?.code === 'turn-stopped') {
try {
stream?.cancel?.();
} catch (streamError) {
this.#logger.warn?.('[dsh-im:qq] unable to cancel a stopped QQ stream:', streamError);
}
try {
await this.#bot.sendText(target, '已停止。');
} catch (sendError) {
@ -749,6 +764,11 @@ export class QqHarnessBridge {
await this.#state.markSeen(messageId);
return;
}
try {
stream?.cancel?.();
} catch (streamError) {
this.#logger.warn?.('[dsh-im:qq] unable to cancel a failed QQ stream:', streamError);
}
if (this.#signal?.aborted) return;
this.#status.lastError = error?.message ?? String(error);
this.#logger.error?.('[dsh-im:qq] failed to process an inbound message:', error);

12
src/channels/shared/harness-client.mjs
View file

@ -368,7 +368,7 @@ export class HarnessReplyTracker {
return this.#targetTurn;
}
consume(entries) {
consumeAll(entries) {
const updates = [];
// 同一批轮询内的 text 帧只保留最新累积，其余事件逐帧透出，
// 让消费方能按顺序看到每个工具调用与结果。
@ -461,6 +461,10 @@ export class HarnessReplyTracker {
}
return updates;
}
consume(entries) {
return this.consumeAll(entries).at(-1) ?? null;
}
}
export class HarnessRpcError extends Error {
@ -1081,6 +1085,7 @@ export class HarnessClient {
const timeoutMs = options.timeoutMs ?? 600_000;
const signal = options.signal;
const onUpdate = typeof options.onUpdate === 'function' ? options.onUpdate : null;
const progressMode = options.progressMode === 'all' ? 'all' : 'latest';
const onArtifact = typeof options.onArtifact === 'function' ? options.onArtifact : null;
const onInteraction = typeof options.onInteraction === 'function'
? options.onInteraction
@ -1234,9 +1239,10 @@ export class HarnessClient {
this.#consumeInteractionOwnerships(sessionId, history.events ?? []);
if (!wasActive && ownership.active) ownership.reconnect?.();
}
const updates = tracker.consume(history.events ?? []);
const updates = tracker.consumeAll(history.events ?? []);
if (onUpdate) {
for (const update of updates) {
const visibleUpdates = progressMode === 'all' ? updates : updates.slice(-1);
for (const update of visibleUpdates) {
try {
await onUpdate(update);
} catch (error) {

2
test/channels/dingtalk/harness-client.test.mjs
View file

@ -399,7 +399,7 @@ test('reply tracker associates only the Harness turn created by the DingTalk pro
data: { turn: 9, step: 0, chunk: { type: 'text-delta', index: 0, text: '钉钉' } },
} },
]);
assert.deepEqual(update, [{ type: 'text', text: '钉钉' }]);
assert.deepEqual(update, { type: 'text', text: '钉钉' });
tracker.consume([
{ event: {
seq: 6,

16
test/channels/feishu/harness-client.test.mjs
View file

@ -869,7 +869,7 @@ test('HarnessClient delivers an existing file-only Turn directly', async (t) =>
test('HarnessReplyTracker correlates the prompt and emits only answer text', () => {
const tracker = new HarnessReplyTracker({ promptRpcId: 'prompt-1', afterSeq: 10 });
assert.deepEqual(tracker.consume([
assert.equal(tracker.consume([
{ event: { type: 'turn/start', seq: 11, data: { turn: 4 } } },
{ event: {
type: 'user/message',
@ -882,7 +882,7 @@ test('HarnessReplyTracker correlates the prompt and emits only answer text', ()
data: { turn: 4, step: 1, chunk: { type: 'text-delta', index: 0, text: '忽略' } },
} },
{ event: { type: 'turn/end', seq: 14, data: { turn: 4, reason: { kind: 'completed' } } } },
]), []);
]), null);
assert.equal(tracker.finished, false);
const first = tracker.consume([
@ -903,7 +903,7 @@ test('HarnessReplyTracker correlates the prompt and emits only answer text', ()
data: { turn: 5, step: 1, chunk: { type: 'text-delta', index: 1, text: '深圳' } },
} },
]);
assert.deepEqual(first, [{ type: 'text', text: '深圳' }]);
assert.deepEqual(first, { type: 'text', text: '深圳' });
const second = tracker.consume([
{ event: {
@ -917,7 +917,7 @@ test('HarnessReplyTracker correlates the prompt and emits only answer text', ()
data: { turn: 5, step: 1, chunk: { type: 'text-delta', index: 1, text: '明天有雨' } },
} },
]);
assert.deepEqual(second, [{ type: 'text', text: '深圳明天有雨' }]);
assert.deepEqual(second, { type: 'text', text: '深圳明天有雨' });
const final = tracker.consume([
{ event: {
@ -934,7 +934,7 @@ test('HarnessReplyTracker correlates the prompt and emits only answer text', ()
} },
{ event: { type: 'turn/end', seq: 21, data: { turn: 5, reason: { kind: 'completed' } } } },
]);
assert.deepEqual(final, [{ type: 'text', text: '深圳明天有阵雨。' }]);
assert.deepEqual(final, { type: 'text', text: '深圳明天有阵雨。' });
assert.equal(tracker.finished, true);
assert.equal(tracker.answer, '深圳明天有阵雨。');
assert.deepEqual(tracker.reason, { kind: 'completed' });
@ -947,16 +947,16 @@ test('HarnessReplyTracker emits tool progress without exposing tool results', ()
{ type: 'user/message', seq: 2, data: { source: { rpcId: 'prompt-tool' } } },
{ type: 'tool/call', seq: 3, data: { turn: 1, step: 1, name: 'web_search' } },
]);
assert.deepEqual(update, [{ type: 'tool', name: 'web_search' }]);
assert.deepEqual(update, { type: 'tool', name: 'web_search' });
assert.deepEqual(tracker.consume([
{ type: 'tool/result', seq: 4, data: { turn: 1, step: 1, secret: 'not rendered' } },
]), [{ type: 'status', text: '正在整理结果…', toolName: 'web_search' }]);
]), { type: 'status', text: '正在整理结果…', toolName: 'web_search' });
});
test('HarnessReplyTracker keeps every frame of a batched turn in order', () => {
const tracker = new HarnessReplyTracker({ promptRpcId: 'prompt-batch' });
const updates = tracker.consume([
const updates = tracker.consumeAll([
{ type: 'turn/start', seq: 1, data: { turn: 1 } },
{ type: 'user/message', seq: 2, data: { source: { rpcId: 'prompt-batch' } } },
{ type: 'assistant/chunk', seq: 3, data: { turn: 1, step: 0, chunk: { type: 'text-delta', index: 0, text: '先创建再观察：' } } },

79
test/channels/qq/bridge.test.mjs
View file

@ -554,20 +554,26 @@ test('QQ remembers any authorized private inbound as a connection-test target',
assert.equal(sent.length, 2);
});
test('QQ pushes the final answer without streaming intermediate text frames', async () => {
test('QQ private messages produce one final stream bubble', async () => {
const sent = [];
const frames = [];
const seen = new Set();
const bridge = new QqHarnessBridge({
bot: {
sendText: async (_target, text) => sent.push(text),
openStream: () => ({
update: async (text) => frames.push(text),
complete: async () => frames.push('DONE'),
cancel() {},
}),
},
ownerUserOpenid: 'owner-openid',
harness: {
sessionExists: async () => true,
createSession: async () => 'session-new',
ensureRunning: async () => true,
ask: async (_session, _text, { onUpdate }) => {
// 正文流式帧不逐帧推送；最终回答与已暂存文本相同时不重复补发。
ask: async (_session, _text, { onUpdate, progressMode }) => {
assert.equal(progressMode, 'all');
await onUpdate({ type: 'text', text: '最终回' });
await onUpdate({ type: 'text', text: '最终回答' });
return '最终回答';
@ -583,16 +589,52 @@ test('QQ pushes the final answer without streaming intermediate text frames', as
});
await bridge.accept(message());
assert.deepEqual(sent, ['最终回答']);
assert.deepEqual(frames, ['最终回答', 'DONE']);
assert.deepEqual(sent, []);
assert.equal(seen.has('msg-1'), true);
assert.equal(bridge.status.messagesReplied, 1);
});
test('QQ pushes one notice per tool call and ignores status frames', async () => {
test('QQ does not duplicate a visible private answer when stream completion fails', async () => {
const frames = [];
const sent = [];
const bridge = new QqHarnessBridge({
bot: {
sendText: async (_target, text) => sent.push(text),
openStream: () => ({
update: async (text) => frames.push(text),
complete: async () => { throw new Error('already submitted'); },
cancel() {},
}),
},
ownerUserOpenid: 'owner-openid',
harness: {
sessionExists: async () => true,
ask: async () => '最终回答',
},
state: {
hasSeen: () => false,
markSeen: async () => {},
sessionFor: () => 'session-stream-complete-failure',
setSession: async () => {},
clearSession: async () => {},
},
logger: { warn() {}, error() {} },
});
await bridge.accept(message({ messageId: 'msg-stream-complete-failure' }));
assert.deepEqual(frames, ['最终回答']);
assert.deepEqual(sent, []);
assert.equal(bridge.status.messagesReplied, 1);
});
test('QQ group messages suppress every successful progress update', async () => {
const sent = [];
let streamCalls = 0;
const bridge = new QqHarnessBridge({
bot: {
sendText: async (_target, text) => sent.push(text),
openStream: () => { streamCalls += 1; throw new Error('group stream must not open'); },
},
ownerUserOpenid: 'owner-openid',
harness: {
@ -615,12 +657,18 @@ test('QQ pushes one notice per tool call and ignores status frames', async () =>
},
});
await bridge.accept(message({ messageId: 'msg-status-frame' }));
// 工具调用本身不推送，避免多工具任务刷屏。
await bridge.accept(message({
kind: 'group',
rawEventType: 'GROUP_AT_MESSAGE_CREATE',
groupOpenid: 'group-progress',
messageId: 'msg-status-frame',
replyTarget: { scope: 'group', targetId: 'group-progress', msgId: 'msg-status-frame' },
}));
assert.deepEqual(sent, ['最终回答']);
assert.equal(streamCalls, 0);
});
test('QQ pushes a failed tool error and any interim explanation text', async () => {
test('QQ group messages append tool failures to one final answer', async () => {
const sent = [];
const bridge = new QqHarnessBridge({
bot: {
@ -653,12 +701,15 @@ test('QQ pushes a failed tool error and any interim explanation text', async ()
},
});
await bridge.accept(message({ messageId: 'msg-tool-error' }));
await bridge.accept(message({
kind: 'group',
rawEventType: 'GROUP_AT_MESSAGE_CREATE',
groupOpenid: 'group-error',
messageId: 'msg-tool-error',
replyTarget: { scope: 'group', targetId: 'group-error', msgId: 'msg-tool-error' },
}));
assert.deepEqual(sent, [
'实体不存在，先创建再添加观察：',
'Tool call add_observations\nError: Error calling add_observations. Status code: 404.',
'改用创建实体的方式：',
'已存入两套记忆。',
'已存入两套记忆。\n\n---\n\nTool call add_observations\nError: Error calling add_observations. Status code: 404.',
]);
});
@ -734,7 +785,7 @@ test('QQ falls back to plain text when the platform rejects markdown', async ()
assert.equal(bridge.status.lastError, null);
});
test('QQ announces a stopped turn after any tool notices already pushed', async () => {
test('QQ announces a stopped turn and closes its unused private stream', async () => {
const fixture = stateFixture([['c2c:owner-openid', 'session-stopped']]);
const sent = [];
let loggedErrors = 0;

45
test/channels/qq/markdown-reply.test.mjs
View file

@ -65,6 +65,13 @@ test('chunkMarkdownText hard-splits an oversized single line', () => {
assert.deepEqual(chunks, ['x'.repeat(100), 'x'.repeat(100), 'x'.repeat(50)]);
});
test('chunkMarkdownText does not split an emoji surrogate pair', () => {
const chunks = chunkMarkdownText(`1234😀5678`, 5);
assert.equal(chunks.join(''), '1234😀5678');
assert.equal(chunks.some((chunk) => chunk.includes('\uFFFD')), false);
for (const chunk of chunks) assert.ok(chunk.length <= 5);
});
test('sendMarkdownReply sends markdown with unique msg_seq per chunk', async () => {
const calls = [];
const results = await sendMarkdownReply({
@ -147,6 +154,44 @@ test('sendMarkdownReply delivers long answers as multiple markdown chunks', asyn
assert.equal(markdownChunks.join('\n'), text);
});
test('sendMarkdownReply moves overflow chunks off the passive group reply target', async () => {
const targets = [];
const groupTarget = { scope: 'group', targetId: 'group-1', msgId: 'group-msg' };
await sendMarkdownReply({
send: async ({ target: sentTarget }) => {
targets.push(sentTarget);
return { id: `id-${targets.length}` };
},
sendText: async () => { throw new Error('unexpected'); },
}, groupTarget, 'x'.repeat(4_500 * 6));
assert.equal(targets.length, 6);
assert.equal(targets.slice(0, 4).every((sentTarget) => sentTarget.msgId === 'group-msg'), true);
assert.deepEqual(targets.slice(4), [
{ scope: 'group', targetId: 'group-1' },
{ scope: 'group', targetId: 'group-1' },
]);
});
test('sendMarkdownReply uses the reserved passive reply for a visible partial notice', async () => {
const groupTarget = { scope: 'group', targetId: 'group-1', msgId: 'group-msg' };
const notices = [];
const results = await sendMarkdownReply({
send: async ({ target: sentTarget }) => {
if (!sentTarget.msgId) throw new Error('proactive disabled');
return { id: 'passive' };
},
sendText: async (sentTarget, text) => {
if (!sentTarget.msgId) throw new Error('proactive disabled');
notices.push(text);
return { id: 'partial-notice' };
},
}, groupTarget, 'x'.repeat(4_500 * 6), { logger: { warn() {} } });
assert.equal(results.length, 5);
assert.deepEqual(notices, ['回答较长，后续内容未能通过 QQ 完整发送，请回复“继续”。']);
});
test('sendMarkdownReply returns no deliveries for empty text', async () => {
const results = await sendMarkdownReply({
send: async () => { throw new Error('unexpected'); },

2
test/channels/weixin/harness-client.test.mjs
View file

@ -513,7 +513,7 @@ test('reply tracker associates only the Harness turn created by the Weixin promp
data: { turn: 9, step: 0, chunk: { type: 'text-delta', index: 0, text: '微信' } },
} },
]);
assert.deepEqual(first, [{ type: 'text', text: '微信' }]);
assert.deepEqual(first, { type: 'text', text: '微信' });
tracker.consume([
{ event: {
seq: 6,