Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(feishu): 回复跟随提问位置并在完成后新发终稿

Dash39403e1defec
diff --git a/apps/desktop/src/main/im/feishu/adapter.ts b/apps/desktop/src/main/im/feishu/adapter.ts
index dfb70dd5ac..9d5123eeb5 100644
--- a/apps/desktop/src/main/im/feishu/adapter.ts
+++ b/apps/desktop/src/main/im/feishu/adapter.ts
@@ -9,10 +9,8 @@ import { captureImContext } from '../../../shared/imMessageSource';
* MCP (send_file_to_user)
* - ack emoji: REACTION_PROCESSING
* - 群 lane(senderId = `g/{chatId}[/{threadId}]`, @cindy/im feishu/codec.ts):
- * 群主流 @ 入站即开话题(每话题一个会话, 群 lane 仅开话题失败的降级路径);
- * **`/ctr` 接管严格按话题记账**: binding 的 userId 就是话题 lane, 一个话题
- * 一份接管, 群主流的 @ 恒开新话题走该话题自己的会话(不会被任何接管吃掉);
- * 要跟接管会话说话就在那个话题里说 —— 群主流不是接管的入口;
+ * 群主流提问留在群 lane, 话题内提问留在原话题 lane, 不自动开新话题;
+ * 接管绑定按完整 lane 区分, 群主流不会改道进入某个话题的接管会话;
* 群里新建的会话一律用渠道设置「群聊新建任务权限档」(sessions.permissionModeFor,
* `/ctr` 新建走 cardActionHandler 读同一设置);
* 群轮次挂「非只读即确认」策略 + 触发时按页回翻群历史(50/页, 最多 5 页,
@@ -316,9 +314,8 @@ export function buildFeishuAdapter(
* 面向私聊的 `permissionMode`。
*
* 覆盖到的建会话路径(都经 sessionRepo.prepareNewSession):
- * - 群主流 @bot 开新话题 → 话题 lane 首条消息建行(turnRunner)
+ * - 群主流 / 话题 @bot → 对应 lane 首条消息建行(turnRunner)
* - 群里 `/new` 重开上下文(slashCommands → resetSessionToDefaults)
- * - 群主流降级 lane(开话题失败时)建行
* `/ctr` 新建接管会话不走这里(它建的是 desktop 会话, 见
* cardActionHandler), 那边读的是同一个设置项。
*
@@ -340,7 +337,7 @@ export function buildFeishuAdapter(
if (!name) return null;
return `${groupPrefix(lane.threadId)}${name}`;
},
- // 群主流 lane(仅开话题失败的降级路径)标题是稳定的群名, 不参与首条消息
+ // 群主流 lane 标题是稳定的群名, 不参与首条消息
// oneshot 起名; 话题 lane 需要 oneshot 出「话题简介」, 照常参与。
skipOneshotTitleFor: (userId) => {
const lane = decodeFeishuLaneUserId(userId);
@@ -463,15 +460,8 @@ export function buildFeishuAdapter(
replyContext: safeReply,
};
}
- // 群主流 @ 开新话题: 上下文取数 lane 与路由 lane 分离(见
- // IMMessageEvent.groupContextLane) — 触发消息发在群主流(只是回复被折成
- // 了新话题), 所以群历史仍按群主流拉取, 「总结上面」才拿得到上下文。
- //
- // 话题里发的消息一律按**话题容器**取数(contextLane = lane): 会话里只看
- // 会话。`/ctr` 曾把「开话题之前的群主流讨论」记下来补给话题里第一条消息,
- // 已按产品裁决去掉 —— 它让 /ctr 后的第一句要回翻整条群主流(5 页 + 每页
- // 一次模型判断), 首句实测被拖到 87s; 而话题的语义本就是「另起一摊」,
- // 需要群里的上文时在群主流里 @ 即可。
+ // Ordinary inbound context follows its originating group/topic lane.
+ // Retain explicit context overrides for existing callers.
const contextLane = event.groupContextLane ?? lane;
const built = await buildFeishuGroupContext({
lane: contextLane,
diff --git a/docs/dev-rules/im-turn-flow.md b/docs/dev-rules/im-turn-flow.md
index 683fa9b067..4810c5de21 100644
--- a/docs/dev-rules/im-turn-flow.md
+++ b/docs/dev-rules/im-turn-flow.md
@@ -147,6 +147,12 @@ Telegram / Slack / X)是同一件事的两套实现:把渠道里的一条消
它是桌面、IM、目标恢复等所有建任务入口共有的既有问题,要堵需让账号守卫穿过 maker-core
启动 / 持久化边界或新增回滚机制,另行处理。
+12. **飞书回复跟随提问位置**:群主聊天的消息用群 lane,带 `thread_id` 的消息用原话题 lane;
+ 普通引用的 `parent_id` / `root_id` 不等于话题,不自动开新话题。个人和伙伴复用同一渠道实现。
+ 工作中编辑进度卡;完成后在同一位置新发终稿,确认发送成功再撤回进度卡,避免失败时丢掉已有内容。
+ 终稿和附件不领取下一轮排队消息的锚点。空结果撤回进度卡且不发占位,图片/文件仍正常投递;
+ 新消息发送失败时保留进度卡并尝试就地展示终稿,撤回失败不得重复发送已成功的终稿。
+
## 4. 状态模型(一轮)
```
diff --git a/packages/lizi-im/src/feishu/__tests__/outboundLane.test.ts b/packages/lizi-im/src/feishu/__tests__/outboundLane.test.ts
index c065a84f10..d4f7c8f635 100644
--- a/packages/lizi-im/src/feishu/__tests__/outboundLane.test.ts
+++ b/packages/lizi-im/src/feishu/__tests__/outboundLane.test.ts
@@ -31,13 +31,13 @@ const larkMocks = vi.hoisted(() => {
},
);
const deleteMessage = vi.fn(
- function (this: unknown): Promise<{ code?: number; msg?: string; data?: {} }> {
+ function (this: unknown): Promise<{ code?: number; msg?: string; data?: object }> {
deleteOwners.push(this);
return Promise.resolve({ data: {} });
},
);
const patch = vi.fn(
- async (): Promise<{ code?: number; msg?: string; data?: {} }> => ({ data: {} }),
+ async (): Promise<{ code?: number; msg?: string; data?: object }> => ({ data: {} }),
);
const getMessage = vi.fn(
function (
@@ -152,12 +152,12 @@ describe('feishu outbound lane routing', () => {
handle.replace('revised');
await vi.advanceTimersByTimeAsync(1500);
await handle.finalize('finished');
- expect(larkMocks.patch).toHaveBeenCalledTimes(3);
+ expect(larkMocks.patch).toHaveBeenCalledTimes(2);
for (const client of larkMocks.patch.mock.contexts) expect(client).toBe(creator);
- expect(larkMocks.patch).toHaveBeenLastCalledWith({
- path: { message_id: handle.messageId },
- data: { content: expect.stringContaining('finished') },
- });
+ expect(larkMocks.create.mock.contexts.at(-1)).toBe(creator);
+ expect(larkMocks.create).toHaveBeenLastCalledWith(expect.objectContaining({
+ data: expect.objectContaining({ content: expect.stringContaining('finished') }),
+ }));
},
);
@@ -177,6 +177,28 @@ describe('feishu outbound lane routing', () => {
});
});
+ it.each([false, true])('final stays in its lane and does not consume the next queued turn (thread=%s)', async (thread) => {
+ const lane = thread ? 'g/oc_chat/omt_topic' : 'g/oc_chat';
+ outbound.pushReplyAnchor(lane, 'om_first');
+ outbound.pushReplyAnchor(lane, 'om_second');
+ const handle = await start(lane);
+ expect(larkMocks.reply.mock.calls[0][0].path).toEqual({ message_id: 'om_first' });
+ await handle.finalize('answer');
+ if (thread) {
+ expect(larkMocks.reply.mock.calls[1][0].path).toEqual({ message_id: 'om_first' });
+ expect(larkMocks.create).not.toHaveBeenCalled();
+ } else {
+ expect(larkMocks.reply.mock.calls[0][0].data).not.toHaveProperty('reply_in_thread');
+ expect(larkMocks.create).toHaveBeenCalledWith(expect.objectContaining({
+ params: { receive_id_type: 'chat_id' },
+ data: expect.objectContaining({ receive_id: 'oc_chat', content: expect.stringContaining('answer') }),
+ }));
+ }
+ const next = await start(lane);
+ expect(larkMocks.reply.mock.calls.at(-1)?.[0].path).toEqual({ message_id: 'om_second' });
+ next.close();
+ });
+
it('sends p2p messages via open_id unchanged', async () => {
await outbound.sendText('ou_someone', 'hi');
expect(larkMocks.create).toHaveBeenCalledWith(
diff --git a/packages/lizi-im/src/feishu/__tests__/streamingText.test.ts b/packages/lizi-im/src/feishu/__tests__/streamingText.test.ts
index 233e250686..6e4a038d18 100644
--- a/packages/lizi-im/src/feishu/__tests__/streamingText.test.ts
+++ b/packages/lizi-im/src/feishu/__tests__/streamingText.test.ts
@@ -1,7 +1,9 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
const mocks = vi.hoisted(() => ({
patchCardRaw: vi.fn(),
+ getAccountEpoch: vi.fn(() => 1),
+ rearmAnchorToTrigger: vi.fn(),
recallMessage: vi.fn(),
sendCardRaw: vi.fn(),
sendFile: vi.fn(),
@@ -34,8 +36,9 @@ function requestBytes(card: unknown): number {
describe('feishu streaming text', () => {
beforeEach(() => {
- vi.clearAllMocks();
- mocks.sendCardRaw.mockResolvedValue({ messageId: 'om_stream' });
+ vi.resetAllMocks();
+ mocks.getAccountEpoch.mockReturnValue(1);
+ mocks.sendCardRaw.mockResolvedValueOnce({ messageId: 'om_stream' }).mockResolvedValue({ messageId: 'om_final' });
mocks.patchCardRaw.mockResolvedValue(undefined);
mocks.sendFile.mockResolvedValue({
ok: true,
@@ -49,7 +52,7 @@ describe('feishu streaming text', () => {
const handle = await start('ou_owner');
await handle.finalize('正常正文');
- expect(markdownContent(mocks.patchCardRaw.mock.calls[0][1])).toBe('正常正文');
+ expect(markdownContent(mocks.sendCardRaw.mock.calls[1][1])).toBe('正常正文');
});
it.each(['', ' \n '])('recalls an empty final %j without a placeholder', async (text) => {
@@ -73,8 +76,8 @@ describe('feishu streaming text', () => {
handle.addExtraImageAbsPath?.('/tmp/image.png');
await handle.finalize('');
expect(mocks.uploadImage).toHaveBeenCalledWith('/tmp/image.png');
- expect(mocks.patchCardRaw).toHaveBeenCalled();
- expect(mocks.recallMessage).not.toHaveBeenCalled();
+ expect(mocks.sendCardRaw).toHaveBeenCalledTimes(2);
+ expect(mocks.recallMessage).toHaveBeenCalledWith('om_stream');
});
it('truncates an oversized final card within Feishu request limits', async () => {
@@ -89,7 +92,7 @@ describe('feishu streaming text', () => {
].join('\n').repeat(500);
await handle.finalize(longMarkdown);
- const card = mocks.patchCardRaw.mock.calls[0][1];
+ const card = mocks.sendCardRaw.mock.calls[1][1];
expect(requestBytes(card)).toBeLessThanOrEqual(FEISHU_CARD_REQUEST_MAX_BYTES);
expect(markdownContent(card)).toContain('完整内容仍可在 Cindy 桌面端查看');
});
@@ -100,26 +103,68 @@ describe('feishu streaming text', () => {
for (let i = 0; i < 200; i++) handle.addExtraImageAbsPath?.(`/tmp/${i}.png`);
await handle.finalize('正文');
- const card = mocks.patchCardRaw.mock.calls[0][1];
+ const card = mocks.sendCardRaw.mock.calls[1][1];
expect(requestBytes(card)).toBeLessThanOrEqual(FEISHU_CARD_REQUEST_MAX_BYTES);
expect(markdownContent(card)).toBe(messages.streaming.deliveryFailed);
});
- it('patches a short notice when the primary final card is rejected', async () => {
- mocks.patchCardRaw.mockRejectedValueOnce(new Error('unsupported card shape'));
+ it('preserves the full final on the progress card if sending a new message fails', async () => {
const handle = await start('ou_owner');
+ mocks.sendCardRaw.mockRejectedValueOnce(new Error('send unavailable'));
await handle.finalize('正文');
+ expect(mocks.patchCardRaw).toHaveBeenCalledTimes(1);
+ expect(markdownContent(mocks.patchCardRaw.mock.calls[0][1])).toBe('正文');
+ expect(mocks.recallMessage).not.toHaveBeenCalled();
+ expect(mocks.sendText).not.toHaveBeenCalled();
+ });
- expect(mocks.patchCardRaw).toHaveBeenCalledTimes(2);
- expect(markdownContent(mocks.patchCardRaw.mock.calls[1][1])).toBe(
- messages.streaming.deliveryFailed,
- );
+ it('edits progress, then sends a fresh final before recalling progress, only once', async () => {
+ vi.useFakeTimers();
+ try {
+ const handle = await start('ou_owner', 'working', { threadTs: 'om_root' });
+ handle.append('draft');
+ await vi.advanceTimersByTimeAsync(1500);
+ expect(markdownContent(mocks.patchCardRaw.mock.calls[0][1])).toBe('draft');
+ handle.replace('pending draft');
+ await handle.finalize('answer');
+ await handle.finalize('answer');
+ await vi.advanceTimersByTimeAsync(1500);
+ expect(mocks.patchCardRaw).toHaveBeenCalledTimes(1);
+ expect(mocks.sendCardRaw).toHaveBeenCalledTimes(2);
+ expect(mocks.sendCardRaw.mock.calls[1][2]).toEqual({ threadTs: 'om_root', advanceRound: false });
+ expect(mocks.sendCardRaw.mock.invocationCallOrder[1]).toBeLessThan(mocks.recallMessage.mock.invocationCallOrder[0]);
+ expect(mocks.recallMessage).toHaveBeenCalledExactlyOnceWith('om_stream');
+ expect(handle.messageId).toBe('om_final');
+ } finally { vi.useRealTimers(); }
+ });
+
+ it('does not resend the final if recalling progress fails', async () => {
+ mocks.recallMessage.mockRejectedValue(new Error('recall unavailable'));
+ const handle = await start('ou_owner');
+ await handle.finalize('answer');
+ expect(mocks.sendCardRaw).toHaveBeenCalledTimes(2);
+ expect(mocks.patchCardRaw).not.toHaveBeenCalled();
expect(mocks.sendText).not.toHaveBeenCalled();
+ expect(handle.messageId).toBe('om_final');
+ });
+
+ it('does not send or recall through a replacement account after image upload', async () => {
+ mocks.uploadImage.mockImplementation(async () => {
+ mocks.getAccountEpoch.mockReturnValue(2);
+ return 'img_old_account';
+ });
+ const handle = await start('ou_owner');
+ handle.addExtraImageAbsPath?.('/tmp/image.png');
+ await handle.finalize('answer');
+ expect(mocks.sendCardRaw).toHaveBeenCalledTimes(1);
+ expect(mocks.patchCardRaw).not.toHaveBeenCalled();
+ expect(mocks.recallMessage).not.toHaveBeenCalled();
});
it('falls back to plain text when even the short card patch fails', async () => {
mocks.patchCardRaw.mockRejectedValue(new Error('card patch unavailable'));
const handle = await start('ou_owner');
+ mocks.sendCardRaw.mockRejectedValueOnce(new Error('send unavailable'));
await handle.finalize('正文');
expect(mocks.sendText).toHaveBeenCalledWith(
@@ -140,7 +185,7 @@ describe('feishu streaming text', () => {
).resolves.toBeUndefined();
expect(mocks.uploadImage).toHaveBeenCalledTimes(1);
- expect(mocks.patchCardRaw).toHaveBeenCalledTimes(1);
- expect(markdownContent(mocks.patchCardRaw.mock.calls[0][1])).toContain('终态正文');
+ expect(mocks.sendCardRaw).toHaveBeenCalledTimes(2);
+ expect(markdownContent(mocks.sendCardRaw.mock.calls[1][1])).toContain('终态正文');
});
});
diff --git a/packages/lizi-im/src/feishu/__tests__/wsClientGroup.test.ts b/packages/lizi-im/src/feishu/__tests__/wsClientGroup.test.ts
index 3bc974887c..25c971b946 100644
--- a/packages/lizi-im/src/feishu/__tests__/wsClientGroup.test.ts
+++ b/packages/lizi-im/src/feishu/__tests__/wsClientGroup.test.ts
@@ -1,6 +1,6 @@
/**
* 群消息入站门禁: @ 检测、owner 门、非 owner 礼貌回应(冷却)、lane senderId、
- * mention 占位符剥离、thread_id → 话题 lane、群主流 @ 入站开话题。
+ * mention 占位符剥离、thread_id → 话题 lane、群主流 @ 留在群主流。
*/
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -19,9 +19,7 @@ const mocks = {
sendText: vi.fn(async () => ({ messageId: 'om_sent' })),
replyText: vi.fn(async () => ({ messageId: 'om_reply' })),
openThread: vi.fn(
- async (
- _messageId?: string,
- ): Promise<
+ async (): Promise<
| { kind: 'opened'; messageId: string; threadId: string }
| { kind: 'degraded' }
| { kind: 'orphaned'; openerMessageId: string }
@@ -175,7 +173,6 @@ beforeEach(async () => {
// 入站去重账本按设计跨 stop/start 保留(重推高发在重连前后), 所以用例之间
// 想复用同一个 message_id 必须显式清账。
wsClient.resetInboundDedupeForTest();
- wsClient.resetOrphanRetriesForTest();
mocks.options.length = 0;
mocks.eventHandlers = {};
vi.clearAllMocks();
@@ -246,29 +243,29 @@ describe('feishu group inbound gate', () => {
expect(events).toHaveLength(0);
});
- it('owner mention in main stream opens a thread and emits into the new topic lane', async () => {
+ it('owner mention stays in the main timeline without creating a topic', async () => {
await connect();
const events = collectEvents();
await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.openThread).toHaveBeenCalledWith('om_msg1');
+ expect(mocks.openThread).not.toHaveBeenCalled();
expect(events).toHaveLength(1);
const event = events[0]!;
- expect(event.senderId).toBe('g/oc_chat1/omt_new');
+ expect(event.senderId).toBe('g/oc_chat1');
expect(event.chatId).toBe('oc_chat1');
expect(event.text).toBe('帮我看看');
expect(event.speaker).toEqual({ id: OWNER, name: '', isOwner: true });
expect(event.replyContext).toBeUndefined();
expect(mocks.resolveReplyMessage).not.toHaveBeenCalled();
- // 锚点是开场白消息(话题内合法锚点), 不是触发消息。
- expect(mocks.pushReplyAnchor).toHaveBeenCalledWith('g/oc_chat1/omt_new', 'om_opener');
- // 开场白卡登记为可补丁锚点 — 本轮流式卡直接 patch 它, 不发占位消息。
- expect(mocks.pushPatchableOpener).toHaveBeenCalledWith('g/oc_chat1/omt_new', 'om_opener', 'om_msg1');
- // 路由进新话题 lane, 但上下文取数 lane 仍是群主流(新话题是空的)。
- expect(event.groupContextLane).toEqual({ chatId: 'oc_chat1', threadId: '' });
+ // Quote the actual trigger without creating a topic.
+ expect(mocks.pushReplyAnchor).toHaveBeenCalledWith('g/oc_chat1', 'om_msg1');
+
+ expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
+
+ expect(event.groupContextLane).toBeUndefined();
});
- it('main-stream reply mention resolves parent_id as exact context without changing topic routing', async () => {
+ it('main-stream reply mention resolves parent_id as exact context without turning a quoted reply into a topic', async () => {
mocks.resolveReplyMessage.mockResolvedValueOnce({
replyContext: {
author: '张乾',
@@ -287,9 +284,9 @@ describe('feishu group inbound gate', () => {
author: '张乾',
text: 'Omarchy Quattro 发布了!https://omarchy.org',
});
- // 回答落点仍是现有自动新话题 lane;引用只补上下文,不参与路由。
- expect(events[0]!.senderId).toBe('g/oc_chat1/omt_new');
- expect(mocks.openThread).toHaveBeenCalledWith('om_msg1');
+ // Quoting supplies context without changing the reply location.
+ expect(events[0]!.senderId).toBe('g/oc_chat1');
+ expect(mocks.openThread).not.toHaveBeenCalled();
});
it('main-stream reply fetch failure keeps the existing group-history fallback', async () => {
@@ -302,983 +299,27 @@ describe('feishu group inbound gate', () => {
expect(events).toHaveLength(1);
expect(events[0]!.replyContext).toBeUndefined();
- expect(events[0]!.groupContextLane).toEqual({ chatId: 'oc_chat1', threadId: '' });
- expect(mocks.openThread).toHaveBeenCalledWith('om_msg1');
- });
-
- it('keeps exact reply context through delayed openThread receipt recovery', async () => {
- vi.useFakeTimers();
- try {
- mocks.resolveReplyMessage.mockResolvedValueOnce({
- replyContext: {
- author: '张乾',
- text: 'Omarchy Quattro 发布了',
- },
- });
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'unconfirmed' })
- .mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_recovered_opener',
- threadId: 'omt_recovered',
- });
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(
- groupMessage({ parentId: 'om_parent' }),
- );
- expect(events).toHaveLength(0);
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(events).toHaveLength(1);
- expect(events[0]!.senderId).toBe('g/oc_chat1/omt_recovered');
- expect(events[0]!.replyContext?.author).toBe('张乾');
- expect(events[0]!.replyContext?.text).toBe('Omarchy Quattro 发布了');
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('falls back to the plain group lane when thread creation fails', async () => {
- mocks.openThread.mockResolvedValueOnce({ kind: 'degraded' });
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
-
- expect(events).toHaveLength(1);
- expect(events[0]!.senderId).toBe('g/oc_chat1');
expect(events[0]!.groupContextLane).toBeUndefined();
- expect(mocks.pushReplyAnchor).toHaveBeenCalledWith('g/oc_chat1', 'om_msg1');
- });
-
- it('orphaned opener: replies an in-topic notice and drops the turn instead of degrading', async () => {
- mocks.openThread.mockResolvedValueOnce({ kind: 'orphaned', openerMessageId: 'om_opener' });
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
-
- expect(events).toHaveLength(0);
- expect(mocks.pushReplyAnchor).not.toHaveBeenCalled();
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- // 提示挂在开场白下(自动落回话题) — 不把回答刷进群主流。
- expect(mocks.replyText).toHaveBeenCalledWith('om_opener', expect.any(String));
- });
-
- it('drops the turn when the connection is replaced while openThread is awaiting', async () => {
- let resolveOpenThread!: (outcome: {
- kind: 'opened';
- messageId: string;
- threadId: string;
- }) => void;
- mocks.openThread.mockReturnValueOnce(
- new Promise((resolve) => {
- resolveOpenThread = resolve;
- }),
- );
- await connect();
- const events = collectEvents();
- const handling = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- // openThread 仍在等待 API 时用户断开/换账号 — 旧连接的轮次不得漏进新连接。
- await wsClient.stop({ announceOffline: false, reason: 'test-disconnect-mid-open' });
- resolveOpenThread({ kind: 'opened', messageId: 'om_opener', threadId: 'omt_new' });
- await handling;
-
- expect(events).toHaveLength(0);
- expect(mocks.pushReplyAnchor).not.toHaveBeenCalled();
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- // 放弃路径释放了入站认领并 evict 了开话题缓存 — 新连接上的重投消息应
- // 重新走 openThread API(而不是复用旧连接上的结果), 且正常处理。
- expect(mocks.evictOpenThreadOutcome).toHaveBeenCalledWith('om_msg1');
- await connect();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(events).toHaveLength(1);
- expect(events[0]!.senderId).toBe('g/oc_chat1/omt_new');
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- });
-
- it('orphan notice failure schedules escalating active retries instead of relying on redelivery', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValueOnce({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首发失败 + 前两次重试失败, 第三次重试成功。
- mocks.replyText
- .mockRejectedValueOnce(new Error('transient network error'))
- .mockRejectedValueOnce(new Error('rate limited'))
- .mockRejectedValueOnce(new Error('still down'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
-
- // 首轮: 不起 turn, 提示发送失败。
- expect(events).toHaveLength(0);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 飞书对 3s 内完成处理的事件直接 ACK 不再重推 — 主动重试不依赖重投,
- // 递增间隔(10s / 30s / 90s), 用户不会永远看着「思考中」的开场白卡。
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- await vi.advanceTimersByTimeAsync(30_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
- await vi.advanceTimersByTimeAsync(90_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('orphan notice retries are gated to the triggering connection', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValueOnce({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 首发失败后、重试触发前用户断开/换账号 — 旧账号的开场白不该发进
- // 新账号的会话, 重试应被跳过。
- await wsClient.stop({ announceOffline: false, reason: 'test-disconnect-before-retry' });
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('retry exhaustion recalls the orphaned opener card as last resort', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValueOnce({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首发 + 3 次重试全部失败(持续故障)。
- mocks.replyText.mockRejectedValue(new Error('persistent outage'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- await vi.advanceTimersByTimeAsync(30_000);
- await vi.advanceTimersByTimeAsync(90_000);
-
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
- // 重试耗尽: 撤回开场白卡, 用户看到干净群主流而不是永久「思考中」卡。
- expect(mocks.recallOwnMessage).toHaveBeenCalledWith('om_opener');
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('stop 挂起超过 100 条孤儿收口链后同账号重连仍恢复最早一条', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockImplementation(async (messageId?: string) => ({
- kind: 'orphaned' as const,
- openerMessageId: `om_opener_${messageId ?? 'x'}`,
- }));
- mocks.replyText.mockRejectedValue(new Error('persistent outage'));
- await connect();
-
- for (let i = 0; i < 101; i += 1) {
- await mocks.eventHandlers['im.message.receive_v1']!(
- groupMessage({ messageId: `om_msg_${i}`, text: `@_user_1 孤儿${i}` }),
- );
- }
-
- await wsClient.stop({ announceOffline: false, reason: 'same-account-reconnect' });
- await connect();
- mocks.replyText.mockClear();
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledWith(
- 'om_opener_om_msg_0',
- expect.any(String),
- );
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('redelivery while a retry is in-flight shares the same send (no concurrent duplicate)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- // 第一次定时重试(10s)的发送挂起中 — 重投此刻到达, 必须共享这次发送
- // 而不是并发发出第二条提示。
- let resolveRetry!: (v: { messageId: string }) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((resolve) => {
- resolveRetry = resolve;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 冷却(60s)过后的重投: in-flight 共享 — 重投自己不另发(replyText 不变)。
- // 重投 handler 会等共享发送的结果, 不能 await(否则测试自身挂起)。
- await vi.advanceTimersByTimeAsync(51_000);
- const redelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 执行中的发送成功 — 共享结果 'delivered': 两条路径都收尾, 无新发送。
- resolveRetry({ messageId: 'om_ok' });
- await redelivery;
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('redelivery shared with a failing in-flight retry continues one chain (no duplicate)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- // 第一次定时重试(10s)的发送挂起中 — 重投共享它, 之后该发送失败。
- let rejectRetry!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectRetry = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 冷却过后的重投共享该 in-flight 发送(不另发), 随后发送失败 —
- // 共享结果 'failed': 两条路径各自安排重试, 入口同一(替换计时器)。
- // 重投 handler 等共享结果, 不 await。
- await vi.advanceTimersByTimeAsync(51_000);
- const redelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- rejectRetry(new Error('outage'));
- await redelivery;
- await Promise.resolve();
- await Promise.resolve();
-
- // 重试链继续(单链): 下一次尝试成功送达, 之后不再有发送。
- await vi.advanceTimersByTimeAsync(30_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('retry scheduled after a same-account reconnect proceeds on the new connection', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首次发送挂起中 — 期间断开 + 同一 bot 重连, 挂起的发送之后才失败。
- let rejectFirst!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectFirst = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- const firstDelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 断开 + 同一 bot 重连; stop 已释放 in-flight 认领 — 重投到达时不再被
- // 认领压掉, 而是正常处理并共享在途发送(不另发第二条)。
- await wsClient.stop({ announceOffline: false, reason: 'test-same-account-reconnect' });
- await connect();
- const redelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 旧发送此刻失败 — 共享结果 'failed': 两条路径各自安排重试, 入口同一;
- // 同账号重连后在新连接上继续执行(stale generation 不拦同 bot 的重试)。
- rejectFirst(new Error('client closed'));
- await firstDelivery;
- await redelivery;
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('retry is skipped when the account changed (old account opener never hits the new client)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- let rejectFirst!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectFirst = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- const firstDelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 断开并换成**别的** bot 账号。
- await wsClient.stop({ announceOffline: false, reason: 'test-account-swap' });
- const otherCreds = { appId: 'cli_other_account', appSecret: 'secret', service: 'feishu' as const };
- const connecting = wsClient.start(otherCreds, { announceLifecycle: false });
- mocks.options.at(-1)?.onReady?.();
- await connecting;
- wsClient.setBotOpenIdForTest(BOT_OPEN_ID);
-
- // 旧发送失败 → 安排重试; 重试触发时账号已换 — 必须跳过, 旧账号的
- // 开场白不得经新账号的 client 发出。
- rejectFirst(new Error('client closed'));
- await firstDelivery;
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('queued retry survives a same-bot reconnect (re-armed on start)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- // 10s 重试已排队。
-
- // 定时器触发前断开 + 同一 bot 重连: stop() 挂起重试, start() 恢复入队。
- await wsClient.stop({ announceOffline: false, reason: 'test-reconnect-before-retry' });
- await connect();
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('retry that fires while disconnected is suspended and resumed on same-bot reconnect', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- // 第一次定时重试(10s)的发送挂起中 — 断开, 该发送之后才失败。
- let rejectRetry!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectRetry = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 断开(in-flight 无法挂起); 旧发送失败 → 在停止状态安排下一次重试。
- await wsClient.stop({ announceOffline: false, reason: 'test-disconnect-mid-retry' });
- rejectRetry(new Error('client closed'));
- await Promise.resolve();
- await Promise.resolve();
- await Promise.resolve();
-
- // 该重试在重连前触发: 无连接 → 挂起(不终止)。
- await vi.advanceTimersByTimeAsync(30_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 同一 bot 重连 → 挂起重试恢复入队 → 下一次尝试成功送达。
- await connect();
- await vi.advanceTimersByTimeAsync(30_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('failure after stop suspends immediately instead of creating a live timer', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首次发送挂起中 — 断开, 该发送之后才失败(失败路径运行在停止状态)。
- let rejectFirst!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectFirst = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- const firstDelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- await wsClient.stop({ announceOffline: false, reason: 'test-stop-mid-first-send' });
- rejectFirst(new Error('client closed'));
- await firstDelivery;
-
- // 停止状态: 失败路径不创建定时器(直接挂起)— 推进时间无任何发送。
- await vi.advanceTimersByTimeAsync(60_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 同一 bot 重连 → 挂起恢复入队 → 送达。
- await connect();
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('清凭证期间在途首发失败后,同账号再登录不会恢复登出前的 opener 重试', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- let rejectFirst!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectFirst = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- const firstDelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 生产顺序: stop 再清凭证。在途 REST 此时仍未落定; 只清 map 挡不住
- // 失败续段 suspend, 同账号再登录就会把登出前的 opener 重试复活。
- await wsClient.stop({ announceOffline: false, reason: 'credentials-cleared' });
- wsClient.clearOrphanRetriesForCredentialClear();
- rejectFirst(new Error('client closed'));
- await firstDelivery;
-
- await connect();
- await vi.advanceTimersByTimeAsync(200_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('清凭证期间在途重试失败后,同账号再登录不会恢复登出前的 opener 重试', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- let rejectRetry!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectRetry = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- await wsClient.stop({ announceOffline: false, reason: 'credentials-cleared' });
- wsClient.clearOrphanRetriesForCredentialClear();
- rejectRetry(new Error('client closed'));
- await Promise.resolve();
- await Promise.resolve();
- await Promise.resolve();
-
- await connect();
- await vi.advanceTimersByTimeAsync(200_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('in-flight dedupe survives a same-bot reconnect (redelivery shares the old send)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- // 10s 定时重试的发送挂起中 — 断开重连后, 重投必须共享这次在途发送。
- let resolveRetry!: (v: { messageId: string }) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((resolve) => {
- resolveRetry = resolve;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 断开 + 同一 bot 重连(in-flight 记账保留), 冷却(60s)过后重投。
- await wsClient.stop({ announceOffline: false, reason: 'test-reconnect-mid-inflight' });
- await connect();
- await vi.advanceTimersByTimeAsync(61_000);
- const redelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 在途发送成功 — 共享结果 'delivered', 无第三条发送。
- resolveRetry({ messageId: 'om_ok' });
- await redelivery;
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('suspended retries are not re-armed across service boundary (same appId, feishu → lark)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- // 10s 重试已排队。
-
- // 断开, 用同一 appId 但 service=lark 的凭证重连 — 旧 feishu 的挂起
- // 重试不得恢复(账号边界含 service)。
- await wsClient.stop({ announceOffline: false, reason: 'test-service-swap' });
- const larkCreds = { appId: 'cli_group_test', appSecret: 'secret', service: 'lark' as const };
- const connecting = wsClient.start(larkCreds, { announceLifecycle: false });
- mocks.options.at(-1)?.onReady?.();
- await connecting;
- wsClient.setBotOpenIdForTest(BOT_OPEN_ID);
-
- await vi.advanceTimersByTimeAsync(60_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('redelivery joining a failed in-flight retry does not reset the attempt budget', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首发 + attempt0(10s) + attempt1(40s) 都失败; 下一次重投的发送挂起。
- mocks.replyText
- .mockRejectedValueOnce(new Error('outage'))
- .mockRejectedValueOnce(new Error('outage'))
- .mockRejectedValueOnce(new Error('outage'));
- let rejectShared!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectShared = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(61_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3); // 首发 + attempt0 + attempt1
- // attempt2 已排队(130s 触发)。
-
- // 冷却过后的重投创建 in-flight 发送(第 4 次调用, 挂起)。
- const redelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
-
- // attempt2 定时器触发 → 加入那次 in-flight(不另发)。
- await vi.advanceTimersByTimeAsync(69_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
-
- // 共享发送失败: attempt2 链进撤回兜底; 重投失败路径的 attempt 0 不得
- // 重置预算(预算天花板) — 之后不应再有新发送。
- rejectShared(new Error('outage'));
- await redelivery;
- await Promise.resolve();
- await Promise.resolve();
- await Promise.resolve();
- expect(mocks.recallOwnMessage).toHaveBeenCalled();
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('换账号启动时丢弃旧账号的挂起重试(不再等待旧账号回归)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 断开(重试挂起)→ 换成别的 bot 启动: 挂起项被丢弃。
- await wsClient.stop({ announceOffline: false, reason: 'test-account-swap-drop' });
- const otherCreds = { appId: 'cli_other_account', appSecret: 'secret', service: 'feishu' as const };
- const connecting = wsClient.start(otherCreds, { announceLifecycle: false });
- mocks.options.at(-1)?.onReady?.();
- await connecting;
- wsClient.setBotOpenIdForTest(BOT_OPEN_ID);
- await vi.advanceTimersByTimeAsync(60_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 之后再换回旧账号: 丢弃过的重试不得复活(向早已过时的 opener 补发)。
- await wsClient.stop({ announceOffline: false, reason: 'test-back-to-old-account' });
- const back = wsClient.start(credentials, { announceLifecycle: false });
- mocks.options.at(-1)?.onReady?.();
- await back;
- wsClient.setBotOpenIdForTest(BOT_OPEN_ID);
- await vi.advanceTimersByTimeAsync(120_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('清凭证取消在途孤儿发送的续段(不再 schedule/suspend 新状态)', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- let rejectFirst!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectFirst = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- const firstDelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 在途发送期间清凭证: 续段按代次放弃 — 不 schedule、不 suspend。
- wsClient.clearOrphanRetriesForCredentialClear();
- rejectFirst(new Error('client closed'));
- await firstDelivery;
- await vi.advanceTimersByTimeAsync(200_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
-
- // 清凭证后同凭证重连: 也不应有任何重试复活。
- await wsClient.stop({ announceOffline: false, reason: 'test-relogin' });
- await connect();
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('stale in-flight 不丢本代收口链: 安排本代重试, 旧请求落定后送达', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首次发送挂起(代次 N)。
- let rejectOld!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectOld = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- const firstDelivery = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 清凭证(代次 N+1)后同凭证重登录, 平台重投: 新 handler 加入 stale
- // in-flight → 安排本代重试(不丢收口链)。
- wsClient.clearOrphanRetriesForCredentialClear();
- await wsClient.stop({ announceOffline: false, reason: 'test-relogin-stale' });
- await connect();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 旧请求失败 → 旧 handler 的续段被代次拦截; 本代重试在 10s 后触发,
- // 以当前代次重新发送并送达。
- rejectOld(new Error('client closed'));
- await firstDelivery;
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('queued retry is not re-armed when a different bot starts', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 定时器触发前断开, 换成别的 bot — 旧 bot 的挂起重试不得恢复。
- await wsClient.stop({ announceOffline: false, reason: 'test-account-swap-before-retry' });
- const otherCreds = { appId: 'cli_other_account', appSecret: 'secret', service: 'feishu' as const };
- const connecting = wsClient.start(otherCreds, { announceLifecycle: false });
- mocks.options.at(-1)?.onReady?.();
- await connecting;
- wsClient.setBotOpenIdForTest(BOT_OPEN_ID);
-
- await vi.advanceTimersByTimeAsync(60_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('delivered terminal marker blocks a late send path even beyond the 60s cooldown', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
-
- // 10s 定时重试成功送达 — 终态标记写入。
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 远超 60s 冷却窗口后的重投: 送达是终态 + 入站认领已重新认领 —
- // 任何路径都不再发送第三条提示。
- await vi.advanceTimersByTimeAsync(300_000);
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(300_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('successful retry reclaims the message so later redeliveries are suppressed', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText.mockRejectedValueOnce(new Error('transient network error'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 10s 定时重试成功 — 重新认领触发消息。
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
-
- // 冷却(60s)过后的重投: 入站去重拦下(已重新认领), 不再进入提示流程。
- await vi.advanceTimersByTimeAsync(61_000);
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(2);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('successful redelivery cancels the stale retry scheduled by the failed first attempt', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首发 + 前两轮定时重试都失败(90s 重试挂起中) — 重投在此时成功送达。
- mocks.replyText
- .mockRejectedValueOnce(new Error('transient network error'))
- .mockRejectedValueOnce(new Error('still down'))
- .mockRejectedValueOnce(new Error('still down'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 冷却过后的重投成功发送提示 — 之前失败轮次安排的定时重试应被清掉,
- // 否则它会绕过冷却在稍后重复提示, 甚至耗尽后误撤回开场白卡。
- await vi.advanceTimersByTimeAsync(61_000);
- // 61s 内 10s + 30s 两轮定时重试都跑过且失败(共 3 次调用)。
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
-
- // 再推进远超 90s 的重试窗口: 被清掉的重试链不应再有任何发送。
- await vi.advanceTimersByTimeAsync(200_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('exhaustion recall is gated to the triggering connection', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValueOnce({ kind: 'orphaned', openerMessageId: 'om_opener' });
- mocks.replyText
- .mockRejectedValueOnce(new Error('outage'))
- .mockRejectedValueOnce(new Error('outage'))
- .mockRejectedValueOnce(new Error('outage'));
- // 最后一次重试(retry2)的 replyText 挂起 — 期间用户换代, 之后才失败。
- let rejectLast!: (err: Error) => void;
- mocks.replyText.mockImplementationOnce(
- () =>
- new Promise<{ messageId: string }>((_, reject) => {
- rejectLast = reject;
- }),
- );
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.advanceTimersByTimeAsync(10_000);
- await vi.advanceTimersByTimeAsync(30_000);
- await vi.advanceTimersByTimeAsync(90_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
-
- // 最后一次重试挂起期间换代, 然后失败 → 耗尽分支应 gate 拦截撤回:
- // 旧账号的开场白卡不得经新 client 发出删除请求。
- await wsClient.stop({ announceOffline: false, reason: 'test-disconnect-mid-retry' });
- rejectLast(new Error('outage'));
- await Promise.resolve();
- await Promise.resolve();
- await Promise.resolve();
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
- });
-
- it('cooldown-hit redelivery releases its claim so a later redelivery can retry', async () => {
- vi.useFakeTimers();
- try {
- mocks.openThread.mockResolvedValue({ kind: 'orphaned', openerMessageId: 'om_opener' });
- // 首发 + 前两次定时重试都失败; 第三次重试(90s)不触发。
- mocks.replyText
- .mockRejectedValueOnce(new Error('transient network error'))
- .mockRejectedValueOnce(new Error('still down'))
- .mockRejectedValueOnce(new Error('still down'));
- await connect();
- const events = collectEvents();
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 冷却期内的重投: 冷却命中不发送 — 必须释放本次认领, 否则冷却期间
- // 的 claim 卡满 10 分钟, 之后换代会丢消息。
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(1);
-
- // 推进 61s: 定时重试(10s/30s)跑两轮都失败; 冷却已过期。
- await vi.advanceTimersByTimeAsync(61_000);
- expect(mocks.replyText).toHaveBeenCalledTimes(3);
-
- // 冷却过期后的重投: 认领未被卡住 → 正常处理 → 提示发送成功(第 4 次)。
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(mocks.replyText).toHaveBeenCalledTimes(4);
- expect(events).toHaveLength(0);
- } finally {
- vi.useRealTimers();
- }
+ expect(mocks.openThread).not.toHaveBeenCalled();
});
- it('stop releases the in-flight claim so a redelivery on the reconnected bot is processed', async () => {
- // 旧连接的 openThread 挂起中; stop(同账号重连)释放认领; 新连接的重投
- // 到达 → 正常处理(不被仍持有的认领压掉)。
- let resolveOldOpen!: (o: { kind: 'opened'; messageId: string; threadId: string }) => void;
- mocks.openThread.mockReturnValueOnce(
- new Promise((resolve) => {
- resolveOldOpen = resolve;
- }),
- );
+ it('releases unfinished quoted-message lookup on reconnect without duplicating the turn', async () => {
+ let resolveOld!: (value: null) => void;
+ mocks.resolveReplyMessage.mockReturnValueOnce(new Promise((resolve) => { resolveOld = resolve; }));
await connect();
const events = collectEvents();
- const oldHandling = mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await Promise.resolve();
- expect(mocks.openThread).toHaveBeenCalledTimes(1);
-
- await wsClient.stop({ announceOffline: false, reason: 'test-reconnect-while-opening' });
+ const message = groupMessage({ parentId: 'om_parent' });
+ const oldHandling = mocks.eventHandlers['im.message.receive_v1']!(message);
+ await vi.waitFor(() => expect(mocks.resolveReplyMessage).toHaveBeenCalledTimes(1));
+ await wsClient.stop({ announceOffline: false, reason: 'test-reconnect' });
await connect();
- // 重投(旧请求恢复前到达): stop 已释放认领 → 新连接正常处理并 emit。
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- await vi.waitFor(() => expect(mocks.openThread).toHaveBeenCalledTimes(2));
+ await mocks.eventHandlers['im.message.receive_v1']!(message);
expect(events).toHaveLength(1);
- expect(events[0]!.senderId).toBe('g/oc_chat1/omt_new');
-
- // 旧 handler 此刻才恢复: gate-drop, 且不得再释放新连接的认领。
- resolveOldOpen({ kind: 'opened', messageId: 'om_opener', threadId: 'omt_new' });
+ resolveOld(null);
await oldHandling;
+ await mocks.eventHandlers['im.message.receive_v1']!(message);
expect(events).toHaveLength(1);
-
- // 第三次投递: 新连接的认领仍在 → 重推被压掉, 不会重复起 turn。
- await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
- expect(events).toHaveLength(1);
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
+ expect(mocks.pushReplyAnchor).toHaveBeenCalledExactlyOnceWith('g/oc_chat1', 'om_msg1');
});
it('drops duplicate delivery of the same message (one turn per message)', async () => {
@@ -1290,7 +331,7 @@ describe('feishu group inbound gate', () => {
await mocks.eventHandlers['im.message.receive_v1']!(groupMessage({}));
expect(events).toHaveLength(1);
- expect(mocks.openThread).toHaveBeenCalledTimes(1);
+ expect(mocks.openThread).not.toHaveBeenCalled();
expect(mocks.pushReplyAnchor).toHaveBeenCalledTimes(1);
});
diff --git a/packages/lizi-im/src/feishu/__tests__/wsClientGroupThreadRouting.test.ts b/packages/lizi-im/src/feishu/__tests__/wsClientGroupThreadRouting.test.ts
index 313f777e09..afcd01e179 100644
--- a/packages/lizi-im/src/feishu/__tests__/wsClientGroupThreadRouting.test.ts
+++ b/packages/lizi-im/src/feishu/__tests__/wsClientGroupThreadRouting.test.ts
@@ -1,16 +1,7 @@
/**
- * 群消息的话题路由不变量 —— 每条话题一条 lane, 谁也别想截流。
- *
- * 语义:
- * - 群主流 @bot: **恒** openThread 开新话题, 以新话题 lane 路由(senderId =
- * 新话题 lane, 回复锚点 = 开场白消息), 上下文取数 lane 仍指向群主流;
- * 开话题失败才降级回群 lane(锚点 = 触发消息)。
- * - 话题内消息: 直接进该话题自己的 lane, 锚点 = 触发消息。
- *
- * 这条不变量是 `/ctr` 接管「只跟话题走」的地基: 接管 binding 的 key 就是话题
- * lane, transport 这边不给任何「把群主流消息改道进某条接管话题」的口子 ——
- * 有过一版这样的覆写钩子, 结果群里随便 @ 一句都掉进被接管的会话里
- * (用户感知: 不管在哪问, 工作目录都是绑定那个项目), 已移除。
+ * Main-timeline questions stay in the group lane; topic questions stay in their
+ * own topic lane. Duplicate deliveries elect a single route before queueing an
+ * anchor. Account changes discard pending leases, same-account reconnects keep them.
*/
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -38,7 +29,7 @@ const mocks = {
getAccountEpoch: vi.fn(() => 1),
sendText: vi.fn(async () => ({ messageId: 'om_sent' })),
replyText: vi.fn(async () => ({ messageId: 'om_reply' })),
- // 返回 degraded = 开话题失败(降级回群 lane), 单测按用例覆盖。
+ // Guard against accidentally creating topics for incoming messages.
openThread: vi.fn<
(messageId?: string) => Promise<
| { kind: 'opened'; messageId: string; threadId: string }
@@ -187,7 +178,6 @@ beforeEach(async () => {
// 去重账本按设计跨 stop/start 保留, 用例之间必须显式清掉才能复用同一个
// message_id。
wsClient.resetInboundDedupeForTest();
- wsClient.resetOrphanRetriesForTest();
resetDualDeliveryForTest();
mocks.options.length = 0;
mocks.eventHandlers = {};
@@ -204,7 +194,6 @@ beforeEach(async () => {
afterEach(async () => {
await wsClient.stop({ announceOffline: false, reason: 'test-cleanup' });
- wsClient.resetOrphanRetriesForTest();
resetDualDeliveryForTest();
feishuEvents.removeAllListeners('message');
vi.useRealTimers();
@@ -224,46 +213,35 @@ afterAll(() => {
});
describe('feishu group thread routing', () => {
- it('群主流 @bot 恒开新话题, 以新话题 lane 路由, 锚点 = 开场白消息', async () => {
+ it('群主流 @bot 留在群主流, 锚点 = 触发消息', async () => {
const events = collectMessages();
await connect();
await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('开个新话题'));
- expect(mocks.openThread).toHaveBeenCalledWith('om_msg1');
- expect(mocks.pushReplyAnchor).toHaveBeenCalledWith('g/oc_chat1/omt_new', 'om_opener');
- expect(mocks.pushPatchableOpener).toHaveBeenCalledWith('g/oc_chat1/omt_new', 'om_opener', 'om_msg1');
+ expect(mocks.openThread).not.toHaveBeenCalled();
+ expect(mocks.pushReplyAnchor).toHaveBeenCalledWith('g/oc_chat1', 'om_msg1');
+ expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
expect(events).toHaveLength(1);
- expect(events[0].senderId).toBe('g/oc_chat1/omt_new');
- // 新话题是空的, 群历史前缀仍按触发时所在的群主流拉取。
- expect(events[0].groupContextLane).toEqual({ chatId: 'oc_chat1', threadId: '' });
+ expect(events[0].senderId).toBe('g/oc_chat1');
+ // Context follows the original main-timeline lane.
+ expect(events[0].groupContextLane).toBeUndefined();
expect(events[0].text).toBe('开个新话题');
// Events have stable IDs but no display names; the host uses chatId fallback.
expect(events[0].interactionSource).toBeUndefined();
expect(events[0].chatId).toBe('oc_chat1');
});
- /**
- * 回归守卫: 曾有一版「群里存在 /ctr 接管时把群主流消息改道进接管话题」的
- * transport 钩子, 结果群里随便 @ 一句都进那条被接管的会话。接管只跟话题走,
- * 群主流永远只会开出新话题 —— transport 这层不认识任何接管状态。
- */
- it('每次群主流 @bot 都开自己的新话题(没有任何"截流进接管话题"的通道)', async () => {
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'opened', messageId: 'om_opener1', threadId: 'omt_a' })
- .mockResolvedValueOnce({ kind: 'opened', messageId: 'om_opener2', threadId: 'omt_b' });
+ it('successive main-timeline mentions share the group lane without entering a topic', async () => {
const events = collectMessages();
await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](
- groupMainFlowMessage('第一句', 'om_first'),
- );
- await mocks.eventHandlers['im.message.receive_v1'](
- groupMainFlowMessage('第二句', 'om_second'),
- );
-
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- expect(events.map((e) => e.senderId)).toEqual(['g/oc_chat1/omt_a', 'g/oc_chat1/omt_b']);
+ await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('第一句', 'om_first'));
+ await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('第二句', 'om_second'));
+ expect(mocks.openThread).not.toHaveBeenCalled();
+ expect(events.map((e) => e.senderId)).toEqual(['g/oc_chat1', 'g/oc_chat1']);
+ expect(mocks.pushReplyAnchor.mock.calls).toEqual([
+ ['g/oc_chat1', 'om_first'], ['g/oc_chat1', 'om_second'],
+ ]);
});
it('话题内消息进该话题自己的 lane, 不开新话题, 锚点 = 触发消息', async () => {
@@ -365,7 +343,7 @@ describe('feishu group thread routing', () => {
expect(pendingTopicLeaseCountForTest()).toBe(0);
});
- it('群主流纯 @bot 同样开话题起一轮; @ 在句尾时只剥掉 @bot', async () => {
+ it('群主流纯 @bot 在群主流起一轮; @ 在句尾时只剥掉 @bot', async () => {
const events = collectMessages();
await connect();
@@ -379,7 +357,8 @@ describe('feishu group thread routing', () => {
expect(events).toHaveLength(2);
expect(events[0]).toMatchObject({ text: '', invoked: true });
expect(events[1].text).toBe('重新想一想');
- expect(mocks.openThread).toHaveBeenCalledWith('om_bare_main');
+ expect(mocks.openThread).not.toHaveBeenCalled();
+ expect(events[0].senderId).toBe('g/oc_chat1');
});
it('abandons the topic lease when the account is replaced during attachment download', async () => {
@@ -579,627 +558,4 @@ describe('feishu group thread routing', () => {
expect(pendingTopicLeaseCountForTest()).toBe(0);
});
- it('late topic after the cache TTL still takes over while the flat route is uncommitted', async () => {
- vi.useFakeTimers();
- let releaseOpenThread: ((value: { kind: 'opened'; messageId: string; threadId: string }) => void) | undefined;
- mocks.openThread.mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- releaseOpenThread = resolve;
- }),
- );
- mocks.recallOwnMessage.mockResolvedValue(true);
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('迟到话题', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000000000';
- topic.message.message_id = 'om_topic_late';
- const flat = groupMainFlowMessage('迟到话题', 'om_flat_late') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000000000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await vi.advanceTimersByTimeAsync(25_001);
- await mocks.eventHandlers['im.message.receive_v1'](topic);
- expect(releaseOpenThread).toBeDefined();
- releaseOpenThread?.({ kind: 'opened', messageId: 'om_bot_opener', threadId: 'omt_bot' });
- await flatHandling;
-
- expect(events).toHaveLength(1);
- expect(events[0].senderId).toBe('g/oc_chat1/omt_existing');
- expect(mocks.openThread).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).toHaveBeenCalledWith('om_bot_opener');
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- });
-
- it('retries a late-takeover opener recall when Feishu returns a business rejection', async () => {
- vi.useFakeTimers();
- let releaseOpenThread:
- | ((value: { kind: 'opened'; messageId: string; threadId: string }) => void)
- | undefined;
- mocks.openThread
- .mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- releaseOpenThread = resolve;
- }),
- )
- .mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_bot_opener_retry',
- threadId: 'omt_bot_retry',
- });
- mocks.recallOwnMessage.mockResolvedValueOnce(false).mockResolvedValueOnce(true);
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('迟到话题撤回重试', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000009000';
- topic.message.message_id = 'om_topic_recall_retry';
- const flat = groupMainFlowMessage('迟到话题撤回重试', 'om_flat_recall_retry') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000009000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await mocks.eventHandlers['im.message.receive_v1'](topic);
- expect(releaseOpenThread).toBeDefined();
- releaseOpenThread?.({
- kind: 'opened',
- messageId: 'om_bot_opener_retry',
- threadId: 'omt_bot_retry',
- });
- await flatHandling;
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_existing');
- expect(mocks.recallOwnMessage).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).toHaveBeenLastCalledWith('om_bot_opener_retry');
-
- await vi.advanceTimersByTimeAsync(10_000);
-
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- expect(mocks.openThread).toHaveBeenLastCalledWith('om_flat_recall_retry');
- expect(mocks.recallOwnMessage).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).toHaveBeenLastCalledWith('om_bot_opener_retry');
- expect(events).toHaveLength(1);
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- });
-
- it('does not revive a pending takeover recall after credentials are cleared', async () => {
- vi.useFakeTimers();
- let releaseOpenThread:
- | ((value: { kind: 'opened'; messageId: string; threadId: string }) => void)
- | undefined;
- let releaseRecall: ((value: boolean) => void) | undefined;
- mocks.openThread.mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- releaseOpenThread = resolve;
- }),
- );
- mocks.recallOwnMessage.mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- releaseRecall = resolve;
- }),
- );
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('撤回在途时清凭证', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000010000';
- topic.message.message_id = 'om_topic_clear_during_recall';
- const flat = groupMainFlowMessage('撤回在途时清凭证', 'om_flat_clear_during_recall') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000010000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await mocks.eventHandlers['im.message.receive_v1'](topic);
- expect(releaseOpenThread).toBeDefined();
- releaseOpenThread?.({
- kind: 'opened',
- messageId: 'om_bot_clear_during_recall',
- threadId: 'omt_bot_clear_during_recall',
- });
- await Promise.resolve();
- expect(releaseRecall).toBeDefined();
-
- await wsClient.stop({ announceOffline: false, reason: 'clear-credentials' });
- wsClient.clearOrphanRetriesForCredentialClear();
- releaseRecall?.(false);
- await flatHandling;
-
- await connect();
- await vi.advanceTimersByTimeAsync(10_000 + 30_000 + 90_000 + 1_000);
-
- expect(events).toHaveLength(1);
- expect(mocks.openThread).toHaveBeenCalledTimes(1);
- expect(mocks.recallOwnMessage).toHaveBeenCalledTimes(1);
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- });
-
- it('committed unpaired flat still mirrors parent chat when a late topic is suppressed', async () => {
- vi.useFakeTimers();
- mocks.openThread.mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_bot_committed',
- threadId: 'omt_bot_committed',
- });
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('已提交后迟到话题', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000007000';
- topic.message.message_id = 'om_topic_after_commit';
- const flat = groupMainFlowMessage('已提交后迟到话题', 'om_flat_committed') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000007000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await flatHandling;
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_bot_committed');
- expect(mocks.openThread).toHaveBeenCalledTimes(1);
- expect(mocks.pushPatchableOpener).toHaveBeenCalledWith(
- 'g/oc_chat1/omt_bot_committed',
- 'om_bot_committed',
- 'om_flat_committed',
- );
-
- await mocks.eventHandlers['im.message.receive_v1'](topic);
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_bot_committed');
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- vi.useRealTimers();
- });
-
- it('recovered unconfirmed flat keeps its mirror when the native topic arrives afterward', async () => {
- vi.useFakeTimers();
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'unconfirmed' })
- .mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_bot_recovered_committed',
- threadId: 'omt_bot_recovered_committed',
- });
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('恢复提交后迟到话题', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000008000';
- topic.message.message_id = 'om_topic_after_recovered_commit';
- const flat = groupMainFlowMessage(
- '恢复提交后迟到话题',
- 'om_flat_recovered_committed',
- ) as { message: Record<string, unknown> };
- flat.message.create_time = '1788000008000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await flatHandling;
- expect(events).toHaveLength(0);
-
- await vi.advanceTimersByTimeAsync(10_000);
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_bot_recovered_committed');
- expect(events[0]?.interactionSource).toBeUndefined();
- expect(events[0]?.chatId).toBe('oc_chat1');
-
- await mocks.eventHandlers['im.message.receive_v1'](topic);
-
- expect(events).toHaveLength(1);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- vi.useRealTimers();
- });
-
- it('orphaned unpaired flat stays takeable so a late topic still dispatches', async () => {
- vi.useFakeTimers();
- mocks.openThread.mockResolvedValueOnce({
- kind: 'orphaned',
- openerMessageId: 'om_orphan_opener',
- });
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('孤儿后迟到话题', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000003000';
- topic.message.message_id = 'om_topic_after_orphan';
- const flat = groupMainFlowMessage('孤儿后迟到话题', 'om_flat_after_orphan') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000003000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await flatHandling;
-
- expect(events).toHaveLength(0);
- expect(mocks.replyText).toHaveBeenCalledWith('om_orphan_opener', expect.any(String));
-
- await mocks.eventHandlers['im.message.receive_v1'](topic);
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_existing');
- expect(events[0]?.messageId).toBe('om_topic_after_orphan');
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- });
-
- it('unconfirmed unpaired flat stays takeable so a late topic still dispatches', async () => {
- vi.useFakeTimers();
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'unconfirmed' })
- .mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_recovered_after_unconfirmed',
- threadId: 'omt_bot_unconfirmed',
- });
- mocks.recallOwnMessage.mockResolvedValue(true);
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('未确认后迟到话题', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000005000';
- topic.message.message_id = 'om_topic_after_unconfirmed';
- const flat = groupMainFlowMessage('未确认后迟到话题', 'om_flat_after_unconfirmed') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000005000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await flatHandling;
-
- expect(events).toHaveLength(0);
-
- await mocks.eventHandlers['im.message.receive_v1'](topic);
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_existing');
- expect(events[0]?.messageId).toBe('om_topic_after_unconfirmed');
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).toHaveBeenCalledWith('om_recovered_after_unconfirmed');
- expect(events).toHaveLength(1);
- });
-
- it('late topic takeover during orphaned openThread recalls the opener without a second turn', async () => {
- vi.useFakeTimers();
- let releaseOpenThread: ((value: { kind: 'orphaned'; openerMessageId: string }) => void) | undefined;
- mocks.openThread.mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- releaseOpenThread = resolve;
- }),
- );
- mocks.recallOwnMessage.mockResolvedValue(true);
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('孤儿途中接管', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000004000';
- topic.message.message_id = 'om_topic_during_orphan';
- const flat = groupMainFlowMessage('孤儿途中接管', 'om_flat_during_orphan') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000004000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await mocks.eventHandlers['im.message.receive_v1'](topic);
- expect(releaseOpenThread).toBeDefined();
- releaseOpenThread?.({ kind: 'orphaned', openerMessageId: 'om_orphan_during' });
- await flatHandling;
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_existing');
- expect(mocks.recallOwnMessage).toHaveBeenCalledWith('om_orphan_during');
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- });
-
- it('late topic takeover recovers unconfirmed opener uuid and recalls it without a second turn', async () => {
- vi.useFakeTimers();
- let releaseOpenThread: ((value: { kind: 'unconfirmed' }) => void) | undefined;
- mocks.openThread
- .mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- releaseOpenThread = resolve;
- }),
- )
- .mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_recovered_opener',
- threadId: 'omt_bot',
- });
- mocks.recallOwnMessage.mockResolvedValue(true);
- const events = collectMessages();
- await connect();
- const topic = groupTopicMessage('迟到话题未确认', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000001000';
- topic.message.message_id = 'om_topic_late_unconfirmed';
- const flat = groupMainFlowMessage('迟到话题未确认', 'om_flat_late_unconfirmed') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000001000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- await mocks.eventHandlers['im.message.receive_v1'](topic);
- expect(releaseOpenThread).toBeDefined();
- releaseOpenThread?.({ kind: 'unconfirmed' });
- await flatHandling;
-
- expect(events).toHaveLength(1);
- expect(events[0].senderId).toBe('g/oc_chat1/omt_existing');
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- expect(mocks.recallOwnMessage).toHaveBeenCalledWith('om_recovered_opener');
- expect(events).toHaveLength(1);
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- });
-
- it('开话题失败时降级回群 lane(锚点 = 触发消息)', async () => {
- mocks.openThread.mockResolvedValueOnce({ kind: 'degraded' });
- const events = collectMessages();
- await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('开话题失败'));
-
- expect(events[0].senderId).toBe('g/oc_chat1');
- expect(mocks.pushReplyAnchor).toHaveBeenCalledWith('g/oc_chat1', 'om_msg1');
- expect(events[0].groupContextLane).toBeUndefined();
- });
-
- it('开话题回执不确定时立刻不起 turn、不降级, 也不释放认领', async () => {
- mocks.openThread.mockResolvedValueOnce({ kind: 'unconfirmed' });
- const events = collectMessages();
- await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('回执不确定'));
-
- expect(events).toHaveLength(0);
- expect(mocks.pushReplyAnchor).not.toHaveBeenCalled();
- expect(mocks.evictOpenThreadOutcome).not.toHaveBeenCalled();
- });
-
- it('回执不确定后定时用同一 uuid 取回 opened, 再发出话题 turn', async () => {
- vi.useFakeTimers();
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'unconfirmed' })
- .mockResolvedValueOnce({ kind: 'opened', messageId: 'om_recovered', threadId: 'omt_rec' });
- const events = collectMessages();
- await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('回执不确定后恢复'));
- expect(events).toHaveLength(0);
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- expect(mocks.openThread).toHaveBeenLastCalledWith('om_msg1');
- expect(events).toHaveLength(1);
- expect(events[0].senderId).toBe('g/oc_chat1/omt_rec');
- expect(mocks.pushPatchableOpener).toHaveBeenCalledWith(
- 'g/oc_chat1/omt_rec',
- 'om_recovered',
- 'om_msg1',
- );
- vi.useRealTimers();
- });
-
- it('回执不确定耗尽后同账号重连仍能恢复, 不丢弃恢复链', async () => {
- vi.useFakeTimers();
- mocks.openThread.mockReset();
- mocks.openThread.mockResolvedValue({ kind: 'unconfirmed' });
- const events = collectMessages();
- await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('耗尽后重连'));
- await vi.advanceTimersByTimeAsync(10_000 + 30_000 + 90_000 + 1_000);
- expect(events).toHaveLength(0);
- expect(mocks.openThread).toHaveBeenCalledTimes(4);
-
- await wsClient.stop({ announceOffline: false, reason: 'same-account-reconnect' });
- await connect();
- mocks.openThread.mockClear();
- mocks.openThread.mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_late',
- threadId: 'omt_late',
- });
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledWith('om_msg1');
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_late');
- vi.useRealTimers();
- });
-
- it('回执不确定后恢复为 degraded 不视为确认无卡, 不降级派发', async () => {
- vi.useFakeTimers();
- mocks.openThread.mockReset();
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'unconfirmed' })
- .mockResolvedValueOnce({ kind: 'degraded' })
- .mockResolvedValueOnce({
- kind: 'opened',
- messageId: 'om_late',
- threadId: 'omt_late',
- });
- const events = collectMessages();
- await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('先不确定后失败'));
- expect(events).toHaveLength(0);
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
- expect(events).toHaveLength(0);
- expect(mocks.pushReplyAnchor).not.toHaveBeenCalled();
-
- await vi.advanceTimersByTimeAsync(30_000);
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_late');
- expect(mocks.pushPatchableOpener).toHaveBeenCalledWith(
- 'g/oc_chat1/omt_late',
- 'om_late',
- 'om_msg1',
- );
- vi.useRealTimers();
- });
-
- it('回执不确定耗尽定时重试后仍不降级群主流', async () => {
- vi.useFakeTimers();
- mocks.openThread.mockResolvedValue({ kind: 'unconfirmed' });
- const events = collectMessages();
- await connect();
-
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('一直不确定'));
- await vi.advanceTimersByTimeAsync(10_000 + 30_000 + 90_000 + 1_000);
-
- expect(events).toHaveLength(0);
- expect(mocks.pushReplyAnchor).not.toHaveBeenCalled();
- // 首次 + 三档延迟重试
- expect(mocks.openThread).toHaveBeenCalledTimes(4);
- vi.useRealTimers();
- });
-
- it('stop 挂起超过 100 条 unconfirmed 后同账号重连仍恢复最早一条', async () => {
- vi.useFakeTimers();
- mocks.openThread.mockResolvedValue({ kind: 'unconfirmed' });
- const events = collectMessages();
- await connect();
-
- for (let i = 0; i < 101; i += 1) {
- await mocks.eventHandlers['im.message.receive_v1'](
- groupMainFlowMessage(`回执不确定${i}`, `om_unconfirmed_${i}`),
- );
- }
- expect(events).toHaveLength(0);
-
- await wsClient.stop({ announceOffline: false, reason: 'same-account-reconnect' });
- await connect();
- mocks.openThread.mockClear();
- mocks.openThread.mockImplementation(async (messageId?: string) => {
- if (messageId === 'om_unconfirmed_0') {
- return { kind: 'opened' as const, messageId: 'om_first', threadId: 'omt_first' };
- }
- return { kind: 'unconfirmed' as const };
- });
-
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledWith('om_unconfirmed_0');
- expect(events.some((event) => event.messageId === 'om_unconfirmed_0')).toBe(true);
- vi.useRealTimers();
- });
-
- it('延迟恢复 await openThread 期间换账号后不再登记锚点或派发 turn', async () => {
- vi.useFakeTimers();
- let resolveOpen!: (value: {
- kind: 'opened';
- messageId: string;
- threadId: string;
- }) => void;
- mocks.openThread
- .mockResolvedValueOnce({ kind: 'unconfirmed' })
- .mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- resolveOpen = resolve;
- }),
- );
- const events = collectMessages();
- await connect();
- await mocks.eventHandlers['im.message.receive_v1'](groupMainFlowMessage('换账号'));
- await vi.advanceTimersByTimeAsync(10_000);
- expect(mocks.openThread).toHaveBeenCalledTimes(2);
-
- await wsClient.stop({ announceOffline: false, reason: 'switch-account' });
- const connecting = wsClient.start(
- { appId: 'cli_other_bot', appSecret: 'secret', service: 'feishu' },
- { announceLifecycle: false },
- );
- mocks.options.at(-1)?.onReady?.();
- await connecting;
-
- resolveOpen({ kind: 'opened', messageId: 'om_stale', threadId: 'omt_stale' });
- await Promise.resolve();
- await Promise.resolve();
-
- expect(events).toHaveLength(0);
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
- expect(mocks.pushReplyAnchor).not.toHaveBeenCalled();
- vi.useRealTimers();
- });
-
- it('openThread 在途换代后不提交双投路由、不用新连接撤回旧开场白', async () => {
- vi.useFakeTimers();
- let resolveOpen!: (value: {
- kind: 'opened';
- messageId: string;
- threadId: string;
- }) => void;
- mocks.openThread.mockImplementationOnce(
- () =>
- new Promise((resolve) => {
- resolveOpen = resolve;
- }),
- );
- const events = collectMessages();
- await connect();
- const flat = groupMainFlowMessage('换代中的副本', 'om_flat_stale') as {
- message: Record<string, unknown>;
- };
- flat.message.create_time = '1788000000000';
-
- const flatHandling = mocks.eventHandlers['im.message.receive_v1'](flat);
- await vi.advanceTimersByTimeAsync(1_000);
- expect(resolveOpen).toBeDefined();
-
- await wsClient.stop({ announceOffline: false, reason: 'same-account-reconnect' });
- await connect();
-
- resolveOpen({ kind: 'opened', messageId: 'om_stale_opener', threadId: 'omt_stale' });
- await flatHandling;
-
- expect(events).toHaveLength(0);
- expect(mocks.recallOwnMessage).not.toHaveBeenCalled();
- expect(mocks.pushPatchableOpener).not.toHaveBeenCalled();
-
- const topic = groupTopicMessage('换代中的副本', 'omt_existing') as {
- message: Record<string, unknown>;
- };
- topic.message.create_time = '1788000000000';
- topic.message.message_id = 'om_topic_after_reconnect';
- await mocks.eventHandlers['im.message.receive_v1'](topic);
-
- expect(events).toHaveLength(1);
- expect(events[0]?.senderId).toBe('g/oc_chat1/omt_existing');
- vi.useRealTimers();
- });
});
diff --git a/packages/lizi-im/src/feishu/__tests__/wsClientInboundDedupe.test.ts b/packages/lizi-im/src/feishu/__tests__/wsClientInboundDedupe.test.ts
index acf319449e..bd986a2a11 100644
--- a/packages/lizi-im/src/feishu/__tests__/wsClientInboundDedupe.test.ts
+++ b/packages/lizi-im/src/feishu/__tests__/wsClientInboundDedupe.test.ts
@@ -196,7 +196,7 @@ describe('feishu inbound message dedupe', () => {
expect(events[0].text).toBe('出行要注意什么吗');
});
- it('重推不留任何副作用: 群主流的重推不会再开一次话题', async () => {
+ it('重推不留任何副作用: 群主流只派发一次且不开话题', async () => {
const events = collectMessages();
await connect();
@@ -214,7 +214,7 @@ describe('feishu inbound message dedupe', () => {
await mocks.eventHandlers['im.message.receive_v1'](mainFlow);
await mocks.eventHandlers['im.message.receive_v1'](mainFlow);
- expect(mocks.openThread).toHaveBeenCalledTimes(1);
+ expect(mocks.openThread).not.toHaveBeenCalled();
expect(events).toHaveLength(1);
});
diff --git a/packages/lizi-im/src/feishu/ipc.ts b/packages/lizi-im/src/feishu/ipc.ts
index ec1bb30ac5..1ab493ccab 100644
--- a/packages/lizi-im/src/feishu/ipc.ts
+++ b/packages/lizi-im/src/feishu/ipc.ts
@@ -414,8 +414,7 @@ export async function clearAndDisconnect(): Promise<void> {
});
// 逻辑凭证清除(而非 transport 重连): 清掉账号态并重置 lastBoundCreds —
// 之后重新保存相同 appId/service 不会被误判为同账号重连, 登出前的
- // opener/锚点不会被新一轮会话认领; 挂起的孤儿提示重试同样丢弃。
+ // opener/锚点不会被新一轮会话认领。
outbound.forgetBoundAccount();
- wsClient.clearOrphanRetriesForCredentialClear();
storage.clearAll();
}
diff --git a/packages/lizi-im/src/feishu/outbound.ts b/packages/lizi-im/src/feishu/outbound.ts
index 23fbb58ba5..185b4fdf8c 100644
--- a/packages/lizi-im/src/feishu/outbound.ts
+++ b/packages/lizi-im/src/feishu/outbound.ts
@@ -1219,7 +1219,7 @@ export async function patchCardRaw(messageId: string, cardJson: unknown): Promis
export async function sendCardRaw(
userId: string,
cardJson: unknown,
- opts?: { threadTs?: string },
+ opts?: { threadTs?: string; advanceRound?: boolean },
): Promise<{ messageId: string }> {
return withSendTarget(userId, { advanceRound: true, ...opts }, (target) => createMessage(
target,
diff --git a/packages/lizi-im/src/feishu/streamingText.ts b/packages/lizi-im/src/feishu/streamingText.ts
index 9f9f8cd302..9cd74b7d20 100644
--- a/packages/lizi-im/src/feishu/streamingText.ts
+++ b/packages/lizi-im/src/feishu/streamingText.ts
@@ -14,9 +14,8 @@
* 2) parse xdt-file URLs (dedup), send each
* as a separate file message
* 3) strip xdt-file from card text
- * 4) patch card with mixed text + img
- * elements (or plain markdown card if no
- * images)
+ * 4) send final card with text/images, then
+ * recall the progress card
* handle.close() → cancel pending throttle, no further patches
*
* Design parity: matches the legacy feishuBot/replyClient.ts behaviour
@@ -105,7 +104,10 @@ async function uploadExtraImageKeys(absPaths: readonly string[]): Promise<string
}
class FeishuStreamingTextHandle implements StreamingTextHandle {
- readonly messageId: string;
+ private messageIdValue: string;
+ get messageId(): string {
+ return this.messageIdValue;
+ }
private readonly openId: string;
private buffer: string;
private flushed: string;
@@ -120,8 +122,8 @@ class FeishuStreamingTextHandle implements StreamingTextHandle {
*/
private extraImageAbsPaths: string[] = [];
- constructor(messageId: string, openId: string, initial: string, private readonly opts?: { threadTs?: string }, private readonly openerEpoch?: number) {
- this.messageId = messageId;
+ constructor(messageId: string, openId: string, initial: string, private readonly opts?: { threadTs?: string }, private readonly accountEpoch = getAccountEpoch(), private readonly claimedOpener = false) {
+ this.messageIdValue = messageId;
this.openId = openId;
// `initial` is what's currently DISPLAYED in feishu (e.g. "🧠 思考中...").
// `buffer` is what we've ACCUMULATED to display — starts empty so the
@@ -202,7 +204,7 @@ class FeishuStreamingTextHandle implements StreamingTextHandle {
/* swallow */
}
}
- if (this.buffer === this.flushed) return;
+ if (this.finalized || getAccountEpoch() !== this.accountEpoch || this.buffer === this.flushed) return;
// Friendlier placeholder when buffer is xdt-only (model sent images/files
// but no narration yet) — `classifyXdtOnly` returns the kind so we can
// show a hint instead of stripped placeholders.
@@ -228,17 +230,17 @@ class FeishuStreamingTextHandle implements StreamingTextHandle {
await this.inFlight;
}
- // ── finalize: upload images, send files, patch with mixed elements ────────
+ // ── finalize: upload media, send final, recall progress ───────────────────
private async doFinalize(): Promise<void> {
const log = getLog();
const text = this.buffer;
+ if (getAccountEpoch() !== this.accountEpoch) return;
if (!text.trim() && this.extraImageAbsPaths.length === 0) {
// A claimed opener is also the topic's reply anchor. Only its owning
// account/round may restore that anchor after a successful recall.
- if (this.openerEpoch !== undefined && getAccountEpoch() !== this.openerEpoch) return;
await recallMessage(this.messageId);
- if (this.openerEpoch !== undefined && getAccountEpoch() === this.openerEpoch) {
+ if (this.claimedOpener && getAccountEpoch() === this.accountEpoch) {
rearmAnchorToTrigger(this.openId, this.messageId);
}
return;
@@ -299,7 +301,9 @@ class FeishuStreamingTextHandle implements StreamingTextHandle {
`[feishu/streamingText] uploading ${extrasToUpload.length} extra image(s) from tool_result`,
);
}
+ if (getAccountEpoch() !== this.accountEpoch) return;
const extraImageKeys = await uploadExtraImageKeys(extrasToUpload);
+ if (getAccountEpoch() !== this.accountEpoch) return;
// 2. Send xdt-file links as separate file messages.
const fileLinks = collectXdtFileLinks(text);
@@ -319,19 +323,21 @@ class FeishuStreamingTextHandle implements StreamingTextHandle {
);
}
+ if (getAccountEpoch() !== this.accountEpoch) return;
+
// 3. Strip xdt-file from card text (delivered separately, no placeholder).
const cardText = stripXdtFileLinks(text);
const cardTextTrimmed = cardText.trim();
- // 4. Patch the card. Terminal shapes:
+ // 4. Send a new final message, then remove the progress card. Terminal shapes:
// a) text only → plain markdown card v2
// b) text + images (markdown 内联 OR tool_result 追加) → mixed elements card
// c) empty text + only files → "🎉 N 个文件已送达" placeholder
// d) extra images all failed → delivery failure (truly empty finals returned above)
const hasAnyImage = imageUrls.length > 0 || extraImageKeys.length > 0;
const fileOnly = cardTextTrimmed.length === 0 && !hasAnyImage && fileLinks.length > 0;
+ let card: unknown;
try {
- let card: unknown;
if (fileOnly) {
card = buildMarkdownCardV2(transportMessages.streaming.fileSentDone(fileLinks.length));
} else if (hasAnyImage) {
@@ -347,18 +353,33 @@ class FeishuStreamingTextHandle implements StreamingTextHandle {
? buildMixedMarkdownCardV2(visibleText, imageMap, extraImageKeys)
: buildMarkdownCardV2(visibleText),
);
- await patchCardRaw(this.messageId, card);
+ const progressId = this.messageId;
+ const result = await sendCardRaw(this.openId, card, { ...this.opts, advanceRound: false });
+ this.messageIdValue = result.messageId;
this.flushed = this.buffer;
+ // Cleanup is best-effort: a failed recall must never resend the final.
+ if (getAccountEpoch() !== this.accountEpoch) return;
+ try {
+ await recallMessage(progressId);
+ if (this.claimedOpener && getAccountEpoch() === this.accountEpoch) {
+ rearmAnchorToTrigger(this.openId, progressId);
+ }
+ } catch (err) {
+ log.warn(`[feishu/streamingText] progress recall failed: ${String(err)}`);
+ }
} catch (err) {
const msg = err instanceof Error ? err.message : String(err);
- log.warn(`[feishu/streamingText] finalize patch failed: ${msg}`);
+ log.warn(`[feishu/streamingText] finalize send failed: ${msg}`);
+ if (getAccountEpoch() !== this.accountEpoch) return;
const notice = transportMessages.streaming.deliveryFailed;
try {
- await patchCardRaw(this.messageId, buildMarkdownCardV2(notice));
+ // Preserve the answer on the progress card when fresh delivery fails.
+ await patchCardRaw(this.messageId, card ?? buildMarkdownCardV2(notice));
} catch (fallbackErr) {
const fallbackMsg =
fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
log.warn(`[feishu/streamingText] fallback patch failed: ${fallbackMsg}`);
+ if (getAccountEpoch() !== this.accountEpoch) return;
try {
await sendText(this.openId, notice, this.opts);
} catch (textErr) {
@@ -375,14 +396,14 @@ export async function start(
initial: string = transportMessages.streaming.randomThinking(),
opts?: { threadTs?: string },
): Promise<StreamingTextHandle> {
- // 群主流 @ 开话题时, 开场白卡就是本轮流式卡(openThread 已用它开好话题) —
- // 认领后直接 patch, 不再新建一条「开个话题」占位回复。
+ // Preserve explicit opener callers; ordinary inbound messages never create topics.
+ const epoch = getAccountEpoch();
const claimed = opts?.threadTs ? null : claimPatchableOpener(openId);
if (claimed) {
- return new FeishuStreamingTextHandle(claimed, openId, initial, opts, getAccountEpoch());
+ return new FeishuStreamingTextHandle(claimed, openId, initial, opts, epoch, true);
}
const { messageId } = await sendCardRaw(openId, buildMarkdownCardV2(initial), opts);
- return new FeishuStreamingTextHandle(messageId, openId, initial, opts);
+ return new FeishuStreamingTextHandle(messageId, openId, initial, opts, epoch);
}
/**
diff --git a/packages/lizi-im/src/feishu/wsClient.ts b/packages/lizi-im/src/feishu/wsClient.ts
index 51830d0269..fac611c066 100644
--- a/packages/lizi-im/src/feishu/wsClient.ts
+++ b/packages/lizi-im/src/feishu/wsClient.ts
@@ -32,14 +32,10 @@
*
* 入站统一门禁(所有 chat_type 生效):
* → 重推去重: 同一 (appId, message_id) 只处理一次(见 claimInboundMessage)
- * → 连接换代门禁: 处理途中的 await(附件下载/开话题)之后复查
+ * → 连接换代门禁: 处理途中的 await(附件下载/引用查询)之后复查
* isActiveConnection(generation, botAppId) — 断开/换账号的旧连接轮次
* 直接丢弃, 不 push 锚点、不 emit, 不会路由进新账号的 client/session
- * → 群主流 @ 开话题(opened / degraded / orphaned / unconfirmed):
- * opened → 新话题 lane; degraded → 降级群 lane 旧行为; orphaned →
- * 回复开场白(落回话题)说明失败并放弃本轮, 不降级刷群主流;
- * unconfirmed → 事件已 ACK, 定时再用同一 uuid 有界重试, 取回后
- * 恢复 turn 或走 orphan 收口, 不立刻降级群主流
+ * → 群主流保持群 lane,话题消息保持原话题 lane
*
* card.action.trigger(_v1)
* → drop if sender not in whitelist
@@ -65,7 +61,6 @@ import {
import { bindScope, getLog, getScope, runInScope, scopeSlot } from './moduleScope.js';
import { messages as transportMessages } from './messages.js';
import type { BotCredentials, FeishuConnectionStatus } from './internal-types.js';
-import type { IMMessageEvent } from '../types.js';
// ── module state ──────────────────────────────────────────────────────────────
@@ -86,467 +81,16 @@ function createWsState() {
pendingOfflineNotice: false,
botOpenId: null as string | null,
strangerNoticeAt: new Map<string, number>(),
- orphanNoticeAt: new Map<string, number>(),
- orphanRetryEpoch: 0,
- orphanNoticeDelivered: new Set<string>(),
- orphanNoticeRetries: new Map<string, PendingOrphanRetry>(),
- suspendedOrphanRetries: [] as SuspendedOrphanRetry[],
- orphanAttemptCeiling: new Map<string, number>(),
- unconfirmedOpenRetries: new Map<string, UnconfirmedOpenRetry>(),
- suspendedUnconfirmedOpens: [] as UnconfirmedOpenRetry[],
- orphanNoticeInFlight: new Map<string, InFlightOrphanSend>(),
inboundInFlight: new Map<string, { generation: number }>(),
seenInboundMessages: new Map<string, number>(),
};
}
/** 本实例(FeishuScope)的模块状态; 没有 scope 时落在默认实例上。 */
const S = () => scopeSlot(ws_SLOT, createWsState);
-/** 当前连接的 service(feishu/lark)— 账号边界含 service, 同名 appId 也不可串。 */
-/**
- * start() 等待旧连接 stop() 时即发布下一账号身份。旧入站 await 若在
- * currentBotAppId 已清空、新账号尚未装入的空窗恢复,仍能区分同账号重连与换号。
- */
-/** Latest connection generation invalidated by an explicit logical logout/shutdown. */
-
-
-/**
- * 本 bot 在自己 app 视角下的 open_id — 群消息判 @ 用(mentions[].id.open_id
- * 对比)。连接成功后从 /open-apis/bot/v3/info 拉取; null = 未知, 此时群消息
- * 一律丢弃(惰性失效, 不影响私聊)。换凭证/断开时清空。
- */
-
/** 非 owner 群 @ 的礼貌回应 per-user 冷却(open_id → 上次回应 ts)。 */
const STRANGER_NOTICE_COOLDOWN_MS = 60_000;
-/**
- * 开场白孤立(话题 id 不可恢复且撤回失败)时回复开场白说明失败 — per-opener
- * 冷却(开场白消息 id → 上次提示 ts)防重投事件重复提示。回复挂在开场白下
- * 自动落回话题, 不惊动群主流。
- *
- * 提示发送失败时: 释放入站认领(重推若来可重新处理)并**主动调度递增间隔的
- * 延迟重试** — 飞书长连接对「处理 3s 内完成」的事件直接 ACK 不再重推, 只靠
- * 释放认领等重推不可靠, 用户会永久看着「思考中」的开场白卡等不到说明。
- * 每次重试前 gate 到触发时的 connection generation — 换代后旧账号的开场白
- * 不会发进新账号的会话。重试由定时器执行, 不经过本函数的冷却(重推在冷却期
- * 内到达会被拦截, 不会双发); 3 次重试(总窗口 ~2 分钟)全失败后放弃 —
- * 再长的故障窗口里平台重推同样无效, 无限重试只会让定时器跨连接悬挂。
- */
-const ORPHAN_NOTICE_COOLDOWN_MS = 60_000;
-
-/**
- * 清凭证代次。clearOrphanRetriesForCredentialClear 只删 map 条目, 挡不住
- * 已经 await 出去的 REST。代次在清凭证时递增, 发送前后比对: 过期续段不得
- * 再 suspend/schedule, 否则同账号再登录会把登出前的 opener 重试/撤回复活。
- */
-
-/**
- * 提示**成功送达**的 opener 集合。与 orphanNoticeAt 分离: 后者在发送前
- * 就 set(表达「最近一次尝试」, 失败不回溯), 前者只在成功路径加入 —
- * 送达是终态事实, 不随时间失效: 重试链用它判断「提示已由其它路径送达,
- * 本链应收尾」, 挂起超 60s 的旧重试失败时同样成立。stop() 清空, 并有
- * 容量上限(孤儿事件每次一个 opener, 进程内不会无界增长)。
- */
-const ORPHAN_DELIVERED_MAX_ENTRIES = 200;
-
-function markNoticeDelivered(openerMessageId: string): void {
- S().orphanNoticeDelivered.add(openerMessageId);
- while (S().orphanNoticeDelivered.size > ORPHAN_DELIVERED_MAX_ENTRIES) {
- const oldest = S().orphanNoticeDelivered.values().next().value;
- if (typeof oldest !== 'string') break;
- S().orphanNoticeDelivered.delete(oldest);
- }
-}
-
-/** 重试间隔按尝试次数递增 — attempt 0 用首个间隔, 超出数组则放弃。 */
-const ORPHAN_NOTICE_RETRY_DELAYS_MS = [10_000, 30_000, 90_000] as const;
-
-interface PendingOrphanRetry {
- timer: ReturnType<typeof setTimeout>;
- botAppId: string;
- service: BotCredentials['service'];
- openerMessageId: string;
- /** 触发消息 id — 重试成功时重新认领, 抑制冷却后的重投再次进入提示流程。 */
- messageId: string;
- /** 已尝试次数 — stop() 挂起后恢复时保持退避进度。 */
- attempt: number;
-}
-
-
-/**
- * stop() 时被挂起的排队重试(定时器已取消, 元数据保留)。同账号重连后由
- * start() 重新入队 — 否则事件已被 ACK, 重试随 stop 消失, 用户会一直看到
- * 「思考中」的开场白卡。跨账号不恢复(appId + service 双键, 见
- * resumeOrphanRetriesFor 的过滤)。
- */
-interface SuspendedOrphanRetry {
- botAppId: string;
- service: BotCredentials['service'];
- openerMessageId: string;
- messageId: string;
- attempt: number;
-}
-
-/**
- * 该 opener 的尝试预算天花板(opener → 最高 attempt, 只增不减, 跨链保持)。
- * 重投失败路径原本会用 attempt 0 覆盖更先进的重试链 — 反复重连+重投会把
- * 预算反复重置, 撤回兜底永远到不了; 天花板让任何新链都从既有进度续接。
- */
-const ORPHAN_ATTEMPT_CEILING_MAX_ENTRIES = 200;
-
-function bumpOrphanAttemptCeiling(openerMessageId: string, attempt: number): number {
- const ceiling = Math.max(S().orphanAttemptCeiling.get(openerMessageId) ?? 0, attempt);
- S().orphanAttemptCeiling.set(openerMessageId, ceiling);
- while (S().orphanAttemptCeiling.size > ORPHAN_ATTEMPT_CEILING_MAX_ENTRIES) {
- const oldest = S().orphanAttemptCeiling.keys().next().value;
- if (typeof oldest !== 'string') break;
- S().orphanAttemptCeiling.delete(oldest);
- }
- return ceiling;
-}
-
-/** 挂起一个排队重试(按 opener 去重, 预算续接天花板)。 */
-function suspendOrphanRetry(entry: SuspendedOrphanRetry): void {
- entry.attempt = bumpOrphanAttemptCeiling(entry.openerMessageId, entry.attempt);
- for (let i = S().suspendedOrphanRetries.length - 1; i >= 0; i--) {
- if (S().suspendedOrphanRetries[i]!.openerMessageId === entry.openerMessageId) {
- S().suspendedOrphanRetries.splice(i, 1);
- }
- }
- // 不设容量帽: 每条都是尚未终态化的孤儿收口链, 事件已 ACK。
- // 静默 shift 最早一条会让重连后既不提示也不撤回, 用户永久看到「思考中」。
- S().suspendedOrphanRetries.push(entry);
-}
-
-/**
- * start() 连接就绪后调用: 匹配当前账号(appId + service)的挂起重试恢复
- * 入队(保持退避进度); **不匹配的直接丢弃** — 换账号时旧账号遗留的重试
- * 不能无限期等待账号再次出现(届时向早已过时的 opener 补发提示/撤回)。
- */
-function resumeOrphanRetriesFor(botAppId: string, service: BotCredentials['service']): void {
- for (let i = S().suspendedOrphanRetries.length - 1; i >= 0; i--) {
- const entry = S().suspendedOrphanRetries[i]!;
- S().suspendedOrphanRetries.splice(i, 1);
- if (entry.botAppId !== botAppId || entry.service !== service) continue;
- scheduleOrphanNoticeRetry(
- entry.botAppId,
- entry.service,
- entry.openerMessageId,
- entry.messageId,
- entry.attempt,
- );
- }
-}
-
-/**
- * 连接状态处置: 同一 bot 活跃 → false(照常执行); 已换成别的账号 → true
- * (终止 — 旧账号的开场白不得经新 client 操作); 无连接(停止/重连中) →
- * true 且挂起排队等重连(事件已 ACK, 终止会让提示永久消失)。
- */
-function suspendOrDropOnConnectionChange(
- botAppId: string,
- service: BotCredentials['service'],
- entry: SuspendedOrphanRetry,
- context: string,
-): boolean {
- if (isSameBotActive(botAppId, service)) return false;
- const log = getLog();
- const accountChanged =
- S().currentBotAppId !== null && (S().currentBotAppId !== botAppId || S().currentService !== service);
- if (accountChanged) {
- log.info(`[feishu/wsClient] orphan opener ${context} skipped: account changed`);
- return true;
- }
- suspendOrphanRetry(entry);
- log.info(`[feishu/wsClient] orphan opener ${context} suspended for same-bot reconnect`);
- return true;
-}
-
-/**
- * openThread 回执不确定时的 ACK 后恢复链。三次即时 uuid 重试仍无回执时,
- * 事件会在 3s 内被 ACK, 不能指望平台重投。这里按孤儿提示同一套间隔
- * (10s/30s/90s) 再用同一 uuid 取回原消息: opened → 补发 turn;
- * orphaned → 走孤儿提示收口; degraded → 确认无卡后降级群 lane 起 turn;
- * 仍 unconfirmed → 下一档。stop 挂起、同账号 start 恢复。
- */
-interface UnconfirmedOpenRetry {
- timer?: ReturnType<typeof setTimeout>;
- botAppId: string;
- service: BotCredentials['service'];
- messageId: string;
- chatId: string;
- senderOpenId: string;
- text: string;
- attachments: Awaited<ReturnType<typeof downloadAttachments>>['attachments'];
- unsupported: ReturnType<typeof parseIncoming>['unsupported'];
- replyContext?: NonNullable<IMMessageEvent['replyContext']>;
- raw: RawMessageEvent;
- attempt: number;
- /** 迟到话题已接管路由: 只恢复 UUID 并撤回开场白, 不再派 turn。 */
- recallOnly?: boolean;
- /** 未配对群副本: 恢复链真正要派 turn 时才提交路由。 */
- commitUnpairedFlat?: () => boolean;
- isUnpairedFlatTakenOver?: () => boolean;
- abandonUnpairedFlat?: () => void;
-}
-
-
-function clearUnconfirmedOpenRetries(): void {
- for (const retry of S().unconfirmedOpenRetries.values()) {
- if (retry.timer) clearTimeout(retry.timer);
- retry.abandonUnpairedFlat?.();
- }
- S().unconfirmedOpenRetries.clear();
- for (const retry of S().suspendedUnconfirmedOpens) retry.abandonUnpairedFlat?.();
- S().suspendedUnconfirmedOpens.length = 0;
-}
-
-function suspendUnconfirmedOpenRetry(entry: UnconfirmedOpenRetry): void {
- if (entry.timer) {
- clearTimeout(entry.timer);
- entry.timer = undefined;
- }
- S().unconfirmedOpenRetries.delete(entry.messageId);
- for (let i = S().suspendedUnconfirmedOpens.length - 1; i >= 0; i--) {
- if (S().suspendedUnconfirmedOpens[i]!.messageId === entry.messageId) {
- S().suspendedUnconfirmedOpens.splice(i, 1);
- }
- }
- // 不设容量帽: 每条都是尚未终态化的轮次, 事件已 ACK、入站认领仍在。
- // 静默 shift 最早一条会让重连后既不重派 turn, 也无法收口服务端思考卡。
- S().suspendedUnconfirmedOpens.push(entry);
-}
-
-function resumeUnconfirmedOpenRetriesFor(
- botAppId: string,
- service: BotCredentials['service'],
-): void {
- for (let i = S().suspendedUnconfirmedOpens.length - 1; i >= 0; i--) {
- const entry = S().suspendedUnconfirmedOpens[i]!;
- S().suspendedUnconfirmedOpens.splice(i, 1);
- if (entry.botAppId !== botAppId || entry.service !== service) {
- entry.abandonUnpairedFlat?.();
- continue;
- }
- scheduleUnconfirmedOpenRetry(entry);
- }
-}
-
-async function recallRecoveredOpener(
- messageId: string,
- kind: 'opened' | 'orphaned',
-): Promise<boolean> {
- const log = getLog();
- try {
- const recalled = await outbound.recallOwnMessage(messageId);
- if (!recalled) {
- log.warn(
- `[feishu/wsClient] recall ${kind} opener after late topic takeover was rejected (non-fatal)`,
- );
- }
- return recalled;
- } catch (err) {
- const msg = err instanceof Error ? err.message : String(err);
- log.warn(
- `[feishu/wsClient] recall ${kind} opener after late topic takeover failed (non-fatal): ${msg}`,
- );
- return false;
- }
-}
-
-function scheduleTakeoverRecallRetry(entry: UnconfirmedOpenRetry, epoch: number): void {
- if (S().orphanRetryEpoch !== epoch) {
- getLog().info(
- '[feishu/wsClient] late-takeover opener recall stale after credential clear — dropping retry',
- );
- return;
- }
- scheduleUnconfirmedOpenRetry({ ...entry, timer: undefined, recallOnly: true });
-}
-
-function scheduleUnconfirmedOpenRetry(entry: UnconfirmedOpenRetry): void {
- const delay = ORPHAN_NOTICE_RETRY_DELAYS_MS[entry.attempt];
- if (delay === undefined) {
- getLog().error(
- '[feishu/wsClient] unconfirmed openThread retries exhausted — holding for next reconnect',
- );
- // 事件已 ACK, 不能释放恢复链: 挂起并把 attempt 归零, 同账号重连后再走
- // 一轮 10/30/90s。留着耗尽的 attempt 会让 resume 立刻再次耗尽。
- suspendUnconfirmedOpenRetry({ ...entry, timer: undefined, attempt: 0 });
- return;
- }
- const existing = S().unconfirmedOpenRetries.get(entry.messageId);
- if (existing?.timer) clearTimeout(existing.timer);
- const epoch = S().orphanRetryEpoch;
- entry.timer = setTimeout(() => {
- S().unconfirmedOpenRetries.delete(entry.messageId);
- void retryUnconfirmedOpen(entry, epoch);
- }, delay);
- S().unconfirmedOpenRetries.set(entry.messageId, entry);
-}
-
-async function retryUnconfirmedOpen(
- entry: UnconfirmedOpenRetry,
- epoch: number,
-): Promise<void> {
- const log = getLog();
- if (!isSameBotActive(entry.botAppId, entry.service)) {
- const accountChanged =
- S().currentBotAppId !== null &&
- (S().currentBotAppId !== entry.botAppId || S().currentService !== entry.service);
- if (accountChanged) {
- log.info('[feishu/wsClient] unconfirmed openThread retry skipped: account changed');
- entry.abandonUnpairedFlat?.();
- return;
- }
- suspendUnconfirmedOpenRetry({ ...entry, timer: undefined });
- log.info('[feishu/wsClient] unconfirmed openThread retry suspended for same-bot reconnect');
- return;
- }
- const opener = await outbound.openThread(entry.messageId);
- if (S().orphanRetryEpoch !== epoch) {
- entry.abandonUnpairedFlat?.();
- return;
- }
- // saveAndConnect 的普通换账号只 stop/start, 不推进 orphanRetryEpoch —
- // await 后必须再核当前 bot, 否则会把 A 的 opener/turn 写进 B 的 outbound。
- if (!isSameBotActive(entry.botAppId, entry.service)) {
- const accountChanged =
- S().currentBotAppId !== null &&
- (S().currentBotAppId !== entry.botAppId || S().currentService !== entry.service);
- if (accountChanged) {
- log.info('[feishu/wsClient] unconfirmed openThread dropped after await: account changed');
- entry.abandonUnpairedFlat?.();
- return;
- }
- suspendUnconfirmedOpenRetry({ ...entry, timer: undefined });
- log.info('[feishu/wsClient] unconfirmed openThread suspended after await for same-bot reconnect');
- return;
- }
- if (opener.kind === 'unconfirmed') {
- scheduleUnconfirmedOpenRetry({ ...entry, timer: undefined, attempt: entry.attempt + 1 });
- return;
- }
- if (opener.kind === 'orphaned') {
- if (entry.recallOnly || entry.isUnpairedFlatTakenOver?.()) {
- const recalled = await recallRecoveredOpener(opener.openerMessageId, 'orphaned');
- if (!recalled) {
- scheduleTakeoverRecallRetry(
- { ...entry, attempt: entry.attempt + 1 },
- epoch,
- );
- }
- return;
- }
- log.error(
- `[feishu/wsClient] unconfirmed openThread recovered as orphaned opener=...${opener.openerMessageId.slice(-8)}`,
- );
- await sendOrphanOpenerNotice(
- entry.botAppId,
- entry.service,
- entry.messageId,
- opener.openerMessageId,
- );
- entry.abandonUnpairedFlat?.();
- return;
- }
- let laneUserId: string;
- let groupContextLane: { chatId: string; threadId: string } | undefined;
- if (opener.kind === 'opened') {
- if (entry.recallOnly || (entry.commitUnpairedFlat && !entry.commitUnpairedFlat())) {
- const recalled = await recallRecoveredOpener(opener.messageId, 'opened');
- if (!recalled) {
- scheduleTakeoverRecallRetry(
- { ...entry, attempt: entry.attempt + 1 },
- epoch,
- );
- }
- return;
- }
- laneUserId = encodeLaneUserId(entry.chatId, opener.threadId);
- outbound.pushReplyAnchor(laneUserId, opener.messageId);
- outbound.pushPatchableOpener(laneUserId, opener.messageId, entry.messageId);
- groupContextLane = { chatId: entry.chatId, threadId: '' };
- } else {
- // degraded 只说明这次调用没确认发出, 不能否定先前 unconfirmed 请求已经
- // 落地。当成确认无卡去群主流派 turn, 会一边留着思考卡一边刷屏。
- log.info(
- '[feishu/wsClient] unconfirmed openThread still unknown after degraded — keeping recovery chain',
- );
- scheduleUnconfirmedOpenRetry({ ...entry, timer: undefined, attempt: entry.attempt + 1 });
- return;
- }
- log.info(
- `[feishu/wsClient] unconfirmed openThread recovered as ${opener.kind} — emitting deferred turn`,
- );
- feishuEvents.emit('message', {
- channelName: 'feishu',
- senderId: laneUserId,
- invoked: true,
- chatId: entry.chatId,
- contextId: entry.botAppId,
- messageId: entry.messageId,
- text: entry.text,
- speaker: { id: entry.senderOpenId, name: '', isOwner: ownerGuard.check(entry.senderOpenId) },
- ...(groupContextLane ? { groupContextLane } : {}),
- ...(entry.replyContext ? { replyContext: entry.replyContext } : {}),
- attachments: entry.attachments,
- unsupported: entry.unsupported,
- raw: entry.raw,
- });
-}
-
-/** 测试注入口 — 清空挂起/排队重试。生产代码不要调用。 */
-export function resetOrphanRetriesForTest(): void {
- for (const retry of S().orphanNoticeRetries.values()) clearTimeout(retry.timer);
- S().orphanNoticeRetries.clear();
- S().suspendedOrphanRetries.length = 0;
- S().orphanAttemptCeiling.clear();
- clearUnconfirmedOpenRetries();
-}
-
-/**
- * 明确清除凭证/登出(clearAndDisconnect)时丢弃孤儿重试状态: 排队/挂起的
- * 重试、预算与送达标记全部清空, 并递增 orphanRetryEpoch, 让已 await 出去
- * 的 REST 续段在落定后放弃 — 之后重新保存相同 appId/service 不会恢复旧
- * 重试向登出前的 opener 补发提示或撤回旧卡(那是 transport 重连才该有的
- * 保留语义)。
- */
-export function clearOrphanRetriesForCredentialClear(): void {
- S().orphanRetryEpoch += 1;
- for (const retry of S().orphanNoticeRetries.values()) clearTimeout(retry.timer);
- S().orphanNoticeRetries.clear();
- S().suspendedOrphanRetries.length = 0;
- S().orphanAttemptCeiling.clear();
- S().orphanNoticeDelivered.clear();
- clearUnconfirmedOpenRetries();
- // 注意: orphanNoticeInFlight **不清空** — 在途 REST 无法取消, 保留去重
- // 记账让同凭证快速重登录后的重投共享旧请求(而不是并发第二条提示);
- // 旧请求落定后条目自清理, 续段由 orphanRetryEpoch 放弃。
-}
-
-/** 该 opener 的提示是否已成功送达过(首发/重投/重试任一成功 — 终态)。 */
-function wasNoticeDelivered(openerMessageId: string): boolean {
- return S().orphanNoticeDelivered.has(openerMessageId);
-}
-
-/**
- * 重试/撤回的账号门: 换代后只要还是**同一个 bot**(appId + service 双键,
- * Feishu/Lark 同名 appId 也不可串 — 凭证替换逻辑同样视 service 为账号
- * 边界), 提示/撤回仍然安全 — 用当前 client 继续即可(同账号可操作自己发
- * 的消息, 跨 stop 保留的重试因此不会死在 stale generation 上); 只有换成
- * 别的账号或无连接时才失败, 旧账号的开场白不得经新账号的 client 操作。
- */
-function isSameBotActive(botAppId: string, service: BotCredentials['service']): boolean {
- return S().acceptingInbound && S().currentBotAppId === botAppId && S().currentService === service;
-}
-
-/**
- * 入站 await 恢复时是否应放弃 topic lease。明确登出/销毁会按 connection
- * generation 永久作废旧 lease;transport 重连则保留。账号替换的 stop/start
- * 空窗优先比较待启动账号,同账号保留、跨账号放弃。否则
- * pruneTopicLeases 永久跳过 pending, 反复换号会让 Map 无界增长, 切回旧账号
- * 还能沿旧 lease 起 turn。
- */
+/** Preserve pending topic leases only across same-account transport reconnects. */
function shouldAbandonTopicLease(
botAppId: string,
service: BotCredentials['service'],
@@ -563,251 +107,6 @@ function shouldAbandonTopicLease(
);
}
-/**
- * 该 opener 当前**正在执行**的提示发送(in-flight 去重)。重试的 timer 条目
- * 在 setTimeout 回调里先删后发 — 仅凭 orphanNoticeRetries 看不到执行中的
- * 发送; 这里单独记账, 任何路径的发送开始前先查: 冷却后的重投不会与执行
- * 中的重试并发发出第二条提示。结果在所有等待者间共享 — 谁发起都只有一条。
- */
-interface InFlightOrphanSend {
- epoch: number;
- promise: Promise<'delivered' | 'failed'>;
-}
-
-/**
- * 处理中的入站消息记账(key = `${appId}:${messageId}` → 所属 generation)。
- * stop() 用它释放「认领了但所属连接即将失效、不会有产出」的消息认领 —
- * 同账号重连后该消息的重投能被新连接处理(不被仍持有的认领压掉); 已处理
- * 完的消息认领不受影响(重推抑制不变)。
- */
-
-/**
- * 发送孤儿提示(单一 in-flight): 同一 opener 并发进入时共享同一次发送结果,
- * 不会打出第二条。成功即标记送达(终态); 失败返回 'failed' 由调用方决定
- * 释放认领/安排重试。
- */
-function sendOrphanNoticeOnce(
- openerMessageId: string,
- epoch: number,
-): Promise<'delivered' | 'failed' | 'stale'> {
- const inFlight = S().orphanNoticeInFlight.get(openerMessageId);
- if (inFlight) {
- // 清凭证前创建的 in-flight 不得被新代处理者当作本代结果推进 — 否则
- // 旧请求失败时新 handler 的 epoch 校验通过, 登出前的重试复活。
- if (inFlight.epoch !== epoch) return Promise.resolve('stale');
- return inFlight.promise;
- }
- const log = getLog();
- const attempt = (async (): Promise<'delivered' | 'failed'> => {
- try {
- await outbound.replyText(openerMessageId, transportMessages.group.threadOrphanNotice);
- markNoticeDelivered(openerMessageId);
- log.info('[feishu/wsClient] orphan opener notice delivered');
- return 'delivered';
- } catch (err) {
- const msg = err instanceof Error ? err.message : String(err);
- log.warn(`[feishu/wsClient] orphan opener notice send failed: ${msg}`);
- return 'failed';
- }
- })();
- // set 与 get 在同一同步块内完成 — 并发调用不会双双通过(JS 单线程)。
- S().orphanNoticeInFlight.set(openerMessageId, { epoch, promise: attempt });
- return attempt.finally(() => {
- // 结果已共享给所有等待者后才清理; 幂等删除, 早到的 finally 不影响
- // 已经持有 promise 引用的等待者。
- S().orphanNoticeInFlight.delete(openerMessageId);
- });
-}
-
-async function sendOrphanOpenerNotice(
- botAppId: string,
- service: BotCredentials['service'],
- messageId: string,
- openerMessageId: string,
-): Promise<void> {
- const log = getLog();
- // 终态守卫: 提示已送达过(执行中重试/重投任一成功)则不再发送 — 这次投递
- // 不产出可见结果, 释放本次认领。
- if (wasNoticeDelivered(openerMessageId)) {
- releaseInboundClaim(botAppId, messageId);
- return;
- }
- const last = S().orphanNoticeAt.get(openerMessageId) ?? 0;
- if (Date.now() - last < ORPHAN_NOTICE_COOLDOWN_MS) {
- // 冷却命中(重投场景): 这次投递不产出任何可见结果 — 释放本次认领, 否则
- // 冷却期间的 claim 会卡满 10 分钟, 换代后新连接的重投被丢弃(stop 已清掉
- // 定时重试), 用户的 @ 就丢了。
- releaseInboundClaim(botAppId, messageId);
- return;
- }
- S().orphanNoticeAt.set(openerMessageId, Date.now());
- // in-flight 去重: 执行中的重试会与这里共享同一次发送 — 重投不并发打出
- // 第二条提示; 结果为共享, 送达/失败按共享结果处理。
- const epoch = S().orphanRetryEpoch;
- const outcome = await sendOrphanNoticeOnce(openerMessageId, epoch);
- if (epoch !== S().orphanRetryEpoch) {
- // 清凭证发生在发送期间: 续段放弃 — 不再 schedule/suspend。
- log.info('[feishu/wsClient] orphan opener notice stale after credential clear — dropping continuation');
- return;
- }
- if (outcome === 'stale') {
- // 加入的 in-flight 是清凭证前创建的: 本代不推进其失败结果, 但也不能
- // 丢掉本代收口链(事件已 ACK)— 安排本代重试, 旧请求落定后的下一次
- // 尝试会以当前代次重新发起。
- log.info('[feishu/wsClient] orphan opener notice joined stale in-flight — scheduling own retry');
- scheduleOrphanNoticeRetry(botAppId, service, openerMessageId, messageId, 0);
- return;
- }
- if (outcome === 'delivered') {
- // 送达: 重新认领触发消息(后续重投被入站去重拦下) + 清掉该 opener 的
- // 挂起重试(重试绕过冷却, 不清会在稍后重复提示, 甚至重试耗尽时误撤回)。
- claimInboundMessage(botAppId, messageId);
- const pending = S().orphanNoticeRetries.get(openerMessageId);
- if (pending) {
- clearTimeout(pending.timer);
- S().orphanNoticeRetries.delete(openerMessageId);
- }
- } else {
- releaseInboundClaim(botAppId, messageId);
- log.warn(
- '[feishu/wsClient] orphan opener notice failed — inbound claim released',
- );
- // 发送失败发生在 stop 之后时, 连接已不在: 直接挂起排队(不创建定时器),
- // 同账号重连后恢复; 已换账号则终止, 由新账号的重投走自己的处理。
- const handled = suspendOrDropOnConnectionChange(
- botAppId,
- service,
- { botAppId, service, openerMessageId, messageId, attempt: 0 },
- 'first-send',
- );
- if (!handled) {
- scheduleOrphanNoticeRetry(botAppId, service, openerMessageId, messageId, 0);
- }
- }
-}
-
-function scheduleOrphanNoticeRetry(
- botAppId: string,
- service: BotCredentials['service'],
- openerMessageId: string,
- messageId: string,
- attempt: number,
-): void {
- const log = getLog();
- // 预算续接天花板: 共享失败后重投路径的 attempt 0 不得覆盖更先进的
- // 重试链(否则反复重连+重投永远到不了撤回兜底)。
- attempt = bumpOrphanAttemptCeiling(openerMessageId, attempt);
- const delay = ORPHAN_NOTICE_RETRY_DELAYS_MS[attempt];
- if (delay === undefined) {
- // 提示已由其它路径(重投成功)送达时, 撤回会误删一张已经给出说明的卡 —
- // 跳过撤回, 收尾重试链。
- if (wasNoticeDelivered(openerMessageId)) {
- log.info('[feishu/wsClient] orphan notice already delivered — skipping opener recall');
- return;
- }
- // 账号门: 已换成别的账号时终止(旧账号的开场白卡不得经新账号的 client
- // 操作); 无连接(停止/重连中)时挂起等重连恢复 — 终止会让事件已被 ACK
- // 的撤回链永久消失; 同一 bot 重连则照常(见 isSameBotActive)。
- if (
- suspendOrDropOnConnectionChange(
- botAppId,
- service,
- { botAppId, service, openerMessageId, messageId, attempt },
- 'recall',
- )
- ) {
- return;
- }
- // 重试耗尽: 最后兜底是撤回开场白卡 — 撤回成功用户看到干净群主流而不是
- // 永久「思考中」卡; 撤回失败说明故障仍未恢复, 已无更进一步的兜底手段。
- log.error(
- '[feishu/wsClient] orphan opener notice retries exhausted — recalling opener card as last resort',
- );
- void outbound.recallOwnMessage(openerMessageId);
- return;
- }
- const existing = S().orphanNoticeRetries.get(openerMessageId);
- if (existing) clearTimeout(existing.timer);
- const timer = setTimeout(() => {
- S().orphanNoticeRetries.delete(openerMessageId);
- void retryOrphanOpenerNotice(botAppId, service, openerMessageId, messageId, attempt);
- }, delay);
- S().orphanNoticeRetries.set(openerMessageId, {
- timer,
- botAppId,
- service,
- openerMessageId,
- messageId,
- attempt,
- });
-}
-
-async function retryOrphanOpenerNotice(
- botAppId: string,
- service: BotCredentials['service'],
- openerMessageId: string,
- messageId: string,
- attempt: number,
-): Promise<void> {
- const log = getLog();
- // 账号门(重连安全): 换代后仍是同一个 bot 就用当前 client 继续重试 —
- // 跨 stop 保留的重试链不会死在 stale generation 上; 换成别的账号时
- // 终止(旧账号的开场白不发进新账号的会话); 无连接时挂起等重连恢复 —
- // 停止状态排队的重试若在重连前触发, 终止会让提示永久消失。
- if (
- suspendOrDropOnConnectionChange(
- botAppId,
- service,
- { botAppId, service, openerMessageId, messageId, attempt },
- 'retry',
- )
- ) {
- return;
- }
- // 提示已由其它路径送达(执行中的重试与重投成功交错) — 放弃整条重试链。
- if (wasNoticeDelivered(openerMessageId)) {
- log.info('[feishu/wsClient] orphan notice already delivered — retry chain dropped');
- return;
- }
- // in-flight 去重: 与冷却后的重投共享同一次发送 — 不会并发打出第二条提示;
- // 若重投的发送已在进行, 这里等待它的结果而不是另发一条。
- const epoch = S().orphanRetryEpoch;
- const outcome = await sendOrphanNoticeOnce(openerMessageId, epoch);
- if (epoch !== S().orphanRetryEpoch) {
- log.info('[feishu/wsClient] orphan opener notice retry stale after credential clear — dropping continuation');
- return;
- }
- if (outcome === 'stale') {
- // 同上: 不推进旧请求结果, 但保留本代重试链。
- log.info('[feishu/wsClient] orphan opener notice retry joined stale in-flight — scheduling own retry');
- scheduleOrphanNoticeRetry(botAppId, service, openerMessageId, messageId, attempt);
- return;
- }
- if (outcome === 'delivered') {
- // 送达: 重新认领触发消息(抑制冷却后的重投再次进入提示流程)。
- claimInboundMessage(botAppId, messageId);
- log.info('[feishu/wsClient] orphan opener notice retry succeeded');
- return;
- }
- // 失败发生在共享发送 await 期间时, 其它路径可能已成功送达 — 先查终态
- // 标记再决定是否继续, 否则会重复提示甚至耗尽后误撤回已成功提示过的卡。
- if (wasNoticeDelivered(openerMessageId)) {
- log.info('[feishu/wsClient] orphan notice delivered during retry — retry chain dropped');
- return;
- }
- log.warn(`[feishu/wsClient] orphan opener notice retry failed (attempt ${attempt})`);
- // 发送失败可能发生在 stop 之后: 无连接时直接挂起(不创建定时器), 换账号
- // 时终止 — 同账号重连后恢复。
- const handled = suspendOrDropOnConnectionChange(
- botAppId,
- service,
- { botAppId, service, openerMessageId, messageId, attempt: attempt + 1 },
- 'retry-failed',
- );
- if (!handled) {
- scheduleOrphanNoticeRetry(botAppId, service, openerMessageId, messageId, attempt + 1);
- }
-}
/**
* 入站消息去重 —— 飞书事件是「至少送达一次」: 服务端等不到我们的 ACK 就会把
@@ -850,7 +149,7 @@ function claimInboundMessage(appId: string, messageId: string): boolean {
/**
* 释放某条消息的入站认领 —— 只在「认领了但本轮没有产出任何用户可见结果」的
- * 放弃路径上调用(连接换代丢弃、孤儿开场白提示发送失败), 让重推能在新连接/
+ * 放弃路径上调用(连接换代丢弃), 让重推能在新连接/
* 重试路径上重新处理。正常处理完(含已给出失败说明的放弃)绝不释放, 否则重推
* 会再次起 turn。
*/
@@ -858,16 +157,9 @@ function releaseInboundClaim(appId: string, messageId: string): void {
S().seenInboundMessages.delete(`${appId}:${messageId}`);
}
-/**
- * 放弃一条已认领但未产出结果的入站消息(连接换代丢弃路径): 释放去重认领 +
- * evict 开话题结果缓存。只释放认领不 evict 的话, 重投会复用旧连接上的
- * degraded/orphaned 缓存结果(旧客户端已 unbind, 补查/撤回必然失败)而不是
- * 用新客户端重试 API。孤儿提示失败的重试不经过这里 — 复用 orphaned 结果
- * 重试提示正是设计意图。
- */
+/** Release an unfinished turn when its connection changes. */
function abandonInboundTurn(botAppId: string, messageId: string): void {
releaseInboundClaim(botAppId, messageId);
- outbound.evictOpenThreadOutcome(messageId);
}
/** 测试注入口 — 生产代码不要调用(生产语义就是跨 stop/start 不清空)。 */
@@ -1165,7 +457,7 @@ export async function start(
await runInScope(scope, async () => {
try {
// 传入本代 connection 的 generation — 处理途中有 await(附件下载/
- // 开话题), 恢复执行时必须复查门禁, 防止旧连接的轮次漏进新连接。
+ // 引用查询), 恢复执行时必须复查门禁, 防止旧连接的轮次漏进新连接。
await handleIncomingMessage(
creds.appId,
creds.service,
@@ -1208,8 +500,6 @@ export async function start(
void fetchBotOpenId();
// 恢复本 bot 在 stop() 时被挂起的排队重试(同账号重连) — 事件已被
// ACK, 不恢复的话孤儿提示/撤回链随断连永久消失。
- resumeOrphanRetriesFor(creds.appId, creds.service);
- resumeUnconfirmedOpenRetriesFor(creds.appId, creds.service);
if (opts.announceLifecycle !== false) {
void announceLifecycle('online');
} else {
@@ -1330,34 +620,9 @@ async function stopCurrentClient(opts: StopOptions): Promise<void> {
}
S().botOpenId = null;
S().strangerNoticeAt.clear();
- S().orphanNoticeAt.clear();
- S().orphanNoticeDelivered.clear();
- // 排队的重试挂起(不丢弃): 事件已被 ACK, 直接取消会让提示永远不再出现 —
- // 元数据入 suspendedOrphanRetries, 同账号重连后由 start() 恢复入队。
- for (const retry of S().orphanNoticeRetries.values()) {
- clearTimeout(retry.timer);
- suspendOrphanRetry({
- botAppId: retry.botAppId,
- service: retry.service,
- openerMessageId: retry.openerMessageId,
- messageId: retry.messageId,
- attempt: retry.attempt,
- });
- }
- S().orphanNoticeRetries.clear();
- for (const retry of [...S().unconfirmedOpenRetries.values()]) {
- suspendUnconfirmedOpenRetry(retry);
- }
- // 注意: orphanNoticeInFlight **不**清空 — in-flight 的 REST 请求在 stop()
- // 时已捕获旧 client, close 不保证取消它; 保留去重记账, 同 bot 重连后的
- // 重投仍会共享那次在途发送而不是并发第二条(条目随 promise 落定自清理)。
- // 处理中的入站消息: 所属连接即将失效, 该消息不会再有产出 — 释放认领并
- // evict 开话题缓存, 让同账号重连后的重投被新连接处理(而不是被仍持有的
- // 认领压掉后 ACK 掉、且不再有重投保证); 已处理完的消息认领不动。
+ // Release unfinished deliveries so the same account can process a redelivery.
for (const key of S().inboundInFlight.keys()) {
S().seenInboundMessages.delete(key);
- const sep = key.indexOf(':');
- if (sep > 0) outbound.evictOpenThreadOutcome(key.slice(sep + 1));
}
S().inboundInFlight.clear();
outbound.unbindClient();
@@ -1503,7 +768,7 @@ async function handleIncomingMessage(
if (!senderOpenId || !messageId || !chatId) return;
// 重推闸门 —— 必须在第一个 await 之前同步认领(见 claimInboundMessage), 也必须
- // 排在所有副作用(开话题 / 打表情 / 下附件 / 陌生人提示)之前: 重推一旦漏过去,
+ // 排在所有副作用(打表情 / 下附件 / 陌生人提示)之前: 重推一旦漏过去,
// 这些动作都会再做一遍。
if (!claimInboundMessage(botAppId, messageId)) {
log.info(
@@ -1548,7 +813,6 @@ async function processClaimedMessage(
const msgType = data.message?.message_type ?? '';
const rawContent = data.message?.content ?? '';
let commitUnpairedFlat: (() => boolean) | undefined;
- let isUnpairedFlatTakenOver: (() => boolean) | undefined;
let abandonUnpairedFlat: (() => void) | undefined;
let commitTopic: (() => boolean) | undefined;
let abandonTopic: (() => void) | undefined;
@@ -1593,7 +857,6 @@ async function processClaimedMessage(
return;
}
commitUnpairedFlat = paired.commitUnpairedFlat;
- isUnpairedFlatTakenOver = paired.isUnpairedFlatTakenOver;
abandonUnpairedFlat = paired.abandonUnpairedFlat;
commitTopic = paired.commitTopic;
abandonTopic = paired.abandonTopic;
@@ -1693,169 +956,14 @@ async function processClaimedMessage(
return;
}
- // 群 lane: senderId = g/{chatId}[/{threadId}], 出站按 lane 解码回群。
- // 话题内触发直接进话题 lane(锚点=触发消息, 回复自动落回话题); 群主流
- // 触发先以触发消息为根开话题再进新话题 lane(锚点=开场白消息) — 每话题
- // 独立 session, 群主流保持干净; 开话题失败才降级回群 lane 旧行为。
+ // Replies stay where the question was asked; never create a topic for a
+ // main-timeline message. Commit the elected copy before queueing its anchor.
let laneUserId: string | null = null;
- let groupContextLane: { chatId: string; threadId: string } | undefined;
if (isGroup) {
- if (incomingThreadId) {
- // Commit before the FIFO reply-anchor: two topic deliveries of the same
- // logical send can both pass the coordinator while the lease is pending.
- // The loser must not enqueue an anchor that a later streaming reply would claim.
- if (commitTopic && !commitTopic()) {
- log.info('[feishu/wsClient] elected topic aborted: another topic delivery already committed');
- return;
- }
- laneUserId = encodeLaneUserId(chatId, incomingThreadId);
- outbound.pushReplyAnchor(laneUserId, messageId);
- } else {
- // 群主流的 @ 恒开新话题 —— 群里存在 /ctr 接管也不例外: 接管严格按话题
- // 记账(binding 的 userId 就是话题 lane), 群主流不是任何接管的入口。
- // 拿接管话题去截流群主流消息会让「群里随便 @ 一句」都掉进那条被接管的
- // 会话(用户感知: 不管在哪问, 工作目录都是绑定那个项目)。要跟接管会话
- // 说话就在那个话题里说。
- const opener = await outbound.openThread(messageId);
- // 开话题是一次跨网络的 await — 期间用户可能断开/换账号: 先复查门禁,
- // 再提交双投路由或撤回 opener。失效连接不得改跨重连保留的 dual-delivery
- // 状态, 也不得用新绑定的 client 去撤回旧连接发出的消息。
- if (!isActiveConnection(generation, botAppId)) {
- // 同上: stop() 已释放认领时不重复释放; 记账还在才 abandon(释放 +
- // evict 开话题缓存, 让重推在新连接上用新客户端重试 API)。
- if (S().inboundInFlight.get(`${botAppId}:${messageId}`)?.generation === generation) {
- abandonInboundTurn(botAppId, messageId);
- }
- log.info('[feishu/wsClient] drop group message: connection changed while opening thread');
- abandonUnpairedFlat?.();
- if (shouldAbandonTopicLease(botAppId, service, generation)) abandonTopic?.();
- return;
- }
- // 孤儿开场白不会派发副本 turn: 先 peek 是否已被迟到话题接管, 再决定
- // 撤回或发故障提示。不要 commitUnpairedFlat — 提交会让迟到窗口内的
- // 真实话题被抑制, 用户请求整轮丢掉。
- if (opener.kind === 'orphaned') {
- if (isUnpairedFlatTakenOver?.()) {
- log.info('[feishu/wsClient] unpaired flat aborted: late topic took over routing');
- const recallEpoch = S().orphanRetryEpoch;
- const recalled = await recallRecoveredOpener(opener.openerMessageId, 'orphaned');
- if (!recalled) {
- scheduleTakeoverRecallRetry(
- {
- botAppId,
- service,
- messageId,
- chatId,
- senderOpenId,
- text,
- attachments,
- unsupported,
- raw: data,
- attempt: 0,
- recallOnly: true,
- },
- recallEpoch,
- );
- }
- return;
- }
- // 开场白卡已发出但话题 id 恢复失败、撤回也失败: 降级群 lane 会一边
- // 留着「思考中」的开场白卡、一边把回答刷进群主流。不起 turn, 回复
- // 开场白(落回话题)说明失败 — 宁可丢一轮, 不误导 + 不刷屏。迟到话题
- // 仍可在 LATE_COPY_TTL 内接管这条尚未提交的路由。
- log.error(
- `[feishu/wsClient] openThread orphaned opener=...${opener.openerMessageId.slice(-8)} — turn dropped with in-topic notice`,
- );
- await sendOrphanOpenerNotice(botAppId, service, messageId, opener.openerMessageId);
- abandonUnpairedFlat?.();
- return;
- }
- if (opener.kind === 'unconfirmed') {
- // 三次即时 uuid 重试仍无回执: 服务端可能已发出思考卡。事件会在 3s
- // 内 ACK, 不能指望平台重投。不释放认领、不降级群主流, 也不提交副本
- // 路由 — unconfirmed 还没派 turn, 迟到话题仍可在 LATE_COPY_TTL 内接管。
- if (isUnpairedFlatTakenOver?.()) {
- log.info('[feishu/wsClient] unpaired flat aborted: late topic took over routing');
- scheduleUnconfirmedOpenRetry({
- botAppId,
- service,
- messageId,
- chatId,
- senderOpenId,
- text,
- attachments,
- unsupported,
- raw: data,
- attempt: 0,
- recallOnly: true,
- });
- return;
- }
- log.error(
- '[feishu/wsClient] openThread reply unconfirmed — scheduling delayed uuid recovery, not degrading',
- );
- scheduleUnconfirmedOpenRetry({
- botAppId,
- service,
- messageId,
- chatId,
- senderOpenId,
- text,
- attachments,
- unsupported,
- ...(resolvedReply ? { replyContext: resolvedReply.replyContext } : {}),
- raw: data,
- attempt: 0,
- commitUnpairedFlat,
- isUnpairedFlatTakenOver,
- abandonUnpairedFlat,
- });
- return;
- }
- // 仍是本连接: 迟到的真实话题可能已经接管本轮路由, 不再把回答落进这份
- // 群主流副本刚建的机器人话题。只在即将派发副本 turn 时提交。
- if (commitUnpairedFlat && !commitUnpairedFlat()) {
- log.info('[feishu/wsClient] unpaired flat aborted: late topic took over routing');
- if (opener.kind === 'opened') {
- const recallEpoch = S().orphanRetryEpoch;
- const recalled = await recallRecoveredOpener(opener.messageId, 'opened');
- if (!recalled) {
- scheduleTakeoverRecallRetry(
- {
- botAppId,
- service,
- messageId,
- chatId,
- senderOpenId,
- text,
- attachments,
- unsupported,
- raw: data,
- attempt: 0,
- recallOnly: true,
- },
- recallEpoch,
- );
- }
- }
- return;
- }
- if (opener.kind === 'opened') {
- laneUserId = encodeLaneUserId(chatId, opener.threadId);
- outbound.pushReplyAnchor(laneUserId, opener.messageId);
- // 开场白卡是本轮流式卡: streamingText.start 认领后直接 patch,
- // 话题里不会多出一条占位消息。trigger 一并登记 — patch 失败撤回
- // 开场白卡时锚点回拨到触发消息(reply_in_thread 落回话题)。
- outbound.pushPatchableOpener(laneUserId, opener.messageId, messageId);
- // 上下文取数 lane 与路由 lane 分离: 新话题是空的, 群历史前缀仍按
- // 触发时所在的群主流拉取(「总结上面」等依赖上文的消息才能拿到
- // 群主流历史), 由 host adapter 消费(IMMessageEvent.groupContextLane)。
- groupContextLane = { chatId, threadId: '' };
- } else {
- laneUserId = encodeLaneUserId(chatId, null);
- outbound.pushReplyAnchor(laneUserId, messageId);
- }
- }
+ const commit = incomingThreadId ? commitTopic : commitUnpairedFlat;
+ if (commit && !commit()) return;
+ laneUserId = encodeLaneUserId(chatId, incomingThreadId ?? null);
+ outbound.pushReplyAnchor(laneUserId, messageId);
}
// Emit raw fields — orchestrator decides how to render unsupported (it owns
@@ -1879,7 +987,6 @@ async function processClaimedMessage(
speaker: { id: senderOpenId, name: '', isOwner: senderIsOwner },
}
: {}),
- ...(groupContextLane ? { groupContextLane } : {}),
...(resolvedReply ? { replyContext: resolvedReply.replyContext } : {}),
attachments,
unsupported,