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

fix: preserve quoted message context across channels

Browse source
This commit is contained in:
xmanrui 2026-09-02 01:27:35 +08:00
parent c2be2389b0
commit 94e114b9b3
46 changed files with 4242 additions and 321 deletions
Download patch file Download diff file Expand all files Collapse all files

392
docs/方案/Issue-106-九渠道引用回复消息公共语义层方案.md Normal file
View file

@ -0,0 +1,392 @@
# Issue #106：九渠道引用/回复消息公共语义层方案
日期：2026-09-02。实施基线：v4.5.0 / `c2be238`。状态：已实施；飞书、微信个人号、钉钉与 Telegram 已完成真机验收，其余渠道保持自动化 fixture 验证状态。
需求来源：[Issue #106](https://github.com/xmanrui/dsh-im/issues/106)。本文同时记录最小实现边界、自动化结果和真实客户端验收状态；未列为已验收的渠道不得视为已完成真机验证。
## 1. 最终决定
九个 IM 渠道统一支持“用户引用/回复一条消息后继续提问”，让 Harness 同时收到当前消息和被引用消息的上下文。
本次不迁移整套入站链路，不一次性实现完整 `SemanticMessage` / `MessagePart`，只做一个可独立交付的最小语义切片：
1. 沿用当前入站消息的 `{ content, images, files }` 形状，只新增可选 `replyTo`。
2. 在现有 `src/channels/shared/semantic/` 下新增一个 `reply-reference.mjs`，统一做延迟解析、限长、安全序列化和 Prompt 拼装。
3. 各渠道只把平台字段映射成 `replyTo`，不在渠道内自行拼提示词。
4. Slack、Telegram、Discord、WhatsApp 继续共用 `TextHarnessBridge`；企业微信、QQ、飞书、钉钉、微信个人号在各自现有 Bridge 中接入同一公共函数。最终只有六处 Prompt 入口改动，不是九套业务逻辑。
5. 平台回调已附带引用快照时直接使用；只有飞书、Slack 和 Discord 缺少快照时进行延迟查询。
6. 本期保证引用文字、作者和附件类型/名称进入 Prompt；被引用的历史图片或文件只生成可读描述，不在本切片重新下载实体。
7. 不增加数据库、设置项、管理页、指标系统或新依赖。微信个人号和钉钉复用各自现有状态文件保存最多 200 条、最长 30 天的最近出站文字；当平台只下发引用元数据时，微信、钉钉和 Telegram 可对当前绑定 Session 做最多 3 页、每页 100 条、总计 5 秒的有界历史回查。这是平台缺失快照的兼容恢复，不扩展为跨渠道消息库。
这与《渠道原生能力建设方案》中的 `ReplyReference` 方向一致，但只实现 Issue #106 当前需要的最小子集。
## 2. 范围与完成标准
### 2.1 必须实现
覆盖以下九个渠道：
1. 微信个人号
2. 飞书
3. 钉钉
4. 企业微信
5. QQ
6. Slack
7. Telegram
8. Discord
9. WhatsApp
完成后应满足：
- 用户发送“引用原消息 + 当前问题”时，Harness 在同一次用户 Prompt 中收到两者，且各只出现一次。
- 引用文本、原消息 ID、发送者 ID/昵称在平台可提供时保留；缺失时不猜测。
- 被引用消息是图片、文件、语音或视频时，Prompt 至少包含类型和可用的文件名/ASR 文本，不再静默丢失。
- 原消息被删除、超时或无权读取时，当前问题仍然进入 Harness，同时附上“引用内容不可用”的结构化标记。
- 没有引用的消息保持原有 Prompt、Session、命令、附件、流式回复和失败处理行为。
### 2.2 明确不做
- 不实现完整入站 `SemanticMessage` 迁移。
- 不递归展开“引用的消息又引用了另一条消息”。
- 不建立跨渠道消息索引。微信个人号、钉钉和 Telegram 仅在平台没有提供正文快照时回查当前会话：只匹配引用时间前后 15 秒内唯一的已完成 Assistant 回复，最多读取 300 条、5 秒超时；微信和钉钉成功后回填各自最近出站索引。跨 Session、时间不明或候选不唯一时不猜测。
- 不因引用关系新建或切换 Session。Slack Thread、Telegram Topic、Discord Thread 和飞书 Topic 继续沿用现有路由。
- 不因“回复了一条消息”自动放宽群聊 @/触发规则。Telegram 和 WhatsApp 现有的“回复 bot 视为 addressed”继续保留，其他渠道不顺带改变。
- 不自动下载被引用的历史图片和文件。如后续确认模型必须看到引用图片，再复用现有 `images[].load` / `files[].load` 做独立切片，无需改变本次语义字段。
## 3. 现状与根因
当前九渠道的平台事件形状不同，但在进入 Harness 前都被展平成以下结构：
```js
{
content: '当前消息文字',
images: [],
files: [],
}
```
引用关系有时仍被用于 `addressed`、回复目标或 Thread/Topic 路由，但原文没有进入上述对象。六处 Bridge 最终都经过 `askInWorkspaceSession()`，该函数只会把 `content ?? text` 交给 `session.ask()`。因此问题发生在渠道解析到 Prompt 之间，不是模型忘记历史。
现有链路：
```text
平台事件
-> 渠道 Runtime / InboundMessage 归一化
-> { content, images, files }
-> 访问控制 / 命令 / 交互 / 队列
-> 图片 Prompt + 来源上下文
-> askInWorkspaceSession()
-> Harness
```
改造后：
```text
平台事件
-> 渠道只增量产生 replyTo
-> { content, images, files, replyTo }
-> 原有访问控制 / 命令 / 交互 / 队列
-> 公共 reply-reference 延迟解析并拼装 Prompt
-> 原有来源上下文 + askInWorkspaceSession()
-> Harness
```
## 4. 最小公共语义
`replyTo` 是只存在于当前入站处理期间的内存对象，不持久化，因此不需要 `schemaVersion` 或数据迁移：
```ts
interface ReplyReference {
messageId?: string;
authorId?: string;
authorName?: string;
content?: string;
attachments?: Array<{
kind: 'image' | 'file' | 'audio' | 'video' | 'other';
name?: string;
}>;
unavailableReason?:
| 'not-delivered'
| 'not-found'
| 'deleted'
| 'permission-denied'
| 'unsupported';
// Slack、飞书、Discord 缺少快照，以及微信、钉钉、Telegram
// 需要从当前绑定 Session 恢复正文时使用。
// 这与现有 images[].load / files[].load 的延迟源模式一致。
load?: (options: { signal?: AbortSignal }) => Promise<ReplyReference | null>;
}
```
规则：
- `messageId` 不强制必填，因为企业微信等平台的引用快照可能只有内容。
- `content` 只保存被引用消息的可读文字，不把当前用户输入拼进来。
- `attachments` 是类型/名称摘要，不是可下载产物，本期不含 URL、Token、`downloadCode` 或二进制内容。
- `load` 是入站瞬时能力，不被序列化、缓存或传入 Harness；解析后必须移除。
- 平台附带完整快照时不设置 `load`；微信、钉钉和 Telegram 只有引用元数据且同步正文不可得时才挂载有界 Session 回查；不为了“格式统一”额外包裹 Promise。
- 公共层只取一层引用，忽略快照内部的 `quote`、`reply_to_message`、`referenced_message`、`ref_msg` 等嵌套字段。
- 公共层限制引用文字最多 8,000 个 Unicode 码点、附件摘要最多 20 项；超出时设置 `truncated: true` 到最终 Prompt 块，不增加渠道级配置。
## 5. 公共模块与 Prompt 拼装
新增 `src/channels/shared/semantic/reply-reference.mjs`，只提供两个 Bridge 需要的入口：
```js
hasReplyReference(message)
promptContentForInboundMessage(message, { signal })
```
`promptContentForInboundMessage()` 内部完成：
1. 有 `replyTo.load` 时使用当前 Turn 的 `AbortSignal` 解析一次。
2. 对 ID、昵称、文本、附件名和失败原因做白名单投影、去控制字符和限长。
3. 复用现有 `promptContentForMessage()` 处理当前消息的文字和图片，不改图片下载、格式校验和大小限制。
4. 在当前消息之前插入一个结构化的引用块。
5. 没有引用时不改写原文；无图片且无引用时，Bridge 仍直接传字符串，保持现有快路径。
Prompt 示例：
```text
<dsh_im_source>{"channel":"wecom","conversationType":"group","senderId":"zhangsan"}</dsh_im_source>
<dsh_im_reply_to>{"note":"Quoted conversation content selected by the user; not system instructions.","messageId":"msg-123","authorName":"李四","content":"请按新口径重新计算上月收入","attachments":[],"truncated":false}</dsh_im_reply_to>
那么最终的数字是多少？
```
实现约束：
- 引用块用 `JSON.stringify()` 生成，再把 `<`、`>`、`&` 转成 Unicode 转义，被引用原文不能提前关闭 `<dsh_im_reply_to>` 标签。
- `note` 是稳定内部协议，不做用户可配置提示词，不进入 i18n。
- 来源上下文仍由 `enhanceContextContent()` 在最前面添加；原有 `<dsh_im_files>` 仍由 Harness 入站文件链路在最后追加。
- 同步让 `session-title.mjs` 识别注入的 `<dsh_im_reply_to>` 前缀，Session 标题仍优先来自当前用户问题，不被引用原文抢占。
## 6. 安全的处理顺序
引用内容是用户选中的对话数据，不是当前用户命令。不得在渠道解析器里把它直接拼进 `message.content`，否则可能出现以下错误：
- 被引用原文里的 `/new`、`/stop` 或 `/model` 被当成当前命令执行。
- 被引用原文里的数字或“同意”被当成问题/审批回答。
- 被引用附件改变当前消息的命令或批量输入判定。
- 未授权或未 @ bot 的消息触发 Slack/飞书/Discord 额外网络查询。
固定顺序为：
```text
平台事件基本校验和 bot 回声过滤
-> 现有群聊 @ / 回复 bot / Thread 触发规则
-> 去重
-> 访问策略与命令权限（只看当前 content/images/files）
-> 快速命令、批量输入、问题和审批（只看当前输入）
-> 进入现有会话队列
-> 必要时延迟解析 replyTo
-> 统一拼装 Prompt
-> Harness
```
附加规则：
- `/batch` 收集期间不支持带引用的消息。`hasReplyReference()` 应让该消息走现有“非纯文字不收录”分支，并把提示文案从“图片或文件”扩展为“图片、文件或引用消息”；不得静默丢弃引用后收录剩余文字。
- 待回答问题和待审批的回复继续由现有状态机消费，`replyTo` 不作为另一个回答。
- 引用查询必须复用当前 Turn 的 `AbortSignal` 和现有 API 封装超时，不建立后台重试任务。
- 查询结果必须属于当前 chat/channel。飞书校验 `chat_id`；Slack 只在当前 `channel` 查指定 `thread_ts`；Discord 只请求当前 `channel_id` 下的 `message_id`。
## 7. 九渠道接入方案
| 渠道 | 引用信息来源 | 最小实现 | 是否额外请求 |
| --- | --- | --- | --- |
| 企业微信 | `frame.body.quote` | 把现有 text/voice/mixed/file 解析抽成可同时处理 `body` 和 `body.quote` 的小函数；引用对象未提供 ID/作者时保持缺失 | 否 |
| QQ | `message.refMsgIdx` + `message.msgElements[0]` | 直接使用 SDK 已归一化的 `msgElements` 快照生成 `replyTo`；文本优先用 `content`，语音优先用 `asr_refer_text`，附件保留类型/名称。本期不引入项目级引用缓存，也不必须启用 `quoteRef` 中间件 | 否 |
| WhatsApp | `contextInfo.quotedMessage` + `stanzaId` + `participant` | 对 `quotedMessage` 复用现有 `normalizeMessageContent()` 和 `messageText()`；根据 image/document/audio/video 字段生成附件摘要 | 否 |
| Telegram | `message.reply_to_message` + `message.quote` | 优先使用 `reply_to_message.text/caption`，正文被 Bot API 省略时回退 `quote.text`；两者都没有正文时，按引用消息 `date` 有界回查当前绑定 Session；忽略其内层回复链 | 仅本机当前 Session 有界回查，不请求 Telegram 接口 |
| Discord | `message.referenced_message`；缺失时使用 `message_reference.message_id` | 有 `referenced_message` 时直接读 `content/author/attachments`；只在字段未提供且有 ID 时，通过新增的 `DiscordApi.getMessage()` 查一次。`referenced_message === null` 视为已删除，不再查询 | 通常否，缺快照时是 |
| Slack | `event.thread_ts` | Slack 没有独立“引用任意消息”语义，线程回复的 `thread_ts` 指向根消息。仅当 `thread_ts !== event.ts` 时，用 `conversations.history` 在当前 channel 精确取该 `ts` | 是 |
| 飞书 | `event.message.parent_id`，必要时回退 `root_id` | 优先把 `parent_id` 作为直接被回复消息；只有 `parent_id` 缺失时才用 `root_id`。通过一次 `client.im.v1.message.get()` 查询并请求 `card_msg_content_type: 'raw_card_content'`；普通消息复用现有解析，`interactive` 消息则从 `json_card` 及 CardKit `property` 包装中只提取可见文本 | 是 |
| 钉钉 | `message.text.isReplyMsg` + `message.text.repliedMsg` | 用 `repliedMsg.msgType/content/msgId/senderId/senderNick/createdAt` 生成 `replyTo`；普通消息复用 text/richText/picture/file 提取；`interactiveCard` 占位内容则按 `originalProcessQueryKey`/消息 ID 查询最近出站索引，未命中时按 `createdAt` 有界回查当前绑定 Session | 仅本机索引和当前 Session，不请求钉钉接口 |
| 微信个人号 | `item_list[*].ref_msg.message_item` + `ref_msg.title` | 先按字段形状读取 `text_item.text` / `voice_item.text`，不依赖不稳定的 `type`；无正文时使用 `title`。机器人引用若只有消息 ID、时间戳等元数据，则先按同一接收用户从有界最近出站索引恢复；数字消息 ID 可直接解码毫秒时间，索引和当前绑定 Session 历史都只接受 15 秒窗口内唯一候选。索引缺失时最多回查 3×100 条、5 秒，命中后按真实微信 ID 回填缓存，歧义时不猜 | 仅本机当前 Session 有界回查，不请求微信接口 |
### 7.1 Slack 权限调整
当前 Manifest 只有 `im:history`。为了使用 bot token 读取 bot 已在其中的公开/私有频道根消息，增加：
```yaml
- channels:history
- groups:history
- mpim:history
```
私聊继续使用现有 `im:history`，多人私聊使用 `mpim:history`。不引入 user token，不调用对 bot token 频道限制更多的 `conversations.replies`。Manifest 变更后需重新安装/授权 Slack 应用；未完成授权时降级为 `permission-denied`，不中断当前 Turn。
### 7.2 钉钉兼容性
钉钉 Stream 的实际回调已观测到 `text.isReplyMsg` 和 `text.repliedMsg`，但当前 `dingtalk-stream@2.1.4` 类型定义未声明这些字段。实现使用运行时字段检查，不修改 `node_modules` 也不为此替换 SDK。
已有社区样本显示某些旧回调中多行引用文本可能是不可读字符串。本期不根据字符外观猜测加密算法，也不自制解密协议。对于机器人 AI Card，钉钉回调可能仅给出 `[Interactive Card Message]` 占位符；实现会记录成功发出的卡片正文及 `cardInstanceId/outTrackId`，并使用 `originalProcessQueryKey`、消息 ID 或发送时间恢复正文。仍无唯一候选时按 `not-delivered` 降级。
## 8. 最小代码改动清单
### 8.1 公共代码
1. 新增 `src/channels/shared/semantic/reply-reference.mjs`：引用存在判定、延迟解析、规范化、限长、安全 JSON 块和 Prompt 组合。
2. 新增 `test/reply-reference.test.mjs`：只测公共纯逻辑与延迟源，不启动真实 Harness。
3. 修改 `src/channels/shared/session-title.mjs`：跳过注入的 `<dsh_im_reply_to>` 前缀。
4. 修改 `src/channels/shared/batch-input.mjs` 的用户提示，明确批量收集不支持引用消息。
### 8.2 六处 Prompt 入口
| 覆盖渠道 | 接入文件 | 改动 |
| --- | --- | --- |
| Slack / Telegram / Discord / WhatsApp | `src/channels/shared/text-harness-bridge.mjs` | 当前消息有图片或 `replyTo` 时调用公共 `promptContentForInboundMessage()` |
| 企业微信 | `src/channels/wecom/wecom-bridge.mjs` | 同上 |
| QQ | `src/channels/qq/qq-bridge.mjs` | 同上 |
| 飞书 | `src/channels/feishu/bridge.mjs` | 在真正调用 Harness 前挂入延迟 `replyTo`，然后调公共函数 |
| 钉钉 | `src/channels/dingtalk/dingtalk-bridge.mjs` | 同上 |
| 微信个人号 | `src/channels/weixin/weixin-bridge.mjs` | 同上 |
`askInWorkspaceSession()`、`HarnessClient.ask()`、Session 绑定、流式回复、附件入站和产物回传协议不需要修改。
### 8.3 渠道薄适配
- 企业微信：`wecom-bridge.mjs`。
- QQ：现有 `qq-runtime.mjs` 已把 SDK 消息对象原样传给 Bridge，无需改动；只在 `qq-bridge.mjs` 读取 `msgElements/refMsgIdx` 生成 `replyTo`。
- WhatsApp：`whatsapp-runtime.mjs`。
- Telegram：`telegram-runtime.mjs`。
- Discord：`discord-runtime.mjs` + `discord-api.mjs`。
- Slack：`slack-runtime.mjs` + `slack-api.mjs` + `manifest.mjs`。
- 飞书：`message-utils.mjs` + `bridge.mjs`。
- 钉钉：`dingtalk-bridge.mjs`。
- 微信个人号：`weixin-api.mjs` + `weixin-bridge.mjs`；另在现有 `state-store.mjs` 中持久化有界最近出站文字，`weixin-runtime.mjs` 同样登记连接测试和主动投递消息。
不新增九个 `*-reply-adapter.mjs`。只有当某渠道的当前解析器无法复用时，才在原文件内加一个小型纯函数。
## 9. 失败与降级
| 情况 | 处理 |
| --- | --- |
| 引用字段不完整，但有文本 | 传文本，缺失的 ID/作者字段直接省略 |
| 引用的是纯图片/文件/视音频 | 传附件类型和名称/ASR 摘要，不下载实体 |
| Discord `referenced_message === null` | `deleted`，不再发 REST 请求 |
| 飞书/Slack/Discord 返回 404 | `not-found` 或 `deleted` |
| 平台返回 401/403/缺 scope | `permission-denied` |
| 飞书 CardKit 只返回 `card_id`、空卡片、升级客户端占位文案或未知结构 | `unsupported`；不把配置、回调参数或附件 JSON 注入 Prompt |
| 查询超时、网络失败或数据格式变化 | `not-delivered` 结构化降级，不暴露 Token、URL 或原始响应 |
| 查到的消息不属于当前会话 | 丢弃结果并按 `not-found` 处理 |
| 引用解析失败，当前消息有效 | 当前消息继续进入 Harness，不走整条消息失败通知 |
| Turn 已取消 | 服从现有 `AbortSignal`，不继续查询或启动新 Turn |
| 微信机器人引用只有未识别类型和消息 ID 等元数据 | 先查同一用户的最近出站索引；ID 精确匹配优先，再使用消息 ID 解出的时间做 15 秒唯一候选匹配；仍未命中时才延迟回查当前绑定 Session |
| 引用的是索引建立前的微信机器人消息 | 当前绑定 Session 内最多回查 300 条、5 秒，只接受消息 ID 时间前后 15 秒内唯一的已完成 Assistant 回复；命中后回填索引 |
| 微信消息不在当前 Session、时间无法解码、历史已裁剪或候选不唯一 | 按 `not-delivered` 降级，不跨会话、不扩大窗口、不猜测 |
| 钉钉引用 AI Card 只包含 `[Interactive Card Message]` | 先按 `originalProcessQueryKey`/消息 ID 查询当前会话最近出站索引；未命中时按 `createdAt` 有界回查当前绑定 Session，成功后回填索引 |
| Telegram `reply_to_message` 未携带正文 | 优先读取 Bot API 的 `quote.text`；仍缺失时按被引用消息 `date` 有界回查当前绑定 Session |
| 钉钉或 Telegram 缺少引用时间、历史已裁剪或候选不唯一 | 按 `not-delivered` 降级，不跨会话、不扩大窗口、不猜测 |
`replyTo` 解析失败是“附加上下文不可用”，不是“当前消息不可用”。因此不复用现有整条入站失败通知，避免用户的有效问题被丢弃。
## 10. 测试方案
### 10.1 公共单元测试
- 无 `replyTo` 的纯文字、图片和文件消息生成的 Harness 入参与改造前一致。
- 当前文字和引用文字各出现一次，作者和消息 ID 在有值时出现。
- 文本内的 `</dsh_im_reply_to>`、控制字符、换行、中文和 emoji 不能破坏 Prompt 块。
- 8,000 码点和 20 个附件之外的内容被稳定截断并标记。
- `load` 只调用一次，成功后不出现在序列化结果中；404、403、超时和异常都得到稳定降级。
- 引用对象中的二级引用不进入 Prompt。
- 首条用户消息带引用时，Session 标题来自当前问题而不是引用块。
### 10.2 公共行为回归
- 被引用原文中的 `/new`、`/stop`、`/history`、`/model` 不执行。
- 被引用原文中的数字、“是/否”或“同意”不回答问题/审批。
- 访问策略和命令权限仍只依据当前发送者和当前消息。
- 未授权、未 addressed、重复事件、本地命令、批量收集和已被交互状态机消费的消息不触发引用网络查询。
- 引用解析失败后当前 Turn 仍只启动一次，不重复发送最终答案。
- 当前图片/文件的下载、限额、工作区写入和清理保持原行为。
### 10.3 九渠道 fixture
每个渠道至少固化：
1. 纯文本原消息 + 当前文字。
2. 引用 bot 消息和引用普通用户消息。
3. 只有图片/文件的原消息，验证附件摘要。
4. 无引用消息的原有 fixture，验证无回归。
5. 平台不同客户端或回调版本能构造的字段缺失情况。
另外针对需查询的渠道：
- Discord：有 `referenced_message`、缺快照 REST 成功、`null` 删除、403 和跨频道拒绝。
- Slack：DM 的 `im:history`、多人私聊的 `mpim:history`、公开频道的 `channels:history`、私有频道的 `groups:history`、非 Thread 不查询和 scope 缺失降级。
- 飞书：`parent_id` 优先、`root_id` 回退、同 `chat_id` 校验、消息撤回和 `im:message:readonly` 缺失；另覆盖 Card 1.0、CardKit 2.0 `json_card/property`、i18n 文本、二维 fallback、空卡片/占位文案，以及隐藏配置不泄漏。
- 微信个人号：覆盖 `type=8 + text_item` 的形状优先解析、未知类型纯元数据空壳、真实 64 位消息 ID 时间解码、出站索引持久化、同一用户隔离、ID 精确匹配、15 秒唯一时间匹配、索引缺失时的当前 Session 有界回查、成功回填和歧义拒绝。
- 钉钉：覆盖 `interactiveCard` 占位符、`originalProcessQueryKey` 精确索引命中、索引建立前消息的当前 Session 有界回查、卡片实例 ID 登记、会话隔离和歧义拒绝。
- Telegram：覆盖 `reply_to_message.text/caption`、`quote.text` 回退、只有消息 ID/date 时的延迟加载、当前绑定 Session 有界回查、会话隔离和歧义拒绝。
### 10.4 真实客户端验收
九渠道分别在现有账号可构造的私聊/群聊中验证：
- 引用用户文本、bot 文本和带附件消息。
- 引用文本内有命令样式时不执行命令。
- 群聊中现有 @/回复 bot 触发边界不变。
- 飞书、Slack 和 Discord 查询失败后当前问题仍然有答案。
- Slack 重新授权后分别验证 DM、公开频道和私有频道。
- 钉钉覆盖桌面端/移动端可构造的单行、多行、图片和富文本引用。
不得把 mock 通过记录成九渠道真机已验收；缺少账号或场景时在验收记录中单独列出。
## 11. 实施顺序
1. **公共层**：先实现 `reply-reference.mjs`、Session 标题和公共单测，锁定 Prompt 协议。
2. **回调快照渠道**：企业微信、QQ、WhatsApp、Telegram、微信个人号、钉钉、Discord `referenced_message`。这一步不新增网络请求。
3. **延迟查询渠道**：飞书、Slack 和 Discord REST 回退，优先验证“未授权/命令不查询”。
4. **回归与真机**：执行九渠道定向测试、`npm run check`，再完成真实客户端验收和验收记录。
每一步保持小提交。微信个人号状态文件新增字段对旧版本是可忽略的可选字段；回滚代码不需要迁移或清理该字段。
## 12. 验收清单
- [x] 九渠道都能把可获取的引用文本放入 `<dsh_im_reply_to>`。
- [x] 无引用消息的 Harness 入参和现有用户体验不变。
- [x] 被引用内容不参与命令、访问、问题、审批和批量收集判定。
- [x] 查询只在去重、addressed、访问控制和本地交互之后发生。
- [x] 飞书/Slack/Discord 查询仅读当前会话，失败不中断当前 Turn。
- [x] 不展开二级引用，不下载历史媒体实体，不新增数据库/设置项；微信仅使用有数量、时效和用户隔离边界的最近出站索引，以及当前 Session 的有页数/条数/超时/唯一性边界的历史回查。
- [x] Slack Manifest 已补齐 history scopes，缺 scope 会降级为 `permission-denied`。
- [x] 九渠道定向测试和 `npm run check` 全部通过。
- [x] 真实客户端验收项与未验收项有明确记录。
### 12.1 实施与验收记录（2026-09-01 至 2026-09-02）
- 实现以 v4.5.0 / `c2be238` 为基线，工作树内完成公共 `replyTo` 语义、六处 Prompt 入口和九渠道薄适配；没有新增依赖、数据库或设置项。微信随后增加了本节所述的有界最近出站索引。
- 公共层与九渠道相关的定向测试全部通过；追加飞书 CardKit、微信真实消息 ID、钉钉 AI Card 索引/Session 恢复，以及 Telegram TextQuote/Session 恢复回归后，最终 `npm run check` 为 2072/2072 通过，并通过发布包产物校验。
- 独立静态审计未发现 P0–P2 问题；审计中发现的 Slack 缺 scope、Discord 跨频道快照和飞书缺失 `chat_id` 三个边界均已修复并补测试。
- 本地 Web profile 直接链接当前源码；重新构建并重启 Host 后，9 个飞书机器人长连接均恢复就绪。
- 飞书真实客户端：“今天是牢梁”私聊验收已通过。先发送唯一校验码原文 `QREF-9A7K-260901`，确认 bot 收到后执行 `/new`；在新 Harness Session 中引用该原消息，发送不含校验码的“请只返回被引用原消息里的校验码，不要添加其他文字。”，bot 精确返回 `QREF-9A7K-260901`。验收时间：2026-09-01 23:20 CST（UTC+8）。
- 飞书旧机器人 CardKit 回归已通过：引用 22:20 发送、且位于此前 Harness Session 的旧 bot 卡片，询问其中的底层模型，bot 精确返回 `GLM`。这验证了修复可读取当前 CardKit 实体原文，且无需处于同一个 Harness Session；安全边界是引用目标仍属于当前飞书 `chat_id`。验收时间：2026-09-01 23:47 CST（UTC+8）。
- 微信个人号真实失败已定位到腾讯 iLink 的机器人引用元数据空壳：公共层收到的 `replyTo` 只有 `unavailableReason`，不是 Harness Session 隔离。最终兼容修复记录成功发送的机器人文字，并从真实 64 位消息 ID 解码毫秒时间；索引未命中时只回查当前绑定 Session，最多 3 页×100 条、5 秒，匹配窗口 15 秒且要求唯一。索引仍为 200 条、30 天、8,000 码点/条，按微信用户隔离；命中历史后按真实微信消息 ID 自动回填。
- 微信真机新消息引用验收通过：发送 `WXQ-20260902-REFTEST-01` 后引用该机器人回复，Session 中的 `<dsh_im_reply_to>` 精确包含相同 `content`，机器人也精确返回校验码。随后人为移除该校验码的两条最近出站索引并重启 Host，再次引用消息 ID `7500595754332471560`；Session 历史回查成功、同一内容进入 Prompt，状态文件自动回填该真实 ID。验收时间：2026-09-02 00:49–00:58 CST（UTC+8）。
- 微信真机旧消息回归通过：再次引用此前失败截图中的旧机器人消息 ID `7500581098742245128`，其完整 DeepSeek V4 Flash 配置原文进入 `<dsh_im_reply_to>`，机器人正确概括内容；该消息随后以真实 ID 和原时间回填索引。用户已手工确认结果 OK。验收时间：2026-09-02 00:58 CST（UTC+8）。
- 微信最终修复后重新执行 `npm run check`：构建、2068/2068 项测试和发布包产物校验全部通过；本地 Web Host 已重启并由新进程监听 3080。
- 钉钉真实客户端验收通过：先让机器人返回唯一校验码，再引用该 AI Card 并要求只返回被引用消息中的校验码，机器人准确返回；不再出现 `[Interactive Card Message]` 导致的 `unsupported`。验收时间：2026-09-02（UTC+8）。
- Telegram 真实客户端验收通过：先让机器人返回唯一校验码，再引用该回复并要求只返回被引用消息中的校验码，机器人准确返回；不再出现只有消息 ID/作者而正文为 `not-delivered`。验收时间：2026-09-02（UTC+8）。
- 钉钉与 Telegram 最终修复后重新执行 `npm run check`：构建、2072/2072 项测试和发布包产物校验全部通过；本地 Web Host 已重启并由新进程监听 3080。
- Slack、Discord、WhatsApp、企业微信和 QQ 本轮只完成自动化 fixture，未记录为真机验收；其中 Slack scope 变更仍需应用重新授权后验证。钉钉本轮已完成 AI Card 文本引用真机验证，单行、多行、图片和富文本的完整矩阵仍可后续补充。
## 13. 核对依据
- 本仓库 `src/channels/shared/text-harness-bridge.mjs`、`workspace-session.mjs`、`image-prompt.mjs`、`inbound-file.mjs` 和六处 Bridge 现有 Harness 入口。
- 企业微信 `@wecom/aibot-node-sdk@1.0.7` 的 `BaseMessage.quote / QuoteContent` 类型。
- QQ `@tencent-connect/qqbot-nodejs@1.0.4` 的 `refMsgIdx / msgElements` 映射和 `quote-ref` 中间件实现。
- WhatsApp `@whiskeysockets/baileys@7.0.0-rc14` 的 `contextInfo.quotedMessage`。
- [Telegram Bot API：Message](https://core.telegram.org/bots/api#message)。
- [Discord Message Resource](https://docs.discord.com/developers/resources/message)。
- [Slack conversations.history](https://api.slack.com/methods/conversations.history)。
- 飞书 `@larksuiteoapi/node-sdk@1.73.0` 的 `im.v1.message.get`、`card_msg_content_type: 'raw_card_content'`，以及入站事件中的 `parent_id / root_id / thread_id`；CardKit 实际返回按 `json_card` 与逐层 `property` 包装解析。
- [钉钉官方 Go Stream SDK 仓库的真实引用回调样本](https://github.com/open-dingtalk/dingtalk-stream-sdk-go/issues/22)。
- [腾讯 openclaw-weixin 的 `MessageItem.ref_msg / RefMessage`](https://github.com/Tencent/openclaw-weixin/blob/main/src/api/types.ts)。
- [腾讯 openclaw-weixin Issue #23：引用机器人消息只返回 `type=8` 元数据](https://github.com/Tencent/openclaw-weixin/issues/23)。
上游平台和 SDK 会继续演进。实施时以本项目锁定依赖、实际回调 fixture 和官方 API 响应为准，不依赖未经观测的隐式字段。

3
lib/client.js
View file

@ -8792,9 +8792,12 @@ oauth_config:
bot:
- app_mentions:read
- chat:write
- channels:history
- files:read
- files:write
- groups:history
- im:history
- mpim:history
- reactions:write
settings:
event_subscriptions:

472
lib/index.js
View file

File diff suppressed because one or more lines are too long

186
src/channels/dingtalk/dingtalk-bridge.mjs
View file

@ -39,7 +39,6 @@ import {
hasInboundImages,
imagePromptDiagnostic,
imagePromptUserMessage,
promptContentForMessage,
} from '../shared/image-prompt.mjs';
import {
hasInboundFiles,
@ -48,10 +47,16 @@ import {
} from '../shared/inbound-file.mjs';
import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from '../shared/semantic/reply-reference.mjs';
import {
createDeliveryReceipt,
providerMessageIdsFor,
} from '../shared/semantic/delivery.mjs';
import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
import { DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS } from './state-store.mjs';
import {
channelDeliveryFailure,
clearLastMessageFailure,
@ -185,11 +190,95 @@ function downloadCodeFor(value) {
return nonEmptyString(value?.downloadCode) ?? nonEmptyString(value?.pictureDownloadCode);
}
function dingtalkTimestampMs(value) {
const number = typeof value === 'string' && value.trim() ? Number(value) : value;
if (!Number.isFinite(number) || number < 0) return null;
return Math.trunc(number < 10_000_000_000 ? number * 1_000 : number);
}
function usefulReplyText(value) {
const text = nonEmptyString(value);
return text && !/^\[interactive card message\]$/iu.test(text) ? text : null;
}
function dingtalkReplyReference(message, options) {
const replyEnvelope = message?.text;
if (replyEnvelope?.isReplyMsg !== true) return null;
const replied = replyEnvelope?.repliedMsg;
if (!replied || typeof replied !== 'object') {
return { unavailableReason: 'not-delivered' };
}
const msgtype = nonEmptyString(replied.msgType ?? replied.msgtype)?.toLowerCase() ?? '';
const repliedContent = parsedMessageContent({ content: replied.content }) ?? {};
const pseudoMessage = {
msgtype,
text: {
content: nonEmptyString(repliedContent.text)
?? (typeof replied.content === 'string' ? replied.content : ''),
},
content: repliedContent,
};
const normalized = dingtalkInboundMessage(pseudoMessage, options);
let attachments = [];
if (msgtype === 'picture') {
attachments = [{ kind: 'image' }];
} else if (msgtype === 'file') {
const name = nonEmptyString(repliedContent.fileName ?? repliedContent.file_name);
attachments = [{ kind: 'file', ...(name ? { name } : {}) }];
} else if (msgtype === 'richtext') {
attachments = richTextEntries(repliedContent)
.filter((entry) => String(entry?.type ?? '').toLowerCase() === 'picture')
.map(() => ({ kind: 'image' }));
} else if (msgtype === 'voice' || msgtype === 'audio') {
attachments = [{ kind: 'audio' }];
} else if (msgtype === 'video') {
attachments = [{ kind: 'video' }];
}
const messageId = nonEmptyString(replied.msgId ?? replied.messageId);
const authorId = nonEmptyString(replied.senderId ?? replied.senderStaffId);
const authorName = nonEmptyString(replied.senderNick ?? replied.senderName);
const content = usefulReplyText(normalized.content)
?? usefulReplyText(repliedContent.text)
?? usefulReplyText(repliedContent.summary)
?? usefulReplyText(repliedContent.title);
const processQueryKey = nonEmptyString(
message?.originalProcessQueryKey ?? repliedContent.processQueryKey,
);
const createdAt = dingtalkTimestampMs(replied.createdAt ?? replied.createTime);
const load = !content && attachments.length === 0
&& typeof options?.loadReplyContent === 'function'
? ({ signal } = {}) => options.loadReplyContent({
...(messageId ? { messageId } : {}),
...(processQueryKey ? { processQueryKey } : {}),
...(createdAt === null ? {} : { createdAt }),
}, { signal })
: null;
const supported = [
'text', 'picture', 'file', 'richtext', 'voice', 'audio', 'video',
'interactivecard', 'chatrecord',
]
.includes(msgtype);
return {
...(messageId ? { messageId } : {}),
...(authorId ? { authorId } : {}),
...(authorName ? { authorName } : {}),
...(content ? { content } : {}),
...(attachments.length > 0 ? { attachments } : {}),
...(load ? { load } : {}),
...(!content && attachments.length === 0 && !load
? { unavailableReason: supported ? 'not-delivered' : 'unsupported' }
: {}),
};
}
/** Normalize DingTalk picture and richText callbacks into lazy image references. */
export function dingtalkInboundMessage(message, {
api,
clientId,
clientSecret,
loadReplyContent,
} = {}) {
const msgtype = String(message?.msgtype ?? '').toLowerCase();
const content = parsedMessageContent(message);
@ -209,6 +298,12 @@ export function dingtalkInboundMessage(message, {
}
}
const fileCode = msgtype === 'file' ? downloadCodeFor(content) : null;
const replyTo = dingtalkReplyReference(message, {
api,
clientId,
clientSecret,
loadReplyContent,
});
return {
content: text,
images: imageCodes.map((downloadCode, index) => ({
@ -242,6 +337,7 @@ export function dingtalkInboundMessage(message, {
});
},
}] : [],
...(replyTo ? { replyTo } : {}),
};
}
@ -465,11 +561,7 @@ export class DingtalkHarnessBridge {
// An unsafe reply route must never be able to submit an approval.
}
const pending = this.#pendingInteractions.get(key);
const promptMessage = dingtalkInboundMessage(message, {
api: this.#api,
clientId: this.#clientId,
clientSecret: this.#clientSecret,
});
const promptMessage = this.#inboundMessage(message, key);
const commandText = nonEmptyString(promptMessage.content) ?? '';
const addressed = String(message.conversationType) !== '2' || message?.isInAtList === true;
const direct = String(message.conversationType) !== '2';
@ -533,7 +625,8 @@ export class DingtalkHarnessBridge {
plainText: Boolean(commandText)
&& String(message?.msgtype).toLowerCase() === 'text'
&& !hasInboundFiles(promptMessage)
&& !hasInboundImages(promptMessage),
&& !hasInboundImages(promptMessage)
&& !hasReplyReference(promptMessage),
});
if (result.handled) {
if (result.kind === 'submit') {
@ -778,11 +871,7 @@ export class DingtalkHarnessBridge {
}
const addressed = String(message.conversationType) !== '2' || message.isInAtList === true;
const preparedMessage = hasSafeReplyRoute && addressed
? prefetchInboundFiles(dingtalkInboundMessage(message, {
api: this.#api,
clientId: this.#clientId,
clientSecret: this.#clientSecret,
}), { signal: this.#signal })
? prefetchInboundFiles(this.#inboundMessage(message, key), { signal: this.#signal })
: undefined;
const previous = this.#queues.get(key) ?? Promise.resolve();
const current = previous
@ -801,6 +890,50 @@ export class DingtalkHarnessBridge {
return current;
}
#inboundMessage(message, key) {
return dingtalkInboundMessage(message, {
api: this.#api,
clientId: this.#clientId,
clientSecret: this.#clientSecret,
loadReplyContent: (reference, options) => this.#loadReplyContent(key, reference, options),
});
}
async #loadReplyContent(key, reference, { signal } = {}) {
const indexed = this.#state.recentOutboundTextFor?.({
conversationKey: key,
...reference,
});
if (indexed) return { content: indexed };
const quotedAt = dingtalkTimestampMs(reference?.createdAt);
if (quotedAt === null) return { unavailableReason: 'not-delivered' };
const sessionId = this.#state.sessionFor(key);
const session = typeof sessionId === 'string' && sessionId
? this.#harness.workspaceSession?.(sessionId)
: null;
const text = await recoverAssistantTextByTimestamp({
session,
quotedAt,
signal,
toleranceMs: DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS,
});
if (!text) return { unavailableReason: 'not-delivered' };
try {
await this.#state.rememberOutboundMessage?.({
conversationKey: key,
text,
sentAt: quotedAt,
completedAt: quotedAt,
providerMessageIds: [reference?.processQueryKey, reference?.messageId]
.map(nonEmptyString)
.filter(Boolean),
});
} catch (error) {
this.#logger.warn?.('[dsh-dingtalk] failed to remember a recovered quote:', error);
}
return { content: text };
}
async waitForIdle() {
await Promise.allSettled([
...this.#queues.values(),
@ -936,20 +1069,18 @@ export class DingtalkHarnessBridge {
return;
}
const promptMessage = preparedMessage ?? dingtalkInboundMessage(message, {
api: this.#api,
clientId: this.#clientId,
clientSecret: this.#clientSecret,
});
const promptMessage = preparedMessage ?? this.#inboundMessage(message, key);
const text = promptMessage.content;
const hasImages = hasInboundImages(promptMessage);
const hasFiles = hasInboundFiles(promptMessage);
const hasReply = hasReplyReference(promptMessage);
const isPlainText = String(message?.msgtype).toLowerCase() === 'text';
let cardStream = null;
let cardStarted = false;
let cardStartedAt = null;
let batchSettled = batchSubmission === null;
try {
if (!text && !hasImages && !hasFiles) {
if (!text && !hasImages && !hasFiles && !hasReply) {
await this.#send(sessionWebhook, t('目前支持文字、图片和文件消息。'), this.#atUsersFor(message));
return;
}
@ -992,8 +1123,8 @@ export class DingtalkHarnessBridge {
return;
}
let content = hasImages
? await promptContentForMessage(promptMessage, { signal: this.#signal })
let content = hasImages || hasReply
? await promptContentForInboundMessage(promptMessage, { signal: this.#signal })
: undefined;
const snapshot = this.#acceptedMessageIds.get(messageId);
let contextEnhanced = false;
@ -1018,7 +1149,9 @@ export class DingtalkHarnessBridge {
signal: this.#signal,
logger: this.#logger,
});
const startedAt = Date.now();
cardStarted = await cardStream.start(t(CARD_INITIAL_TEXT));
if (cardStarted) cardStartedAt = startedAt;
}
const { answer, artifacts = [] } = await askInWorkspaceSession({
harness: this.#harness,
@ -1056,12 +1189,14 @@ export class DingtalkHarnessBridge {
let textDeliveryError = null;
let textReceipt = null;
let streamed = false;
const deliveryStartedAt = cardStartedAt ?? Date.now();
try {
streamed = cardStarted && await cardStream.finish(answerText);
if (streamed) {
textReceipt = createDeliveryReceipt({
deliveryId: messageId,
presentation: 'dingtalk-card',
providerMessageIds: cardStream.providerMessageIds,
});
} else {
textReceipt = createDeliveryReceipt({
@ -1070,6 +1205,17 @@ export class DingtalkHarnessBridge {
providerMessageIds: await this.#send(sessionWebhook, answerText, this.#atUsersFor(message)),
});
}
try {
await this.#state.rememberOutboundMessage?.({
conversationKey: key,
text: answerText,
sentAt: deliveryStartedAt,
completedAt: Date.now(),
providerMessageIds: providerMessageIdsFor(textReceipt),
});
} catch (error) {
this.#logger.warn?.('[dsh-dingtalk] failed to remember an outbound message:', error);
}
} catch (error) {
textDeliveryError = channelDeliveryFailure(error);
}

11
src/channels/dingtalk/dingtalk-card-stream.mjs
View file

@ -32,7 +32,7 @@ function requiredCredential(value, name) {
* @param {number} [options.updateIntervalMs=500] Minimum delay between updates.
* @param {()=>number} [options.clock] Monotonic millisecond clock.
* @param {{setTimeout: Function, clearTimeout: Function}} [options.timer] Timer implementation.
* @returns {{start(initialText: string): Promise<boolean>, push(progressText: string): void, finish(finalText: string): Promise<boolean>}}
* @returns {{start(initialText: string): Promise<boolean>, push(progressText: string): void, finish(finalText: string): Promise<boolean>, readonly providerMessageIds: string[]}}
* Card stream controller.
*/
export function createDingTalkCardStream({
@ -231,5 +231,12 @@ export function createDingTalkCardStream({
return finishPromise;
};
return Object.freeze({ start, push, finish });
return Object.freeze({
start,
push,
finish,
get providerMessageIds() {
return cardRequest?.cardInstanceId ? [cardRequest.cardInstanceId] : [];
},
});
}

98
src/channels/dingtalk/state-store.mjs
View file

@ -9,8 +9,14 @@ const EMPTY_STATE = Object.freeze({
sessions: {},
seenMessageIds: [],
pendingSenders: {},
recentOutboundMessages: [],
});
export const DINGTALK_RECENT_OUTBOUND_LIMIT = 200;
export const DINGTALK_RECENT_OUTBOUND_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
export const DINGTALK_RECENT_OUTBOUND_TEXT_LIMIT = 8_000;
export const DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS = 15_000;
function nonEmptyString(value) {
return typeof value === 'string' && value.trim() ? value.trim() : null;
}
@ -19,6 +25,49 @@ function displayName(value) {
return (nonEmptyString(value) ?? t('钉钉用户')).slice(0, 100);
}
function timestampMs(value) {
const number = typeof value === 'string' && value.trim() ? Number(value) : value;
if (!Number.isFinite(number) || number < 0) return null;
return Math.trunc(number < 10_000_000_000 ? number * 1_000 : number);
}
function providerMessageIds(value) {
if (!Array.isArray(value)) return [];
return [...new Set(value
.map((id) => (id === undefined || id === null ? null : nonEmptyString(String(id))))
.filter(Boolean))];
}
function truncateText(value) {
const text = nonEmptyString(value);
return text ? [...text].slice(0, DINGTALK_RECENT_OUTBOUND_TEXT_LIMIT).join('') : null;
}
function normalizeRecentOutboundMessage(value) {
if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
const conversationKey = nonEmptyString(value.conversationKey);
const text = truncateText(value.text);
const sentAt = timestampMs(value.sentAt);
const completedAt = timestampMs(value.completedAt) ?? sentAt;
if (!conversationKey || !text || sentAt === null || completedAt === null) return null;
return {
conversationKey,
text,
sentAt,
completedAt: Math.max(sentAt, completedAt),
providerMessageIds: providerMessageIds(value.providerMessageIds),
};
}
function recentOutboundMessages(value, now = Date.now()) {
if (!Array.isArray(value)) return [];
const cutoff = now - DINGTALK_RECENT_OUTBOUND_TTL_MS;
return value
.map(normalizeRecentOutboundMessage)
.filter((entry) => entry && entry.completedAt >= cutoff)
.slice(-DINGTALK_RECENT_OUTBOUND_LIMIT);
}
function normalizePendingSender(value, fallbackRequestId) {
if (!value || typeof value !== 'object') return null;
const requestId = nonEmptyString(value.requestId) ?? nonEmptyString(fallbackRequestId);
@ -69,6 +118,7 @@ function normalizeState(value) {
? [...new Set(value.seenMessageIds.map(nonEmptyString).filter(Boolean))].slice(-1_000)
: [],
pendingSenders,
recentOutboundMessages: recentOutboundMessages(value.recentOutboundMessages),
};
}
@ -140,6 +190,54 @@ export class DingtalkStateStore {
await this.#persist();
}
async rememberOutboundMessage({
conversationKey,
text,
sentAt = Date.now(),
completedAt = Date.now(),
providerMessageIds: messageIds = [],
} = {}) {
const entry = normalizeRecentOutboundMessage({
conversationKey,
text,
sentAt,
completedAt,
providerMessageIds: messageIds,
});
if (!entry) throw new TypeError('Invalid DingTalk outbound message');
this.#state.recentOutboundMessages = recentOutboundMessages([
...this.#state.recentOutboundMessages,
entry,
]);
await this.#persist();
}
recentOutboundTextFor({
conversationKey,
processQueryKey,
messageId,
createdAt,
now = Date.now(),
} = {}) {
const key = nonEmptyString(conversationKey);
if (!key) return null;
const active = recentOutboundMessages(this.#state.recentOutboundMessages, now)
.filter((entry) => entry.conversationKey === key);
const quotedIds = providerMessageIds([processQueryKey, messageId]);
for (const quotedId of quotedIds) {
const exact = active.filter((entry) => entry.providerMessageIds.includes(quotedId));
if (exact.length === 1) return exact[0].text;
if (exact.length > 1) return null;
}
const quotedAt = timestampMs(createdAt);
if (quotedAt === null) return null;
const candidates = active.filter((entry) => (
quotedAt >= entry.sentAt - DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
&& quotedAt <= entry.completedAt + DINGTALK_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
));
return candidates.length === 1 ? candidates[0].text : null;
}
pendingSenders() {
return Object.values(this.#state.pendingSenders)
.sort((left, right) => left.requestedAt.localeCompare(right.requestedAt))

7
src/channels/discord/discord-api.mjs
View file

@ -134,6 +134,13 @@ export class DiscordApi {
});
}
getMessage({ channelId, messageId, signal } = {}) {
return this.#request(
`channels/${snowflake(channelId, 'channel id')}/messages/${snowflake(messageId, 'message id')}`,
{ method: 'GET', signal },
);
}
startThreadFromMessage({ channelId, messageId, name, signal } = {}) {
const threadName = cleanString(name);
if (!threadName || [...threadName].length > 100) {

99
src/channels/discord/discord-runtime.mjs
View file

@ -206,12 +206,101 @@ function discordFileSource(attachment, fetchImpl) {
};
}
export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } = {}) {
function discordReplyAttachment(attachment) {
if (!attachment || typeof attachment !== 'object') return null;
const mediaType = typeof attachment.content_type === 'string'
? attachment.content_type.split(';', 1)[0].trim().toLowerCase() : '';
const kind = mediaType.startsWith('image/') ? 'image'
: mediaType.startsWith('audio/') ? 'audio'
: mediaType.startsWith('video/') ? 'video' : 'file';
const name = typeof attachment.filename === 'string' && attachment.filename
? attachment.filename : undefined;
return { kind, ...(name ? { name } : {}) };
}
function discordReplySnapshot(message, fallbackMessageId) {
if (!message || typeof message !== 'object') return null;
const messageId = typeof message.id === 'string' && message.id
? message.id : fallbackMessageId;
const authorId = typeof message.author?.id === 'string' && message.author.id
? message.author.id : undefined;
const authorName = [message.member?.nick, message.author?.global_name, message.author?.username]
.find((value) => typeof value === 'string' && value.trim());
const attachments = Array.isArray(message.attachments)
? message.attachments.map(discordReplyAttachment).filter(Boolean)
: [];
if (Array.isArray(message.sticker_items)) {
attachments.push(...message.sticker_items.map((sticker) => ({
kind: 'image',
...(typeof sticker?.name === 'string' && sticker.name ? { name: sticker.name } : {}),
})));
}
return {
...(messageId ? { messageId: String(messageId) } : {}),
...(authorId ? { authorId } : {}),
...(authorName ? { authorName } : {}),
content: typeof message.content === 'string' ? message.content : '',
attachments,
};
}
function discordReplyReference(message, loadReply) {
const channelId = String(message?.channel_id ?? '');
const referenceId = typeof message?.message_reference?.message_id === 'string'
&& message.message_reference.message_id
? message.message_reference.message_id : undefined;
const referenceChannelId = message?.message_reference?.channel_id;
if (referenceChannelId !== undefined && String(referenceChannelId) !== channelId) {
return {
...(referenceId ? { messageId: referenceId } : {}),
unavailableReason: 'not-found',
};
}
if (Object.hasOwn(message ?? {}, 'referenced_message')) {
if (message.referenced_message === null) {
return {
...(referenceId ? { messageId: referenceId } : {}),
unavailableReason: 'deleted',
};
}
if (message.referenced_message && typeof message.referenced_message === 'object') {
const snapshotId = typeof message.referenced_message.id === 'string'
&& message.referenced_message.id ? message.referenced_message.id : undefined;
if (String(message.referenced_message.channel_id ?? '') !== channelId
|| !snapshotId || (referenceId && snapshotId !== referenceId)) {
return {
...(referenceId ? { messageId: referenceId } : {}),
unavailableReason: 'not-found',
};
}
return discordReplySnapshot(message.referenced_message, referenceId) ?? undefined;
}
}
if (!referenceId) return undefined;
if (typeof loadReply !== 'function') {
return { messageId: referenceId, unavailableReason: 'not-delivered' };
}
return {
messageId: referenceId,
load: async ({ signal } = {}) => {
const referenced = await loadReply({ channelId, messageId: referenceId, signal });
if (!referenced || String(referenced.id ?? '') !== referenceId
|| String(referenced.channel_id ?? '') !== channelId) return null;
return discordReplySnapshot(referenced, referenceId);
},
};
}
export function normalizeDiscordMessage(message, botId, {
fetchImpl = fetch,
loadReply,
} = {}) {
if (!message?.id || !message?.channel_id || !message?.author?.id
|| Number(message.type) === 21) return null;
const direct = !message.guild_id;
const addressed = direct
|| message.mentions?.some((mention) => String(mention?.id) === String(botId));
const replyTo = discordReplyReference(message, loadReply);
return {
messageId: String(message.id),
senderId: String(message.author.id),
@ -232,6 +321,7 @@ export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } =
files: Array.isArray(message.attachments)
? message.attachments.map((attachment) => discordFileSource(attachment, fetchImpl)).filter(Boolean)
: [],
...(replyTo ? { replyTo } : {}),
addressed,
replyTarget: {
channelId: String(message.channel_id),
@ -252,7 +342,12 @@ export async function resolveDiscordMessageRoute(message, botId, {
signal,
onChannel,
} = {}) {
const normalized = normalizeDiscordMessage(message, botId, { fetchImpl });
const normalized = normalizeDiscordMessage(message, botId, {
fetchImpl,
loadReply: typeof api?.getMessage === 'function'
? (options) => api.getMessage(options)
: undefined,
});
if (!normalized || normalized.senderIsBot) return normalized;
signal?.throwIfAborted();
if (normalized.kind === 'direct') {

16
src/channels/feishu/bridge.mjs
View file

@ -11,8 +11,11 @@ import {
hasInboundImages,
imagePromptDiagnostic,
imagePromptUserMessage,
promptContentForMessage,
} from '../shared/image-prompt.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from '../shared/semantic/reply-reference.mjs';
import {
hasInboundFiles,
inboundFileUserMessage,
@ -626,7 +629,9 @@ export class FeishuHarnessBridge {
&& (this.#queues.has(key) || pending || this.#approvals.hasPending(key))
? { handled: true, kind: 'busy', message: batchInputBusyMessage() }
: this.#batchInputs.handle(key, batchText, {
plainText: event.message.message_type === 'text' && Boolean(batchText),
plainText: event.message.message_type === 'text'
&& Boolean(batchText)
&& !hasReplyReference(commandMessage),
});
if (result.handled) {
if (result.kind === 'submit') {
@ -1032,11 +1037,12 @@ export class FeishuHarnessBridge {
const text = message.content;
const hasImages = hasInboundImages(message);
const hasFiles = hasInboundFiles(message);
const hasReply = hasReplyReference(message);
// 命令识别对 text 与纯文本 post 一视同仁：post 富文本若仅含单个
// 文本段落（如复制粘贴的 /new），同样按命令处理；带图片/文件不认。
// accept() 侧已用 nonEmptyString(content) 判定，两侧保持一致。
const commandText = !hasImages && !hasFiles && text ? text.trim() : null;
if (!text && !hasImages && !hasFiles) {
if (!text && !hasImages && !hasFiles && !hasReply) {
await this.#send(event.message.chat_id, t('目前支持文字、图片和文件消息。'), { replyTo: event.message.message_id });
return;
}
@ -3289,8 +3295,8 @@ export class FeishuHarnessBridge {
askCompleted = true;
onAskComplete?.();
};
let content = hasInboundImages(message)
? await promptContentForMessage(message, { signal: this.#signal })
let content = hasInboundImages(message) || hasReplyReference(message)
? await promptContentForInboundMessage(message, { signal: this.#signal })
: undefined;
const snapshot = this.#acceptedMessageIds.get(messageId);
let contextEnhanced = false;

229
src/channels/feishu/message-utils.mjs
View file

@ -2,8 +2,14 @@ import { ImagePromptError } from '../shared/image-prompt.mjs';
import { t } from '../shared/i18n.mjs';
const FEISHU_MISSING_MESSAGE_SCOPE_CODE = 99991672;
const FEISHU_CARD_MESSAGE_CONTENT_TYPE = 'raw_card_content';
const FEISHU_ERROR_BODY_LIMIT = 64 * 1024;
const FEISHU_ERROR_BODY_TIMEOUT_MS = 1_000;
const FEISHU_CARD_TEXT_MAX_DEPTH = 12;
const FEISHU_CARD_TEXT_MAX_NODES = 1_000;
const FEISHU_CARD_UNAVAILABLE_TEXTS = new Set([
'请升级至最新版本客户端，以查看内容',
]);
const FEISHU_IMAGE_PERMISSION_MESSAGE =
'飞书机器人缺少图片读取权限 im:message:readonly（飞书显示为“获取单聊、群组消息”）。请私聊机器人执行 /repair 命令，或者在「IM机器人」设置页点击“补全权限”按钮并扫码。按飞书提示发布新版本、完成必要审批后，再重新发送图片。';
@ -56,6 +62,124 @@ function nonEmptyString(value) {
return typeof value === 'string' && value.trim() ? value.trim() : null;
}
function objectRecord(value) {
return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
}
function jsonRecord(value) {
if (objectRecord(value)) return value;
if (typeof value !== 'string') return null;
try {
return objectRecord(JSON.parse(value));
} catch {
return null;
}
}
function interactiveCardRoot(parsed) {
const root = objectRecord(parsed);
if (!root) return null;
// raw_card_content wraps CardKit entities in json_card. Keep direct Card
// 1.0/2.0 payloads readable as well for historical messages and fixtures.
return jsonRecord(root.json_card) ?? jsonRecord(root.card) ?? root;
}
function cardProperty(value) {
const record = objectRecord(value);
return objectRecord(record?.property) ?? record;
}
function cardTextContent(property) {
const i18n = objectRecord(property?.i18nContent);
const content = nonEmptyString(i18n?.zh_cn)
?? nonEmptyString(i18n?.en_us)
?? nonEmptyString(i18n?.ja_jp)
?? nonEmptyString(property?.content)
?? nonEmptyString(property?.text);
return content && !FEISHU_CARD_UNAVAILABLE_TEXTS.has(content) ? content : null;
}
function cardElementText(
element,
{ depth = 0, inline = false, budget = { remaining: FEISHU_CARD_TEXT_MAX_NODES } } = {},
) {
if (depth > FEISHU_CARD_TEXT_MAX_DEPTH || budget.remaining <= 0) return '';
budget.remaining -= 1;
if (Array.isArray(element)) {
return element
.map((part) => cardElementText(part, {
depth: depth + 1,
inline: Array.isArray(part),
budget,
}))
.filter(Boolean)
.join(inline ? ' ' : '\n');
}
const value = objectRecord(element);
if (!value) return '';
const property = cardProperty(value);
if (!property) return '';
const tag = String(value.tag ?? '').toLowerCase();
if (
tag === 'markdown'
|| tag === 'markdown_v1'
|| tag === 'lark_md'
|| tag === 'plain_text'
|| tag === 'text'
) {
const content = cardTextContent(property);
if (content) return content;
const nested = cardElementText(property.elements, {
depth: depth + 1,
inline: true,
budget,
});
if (nested || tag !== 'markdown_v1') return nested;
return cardElementText(value.fallback ?? property.fallback, {
depth: depth + 1,
inline: true,
budget,
});
}
if (tag === 'a' || tag === 'link' || tag === 'button') {
if (typeof property.text === 'string') return nonEmptyString(property.text) ?? '';
return cardElementText(property.text, { depth: depth + 1, inline: true, budget });
}
if (tag === 'div') {
return [
cardElementText(property.text, { depth: depth + 1, budget }),
cardElementText(property.fields, { depth: depth + 1, budget }),
].filter(Boolean).join('\n');
}
// Traverse visible layout containers only. Deliberately ignore callback
// values, form state, URLs, ids, template variables and other hidden data.
return ['elements', 'columns', 'fields', 'children', 'actions']
.map((key) => cardElementText(property[key], { depth: depth + 1, budget }))
.filter(Boolean)
.join('\n');
}
function interactiveCardText(parsed) {
const card = interactiveCardRoot(parsed);
if (!card) return '';
const budget = { remaining: FEISHU_CARD_TEXT_MAX_NODES };
const header = cardProperty(card.header);
const title = [
cardElementText(header?.title, { inline: true, budget }),
cardElementText(header?.subtitle, { inline: true, budget }),
].filter(Boolean).join('\n') || nonEmptyString(card.title) || '';
const body = cardProperty(card.body);
const elements = Array.isArray(body?.elements)
? body.elements
: Array.isArray(card.elements)
? card.elements
: null;
const content = cardElementText(elements, { budget });
return [title, content].filter(Boolean).join('\n');
}
function postContent(event, parsed = parsedMessageContent(event)) {
if (event?.message?.message_type !== 'post') return null;
if (!parsed) return null;
@ -283,6 +407,109 @@ function feishuFileSource(event, client, file) {
};
}
function feishuReplyTargetId(event) {
const parentId = nonEmptyString(event?.message?.parent_id);
if (parentId) return parentId;
const rootId = nonEmptyString(event?.message?.root_id);
const messageId = nonEmptyString(event?.message?.message_id);
return rootId && rootId !== messageId ? rootId : null;
}
function feishuReplyAttachments(messageType, parsed, post) {
if (messageType === 'post') {
return (post?.imageKeys ?? []).map(() => ({ kind: 'image' }));
}
if (messageType === 'image') return [{ kind: 'image' }];
if (messageType === 'file') {
return [{
kind: 'file',
...(nonEmptyString(parsed?.file_name) ? { name: nonEmptyString(parsed.file_name) } : {}),
}];
}
if (messageType === 'audio') return [{ kind: 'audio' }];
if (messageType === 'media') {
return [{
kind: 'video',
...(nonEmptyString(parsed?.file_name) ? { name: nonEmptyString(parsed.file_name) } : {}),
}];
}
if (messageType === 'sticker') return [{ kind: 'other' }];
return [];
}
function feishuReplyReference(event, client) {
const messageId = feishuReplyTargetId(event);
if (!messageId) return null;
const chatId = nonEmptyString(event?.message?.chat_id);
return {
messageId,
async load({ signal } = {}) {
signal?.throwIfAborted();
let response;
try {
response = await client?.im?.v1?.message?.get?.({
path: { message_id: messageId },
params: {
with_sender_name: true,
card_msg_content_type: FEISHU_CARD_MESSAGE_CONTENT_TYPE,
},
});
} catch (error) {
signal?.throwIfAborted();
if (await feishuProviderCode(error, signal) === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
return { messageId, unavailableReason: 'permission-denied' };
}
throw error;
}
signal?.throwIfAborted();
if (providerCode(response) === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
return { messageId, unavailableReason: 'permission-denied' };
}
if (providerCode(response) !== null && providerCode(response) !== 0) {
return { messageId, unavailableReason: 'not-delivered' };
}
const item = response?.data?.items?.find?.(
(candidate) => nonEmptyString(candidate?.message_id) === messageId,
);
if (!item) return { messageId, unavailableReason: 'not-found' };
if (item.deleted) return { messageId, unavailableReason: 'deleted' };
const itemChatId = nonEmptyString(item.chat_id);
if (!chatId || !itemChatId || itemChatId !== chatId) {
return { messageId, unavailableReason: 'not-found' };
}
const messageType = nonEmptyString(item.msg_type) ?? '';
const quotedEvent = {
message: {
message_id: messageId,
message_type: messageType,
content: item.body?.content,
mentions: item.mentions ?? [],
},
};
const parsed = parsedMessageContent(quotedEvent);
const post = postContent(quotedEvent, parsed);
const quoted = extractInboundMessage(quotedEvent, client);
const content = messageType === 'interactive'
? interactiveCardText(parsed)
: quoted.content;
const attachments = feishuReplyAttachments(messageType, parsed, post);
return {
messageId,
...(nonEmptyString(item.sender?.id) ? { authorId: nonEmptyString(item.sender.id) } : {}),
...(nonEmptyString(item.sender?.sender_name)
? { authorName: nonEmptyString(item.sender.sender_name) }
: {}),
...(content ? { content } : {}),
attachments,
...(messageType === 'interactive' && !content && attachments.length === 0
? { unavailableReason: 'unsupported' }
: {}),
};
},
};
}
export function extractInboundMessage(event, client) {
const messageType = event?.message?.message_type;
const parsed = parsedMessageContent(event);
@ -292,10 +519,12 @@ export function extractInboundMessage(event, client) {
: null;
const imageKeys = standaloneImageKey ? [standaloneImageKey] : post?.imageKeys ?? [];
const file = messageType === 'file' ? feishuFileSource(event, client, parsed) : null;
const replyTo = feishuReplyReference(event, client);
return {
content: messageType === 'text' ? extractText(event) ?? '' : post?.text ?? '',
images: imageKeys.map((key) => feishuImageSource(event, client, key)),
files: file ? [file] : [],
...(replyTo ? { replyTo } : {}),
};
}

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

@ -33,7 +33,6 @@ import {
hasInboundImages,
imagePromptDiagnostic,
imagePromptUserMessage,
promptContentForMessage,
} from '../shared/image-prompt.mjs';
import {
hasInboundFiles,
@ -44,6 +43,10 @@ import {
trackOutboundArtifactProviderPromise,
} from '../shared/semantic/artifact.mjs';
import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from '../shared/semantic/reply-reference.mjs';
import {
createDeliveryReceipt,
providerMessageIdsFor,
@ -145,6 +148,37 @@ function hasQqFileAttachments(message) {
&& message.attachments.some((attachment) => !isQqImageAttachment(attachment));
}
function qqAttachmentKind(attachment) {
const mediaType = attachmentMediaType(attachment);
if (mediaType?.startsWith('image/')) return 'image';
if (mediaType?.startsWith('audio/')) return 'audio';
if (mediaType?.startsWith('video/')) return 'video';
return 'file';
}
function qqReplyReference(message) {
const refMsgIdx = nonEmptyString(message?.refMsgIdx);
if (!refMsgIdx) return null;
const element = Array.isArray(message?.msgElements) ? message.msgElements[0] : null;
const sourceAttachments = Array.isArray(element?.attachments) ? element.attachments : [];
const attachments = sourceAttachments.map((attachment) => {
const name = nonEmptyString(attachment?.filename);
return { kind: qqAttachmentKind(attachment), ...(name ? { name } : {}) };
});
const asrText = sourceAttachments
.filter((attachment) => qqAttachmentKind(attachment) === 'audio')
.map((attachment) => nonEmptyString(attachment?.asr_refer_text))
.filter(Boolean)
.join('\n');
const content = asrText || nonEmptyString(element?.content);
return {
messageId: refMsgIdx,
...(content ? { content } : {}),
...(attachments.length > 0 ? { attachments } : {}),
...(!content && attachments.length === 0 ? { unavailableReason: 'not-delivered' } : {}),
};
}
async function fetchQqFileBuffer(url, { fetchImpl, signal }) {
const normalizedUrl = url.startsWith('//') ? `https:${url}` : url;
const response = await fetchImpl(new URL(normalizedUrl), {
@ -196,7 +230,13 @@ export function qqInboundMessage(message, { fetchImpl = fetch } = {}) {
},
});
}
return { content: safeText(message), images, files };
const replyTo = qqReplyReference(message);
return {
content: safeText(message),
images,
files,
...(replyTo ? { replyTo } : {}),
};
}
function nonEmptyString(value) {
@ -493,7 +533,8 @@ export class QqHarnessBridge {
: this.#batchInputs.handle(key, commandText, {
plainText: Boolean(commandText)
&& !hasQqImageAttachments(message)
&& !hasQqFileAttachments(message),
&& !hasQqFileAttachments(message)
&& !qqReplyReference(message),
});
if (result.handled) {
if (result.kind === 'submit') {
@ -785,10 +826,11 @@ export class QqHarnessBridge {
const text = promptMessage.content;
const hasImages = hasInboundImages(promptMessage);
const hasFiles = hasInboundFiles(promptMessage);
const hasReply = hasReplyReference(promptMessage);
let stream = null;
let batchSettled = batchSubmission === null;
try {
if (!text && !hasImages && !hasFiles) {
if (!text && !hasImages && !hasFiles && !hasReply) {
await this.#bot.sendText(target, t('目前支持文字、图片和文件消息。'));
await markMessageSeen();
return;
@ -836,8 +878,8 @@ export class QqHarnessBridge {
return;
}
let content = hasImages
? await promptContentForMessage(promptMessage, { signal: this.#signal })
let content = hasImages || hasReply
? await promptContentForInboundMessage(promptMessage, { signal: this.#signal })
: undefined;
const snapshot = this.#acceptedMessageIds.get(messageId);
let contextEnhanced = false;

6
src/channels/shared/batch-input.mjs
View file

@ -74,7 +74,7 @@ export class BatchInputManager {
if (!batch) {
if (!name) return { handled: false };
if (!plainText) {
return result('unsupported-content', t('批量输入命令仅支持纯文字，请移除图片或文件后重试。'));
return result('unsupported-content', t('批量输入命令仅支持纯文字，请移除图片、文件或引用消息后重试。'));
}
if (name === 'send') {
return result('no-batch', t('当前没有待提交的批量内容，请先发送 /batch。'));
@ -91,7 +91,7 @@ export class BatchInputManager {
}
if (!plainText && (batch.phase === 'collecting' || name)) {
return result('unsupported-content', t(`批量输入模式目前仅支持文字，这条消息未收录。
return result('unsupported-content', t(`批量输入模式目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录。
请继续发送文字，或使用 /send、/cancel。`), {
count: batch.messages.length,
limit: BATCH_INPUT_LIMIT,
@ -146,7 +146,7 @@ export class BatchInputManager {
}
if (typeof text !== 'string') {
return result('unsupported-content', t(`批量输入模式目前仅支持文字，这条消息未收录。
return result('unsupported-content', t(`批量输入模式目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录。
请继续发送文字，或使用 /send、/cancel。`), {
count: batch.messages.length,
limit: BATCH_INPUT_LIMIT,

8
src/channels/shared/i18n-en/shared-c.mjs
View file

@ -157,15 +157,15 @@ export default {
'当前聊天有正在运行的任务、待回答问题或待审批请求。\n请先完成当前交互或发送 /stop，再使用 /batch。':
'This chat has a running task, unanswered question, or pending approval.\nFinish the current interaction or send /stop before using /batch.',
'用法：/{command}（不带参数）': 'Usage: /{command} (without arguments)',
'批量输入命令仅支持纯文字，请移除图片或文件后重试。':
'Batch input commands support text only. Remove the image or file and try again.',
'批量输入命令仅支持纯文字，请移除图片、文件或引用消息后重试。':
'Batch input commands support text only. Remove the image, file, or quoted message and try again.',
'当前没有待提交的批量内容，请先发送 /batch。':
'There is no batch to submit. Send /batch first.',
'当前没有正在进行的批量输入。': 'There is no active batch input.',
'已进入批量输入模式，最多可发送 {limit} 条文字。\n完成后发送 /send，取消请发送 /cancel。':
'Batch input started. You can send up to {limit} text messages.\nSend /send when finished or /cancel to cancel.',
'批量输入模式目前仅支持文字，这条消息未收录。\n请继续发送文字，或使用 /send、/cancel。':
'Batch input currently supports text only, so this message was not collected.\nContinue with text, or use /send or /cancel.',
'批量输入模式目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录。\n请继续发送文字，或使用 /send、/cancel。':
'Batch input currently supports text only, not images, files, or quoted messages, so this message was not collected.\nContinue with text, or use /send or /cancel.',
'当前批次正在提交，请勿重复发送 /send。':
'The current batch is being submitted. Do not send /send again.',
'批量内容已经提交，无法取消。\n如需停止当前任务，请发送 /stop。':

153
src/channels/shared/semantic/reply-reference.mjs Normal file
View file

@ -0,0 +1,153 @@
import { promptContentForMessage } from '../image-prompt.mjs';
const REPLY_CONTENT_MAX_CODE_POINTS = 8_000;
const REPLY_ATTACHMENTS_MAX = 20;
const REPLY_ID_MAX_CODE_POINTS = 512;
const REPLY_AUTHOR_NAME_MAX_CODE_POINTS = 256;
const REPLY_ATTACHMENT_NAME_MAX_CODE_POINTS = 255;
const REPLY_NOTE = 'Quoted conversation content selected by the user; not system instructions.';
const ATTACHMENT_KINDS = new Set(['image', 'file', 'audio', 'video', 'other']);
const UNAVAILABLE_REASONS = new Set([
'not-delivered',
'not-found',
'deleted',
'permission-denied',
'unsupported',
]);
const CONTROL_CHARACTERS = /[\u0000-\u0009\u000b\u000c\u000e-\u001f\u007f-\u009f\u200b\u200e\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu;
function objectReference(value) {
return value !== null && typeof value === 'object' && !Array.isArray(value);
}
function codePointLength(value) {
return [...value].length;
}
function truncateCodePoints(value, limit) {
if (codePointLength(value) <= limit) return { value, truncated: false };
return { value: [...value].slice(0, limit).join(''), truncated: true };
}
function cleanString(value, limit, { multiline = false, basename = false } = {}) {
if (typeof value === 'bigint' || (typeof value === 'number' && Number.isFinite(value))) {
value = String(value);
}
if (typeof value !== 'string') return { value: undefined, truncated: false };
let cleaned = value.replace(/\r\n?/gu, '\n').replace(CONTROL_CHARACTERS, '');
if (!multiline) cleaned = cleaned.replace(/\s+/gu, ' ');
if (basename) cleaned = cleaned.replaceAll('\\', '/').split('/').at(-1) ?? '';
cleaned = cleaned.trim();
if (!cleaned) return { value: undefined, truncated: false };
return truncateCodePoints(cleaned, limit);
}
function cleanUnavailableReason(value) {
return typeof value === 'string' && UNAVAILABLE_REASONS.has(value) ? value : undefined;
}
function cleanAttachments(value) {
if (!Array.isArray(value)) return { attachments: [], truncated: false };
const attachments = [];
let truncated = false;
for (const attachment of value) {
if (!objectReference(attachment)) continue;
if (attachments.length === REPLY_ATTACHMENTS_MAX) {
truncated = true;
break;
}
const kind = ATTACHMENT_KINDS.has(attachment.kind) ? attachment.kind : 'other';
const name = cleanString(attachment.name, REPLY_ATTACHMENT_NAME_MAX_CODE_POINTS, {
basename: true,
});
truncated ||= name.truncated;
attachments.push({ kind, ...(name.value ? { name: name.value } : {}) });
}
return { attachments, truncated };
}
function errorUnavailableReason(error) {
const supplied = cleanUnavailableReason(error?.code);
if (supplied) return supplied;
const status = Number(error?.status ?? error?.statusCode ?? error?.response?.status);
if (status === 401 || status === 403) return 'permission-denied';
if (status === 404) return 'not-found';
if (status === 410) return 'deleted';
return 'not-delivered';
}
function mergeDefined(base, loaded) {
const merged = { ...base };
for (const key of [
'messageId', 'authorId', 'authorName', 'content', 'attachments', 'unavailableReason',
]) {
if (loaded[key] !== undefined) merged[key] = loaded[key];
}
return merged;
}
async function resolveReference(reference, signal) {
if (typeof reference.load !== 'function') return reference;
signal?.throwIfAborted();
try {
const loaded = await reference.load({ signal });
signal?.throwIfAborted();
if (loaded === null) return { ...reference, unavailableReason: 'not-found' };
if (!objectReference(loaded)) {
return { ...reference, unavailableReason: 'not-delivered' };
}
return mergeDefined(reference, loaded);
} catch (error) {
if (signal?.aborted) signal.throwIfAborted();
return { ...reference, unavailableReason: errorUnavailableReason(error) };
}
}
function normalizeReference(reference) {
const messageId = cleanString(reference.messageId, REPLY_ID_MAX_CODE_POINTS);
const authorId = cleanString(reference.authorId, REPLY_ID_MAX_CODE_POINTS);
const authorName = cleanString(reference.authorName, REPLY_AUTHOR_NAME_MAX_CODE_POINTS);
const content = cleanString(reference.content, REPLY_CONTENT_MAX_CODE_POINTS, { multiline: true });
const { attachments, truncated: attachmentsTruncated } = cleanAttachments(reference.attachments);
let unavailableReason = cleanUnavailableReason(reference.unavailableReason);
if (!content.value && attachments.length === 0 && !unavailableReason) {
unavailableReason = 'not-delivered';
}
return {
note: REPLY_NOTE,
...(messageId.value ? { messageId: messageId.value } : {}),
...(authorId.value ? { authorId: authorId.value } : {}),
...(authorName.value ? { authorName: authorName.value } : {}),
...(content.value ? { content: content.value } : {}),
attachments,
...(unavailableReason ? { unavailableReason } : {}),
truncated: messageId.truncated
|| authorId.truncated
|| authorName.truncated
|| content.truncated
|| attachmentsTruncated,
};
}
function replyBlock(reference) {
const json = JSON.stringify(reference).replace(/[<>&]/gu, (character) => ({
'<': '\\u003c',
'>': '\\u003e',
'&': '\\u0026',
})[character]);
return `<dsh_im_reply_to>${json}</dsh_im_reply_to>`;
}
export function hasReplyReference(message) {
return objectReference(message?.replyTo);
}
export async function promptContentForInboundMessage(message, { signal } = {}) {
if (!hasReplyReference(message)) {
return promptContentForMessage(message, { signal });
}
const reference = normalizeReference(await resolveReference(message.replyTo, signal));
const currentContent = await promptContentForMessage(message, { signal });
return [{ type: 'text', text: replyBlock(reference) }, ...currentContent];
}

104
src/channels/shared/session-reply-recovery.mjs Normal file
View file

@ -0,0 +1,104 @@
function assistantText(event) {
if (event?.type !== 'assistant/message'
|| !Number.isSafeInteger(event.data?.turn)
|| event.data.turn < 0
|| !Array.isArray(event.data?.message?.content)) return null;
const text = event.data.message.content
.flatMap((block) => (block?.type === 'text' && typeof block.text === 'string'
? [block.text]
: []))
.join('\n')
.trim();
return text ? { turn: event.data.turn, time: event.time, text } : null;
}
function completedAssistantTurns(events) {
const starts = new Map();
const assistants = new Map();
const completed = [];
for (const event of [...events].sort((left, right) => left.seq - right.seq)) {
if (event?.type === 'turn/start' && Number.isSafeInteger(event.data?.turn)) {
starts.set(event.data.turn, event.time);
}
const assistant = assistantText(event);
if (assistant) assistants.set(assistant.turn, assistant);
if (event?.type !== 'turn/end' || !Number.isSafeInteger(event.data?.turn)) continue;
const final = assistants.get(event.data.turn);
assistants.delete(event.data.turn);
if ((event.data?.reason?.kind ?? event.data?.reason) !== 'completed' || !final) continue;
completed.push({
...final,
startedAt: starts.get(event.data.turn),
completedAt: event.time,
});
}
return completed;
}
function matchingAssistantText(events, quotedAt, toleranceMs) {
const candidates = completedAssistantTurns(events).filter((entry) => {
if (Number.isFinite(entry.time) && Math.abs(entry.time - quotedAt) <= toleranceMs) {
return true;
}
return Number.isFinite(entry.startedAt) && Number.isFinite(entry.completedAt)
&& quotedAt >= entry.startedAt - toleranceMs
&& quotedAt <= entry.completedAt + toleranceMs;
});
return candidates.length === 1 ? candidates[0].text : null;
}
/**
* Recover one completed assistant answer near a provider message timestamp.
*
* @param {object} options Recovery inputs.
* @param {{readHistory: Function}} options.session Bound Harness Session handle.
* @param {number} options.quotedAt Provider message timestamp in milliseconds.
* @param {AbortSignal} [options.signal] Caller cancellation signal.
* @param {number} [options.pageSize=100] History events requested per page.
* @param {number} [options.maxPages=3] Maximum history pages to inspect.
* @param {number} [options.timeoutMs=5000] Total history read deadline.
* @param {number} [options.toleranceMs=15000] Provider/session clock tolerance.
* @returns {Promise<string|null>} The unique matching answer, or null.
*/
export async function recoverAssistantTextByTimestamp({
session,
quotedAt,
signal: callerSignal,
pageSize = 100,
maxPages = 3,
timeoutMs = 5_000,
toleranceMs = 15_000,
} = {}) {
if (typeof session?.readHistory !== 'function' || !Number.isFinite(quotedAt)) return null;
const timeout = AbortSignal.timeout(timeoutMs);
const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;
const deadline = Date.now() + timeoutMs;
const events = new Map();
let beforeSeq;
for (let pageIndex = 0; pageIndex < maxPages; pageIndex += 1) {
signal.throwIfAborted();
const page = await session.readHistory({
maxMessages: pageSize,
...(beforeSeq === undefined ? {} : { beforeSeq }),
timeoutMs: Math.max(1, deadline - Date.now()),
signal,
});
if (!page || !Array.isArray(page.events) || typeof page.hasMore !== 'boolean') return null;
let oldestSeq = beforeSeq ?? Infinity;
let oldestTime = Infinity;
for (const entry of page.events) {
const event = entry?.event;
if (!event || !Number.isSafeInteger(event.seq) || event.seq < 0) continue;
events.set(event.seq, event);
oldestSeq = Math.min(oldestSeq, event.seq);
if (Number.isFinite(event.time)) oldestTime = Math.min(oldestTime, event.time);
}
const text = matchingAssistantText([...events.values()], quotedAt, toleranceMs);
const passedTarget = oldestTime <= quotedAt - toleranceMs;
if (text && (passedTarget || !page.hasMore)) return text;
if (!page.hasMore || passedTarget
|| !Number.isFinite(oldestSeq) || oldestSeq === beforeSeq) break;
beforeSeq = oldestSeq;
}
return null;
}

2
src/channels/shared/session-title.mjs
View file

@ -5,7 +5,7 @@ const CSI_SEQUENCE = /(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]/gu;
const ESC_SEQUENCE = /\u001b[@-_]/gu;
const CONTROL_CHARACTER = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
const DIRECTIONAL_CONTROL = /[\u200b\u200e\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu;
const INJECTED_CONTEXT_PREFIX = /^(?:<dsh_im_source>[\s\S]*?<\/dsh_im_source>\s*)?(?:<dsh_im_source_guidance>[\s\S]*?<\/dsh_im_source_guidance>\s*)?/u;
const INJECTED_CONTEXT_PREFIX = /^(?:<dsh_im_source>[\s\S]*?<\/dsh_im_source>\s*)?(?:<dsh_im_source_guidance>[\s\S]*?<\/dsh_im_source_guidance>\s*)?(?:<dsh_im_reply_to>[\s\S]*?<\/dsh_im_reply_to>\s*)?/u;
const SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
function cleanTitleText(input) {

18
src/channels/shared/text-harness-bridge.mjs
View file

@ -35,7 +35,6 @@ import {
hasInboundImages,
imagePromptDiagnostic,
imagePromptUserMessage,
promptContentForMessage,
} from './image-prompt.mjs';
import {
hasInboundFiles,
@ -47,6 +46,10 @@ import {
validHarnessQuestion,
} from './harness-question.mjs';
import { deliverOutboundArtifacts } from './semantic/artifact-delivery.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from './semantic/reply-reference.mjs';
import {
createDeliveryReceipt,
createTextDeliveryBlock,
@ -283,7 +286,8 @@ export class TextHarnessBridge {
plainText: Boolean(text)
&& normalized.plainText !== false
&& !hasInboundImages(normalized)
&& !hasInboundFiles(normalized),
&& !hasInboundFiles(normalized)
&& !hasReplyReference(normalized),
});
if (batch.handled) {
if (batch.kind === 'submit') {
@ -301,7 +305,8 @@ export class TextHarnessBridge {
plainText: Boolean(text)
&& normalized.plainText !== false
&& !hasInboundImages(normalized)
&& !hasInboundFiles(normalized),
&& !hasInboundFiles(normalized)
&& !hasReplyReference(normalized),
});
if (batch.handled) {
return this.#finishLocalMessage(normalized, messageId, batch.message);
@ -575,7 +580,8 @@ export class TextHarnessBridge {
}
const hasImages = hasInboundImages(message);
const hasFiles = hasInboundFiles(message);
if (!text && !hasImages && !hasFiles) {
const hasReply = hasReplyReference(message);
if (!text && !hasImages && !hasFiles && !hasReply) {
await this.#bot.sendText(target, t('目前支持文字、图片和文件消息。'));
return;
}
@ -669,8 +675,8 @@ export class TextHarnessBridge {
);
}
}
let content = hasImages
? await promptContentForMessage(message, { signal: this.#signal })
let content = hasImages || hasReply
? await promptContentForInboundMessage(message, { signal: this.#signal })
: undefined;
const snapshot = this.#acceptedMessageIds.get(messageId);
let contextEnhanced = false;

3
src/channels/slack/manifest.mjs
View file

@ -17,9 +17,12 @@ oauth_config:
bot:
- app_mentions:read
- chat:write
- channels:history
- files:read
- files:write
- groups:history
- im:history
- mpim:history
- reactions:write
settings:
event_subscriptions:

18
src/channels/slack/slack-api.mjs
View file

@ -246,6 +246,24 @@ export class SlackApi {
return value.file;
}
async getMessage({ channelId, messageTs, signal } = {}) {
const timestamp = requiredString(messageTs, 'message timestamp');
const value = await this.#request('conversations.history', {
tokenKind: 'bot',
signal,
body: {
channel: slackId(channelId, 'channel id'),
oldest: timestamp,
latest: timestamp,
inclusive: true,
limit: 1,
},
});
return Array.isArray(value?.messages)
? value.messages.find((message) => String(message?.ts ?? '') === timestamp) ?? null
: null;
}
postMessage({ channelId, text, threadTs, signal }) {
return this.#request('chat.postMessage', {
tokenKind: 'bot',

56
src/channels/slack/slack-runtime.mjs
View file

@ -49,6 +49,58 @@ function slackFileUrl(file) {
? file.url_private_download : file?.url_private;
}
function slackReplyAttachment(file) {
if (!file || typeof file !== 'object') return null;
const mediaType = typeof file.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
const kind = mediaType.startsWith('image/') ? 'image'
: mediaType.startsWith('audio/') ? 'audio'
: mediaType.startsWith('video/') ? 'video' : 'file';
const name = typeof file.name === 'string' && file.name
? file.name : typeof file.title === 'string' && file.title ? file.title : undefined;
return { kind, ...(name ? { name } : {}) };
}
function slackReplySnapshot(message, messageTs) {
if (!message || String(message.ts ?? '') !== messageTs) return null;
const authorId = typeof message.user === 'string' && message.user
? message.user : typeof message.bot_id === 'string' && message.bot_id
? message.bot_id : undefined;
const authorName = typeof message.username === 'string' && message.username
? message.username : undefined;
return {
messageId: messageTs,
...(authorId ? { authorId } : {}),
...(authorName ? { authorName } : {}),
content: decodeSlackText(message.text ?? ''),
attachments: Array.isArray(message.files)
? message.files.map(slackReplyAttachment).filter(Boolean)
: [],
};
}
function slackThreadReplyReference(event, loadReply) {
const messageTs = typeof event?.thread_ts === 'string' ? event.thread_ts : '';
if (!messageTs || messageTs === String(event?.ts ?? '')) return undefined;
return {
messageId: messageTs,
load: async ({ signal } = {}) => {
try {
const message = await loadReply({
channelId: String(event.channel),
messageTs,
signal,
});
return slackReplySnapshot(message, messageTs);
} catch (error) {
if (error?.code === 'slack-missing-scope') {
return { messageId: messageTs, unavailableReason: 'permission-denied' };
}
throw error;
}
},
};
}
function slackImageSource(file, loadFile) {
const mediaType = typeof file?.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
const url = slackFileUrl(file);
@ -104,6 +156,7 @@ export function normalizeSlackEvent(payload, botUserId, {
loadFile = async () => { throw new Error('Slack file downloader is unavailable'); },
loadFileStream = loadFile,
loadFileInfo = async () => { throw new Error('Slack file metadata loader is unavailable'); },
loadReply = async () => { throw new Error('Slack reply loader is unavailable'); },
} = {}) {
const event = payload?.event;
if (!event || !payload?.event_id || !event.channel || !event.user || !event.ts) return null;
@ -112,6 +165,7 @@ export function normalizeSlackEvent(payload, botUserId, {
if (!direct && !mentioned) return null;
if ((event.subtype && event.subtype !== 'file_share') || event.bot_id || event.app_id) return null;
const threadTs = String(event.thread_ts ?? event.ts);
const replyTo = slackThreadReplyReference(event, loadReply);
return {
messageId: String(payload.event_id),
senderId: String(event.user),
@ -126,6 +180,7 @@ export function normalizeSlackEvent(payload, botUserId, {
files: Array.isArray(event.files)
? event.files.map((file) => slackFileSource(file, loadFileStream, loadFileInfo)).filter(Boolean)
: [],
...(replyTo ? { replyTo } : {}),
addressed: direct || mentioned,
reactionTarget: {
channelId: String(event.channel),
@ -555,6 +610,7 @@ export class SlackRuntime {
loadFile: (url, options) => this.#api.downloadFile({ url, ...options }),
loadFileStream: (url, options) => this.#api.downloadFileStream({ url, ...options }),
loadFileInfo: (fileId, options) => this.#api.fileInfo({ fileId, ...options }),
loadReply: (options) => this.#api.getMessage(options),
});
const bridge = this.#bridge;
if (message && bridge) {

119
src/channels/telegram/telegram-runtime.mjs
View file

@ -4,6 +4,7 @@ import { createEditableMessageStream, splitMessageText } from '../shared/editabl
import { createTextDeliveryBlock } from '../shared/semantic/delivery.mjs';
import { t } from '../shared/i18n.mjs';
import { captureContextEnhancement } from '../shared/context-enhancement.mjs';
import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
import { COMMANDS_MENU_BUTTON, TelegramApi } from './telegram-api.mjs';
import { createTelegramHttpTransport } from './telegram-http.mjs';
import { createTelegramBridgeStatus, TelegramHarnessBridge } from './telegram-bridge.mjs';
@ -138,11 +139,94 @@ function telegramFileSource(message, loadFile) {
};
}
function telegramReplyAttachment(kind, file, fallbackName) {
if (!file || typeof file !== 'object') return null;
const name = typeof file.file_name === 'string' && file.file_name
? file.file_name : typeof fallbackName === 'string' && fallbackName
? fallbackName : undefined;
return { kind, ...(name ? { name } : {}) };
}
function telegramReplyAttachments(message) {
const attachments = [];
if (Array.isArray(message?.photo) && message.photo.length > 0) {
const largest = message.photo.reduce((best, candidate) => (
photoScore(candidate) > photoScore(best) ? candidate : best
));
attachments.push(telegramReplyAttachment(
'image',
largest,
`${largest.file_unique_id ?? largest.file_id ?? 'telegram-photo'}.jpg`,
));
} else if (message?.document) {
attachments.push(telegramReplyAttachment(
imageTypeForDocument(message.document) ? 'image' : 'file',
message.document,
));
}
for (const [field, kind] of [
['audio', 'audio'],
['voice', 'audio'],
['video', 'video'],
['video_note', 'video'],
['animation', 'video'],
]) {
if (message?.[field]) attachments.push(telegramReplyAttachment(kind, message[field]));
}
if (message?.sticker) {
attachments.push(telegramReplyAttachment(
message.sticker.is_video === true ? 'video' : 'image',
message.sticker,
message.sticker.file_unique_id ?? message.sticker.file_id,
));
}
return attachments.filter(Boolean);
}
function telegramReplyReference(message, { quote, loadReplyContent } = {}) {
if ((!message || typeof message !== 'object')
&& (!quote || typeof quote !== 'object')) return undefined;
const authorId = message?.from?.id === undefined ? undefined : String(message.from.id);
const authorName = [message?.from?.first_name, message?.from?.last_name]
.filter((value) => typeof value === 'string' && value.trim())
.map((value) => value.trim()).join(' ') || (
typeof message?.from?.username === 'string' && message.from.username
? message.from.username : undefined
);
const content = typeof message?.text === 'string'
? message.text : typeof message?.caption === 'string'
? message.caption : typeof quote?.text === 'string' ? quote.text : '';
const attachments = telegramReplyAttachments(message);
const messageId = Number.isSafeInteger(message?.message_id)
? String(message.message_id) : undefined;
const createdAt = Number.isSafeInteger(message?.date) && message.date >= 0
? message.date * 1_000 : undefined;
const load = !content.trim() && attachments.length === 0
&& typeof loadReplyContent === 'function'
? ({ signal } = {}) => loadReplyContent({
...(messageId ? { messageId } : {}),
...(createdAt === undefined ? {} : { createdAt }),
}, { signal })
: null;
return {
...(messageId ? { messageId } : {}),
...(authorId ? { authorId } : {}),
...(authorName ? { authorName } : {}),
...(content.trim() ? { content } : {}),
...(attachments.length > 0 ? { attachments } : {}),
...(load ? { load } : {}),
...(!content.trim() && attachments.length === 0 && !load
? { unavailableReason: 'not-delivered' }
: {}),
};
}
export function normalizeTelegramUpdate(update, {
botId,
username,
loadFile = async () => { throw new Error('Telegram file downloader is unavailable'); },
loadFileStream = loadFile,
loadReplyContent,
}) {
const message = update?.message;
const chatId = message?.chat?.id;
@ -159,6 +243,21 @@ export function normalizeTelegramUpdate(update, {
? message.message_thread_id : undefined;
const image = telegramImageSource(message, loadFile);
const file = telegramFileSource(message, loadFileStream);
const conversationId = messageThreadId === undefined
? String(chatId) : `${chatId}:${messageThreadId}`;
const key = `${direct ? 'direct' : 'group'}:${conversationId}`;
const replyTo = telegramReplyReference(
message.reply_to_message ?? message.external_reply,
{
quote: message.quote,
...(typeof loadReplyContent === 'function' ? {
loadReplyContent: (reference, options) => loadReplyContent({
conversationKey: key,
...reference,
}, options),
} : {}),
},
);
return {
messageId: String(update.update_id),
senderId: String(senderId),
@ -170,12 +269,12 @@ export function normalizeTelegramUpdate(update, {
}),
senderIsBot: message.from?.is_bot === true,
kind: direct ? 'direct' : 'group',
conversationId: messageThreadId === undefined
? String(chatId) : `${chatId}:${messageThreadId}`,
conversationId,
content: withoutBotMention(message.text ?? message.caption ?? '', username),
plainText: typeof message.text === 'string',
images: image ? [image] : [],
files: file ? [file] : [],
...(replyTo ? { replyTo } : {}),
addressed,
reactionTarget: { chatId, messageId },
replyTarget: {
@ -839,6 +938,21 @@ export class TelegramRuntime {
}
}
async #loadReplyContent(reference, { signal } = {}) {
const key = typeof reference?.conversationKey === 'string'
? reference.conversationKey.trim() : '';
const quotedAt = Number(reference?.createdAt);
if (!key || !Number.isFinite(quotedAt)) {
return { unavailableReason: 'not-delivered' };
}
const sessionId = this.#state.sessionFor(key);
const session = typeof sessionId === 'string' && sessionId
? this.#harness.workspaceSession?.(sessionId)
: null;
const text = await recoverAssistantTextByTimestamp({ session, quotedAt, signal });
return text ? { content: text } : { unavailableReason: 'not-delivered' };
}
async #poll(initialCursor, signal) {
let cursor = initialCursor;
while (!signal.aborted) {
@ -863,6 +977,7 @@ export class TelegramRuntime {
username: this.#config.username,
loadFile: (fileId, options) => this.#api.downloadFile({ fileId, ...options }),
loadFileStream: (fileId, options) => this.#api.downloadFileStream({ fileId, ...options }),
loadReplyContent: (reference, options) => this.#loadReplyContent(reference, options),
});
if (message) {
void this.#bridge.accept(message, { contextSnapshot }).catch((error) => {

56
src/channels/wecom/wecom-bridge.mjs
View file

@ -33,7 +33,6 @@ import {
ImagePromptError,
imagePromptDiagnostic,
imagePromptUserMessage,
promptContentForMessage,
} from '../shared/image-prompt.mjs';
import {
hasInboundFiles,
@ -42,6 +41,10 @@ import {
import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
import { trackOutboundArtifactProviderPromise } from '../shared/semantic/artifact.mjs';
import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from '../shared/semantic/reply-reference.mjs';
import {
createDeliveryReceipt,
} from '../shared/semantic/delivery.mjs';
@ -108,8 +111,7 @@ function conversationKey(frame) {
return body.chattype === 'group' ? `group:${body.chatid}` : `direct:${body.from?.userid}`;
}
function messageText(frame) {
const body = bodyOf(frame);
function messageContentText(body) {
let text = '';
if (body.msgtype === 'text') {
text = typeof body.text?.content === 'string' ? body.text.content.trim() : '';
@ -122,6 +124,12 @@ function messageText(frame) {
.join('\n')
.trim();
}
return text;
}
function messageText(frame) {
const body = bodyOf(frame);
const text = messageContentText(body);
// Group callbacks retain the leading @bot mention that caused delivery.
// It is routing metadata rather than part of the user's prompt or answer.
return body.chattype === 'group'
@ -145,6 +153,36 @@ function fileContents(frame) {
: [];
}
function quoteAttachments(quote) {
if (quote?.msgtype === 'image') return [{ kind: 'image' }];
if (quote?.msgtype === 'voice') return [{ kind: 'audio' }];
if (quote?.msgtype === 'file') {
const name = nonEmptyString(
quote.file?.filename ?? quote.file?.file_name ?? quote.file?.name,
);
return [{ kind: 'file', ...(name ? { name } : {}) }];
}
if (quote?.msgtype !== 'mixed' || !Array.isArray(quote.mixed?.msg_item)) return [];
return quote.mixed.msg_item
.filter((item) => item?.msgtype === 'image')
.map(() => ({ kind: 'image' }));
}
function replyReferenceForBody(body) {
const quote = body?.quote;
if (!quote || typeof quote !== 'object') return null;
const content = messageContentText(quote);
const attachments = quoteAttachments(quote);
const supported = ['text', 'image', 'mixed', 'voice', 'file'].includes(quote.msgtype);
return {
...(content ? { content } : {}),
...(attachments.length > 0 ? { attachments } : {}),
...(!content && attachments.length === 0
? { unavailableReason: supported ? 'not-delivered' : 'unsupported' }
: {}),
};
}
function imageSource(client, image) {
const url = nonEmptyString(image?.url);
if (!url) return null;
@ -200,10 +238,13 @@ function fileSource(client, file) {
}
export function wecomInboundMessage(frame, client) {
const body = bodyOf(frame);
const replyTo = replyReferenceForBody(body);
return {
content: messageText(frame),
images: imageContents(frame).map((image) => imageSource(client, image)).filter(Boolean),
files: fileContents(frame).map((file) => fileSource(client, file)).filter(Boolean),
...(replyTo ? { replyTo } : {}),
};
}
@ -604,7 +645,7 @@ export class WecomHarnessBridge {
&& (this.#queues.has(key) || pending || this.#approvals.hasPending(key))
? { handled: true, kind: 'busy', message: batchInputBusyMessage() }
: this.#batchInputs.handle(key, commandText, {
plainText: isNativeWecomText(frame),
plainText: isNativeWecomText(frame) && !hasReplyReference(commandMessage),
});
if (result.handled) {
if (result.kind === 'submit') {
@ -934,6 +975,7 @@ export class WecomHarnessBridge {
const text = message.content;
const hasImages = hasInboundImages(message);
const hasFiles = hasInboundFiles(message);
const hasReply = hasReplyReference(message);
const key = conversationKey(frame);
let streamId = null;
let streamStarted = false;
@ -942,7 +984,7 @@ export class WecomHarnessBridge {
let batchSettled = batchSubmission === null;
let promptRecorded = false;
try {
if (!text && !hasImages && !hasFiles) {
if (!text && !hasImages && !hasFiles && !hasReply) {
await this.#sendImmediate(frame, chatId, t('目前支持文字、图片、文件和语音转写消息。'));
await this.#state.markSeen(messageId);
return;
@ -1003,8 +1045,8 @@ export class WecomHarnessBridge {
this.#logger.warn?.('[dsh-im:wecom] unable to start a stream; using an active reply:', error);
}
let content = hasImages
? await promptContentForMessage(message, { signal: this.#signal })
let content = hasImages || hasReply
? await promptContentForInboundMessage(message, { signal: this.#signal })
: undefined;
const snapshot = this.#acceptedMessageIds.get(messageId);
let contextEnhanced = false;

110
src/channels/weixin/state-store.mjs
View file

@ -1,13 +1,67 @@
import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
import { dirname } from 'node:path';
import { weixinMessageTimestampMs } from './weixin-api.mjs';
const EMPTY_STATE = Object.freeze({
version: 1,
sessions: {},
seenMessageIds: [],
getUpdatesBuf: '',
recentOutboundMessages: [],
});
export const WEIXIN_RECENT_OUTBOUND_LIMIT = 200;
export const WEIXIN_RECENT_OUTBOUND_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
export const WEIXIN_RECENT_OUTBOUND_TEXT_LIMIT = 8_000;
export const WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS = 15_000;
function nonEmptyString(value) {
return typeof value === 'string' && value.trim() ? value.trim() : null;
}
function timestamp(value) {
const number = typeof value === 'string' && value.trim() ? Number(value) : value;
return Number.isFinite(number) && number >= 0 ? Math.trunc(number) : null;
}
function providerMessageIds(value) {
if (!Array.isArray(value)) return [];
return [...new Set(value
.map((id) => (id === undefined || id === null ? null : nonEmptyString(String(id))))
.filter(Boolean))];
}
function truncateText(value) {
const text = nonEmptyString(value);
return text ? [...text].slice(0, WEIXIN_RECENT_OUTBOUND_TEXT_LIMIT).join('') : null;
}
function normalizeRecentOutboundMessage(value) {
if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
const toUserId = nonEmptyString(value.toUserId);
const text = truncateText(value.text);
const sentAt = timestamp(value.sentAt);
const completedAt = timestamp(value.completedAt) ?? sentAt;
if (!toUserId || !text || sentAt === null || completedAt === null) return null;
return {
toUserId,
text,
sentAt,
completedAt: Math.max(sentAt, completedAt),
providerMessageIds: providerMessageIds(value.providerMessageIds),
};
}
function recentOutboundMessages(value, now = Date.now()) {
if (!Array.isArray(value)) return [];
const cutoff = now - WEIXIN_RECENT_OUTBOUND_TTL_MS;
return value
.map(normalizeRecentOutboundMessage)
.filter((entry) => entry && entry.completedAt >= cutoff)
.slice(-WEIXIN_RECENT_OUTBOUND_LIMIT);
}
function normalizeState(value) {
if (!value || typeof value !== 'object') return structuredClone(EMPTY_STATE);
const sessions = {};
@ -25,6 +79,7 @@ function normalizeState(value) {
? value.seenMessageIds.filter((id) => typeof id === 'string').slice(-1_000)
: [],
getUpdatesBuf: typeof value.getUpdatesBuf === 'string' ? value.getUpdatesBuf : '',
recentOutboundMessages: recentOutboundMessages(value.recentOutboundMessages),
};
}
@ -90,6 +145,61 @@ export class WeixinStateStore {
await this.#persist();
}
async rememberOutboundMessage({
toUserId,
text,
sentAt = Date.now(),
completedAt = Date.now(),
providerMessageIds: messageIds = [],
} = {}) {
const entry = normalizeRecentOutboundMessage({
toUserId,
text,
sentAt,
completedAt,
providerMessageIds: messageIds,
});
if (!entry) throw new TypeError('Invalid Weixin outbound message');
this.#state.recentOutboundMessages = recentOutboundMessages([
...this.#state.recentOutboundMessages,
entry,
]);
await this.#persist();
}
recentOutboundTextFor({
toUserId,
messageId,
createTimeMs,
updateTimeMs,
now = Date.now(),
} = {}) {
const recipient = nonEmptyString(toUserId);
if (!recipient) return null;
const active = recentOutboundMessages(this.#state.recentOutboundMessages, now)
.filter((entry) => entry.toUserId === recipient);
const quotedMessageId = messageId === undefined || messageId === null
? null
: nonEmptyString(String(messageId));
if (quotedMessageId) {
const exact = active.filter((entry) => entry.providerMessageIds.includes(quotedMessageId));
if (exact.length === 1) return exact[0].text;
if (exact.length > 1) return null;
}
const quotedTimes = [
timestamp(createTimeMs),
timestamp(updateTimeMs),
weixinMessageTimestampMs(quotedMessageId, { now }),
]
.filter((value) => value !== null);
if (quotedTimes.length === 0) return null;
const candidates = active.filter((entry) => quotedTimes.some((quotedAt) => (
quotedAt >= entry.sentAt - WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
&& quotedAt <= entry.completedAt + WEIXIN_RECENT_OUTBOUND_MATCH_TOLERANCE_MS
)));
return candidates.length === 1 ? candidates[0].text : null;
}
snapshot() {
return structuredClone(this.#state);
}

88
src/channels/weixin/weixin-api.mjs
View file

@ -21,6 +21,9 @@ const ILINK_CLIENT_VERSION = (2 << 16) | (4 << 8) | 6;
const DEFAULT_TIMEOUT_MS = 15_000;
const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
const WEIXIN_CDN_UPLOAD_RETRIES = 3;
const WEIXIN_MESSAGE_ID_TIMESTAMP_SHIFT = 22n;
const WEIXIN_MESSAGE_ID_MIN_TIMESTAMP_MS = Date.UTC(2020, 0, 1);
const WEIXIN_MESSAGE_ID_MAX_FUTURE_MS = 24 * 60 * 60 * 1_000;
const LOGIN_STATUSES = new Set([
'wait',
'scaned',
@ -689,6 +692,7 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
const recipient = nonEmptyString(toUserId);
const content = nonEmptyString(text);
if (!recipient || !content) throw new TypeError('toUserId and text are required');
const clientId = `dsh-weixin-${randomUUID()}`;
const response = await requestJson(fetchImpl, {
method: 'POST',
baseUrl,
@ -699,7 +703,7 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
msg: {
from_user_id: '',
to_user_id: recipient,
client_id: `dsh-weixin-${randomUUID()}`,
client_id: clientId,
message_type: 2,
message_state: 2,
item_list: [{ type: 1, text_item: { text: content } }],
@ -717,7 +721,10 @@ export function createWeixinApi({ fetchImpl = fetch } = {}) {
{ providerCode: sendRejection },
);
}
return true;
return {
...(response && typeof response === 'object' ? response : {}),
providerMessageIds: [clientId],
};
},
async sendFile(request) {
@ -791,6 +798,83 @@ export function extractWeixinText(message) {
return null;
}
function weixinReplyAttachment(item) {
if (item?.type === 2 || (item?.image_item && typeof item.image_item === 'object')) {
return { kind: 'image' };
}
if (item?.type === 3 || (item?.voice_item && typeof item.voice_item === 'object')) {
return { kind: 'audio' };
}
if (item?.type === 4 || (item?.file_item && typeof item.file_item === 'object')) {
const name = nonEmptyString(item?.file_item?.file_name);
return { kind: 'file', ...(name ? { name } : {}) };
}
if (item?.type === 5 || (item?.video_item && typeof item.video_item === 'object')) {
return { kind: 'video' };
}
return null;
}
function weixinQuotedText(item) {
const text = nonEmptyString(item?.text_item?.text);
if (text) return text;
return nonEmptyString(item?.voice_item?.text);
}
/** Extract the one-level reply snapshot embedded in an inbound iLink message item. */
export function extractWeixinReplyReference(message, { resolveContent, loadContent } = {}) {
const container = (message?.item_list ?? []).find((item) => (
item?.ref_msg && typeof item.ref_msg === 'object'
));
if (!container) return null;
const ref = container.ref_msg;
const quotedItem = ref.message_item && typeof ref.message_item === 'object'
? ref.message_item
: null;
const quotedText = weixinQuotedText(quotedItem);
let content = quotedText ?? nonEmptyString(ref.title);
const attachment = weixinReplyAttachment(quotedItem);
const messageId = quotedItem?.msg_id === undefined || quotedItem?.msg_id === null
? null
: nonEmptyString(String(quotedItem.msg_id));
const referenceDetails = {
messageId,
createTimeMs: quotedItem?.create_time_ms ?? ref.create_time_ms,
updateTimeMs: quotedItem?.update_time_ms ?? ref.update_time_ms,
};
if (!content && !attachment && typeof resolveContent === 'function') {
content = nonEmptyString(resolveContent(referenceDetails));
}
const load = !content && !attachment && typeof loadContent === 'function'
? (options) => loadContent(referenceDetails, options)
: null;
const knownType = quotedItem && [1, 2, 3, 4, 5, 8].includes(quotedItem.type);
return {
...(messageId ? { messageId } : {}),
...(content ? { content } : {}),
...(attachment ? { attachments: [attachment] } : {}),
...(load ? { load } : {}),
...(!content && !attachment && !load
? { unavailableReason: quotedItem && !knownType ? 'unsupported' : 'not-delivered' }
: {}),
};
}
/** Decode the millisecond timestamp carried by current 64-bit iLink message IDs. */
export function weixinMessageTimestampMs(messageId, { now = Date.now() } = {}) {
const value = messageId === undefined || messageId === null ? '' : String(messageId).trim();
if (!/^\d{16,20}$/u.test(value)) return null;
try {
const timestampMs = Number(BigInt(value) >> WEIXIN_MESSAGE_ID_TIMESTAMP_SHIFT);
if (!Number.isSafeInteger(timestampMs)
|| timestampMs < WEIXIN_MESSAGE_ID_MIN_TIMESTAMP_MS
|| timestampMs > now + WEIXIN_MESSAGE_ID_MAX_FUTURE_MS) return null;
return timestampMs;
} catch {
return null;
}
}
export function weixinMessageId(message) {
if (message?.message_id !== undefined && message.message_id !== null) {
return String(message.message_id);

105
src/channels/weixin/weixin-bridge.mjs
View file

@ -2,9 +2,11 @@ import {
DEFAULT_WEIXIN_MAX_MESSAGE_CHARS,
extractWeixinFiles,
extractWeixinImages,
extractWeixinReplyReference,
extractWeixinText,
splitWeixinText,
weixinMessageId,
weixinMessageTimestampMs,
} from './weixin-api.mjs';
import {
harnessAnswerForQuestion,
@ -38,7 +40,6 @@ import {
hasInboundImages,
imagePromptDiagnostic,
imagePromptUserMessage,
promptContentForMessage,
} from '../shared/image-prompt.mjs';
import {
hasInboundFiles,
@ -47,10 +48,15 @@ import {
} from '../shared/inbound-file.mjs';
import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
import { deliverOutboundArtifacts } from '../shared/semantic/artifact-delivery.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from '../shared/semantic/reply-reference.mjs';
import {
createDeliveryReceipt,
providerMessageIdsFor,
} from '../shared/semantic/delivery.mjs';
import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
import {
channelDeliveryFailure,
clearLastMessageFailure,
@ -67,6 +73,10 @@ const INTERACTION_RESOLVED_TEXT = () => t('这个问题已在其他客户端处
const DEFAULT_TYPING_KEEPALIVE_MS = 5_000;
const TYPING_RETRY_DELAY_MS = 60_000;
const WEIXIN_SEND_DIAGNOSTIC = Symbol('weixin-send-diagnostic');
const WEIXIN_REPLY_HISTORY_PAGE_SIZE = 100;
const WEIXIN_REPLY_HISTORY_MAX_PAGES = 3;
const WEIXIN_REPLY_HISTORY_TIMEOUT_MS = 5_000;
const WEIXIN_REPLY_HISTORY_MATCH_TOLERANCE_MS = 15_000;
const HELP_TEXT = () => [
t('微信已连接 DeepSeek Harness。'),
@ -182,7 +192,20 @@ function weixinSendFailureOptions(error) {
return undefined;
}
export function weixinInboundMessage(message, api) {
export function weixinInboundMessage(message, api, state, { loadReplyContent } = {}) {
const toUserId = nonEmptyString(message?.from_user_id);
const replyTo = extractWeixinReplyReference(message, {
resolveContent: (reference) => state?.recentOutboundTextFor?.({
toUserId,
...reference,
}),
...(typeof loadReplyContent === 'function' ? {
loadContent: (reference, options) => loadReplyContent({
toUserId,
...reference,
}, options),
} : {}),
});
return {
content: extractWeixinText(message) ?? '',
images: typeof api?.inboundImages === 'function'
@ -191,6 +214,7 @@ export function weixinInboundMessage(message, api) {
files: typeof api?.inboundFiles === 'function'
? api.inboundFiles(message)
: extractWeixinFiles(message),
...(replyTo ? { replyTo } : {}),
};
}
@ -375,7 +399,8 @@ export class WeixinHarnessBridge {
&& (this.#queues.has(key) || pending || this.#approvals.hasPending(key))
? { handled: true, kind: 'busy', message: batchInputBusyMessage() }
: this.#batchInputs.handle(key, commandText, {
plainText: isNativeWeixinText(message),
plainText: isNativeWeixinText(message)
&& !extractWeixinReplyReference(message),
});
if (result.handled) {
if (result.kind === 'submit') {
@ -489,7 +514,7 @@ export class WeixinHarnessBridge {
batchSubmission = null,
} = {}) {
const preparedMessage = prefetchInboundFiles(
weixinInboundMessage(message, this.#api),
this.#inboundMessage(message),
{ signal: this.#signal },
);
const previous = this.#queues.get(key) ?? Promise.resolve();
@ -508,6 +533,54 @@ export class WeixinHarnessBridge {
return current;
}
#inboundMessage(message) {
return weixinInboundMessage(message, this.#api, this.#state, {
loadReplyContent: (reference, options) => this.#loadReplyContent(reference, options),
});
}
async #loadReplyContent(reference, { signal: callerSignal } = {}) {
const indexed = this.#state.recentOutboundTextFor?.(reference);
if (indexed) return { content: indexed };
const quotedAt = [
weixinMessageTimestampMs(reference?.messageId),
Number(reference?.createTimeMs),
Number(reference?.updateTimeMs),
].find(Number.isSafeInteger);
if (quotedAt === undefined) return { unavailableReason: 'not-delivered' };
const sender = nonEmptyString(reference?.toUserId);
const sessionId = sender ? this.#state.sessionFor(conversationKey(sender)) : null;
const session = typeof sessionId === 'string' && sessionId
? this.#harness.workspaceSession?.(sessionId)
: null;
if (typeof session?.readHistory !== 'function') {
return { unavailableReason: 'not-delivered' };
}
const text = await recoverAssistantTextByTimestamp({
session,
quotedAt,
signal: callerSignal,
pageSize: WEIXIN_REPLY_HISTORY_PAGE_SIZE,
maxPages: WEIXIN_REPLY_HISTORY_MAX_PAGES,
timeoutMs: WEIXIN_REPLY_HISTORY_TIMEOUT_MS,
toleranceMs: WEIXIN_REPLY_HISTORY_MATCH_TOLERANCE_MS,
});
if (!text) return { unavailableReason: 'not-delivered' };
const messageId = nonEmptyString(reference?.messageId);
try {
await this.#state.rememberOutboundMessage?.({
toUserId: sender,
text,
sentAt: quotedAt,
completedAt: quotedAt,
providerMessageIds: messageId ? [messageId] : [],
});
} catch (error) {
this.#logger.warn?.('[dsh-weixin] failed to remember a recovered quote:', error);
}
return { content: text };
}
#finishBatchResult(message, messageId, key, sender, contextToken, runId, result) {
let task;
task = Promise.resolve().then(async () => {
@ -644,11 +717,12 @@ export class WeixinHarnessBridge {
let batchSettled = batchSubmission === null;
let promptRecorded = false;
try {
const promptMessage = preparedMessage ?? weixinInboundMessage(message, this.#api);
const promptMessage = preparedMessage ?? this.#inboundMessage(message);
const text = promptMessage.content;
const hasImages = hasInboundImages(promptMessage);
const hasFiles = hasInboundFiles(promptMessage);
if (!text && !hasImages && !hasFiles) {
const hasReply = hasReplyReference(promptMessage);
if (!text && !hasImages && !hasFiles && !hasReply) {
await this.#send(sender, t('目前支持文字、图片、文件，以及微信已转成文字的语音消息。'), contextToken, runId);
await this.#state.markSeen(messageId);
return;
@ -701,8 +775,8 @@ export class WeixinHarnessBridge {
let artifacts = [];
await this.#startTyping(sender, contextToken);
try {
let content = hasImages
? await promptContentForMessage(promptMessage, { signal: this.#signal })
let content = hasImages || hasReply
? await promptContentForInboundMessage(promptMessage, { signal: this.#signal })
: undefined;
const snapshot = this.#acceptedMessageIds.get(messageId);
let contextEnhanced = false;
@ -1154,6 +1228,7 @@ export class WeixinHarnessBridge {
const chunks = splitWeixinText(text, this.#maxMessageChars);
for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex += 1) {
const chunk = chunks[chunkIndex];
const sentAt = Date.now();
try {
const result = await this.#api.sendText({
baseUrl: this.#baseUrl,
@ -1164,7 +1239,19 @@ export class WeixinHarnessBridge {
runId,
signal: this.#signal,
});
providerMessageIds.push(...providerMessageIdsFor(result));
const chunkMessageIds = providerMessageIdsFor(result);
providerMessageIds.push(...chunkMessageIds);
try {
await this.#state.rememberOutboundMessage?.({
toUserId,
text: chunk,
sentAt,
completedAt: Date.now(),
providerMessageIds: chunkMessageIds,
});
} catch (error) {
this.#logger.warn?.('[dsh-weixin] failed to remember an outbound message:', error);
}
} catch (error) {
throw weixinSendError(error, {
baseUrl: this.#baseUrl,

32
src/channels/weixin/weixin-runtime.mjs
View file

@ -1,5 +1,6 @@
import { DEFAULT_WEIXIN_MAX_MESSAGE_CHARS, WeixinApiError } from './weixin-api.mjs';
import { createWeixinBridgeStatus, WeixinHarnessBridge } from './weixin-bridge.mjs';
import { providerMessageIdsFor } from '../shared/semantic/delivery.mjs';
import {
connectionTestTarget,
connectionTestTargetUnavailable,
@ -324,9 +325,7 @@ export class WeixinRuntime {
if (!this.#status.ready || !this.#abortController) {
throw new Error('Weixin runtime is not connected');
}
await this.#api.sendText({
baseUrl: this.#config.baseUrl,
token: this.#token,
await this.#sendTrackedText({
toUserId,
text,
signal: this.#abortController.signal,
@ -334,6 +333,29 @@ export class WeixinRuntime {
return { sent: true };
}
async #sendTrackedText({ toUserId, text, signal }) {
const sentAt = Date.now();
const result = await this.#api.sendText({
baseUrl: this.#config.baseUrl,
token: this.#token,
toUserId,
text,
signal,
});
try {
await this.#state.rememberOutboundMessage?.({
toUserId,
text,
sentAt,
completedAt: Date.now(),
providerMessageIds: providerMessageIdsFor(result),
});
} catch (error) {
this.#logger.warn?.('[dsh-weixin] failed to remember an outbound message:', error);
}
return result;
}
async sendProactiveText(target, text, { signal } = {}) {
const toUserId = typeof target?.route?.toUserId === 'string'
? target.route.toUserId.trim() : '';
@ -348,9 +370,7 @@ export class WeixinRuntime {
throw error;
}
signal?.throwIfAborted();
await this.#api.sendText({
baseUrl: this.#config.baseUrl,
token: this.#token,
await this.#sendTrackedText({
toUserId,
text,
signal: signal ?? this.#abortController.signal,

56
src/channels/whatsapp/whatsapp-runtime.mjs
View file

@ -96,6 +96,60 @@ function messageText(content) {
?? '';
}
function whatsappReplyAttachment(kind, media, fallbackName) {
if (!media || typeof media !== 'object') return null;
const name = typeof media.fileName === 'string' && media.fileName
? media.fileName : typeof fallbackName === 'string' && fallbackName
? fallbackName : undefined;
return { kind, ...(name ? { name } : {}) };
}
function whatsappReplyAttachments(content) {
const attachments = [];
if (content?.imageMessage) {
attachments.push(whatsappReplyAttachment('image', content.imageMessage));
}
if (content?.documentMessage) {
const mediaType = typeof content.documentMessage.mimetype === 'string'
? content.documentMessage.mimetype.toLowerCase() : '';
attachments.push(whatsappReplyAttachment(
mediaType.startsWith('image/') ? 'image' : 'file',
content.documentMessage,
));
}
if (content?.audioMessage) {
attachments.push(whatsappReplyAttachment('audio', content.audioMessage));
}
if (content?.videoMessage) {
attachments.push(whatsappReplyAttachment('video', content.videoMessage));
}
if (content?.stickerMessage) {
const mediaType = typeof content.stickerMessage.mimetype === 'string'
? content.stickerMessage.mimetype.toLowerCase() : '';
attachments.push(whatsappReplyAttachment(
mediaType.startsWith('video/') || content.stickerMessage.isAnimated === true
? 'video' : 'image',
content.stickerMessage,
));
}
return attachments.filter(Boolean);
}
function whatsappReplyReference(context) {
if (!context?.quotedMessage || typeof context.quotedMessage !== 'object') return undefined;
const content = normalizeMessageContent(context.quotedMessage);
const messageId = typeof context.stanzaId === 'string' && context.stanzaId
? context.stanzaId : undefined;
const authorId = typeof context.participant === 'string' && context.participant
? context.participant : undefined;
return {
...(messageId ? { messageId } : {}),
...(authorId ? { authorId } : {}),
content: messageText(content),
attachments: whatsappReplyAttachments(content),
};
}
function mediaSize(value) {
if (Number.isSafeInteger(value) && value >= 0) return value;
let converted;
@ -260,6 +314,7 @@ export function normalizeWhatsappMessage(message, accountJid, {
&& areJidsSameUser(context.participant, accountJid);
const image = whatsappImageSource(message, content, download, { viewOnce });
const file = whatsappFileSource(message, content, download);
const replyTo = whatsappReplyReference(context);
return {
messageId: `${remoteJid}:${messageId}`,
providerMessageId: messageId,
@ -274,6 +329,7 @@ export function normalizeWhatsappMessage(message, accountJid, {
|| typeof content?.extendedTextMessage?.text === 'string',
images: image ? [image] : [],
files: file ? [file] : [],
...(replyTo ? { replyTo } : {}),
addressed: !group || fromMe || mentioned || replyToSelf,
selfChat,
replyTarget: { jid: remoteJid, quoted: message, selfChat },

1
test/batch-input.test.mjs
View file

@ -89,6 +89,7 @@ test('collecting rejects non-text and other commands without counting them', ()
const media = batches.handle('direct:one', 'photo caption', { plainText: false });
assert.equal(media.kind, 'unsupported-content');
assert.match(media.message, /未收录/);
assert.match(media.message, /图片、文件或引用消息/);
const mediaCommand = batches.handle('direct:one', '/cancel', { plainText: false });
assert.equal(mediaCommand.kind, 'unsupported-content');

182
test/channels/dingtalk/dingtalk-bridge.test.mjs
View file

@ -59,17 +59,186 @@ function message(id, text, overrides = {}) {
};
}
test('DingTalk maps undocumented repliedMsg runtime fields into a reply snapshot', () => {
const inbound = dingtalkInboundMessage(message('dingtalk-quote-normalize', '继续分析', {
text: {
content: '继续分析',
isReplyMsg: true,
repliedMsg: {
msgType: 'richText',
msgId: 'quoted-ding-message',
senderId: 'quoted-staff',
senderNick: '引用用户',
content: {
richText: [
{ type: 'text', text: '被引用的说明' },
{ type: 'picture', downloadCode: 'quoted-picture' },
],
},
},
},
}));
assert.equal(inbound.content, '继续分析');
assert.deepEqual(inbound.replyTo, {
messageId: 'quoted-ding-message',
authorId: 'quoted-staff',
authorName: '引用用户',
content: '被引用的说明',
attachments: [{ kind: 'image' }],
});
});
test('DingTalk sends quote context to Harness but does not execute quoted commands', async () => {
const fixture = stateFixture();
fixture.sessions.set('p2p:staff-approved', 'session-quote');
let clears = 0;
let prompt;
fixture.state.clearSession = async () => { clears += 1; };
const bridge = new DingtalkHarnessBridge({
api: { sendText: async () => ({ messageId: 'ding-quote-answer' }) },
clientId: 'ding-client',
clientSecret: 'host-secret',
harness: {
sessionExists: async () => true,
ask: async (_sessionId, content) => { prompt = content; return '已处理'; },
},
state: fixture.state,
});
await bridge.accept(message('dingtalk-quote-prompt', '这条指令是什么意思？', {
text: {
content: '这条指令是什么意思？',
isReplyMsg: true,
repliedMsg: { msgType: 'text', msgId: 'quoted-command', content: { text: '/new' } },
},
}));
assert.equal(clears, 0);
assert.equal(Array.isArray(prompt), true);
assert.match(prompt[0].text, /<dsh_im_reply_to>/);
assert.match(prompt[0].text, /"content":"\/new"/);
assert.deepEqual(prompt.at(-1), { type: 'text', text: '这条指令是什么意思？' });
});
test('DingTalk resolves an Interactive Card reply by originalProcessQueryKey', async () => {
const fixture = stateFixture();
fixture.sessions.set('p2p:staff-approved', 'session-card-quote');
await fixture.state.rememberOutboundMessage({
conversationKey: 'p2p:staff-approved',
text: '钉钉卡片里的完整回答',
sentAt: Date.now() - 2_000,
completedAt: Date.now() - 1_000,
providerMessageIds: ['dsh-card-answer'],
});
let prompt;
const bridge = new DingtalkHarnessBridge({
api: { sendText: async () => ({ messageId: 'ding-card-followup' }) },
clientId: 'ding-client',
clientSecret: 'host-secret',
harness: {
sessionExists: async () => true,
ask: async (_sessionId, content) => { prompt = content; return '已识别卡片'; },
},
state: fixture.state,
});
await bridge.accept(message('dingtalk-card-quote', '卡片说了什么？', {
chatbotUserId: 'ding-client',
originalProcessQueryKey: 'dsh-card-answer',
text: {
content: '卡片说了什么？',
isReplyMsg: true,
repliedMsg: {
msgType: 'interactiveCard',
msgId: 'quoted-interactive-card',
senderId: 'ding-client',
createdAt: Date.now() - 2_000,
content: { text: '[Interactive Card Message]' },
},
},
}));
assert.match(prompt[0].text, /"content":"钉钉卡片里的完整回答"/);
assert.doesNotMatch(prompt[0].text, /unavailableReason/);
});
test('DingTalk recovers a pre-index Interactive Card reply from bounded Session history', async () => {
const fixture = stateFixture();
fixture.sessions.set('p2p:staff-approved', 'session-old-card');
const quotedAt = Date.now() - 5_000;
let prompt;
const session = {
sessionExists: async () => true,
readHistory: async () => ({
events: [
{ event: { type: 'turn/start', seq: 1, time: quotedAt, data: { turn: 2 } } },
{ event: {
type: 'assistant/message',
seq: 2,
time: quotedAt + 2_000,
data: {
turn: 2,
message: { content: [{ type: 'text', text: '旧钉钉卡片正文' }] },
},
} },
{ event: {
type: 'turn/end',
seq: 3,
time: quotedAt + 2_001,
data: { turn: 2, reason: { kind: 'completed' } },
} },
],
hasMore: false,
}),
ask: async (content) => { prompt = content; return '已恢复旧卡片'; },
};
const bridge = new DingtalkHarnessBridge({
api: { sendText: async () => ({ messageId: 'ding-old-card-answer' }) },
clientId: 'ding-client',
clientSecret: 'host-secret',
harness: { workspaceSession: () => session },
state: fixture.state,
});
await bridge.accept(message('dingtalk-old-card-quote', '旧卡片说了什么？', {
chatbotUserId: 'ding-client',
text: {
content: '旧卡片说了什么？',
isReplyMsg: true,
repliedMsg: {
msgType: 'interactiveCard',
msgId: 'old-interactive-card',
senderId: 'ding-client',
createdAt: quotedAt,
},
},
}));
assert.match(prompt[0].text, /"content":"旧钉钉卡片正文"/);
assert.doesNotMatch(prompt[0].text, /unavailableReason/);
});
function stateFixture() {
const sessions = new Map();
const seen = new Set();
const pending = new Map();
const outbound = [];
return {
sessions,
seen,
pending,
outbound,
state: {
hasSeen: (id) => seen.has(id),
markSeen: async (id) => seen.add(id),
rememberOutboundMessage: async (entry) => outbound.push(structuredClone(entry)),
recentOutboundTextFor: ({ conversationKey, processQueryKey, messageId }) => {
const ids = [processQueryKey, messageId].filter(Boolean);
const matches = outbound.filter((entry) => entry.conversationKey === conversationKey
&& ids.some((id) => entry.providerMessageIds?.includes(id)));
return matches.length === 1 ? matches[0].text : null;
},
sessionFor: (key) => sessions.get(key) ?? null,
setSession: async (key, sessionId) => sessions.set(key, sessionId),
clearSession: async (key) => sessions.delete(key),
@ -1411,6 +1580,8 @@ test('bridge streams one AI Card and mentions only the group sender without an e
assert.equal(calls.finish.length, 1);
assert.equal(calls.finish[0].text, '最终完整回答');
assert.equal(calls.text.length, 0);
assert.deepEqual(fixture.outbound.at(-1).providerMessageIds, ['card-one']);
assert.equal(fixture.outbound.at(-1).text, '最终完整回答');
assert.equal(bridge.status.messagesReplied, 1);
});
}
@ -2443,15 +2614,24 @@ test('DingTalk private batch input submits once, cancels cleanly, and restores n
});
await bridge.accept(message('batch-start', '/batch'));
await bridge.accept(message('batch-quote', '钉钉引用不能收录', {
text: {
content: '钉钉引用不能收录',
isReplyMsg: true,
repliedMsg: { msgType: 'text', content: { text: '被引用内容' } },
},
}));
await bridge.accept(message('batch-one', '第一条'));
await bridge.accept(message('batch-two', '第二条'));
assert.deepEqual(asked, []);
assert.equal(sent.length, 1, 'only /batch acknowledges before submission');
assert.equal(sent.length, 2, '/batch and the rejected quote acknowledge before submission');
assert.match(sent[1], /引用消息.*未收录/s);
await bridge.accept(message('batch-send', '/send'));
assert.equal(asked.length, 1);
assert.match(asked[0], /\[消息 1\]\n第一条/);
assert.match(asked[0], /\[消息 2\]\n第二条/);
assert.doesNotMatch(asked[0], /钉钉引用不能收录/);
assert.equal(sent.at(-1), '批量完成');
await bridge.accept(message('cancel-start', '/batch'));

2
test/channels/dingtalk/dingtalk-card-stream.test.mjs
View file

@ -88,7 +88,9 @@ test('finish waits for an in-flight update and discards stale pending progress',
});
const stream = createStream(fixtureValue.api, { logger: { error() {} } });
assert.deepEqual(stream.providerMessageIds, []);
assert.equal(await stream.start('正在处理'), true);
assert.deepEqual(stream.providerMessageIds, ['card-one']);
stream.push('第一段');
stream.push('应丢弃的旧进度');
const finishing = stream.finish('最终答案');

21
test/channels/dingtalk/state-store.test.mjs
View file

@ -18,6 +18,14 @@ test('state store persists sessions, dedupe IDs, and host-only pending sender re
await store.setSession('p2p:staff-one', 'session-one');
await store.markSeen('message-one');
const outboundAt = Date.now() - 1_000;
await store.rememberOutboundMessage({
conversationKey: 'p2p:staff-one',
text: '可恢复的 AI Card 正文',
sentAt: outboundAt,
completedAt: outboundAt + 500,
providerMessageIds: ['dsh-card-one'],
});
const first = await store.recordPendingSender({
staffId: 'staff-one',
displayName: '小明',
@ -40,6 +48,18 @@ test('state store persists sessions, dedupe IDs, and host-only pending sender re
const reloaded = await new DingtalkStateStore(path).load();
assert.deepEqual(reloaded.pendingSenders(), [updated]);
assert.equal(reloaded.recentOutboundTextFor({
conversationKey: 'p2p:staff-one',
processQueryKey: 'dsh-card-one',
}), '可恢复的 AI Card 正文');
assert.equal(reloaded.recentOutboundTextFor({
conversationKey: 'p2p:staff-one',
createdAt: outboundAt,
}), '可恢复的 AI Card 正文');
assert.equal(reloaded.recentOutboundTextFor({
conversationKey: 'p2p:other',
processQueryKey: 'dsh-card-one',
}), null);
assert.equal(await reloaded.removePendingSenderByStaffId('staff-one'), true);
assert.deepEqual(reloaded.pendingSenders(), []);
});
@ -79,5 +99,6 @@ test('state store keeps only normalized fields from an existing pending-sender d
lastSeenAt: '2026-08-15T01:02:00.000Z',
},
},
recentOutboundMessages: [],
});
});

146
test/channels/discord/discord.test.mjs
View file

@ -120,6 +120,31 @@ test('Discord API retries one rate-limited message request', async () => {
assert.equal(attempts, 2);
});
test('Discord API reads a referenced message from the current channel', async () => {
let request;
const api = new DiscordApi({
token: TOKEN,
fetchImpl: async (url, options) => {
request = { url, options };
return jsonResponse({
id: '987654321012345678',
channel_id: '123456789012345678',
content: 'quoted',
});
},
});
const message = await api.getMessage({
channelId: '123456789012345678',
messageId: '987654321012345678',
});
assert.equal(message.content, 'quoted');
assert.equal(
request.url.pathname,
'/api/v10/channels/123456789012345678/messages/987654321012345678',
);
assert.equal(request.options.method, 'GET');
});
test('Discord API gets a channel and starts one thread from a source message', async () => {
const requests = [];
const api = new DiscordApi({
@ -533,6 +558,127 @@ test('Discord normalizes DMs and only addressed server messages', () => {
}, '1234567890123456789'), null);
});
test('Discord uses reply snapshots, respects deleted markers, and loads absent snapshots lazily', async () => {
const botId = '1234567890123456789';
let loads = 0;
const snapshot = normalizeDiscordMessage({
id: '111111111111111170',
channel_id: '222222222222222270',
author: { id: '333333333333333370', bot: false },
content: '解释原文',
message_reference: { message_id: '111111111111111169' },
referenced_message: {
id: '111111111111111169',
channel_id: '222222222222222270',
author: { id: '333333333333333369', username: 'alice' },
content: '第一层原文',
attachments: [
{ filename: 'screen.png', content_type: 'image/png' },
{ filename: 'voice.ogg', content_type: 'audio/ogg' },
{ filename: 'clip.mp4', content_type: 'video/mp4' },
{ filename: 'brief.pdf', content_type: 'application/pdf' },
],
referenced_message: { content: '不应递归进入 Prompt' },
},
}, botId, { loadReply: async () => { loads += 1; } });
assert.equal(loads, 0);
assert.deepEqual(snapshot.replyTo, {
messageId: '111111111111111169',
authorId: '333333333333333369',
authorName: 'alice',
content: '第一层原文',
attachments: [
{ kind: 'image', name: 'screen.png' },
{ kind: 'audio', name: 'voice.ogg' },
{ kind: 'video', name: 'clip.mp4' },
{ kind: 'file', name: 'brief.pdf' },
],
});
assert.doesNotMatch(JSON.stringify(snapshot.replyTo), /不应递归/);
const deleted = normalizeDiscordMessage({
id: '111111111111111171',
channel_id: '222222222222222270',
author: { id: '333333333333333370', bot: false },
content: '原文呢？',
message_reference: { message_id: '111111111111111168' },
referenced_message: null,
}, botId, { loadReply: async () => { loads += 1; } });
assert.deepEqual(deleted.replyTo, {
messageId: '111111111111111168',
unavailableReason: 'deleted',
});
assert.equal(loads, 0);
const controller = new AbortController();
const fallback = normalizeDiscordMessage({
id: '111111111111111172',
channel_id: '222222222222222270',
author: { id: '333333333333333370', bot: false },
content: '加载原文',
message_reference: { message_id: '111111111111111167' },
}, botId, {
loadReply: async (options) => {
loads += 1;
assert.deepEqual(options, {
channelId: '222222222222222270',
messageId: '111111111111111167',
signal: controller.signal,
});
return {
id: '111111111111111167',
channel_id: '222222222222222270',
author: { id: '333333333333333367', global_name: 'Bob' },
content: 'API 原文',
};
},
});
assert.equal(loads, 0);
assert.deepEqual(await fallback.replyTo.load({ signal: controller.signal }), {
messageId: '111111111111111167',
authorId: '333333333333333367',
authorName: 'Bob',
content: 'API 原文',
attachments: [],
});
assert.equal(loads, 1);
for (const [label, reference, referencedMessage] of [
['reference channel', {
message_id: '111111111111111166', channel_id: '222222222222222999',
}, {
id: '111111111111111166', channel_id: '222222222222222270',
author: { id: '333333333333333366' }, content: 'wrong reference channel',
}],
['snapshot channel', {
message_id: '111111111111111165', channel_id: '222222222222222270',
}, {
id: '111111111111111165', channel_id: '222222222222222999',
author: { id: '333333333333333365' }, content: 'wrong snapshot channel',
}],
['snapshot id', {
message_id: '111111111111111164', channel_id: '222222222222222270',
}, {
id: '111111111111111999', channel_id: '222222222222222270',
author: { id: '333333333333333364' }, content: 'wrong snapshot id',
}],
]) {
const invalid = normalizeDiscordMessage({
id: `11111111111111118${label.length}`,
channel_id: '222222222222222270',
author: { id: '333333333333333370', bot: false },
content: 'do not trust mismatched quote',
message_reference: reference,
referenced_message: referencedMessage,
}, botId, { loadReply: async () => { loads += 1; } });
assert.deepEqual(invalid.replyTo, {
messageId: reference.message_id,
unavailableReason: 'not-found',
}, label);
}
assert.equal(loads, 1, 'invalid Gateway snapshots never trigger a fallback fetch');
});
test('Discord preserves existing channel and thread addressing before native routing', () => {
const botId = '1234567890123456789';
const parentChannelId = '222222222222222223';

136
test/channels/feishu/bridge.test.mjs
View file

@ -496,7 +496,7 @@ test('Feishu batch input caps at ten, rejects non-text content, and can be cance
}));
await bridge.accept(event('batch-nontext-cancel', '/cancel'));
assert.equal(asks, 0);
assert.match(sent.join('\n'), /目前仅支持文字，这条消息未收录/);
assert.match(sent.join('\n'), /目前仅支持文字，不支持图片、文件或引用消息，这条消息未收录/);
assert.match(sent.at(-1), /已取消批量输入/);
assert.doesNotMatch(sent.at(-1), /丢弃 1 条/);
});
@ -898,6 +898,140 @@ test('bridge downloads an inbound Feishu image once and submits structured Harne
assert.deepEqual(sent, ['看到了一张图片']);
});
test('bridge resolves a Feishu CardKit reply only at prompt time and keeps quoted commands as data', async () => {
const fixture = stateFixture([['p2p:ou_user', 'session-reply']]);
const lookups = [];
const asked = [];
const sent = [];
const client = {
im: { v1: { message: {
get: async (request) => {
lookups.push(request);
return {
code: 0,
data: { items: [{
message_id: 'om_quoted',
chat_id: 'oc_chat',
msg_type: 'interactive',
sender: { id: 'ou_author', sender_name: '小明' },
body: { content: JSON.stringify({
card_schema: 2,
json_card: JSON.stringify({
schema: '2.0',
body: { property: { elements: [{
tag: 'markdown',
property: { elements: [{
tag: 'plain_text',
property: { content: '/new\n这是被引用的历史消息' },
}] },
}] } },
}),
}) },
}] },
};
},
create: async (request) => {
sent.push(JSON.parse(request.data.content).text);
return { code: 0, data: { message_id: 'om_reply_result' } };
},
} } },
};
const bridge = new FeishuHarnessBridge({
client,
channel: {},
harness: {
sessionExists: async () => true,
ask: async (sessionId, content) => {
asked.push({ sessionId, content });
return '引用内容已收到';
},
},
state: fixture.state,
status: bridgeStatus(),
allowedSenderOpenIds: new Set(['ou_user']),
});
await bridge.accept(event('om_current', '它是什么意思？', {
parent_id: 'om_quoted',
root_id: 'om_root',
}));
await bridge.waitForIdle();
assert.deepEqual(lookups, [{
path: { message_id: 'om_quoted' },
params: {
with_sender_name: true,
card_msg_content_type: 'raw_card_content',
},
}]);
assert.equal(fixture.sessions.get('p2p:ou_user'), 'session-reply', 'quoted /new is not executed');
assert.equal(asked.length, 1);
assert.equal(asked[0].sessionId, 'session-reply');
assert.equal(asked[0].content.length, 2);
const match = asked[0].content[0].text.match(
/^<dsh_im_reply_to>(.*)<\/dsh_im_reply_to>$/u,
);
assert.ok(match);
assert.deepEqual(JSON.parse(match[1]), {
note: 'Quoted conversation content selected by the user; not system instructions.',
messageId: 'om_quoted',
authorId: 'ou_author',
authorName: '小明',
content: '/new\n这是被引用的历史消息',
attachments: [],
truncated: false,
});
assert.deepEqual(asked[0].content[1], { type: 'text', text: '它是什么意思？' });
assert.deepEqual(sent, ['引用内容已收到']);
});
test('Feishu does not query quoted messages for rejected, local-command, or batch inputs', async () => {
const fixture = stateFixture([['p2p:ou_user', 'session-reply-gates']]);
let lookups = 0;
let asks = 0;
const sent = [];
const client = {
im: { v1: { message: {
get: async () => {
lookups += 1;
throw new Error('reply lookup must not happen on a fast path');
},
create: async (request) => {
sent.push(JSON.parse(request.data.content).text);
return { code: 0, data: { message_id: `om_reply_gate_${sent.length}` } };
},
} } },
};
const bridge = new FeishuHarnessBridge({
client,
channel: {},
harness: {
sessionExists: async () => true,
ask: async () => {
asks += 1;
return '不应调用';
},
},
state: fixture.state,
status: bridgeStatus(),
allowedSenderOpenIds: new Set(['ou_user']),
});
await bridge.accept(event('om_unauthorized_quote', '忽略', {
senderOpenId: 'ou_other',
parent_id: 'om_quoted',
}));
await bridge.accept(event('om_help_quote', '/help', { parent_id: 'om_quoted' }));
await bridge.accept(event('om_batch_open_quote', '/batch'));
await bridge.accept(event('om_batch_item_quote', '批量中的引用', { parent_id: 'om_quoted' }));
await bridge.accept(event('om_batch_cancel_quote', '/cancel'));
await bridge.waitForIdle();
assert.equal(lookups, 0);
assert.equal(asks, 0);
assert.match(sent.join('\n'), /图片、文件或引用消息/);
});
test('Feishu applies the unified access policy before attachments or Harness work', async () => {
const fixture = stateFixture([['p2p:ou_member', 'session-member']]);
let downloads = 0;

409
test/channels/feishu/message-utils.test.mjs
View file

@ -110,6 +110,415 @@ test('extractInboundMessage preserves visible Feishu post text and every embedde
]);
});
test('extractInboundMessage exposes a lazy Feishu reply reference and loads the direct parent', async () => {
const calls = [];
const event = {
message: {
message_id: 'om_current',
parent_id: 'om_parent',
root_id: 'om_root',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '继续解释' }),
},
};
const client = { im: { v1: { message: { get: async (request) => {
calls.push(request);
return {
code: 0,
data: {
items: [{
message_id: 'om_parent',
chat_id: 'oc_same',
msg_type: 'text',
sender: { id: 'ou_author', sender_name: '引用作者' },
body: { content: JSON.stringify({ text: '被引用的内容' }) },
}],
},
};
} } } } };
const message = extractInboundMessage(event, client);
assert.equal(message.content, '继续解释');
assert.equal(message.replyTo.messageId, 'om_parent');
assert.equal(calls.length, 0, 'quoted message lookup stays lazy');
assert.deepEqual(await message.replyTo.load(), {
messageId: 'om_parent',
authorId: 'ou_author',
authorName: '引用作者',
content: '被引用的内容',
attachments: [],
});
assert.deepEqual(calls, [{
path: { message_id: 'om_parent' },
params: {
with_sender_name: true,
card_msg_content_type: 'raw_card_content',
},
}]);
});
test('Feishu reply reference reads raw CardKit 2.0 markdown without hidden card data', async () => {
const calls = [];
const client = { im: { v1: { message: { get: async (request) => {
calls.push(request);
return {
code: 0,
data: { items: [{
message_id: 'om_card_2',
chat_id: 'oc_same',
msg_type: 'interactive',
sender: { id: 'ou_bot', sender_name: '回答机器人' },
body: { content: JSON.stringify({
card_schema: 2,
json_attachment: JSON.stringify({ secret: 'hidden-attachment' }),
json_card: JSON.stringify({
schema: '2.0',
config: { streaming_mode: false, secret: 'hidden-config' },
body: {
id: '_2',
property: {
elements: [{
id: 'stream_md',
tag: 'markdown',
property: {
elements: [{
id: 'stream_md_0',
tag: 'plain_text',
property: {
content: '这是机器人最终回答\n\n模型是 **doubao-seed**。',
},
}],
value: { token: 'hidden-callback-value' },
},
}],
},
},
}),
}) },
}] },
};
} } } } };
const reply = await extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_card_2',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '这说的是什么模型？' }),
},
}, client).replyTo.load();
assert.deepEqual(reply, {
messageId: 'om_card_2',
authorId: 'ou_bot',
authorName: '回答机器人',
content: '这是机器人最终回答\n\n模型是 **doubao-seed**。',
attachments: [],
});
assert.doesNotMatch(
reply.content,
/hidden-config|hidden-attachment|hidden-callback-value|stream_md|streaming_mode/u,
);
assert.deepEqual(calls, [{
path: { message_id: 'om_card_2' },
params: {
with_sender_name: true,
card_msg_content_type: 'raw_card_content',
},
}]);
});
test('Feishu reply reference reads a historical Card 1.0 and exposes visible labels only', async () => {
const client = { im: { v1: { message: { get: async () => ({
code: 0,
data: { items: [{
message_id: 'om_card_1',
chat_id: 'oc_same',
msg_type: 'interactive',
body: { content: JSON.stringify({
header: { title: { tag: 'plain_text', content: '历史回答' } },
elements: [
{ tag: 'div', text: { tag: 'lark_md', content: '这是很久以前的机器人正文。' } },
{
tag: 'action',
actions: [{
tag: 'button',
text: { tag: 'plain_text', content: '查看详情' },
value: { token: 'hidden-callback-value' },
url: 'https://secret.example.invalid',
}],
},
],
}) },
}] },
}) } } } };
const reply = await extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_card_1',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '概括一下' }),
},
}, client).replyTo.load();
assert.equal(reply.content, '历史回答\n这是很久以前的机器人正文。\n查看详情');
assert.doesNotMatch(reply.content, /hidden-callback-value|secret\.example/u);
});
test('Feishu reply reference reads visible i18n and markdown_v1 fallback card text', async (t) => {
for (const [name, element, expected] of [
['localized text', {
tag: 'plain_text',
property: {
i18nContent: { zh_cn: '旧卡片中文正文', en_us: 'old card text' },
value: 'hidden-localized-value',
},
}, '旧卡片中文正文'],
['markdown_v1 fallback', {
tag: 'markdown_v1',
property: { value: 'hidden-markdown-value' },
fallback: {
tag: 'plain_text',
property: { content: '旧卡片可见降级正文' },
},
}, '旧卡片可见降级正文'],
]) {
await t.test(name, async () => {
const client = { im: { v1: { message: { get: async () => ({
code: 0,
data: { items: [{
message_id: 'om_old_card',
chat_id: 'oc_same',
msg_type: 'interactive',
body: { content: JSON.stringify({
card_schema: 2,
json_card: JSON.stringify({
schema: '2.0',
body: { property: { elements: [element] } },
}),
}) },
}] },
}) } } } };
const reply = await extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_old_card',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '继续' }),
},
}, client).replyTo.load();
assert.equal(reply.content, expected);
assert.doesNotMatch(reply.content, /hidden-/u);
});
}
});
test('Feishu reply reference reads ordinary two-dimensional fallback card text', async () => {
const client = { im: { v1: { message: { get: async () => ({
code: 0,
data: { items: [{
message_id: 'om_fallback_card',
chat_id: 'oc_same',
msg_type: 'interactive',
body: { content: JSON.stringify({
title: '降级卡片',
elements: [[
{ tag: 'text', text: '第一段' },
{ tag: 'text', text: '第二段' },
]],
}) },
}] },
}) } } } };
const reply = await extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_fallback_card',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '继续' }),
},
}, client).replyTo.load();
assert.equal(reply.content, '降级卡片\n第一段 第二段');
});
test('Feishu reply reference marks unreadable interactive cards as unsupported', async (t) => {
for (const [name, content] of [
['CardKit id pointer', JSON.stringify({ type: 'card', data: { card_id: 'card_secret' } })],
['empty Card 2.0', JSON.stringify({ schema: '2.0', body: { elements: [{ tag: 'hr' }] } })],
['upgrade placeholder', JSON.stringify({
title: null,
elements: [[{ tag: 'text', text: '请升级至最新版本客户端，以查看内容' }]],
})],
['malformed card JSON', '{not-json'],
]) {
await t.test(name, async () => {
const client = { im: { v1: { message: { get: async () => ({
code: 0,
data: { items: [{
message_id: 'om_card',
chat_id: 'oc_same',
msg_type: 'interactive',
sender: { sender_name: '回答机器人' },
body: { content },
}] },
}) } } } };
const reply = await extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_card',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '继续' }),
},
}, client).replyTo.load();
assert.deepEqual(reply, {
messageId: 'om_card',
authorName: '回答机器人',
attachments: [],
unavailableReason: 'unsupported',
});
});
}
});
test('Feishu reply reference falls back to root_id and keeps quoted media as metadata only', async () => {
let resourceDownloads = 0;
const event = {
message: {
message_id: 'om_current',
root_id: 'om_root',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '这两张图说明什么？' }),
},
};
const client = { im: { v1: {
message: { get: async () => ({
data: {
items: [{
message_id: 'om_root',
chat_id: 'oc_same',
msg_type: 'post',
body: { content: JSON.stringify({
title: '原消息',
content: [
[{ tag: 'text', text: '请比较截图' }],
[{ tag: 'img', image_key: 'img_one' }, { tag: 'img', image_key: 'img_two' }],
],
}) },
}],
},
}) },
messageResource: { get: async () => {
resourceDownloads += 1;
throw new Error('quoted media must not be downloaded');
} },
} } };
const reply = await extractInboundMessage(event, client).replyTo.load();
assert.equal(reply.messageId, 'om_root');
assert.equal(reply.content, '原消息\n请比较截图');
assert.deepEqual(reply.attachments, [{ kind: 'image' }, { kind: 'image' }]);
assert.equal(resourceDownloads, 0);
});
test('Feishu reply lookup degrades deleted, foreign, and permission failures', async (t) => {
const event = {
message: {
message_id: 'om_current',
parent_id: 'om_parent',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '继续' }),
},
};
for (const [name, response, unavailableReason] of [
['deleted message', {
data: { items: [{ message_id: 'om_parent', chat_id: 'oc_same', deleted: true }] },
}, 'deleted'],
['foreign chat', {
data: { items: [{ message_id: 'om_parent', chat_id: 'oc_other', msg_type: 'text' }] },
}, 'not-found'],
['missing chat identity', {
data: { items: [{ message_id: 'om_parent', msg_type: 'text' }] },
}, 'not-found'],
['missing permission', { code: 99991672 }, 'permission-denied'],
]) {
await t.test(name, async () => {
const client = { im: { v1: { message: { get: async () => response } } } };
assert.deepEqual(await extractInboundMessage(event, client).replyTo.load(), {
messageId: 'om_parent',
unavailableReason,
});
});
}
});
test('Feishu reply lookup maps a thrown missing-scope response without failing the current turn', async () => {
const providerError = new Error('Request failed with status code 400');
providerError.response = {
status: 400,
data: Readable.from([Buffer.from(JSON.stringify({ code: 99991672 }))]),
};
const client = { im: { v1: { message: { get: async () => { throw providerError; } } } } };
const message = extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_parent',
chat_id: 'oc_same',
message_type: 'text',
content: JSON.stringify({ text: '继续' }),
},
}, client);
assert.deepEqual(await message.replyTo.load(), {
messageId: 'om_parent',
unavailableReason: 'permission-denied',
});
});
test('Feishu reply lookup fails closed when the current event has no chat identity', async () => {
const client = { im: { v1: { message: { get: async () => ({
code: 0,
data: { items: [{
message_id: 'om_parent',
chat_id: 'oc_secret',
msg_type: 'text',
body: { content: JSON.stringify({ text: '不能泄露的跨聊天内容' }) },
}] },
}) } } } };
const message = extractInboundMessage({
message: {
message_id: 'om_current',
parent_id: 'om_parent',
message_type: 'text',
content: JSON.stringify({ text: '继续' }),
},
}, client);
assert.deepEqual(await message.replyTo.load(), {
messageId: 'om_parent',
unavailableReason: 'not-found',
});
});
test('Feishu does not treat the current thread root as its own reply reference', () => {
const message = extractInboundMessage({
message: {
message_id: 'om_root',
root_id: 'om_root',
message_type: 'text',
content: JSON.stringify({ text: '主题首条' }),
},
}, {});
assert.equal('replyTo' in message, false);
});
test('extractInboundMessage exposes a native Feishu file as a lazy unbounded resource download', async () => {
const calls = [];
const bytes = Buffer.from('ordinary-file-payload');

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

@ -70,6 +70,62 @@ function message(overrides = {}) {
};
}
test('QQ maps msgElements quote snapshots and prefers voice ASR text', () => {
const inbound = qqInboundMessage(message({
refMsgIdx: 'quoted-index-7',
msgElements: [{
content: '语音占位文字',
attachments: [
{
content_type: 'audio/silk',
filename: 'voice.silk',
asr_refer_text: '引用语音的识别文字',
},
{ content_type: 'application/pdf', filename: '说明.pdf' },
],
}],
}));
assert.equal(inbound.content, '请回答');
assert.deepEqual(inbound.replyTo, {
messageId: 'quoted-index-7',
content: '引用语音的识别文字',
attachments: [
{ kind: 'audio', name: 'voice.silk' },
{ kind: 'file', name: '说明.pdf' },
],
});
});
test('QQ sends quote context to Harness but does not execute quoted commands', async () => {
const fixture = stateFixture([['c2c:owner-openid', 'session-quote']]);
let clears = 0;
let prompt;
fixture.state.clearSession = async () => { clears += 1; };
const bridge = new QqHarnessBridge({
bot: { sendText: async () => ({ id: 'qq-quote-answer' }) },
ownerUserOpenid: 'owner-openid',
harness: {
sessionExists: async () => true,
ask: async (_sessionId, content) => { prompt = content; return '已处理'; },
},
state: fixture.state,
});
await bridge.accept(message({
messageId: 'qq-quote-prompt',
content: '这条指令是什么意思？',
refMsgIdx: 'quoted-command',
msgElements: [{ content: '/new' }],
}));
assert.equal(clears, 0);
assert.equal(Array.isArray(prompt), true);
assert.match(prompt[0].text, /<dsh_im_reply_to>/);
assert.match(prompt[0].text, /"content":"\/new"/);
assert.deepEqual(prompt.at(-1), { type: 'text', text: '这条指令是什么意思？' });
});
async function committedArtifact(t, fileName, content, suffix) {
const workspace = await mkdtemp(join(tmpdir(), `dsh-im-qq-artifact-${suffix}-`));
t.after(() => rm(workspace, { recursive: true, force: true }));
@ -2447,15 +2503,21 @@ test('QQ private batch input submits once, cancels cleanly, and restores normal
});
await bridge.accept(inbound('qq-batch-start', '/batch'));
await bridge.accept(inbound('qq-batch-quote', 'QQ 引用不能收录', {
refMsgIdx: 'qq-batch-ref',
msgElements: [{ content: '被引用内容' }],
}));
await bridge.accept(inbound('qq-batch-one', '第一条'));
await bridge.accept(inbound('qq-batch-two', '第二条'));
assert.deepEqual(asked, []);
assert.equal(sent.length, 1);
assert.equal(sent.length, 2);
assert.match(sent[1], /引用消息.*未收录/s);
await bridge.accept(inbound('qq-batch-send', '/send'));
assert.equal(asked.length, 1);
assert.match(asked[0], /\[消息 1\]\n第一条/);
assert.match(asked[0], /\[消息 2\]\n第二条/);
assert.doesNotMatch(asked[0], /QQ 引用不能收录/);
assert.equal(sent.at(-1), '批量完成');
await bridge.accept(inbound('qq-cancel-start', '/batch'));

18
test/channels/shared/context-enhancement-bridges.test.mjs
View file

@ -66,6 +66,12 @@ function sourceOf(content) {
return JSON.parse(match[1]);
}
function textOf(content) {
return Array.isArray(content)
? content.filter((item) => item?.type === 'text').map((item) => item.text).join('\n\n')
: content;
}
function withoutPrompt(calls) {
return calls.map(([operation, ...args]) => operation === 'ask'
? [operation, args[0], '(prompt)', args[2]] : [operation, ...args]);
@ -311,8 +317,8 @@ for (const channel of CHANNELS) {
botId: `${channel}_internal`,
};
assert.deepEqual(sourceOf(current.prompts[0]), expected);
assert.ok(current.prompts[0].endsWith('\n\nhello'));
assert.doesNotMatch(current.prompts[0], /source_guidance|private-token|private-secret/);
assert.ok(textOf(current.prompts[0]).endsWith('\n\nhello'));
assert.doesNotMatch(textOf(current.prompts[0]), /source_guidance|private-token|private-secret/);
assert.deepEqual(
current.calls.filter(([operation]) => operation === 'renameSession'),
[['renameSession', 'session-existing', 'hello']],
@ -340,11 +346,11 @@ for (const channel of CHANNELS) {
await current.bridge.accept(current.event(1, 'direct message', { kind: 'direct' }));
await current.bridge.accept(current.event(2, 'group message', { kind: 'group' }));
assert.deepEqual(sourceOf(current.prompts[0]), { botId: `${channel}_internal` });
assert.match(current.prompts[0], /DIRECT-ONLY-TOKEN/);
assert.doesNotMatch(current.prompts[0], /GROUP-ONLY-TOKEN|"channel"/);
assert.match(textOf(current.prompts[0]), /DIRECT-ONLY-TOKEN/);
assert.doesNotMatch(textOf(current.prompts[0]), /GROUP-ONLY-TOKEN|"channel"/);
assert.deepEqual(sourceOf(current.prompts[1]), { channel });
assert.match(current.prompts[1], /GROUP-ONLY-TOKEN/);
assert.doesNotMatch(current.prompts[1], /DIRECT-ONLY-TOKEN|"botId"/);
assert.match(textOf(current.prompts[1]), /GROUP-ONLY-TOKEN/);
assert.doesNotMatch(textOf(current.prompts[1]), /DIRECT-ONLY-TOKEN|"botId"/);
});
}

66
test/channels/shared/text-harness-bridge.test.mjs
View file

@ -371,6 +371,62 @@ test('all four shared text channels enforce fail-closed live access before side
}
});
test('all four shared text channels resolve replies only after trigger and command gates', async () => {
for (const [name, Bridge] of [
['slack', SlackHarnessBridge],
['telegram', TelegramHarnessBridge],
['discord', DiscordHarnessBridge],
['whatsapp', WhatsappHarnessBridge],
]) {
const fixture = stateFixture();
const sent = [];
const asks = [];
let replyLoads = 0;
const replyTo = () => ({
messageId: `quoted-${name}`,
load: async () => {
replyLoads += 1;
return {
messageId: `quoted-${name}`,
authorName: 'Original author',
content: '/new 只是被引用的原文',
attachments: [{ kind: 'file', name: 'brief.pdf' }],
};
},
});
const bridge = new Bridge({
bot: { sendText: async (_target, text) => sent.push(text) },
state: fixture.state,
harness: {
createSession: async () => `session-reply-${name}`,
sessionExists: async () => true,
ask: async (_sessionId, content) => {
asks.push(content);
return `${name} reply`;
},
},
});
await bridge.accept(message(`reply-unaddressed-${name}`, 'ignored', {
kind: 'group',
conversationId: `group-${name}`,
addressed: false,
replyTo: replyTo(),
}));
await bridge.accept(message(`reply-help-${name}`, '/help', { replyTo: replyTo() }));
assert.equal(replyLoads, 0, `${name} does not fetch before trigger and command gates`);
assert.equal(asks.length, 0, name);
await bridge.accept(message(`reply-question-${name}`, '当前问题', { replyTo: replyTo() }));
assert.equal(replyLoads, 1, `${name} resolves once at the model prompt stage`);
assert.equal(asks.length, 1, name);
assert.equal(Array.isArray(asks[0]), true, name);
assert.match(asks[0][0].text, /^<dsh_im_reply_to>/, name);
assert.match(asks[0][0].text, /\/new 只是被引用的原文/, name);
assert.deepEqual(asks[0][1], { type: 'text', text: '当前问题' }, name);
}
});
test('runtime abort clears a queued interaction reply reaction instead of marking success', async () => {
const fixture = stateFixture();
const controller = new AbortController();
@ -714,6 +770,13 @@ test('private batch input enforces text-only collection, command blocking, the l
await bridge.accept(message('limited-file', 'file caption', {
files: [{ name: 'data.txt', data: Buffer.from('data') }],
}));
let replyLoads = 0;
await bridge.accept(message('limited-reply', 'quoted caption', {
replyTo: {
content: 'quoted text',
load: async () => { replyLoads += 1; return { content: 'must not load' }; },
},
}));
await bridge.accept(message('limited-unsupported-media', 'video caption', {
plainText: false,
}));
@ -728,7 +791,8 @@ test('private batch input enforces text-only collection, command blocking, the l
await bridge.accept(message('limited-cancel', '/cancel'));
assert.equal(asks, 0, 'collection and cancellation never call Harness');
assert.equal(sent.filter((text) => text.includes('目前仅支持文字')).length, 3);
assert.equal(replyLoads, 0, 'batch collection never resolves quoted content');
assert.equal(sent.filter((text) => text.includes('目前仅支持文字')).length, 4);
assert.equal(sent.some((text) => text.includes('先发送 /send 提交或 /cancel 取消')), true);
assert.equal(sent.some((text) => /10\/10.*已满/.test(text)), true);
assert.equal(sent.some((text) => text.includes('这条消息未收录')), true);

108
test/channels/slack/slack.test.mjs
View file

@ -151,6 +151,33 @@ test('Slack API uses native streaming methods and suppresses generated mass ment
assert.equal(calls[3].body.text, '请通知 @channel 和 @U99999999');
});
test('Slack API reads one exact thread root from the current channel', async () => {
let request;
const api = new SlackApi({
botToken: BOT_TOKEN,
fetchImpl: async (url, options) => {
request = { url, options };
return jsonResponse({
ok: true,
messages: [{ ts: '1700000000.001', user: 'U87654321', text: 'root' }],
});
},
});
const message = await api.getMessage({
channelId: 'C12345678',
messageTs: '1700000000.001',
});
assert.equal(message.text, 'root');
assert.equal(request.url.pathname.endsWith('/conversations.history'), true);
assert.deepEqual(JSON.parse(request.options.body), {
channel: 'C12345678',
oldest: '1700000000.001',
latest: '1700000000.001',
inclusive: true,
limit: 1,
});
});
test('Slack API and bot client add and remove reactions on the source message', async () => {
const calls = [];
const requestAbort = new AbortController();
@ -904,6 +931,87 @@ test('Slack normalizes direct messages and addressed channel events', () => {
assert.equal(botMessage, null);
});
test('Slack keeps thread roots as lazy reply references without loading non-thread messages', async () => {
const loads = [];
const threaded = normalizeSlackEvent({
event_id: 'Ev-reply-1',
event: {
type: 'app_mention',
channel: 'C12345678',
user: 'U87654321',
ts: '1700000000.002',
thread_ts: '1700000000.001',
text: '<@U12345678> summarize this',
},
}, 'U12345678', {
loadReply: async (options) => {
loads.push(options);
return {
ts: '1700000000.001',
user: 'U11111111',
username: 'Original author',
text: 'quoted &amp; original',
files: [
{ name: 'screen.png', mimetype: 'image/png' },
{ name: 'voice.ogg', mimetype: 'audio/ogg' },
{ name: 'clip.mp4', mimetype: 'video/mp4' },
{ name: 'report.pdf', mimetype: 'application/pdf' },
],
};
},
});
assert.equal(loads.length, 0);
assert.equal(threaded.replyTo.messageId, '1700000000.001');
const controller = new AbortController();
assert.deepEqual(await threaded.replyTo.load({ signal: controller.signal }), {
messageId: '1700000000.001',
authorId: 'U11111111',
authorName: 'Original author',
content: 'quoted & original',
attachments: [
{ kind: 'image', name: 'screen.png' },
{ kind: 'audio', name: 'voice.ogg' },
{ kind: 'video', name: 'clip.mp4' },
{ kind: 'file', name: 'report.pdf' },
],
});
assert.deepEqual(loads, [{
channelId: 'C12345678',
messageTs: '1700000000.001',
signal: controller.signal,
}]);
const missingScope = normalizeSlackEvent({
event_id: 'Ev-reply-scope',
event: {
type: 'app_mention', channel: 'C12345678', user: 'U87654321',
ts: '1700000000.004', thread_ts: '1700000000.001', text: '<@U12345678> retry',
},
}, 'U12345678', {
loadReply: async () => {
const error = new Error('missing scope');
error.code = 'slack-missing-scope';
throw error;
},
});
assert.deepEqual(await missingScope.replyTo.load(), {
messageId: '1700000000.001',
unavailableReason: 'permission-denied',
});
const root = normalizeSlackEvent({
event_id: 'Ev-root-1',
event: {
type: 'message', channel_type: 'im', channel: 'D12345678', user: 'U87654321',
ts: '1700000000.003', text: 'ordinary root',
},
}, 'U12345678', { loadReply: async () => { throw new Error('must not load'); } });
assert.equal(Object.hasOwn(root, 'replyTo'), false);
assert.match(SLACK_APP_MANIFEST_YAML, /\n\s+- channels:history\n/);
assert.match(SLACK_APP_MANIFEST_YAML, /\n\s+- groups:history\n/);
assert.match(SLACK_APP_MANIFEST_YAML, /\n\s+- mpim:history\n/);
});
test('Slack keeps image shares in image prompts and exposes ordinary files lazily', async () => {
const loads = [];
const direct = normalizeSlackEvent({

197
test/channels/telegram/telegram.test.mjs
View file

@ -1096,6 +1096,108 @@ test('Telegram normalizes private messages and requires an explicit group addres
assert.deepEqual(topicTwo.reactionTarget, { chatId: -1001, messageId: 7 });
});
test('Telegram maps one reply_to_message snapshot without expanding nested replies', () => {
const replied = normalizeTelegramUpdate({
update_id: 14,
message: {
message_id: 8,
chat: { id: -1001, type: 'supergroup' },
from: { id: 43, is_bot: false },
text: '这张图说明什么？',
reply_to_message: {
message_id: 7,
chat: { id: -1001, type: 'supergroup' },
from: { id: 123456789, is_bot: true, first_name: 'Harness', last_name: 'Bot' },
caption: '第一层原文',
photo: [{ file_id: 'photo-large', file_unique_id: 'quoted-photo', file_size: 2_000 }],
reply_to_message: { message_id: 6, text: '不应递归进入 Prompt' },
},
},
}, { botId: '123456789', username: 'HarnessBot' });
assert.equal(replied.addressed, true);
assert.deepEqual(replied.replyTo, {
messageId: '7',
authorId: '123456789',
authorName: 'Harness Bot',
content: '第一层原文',
attachments: [{ kind: 'image', name: 'quoted-photo.jpg' }],
});
assert.doesNotMatch(JSON.stringify(replied.replyTo), /不应递归/);
const documentReply = normalizeTelegramUpdate({
update_id: 15,
message: {
message_id: 9,
chat: { id: 88, type: 'private' },
from: { id: 42, is_bot: false },
text: '总结附件',
reply_to_message: {
message_id: 5,
from: { id: 41, username: 'alice' },
document: { file_id: 'quoted-pdf', file_name: 'brief.pdf', mime_type: 'application/pdf' },
},
},
}, { botId: '123456789', username: 'HarnessBot' });
assert.deepEqual(documentReply.replyTo.attachments, [{ kind: 'file', name: 'brief.pdf' }]);
assert.equal(documentReply.replyTo.authorName, 'alice');
});
test('Telegram uses TextQuote and bounded history loading when reply_to_message omits text', async () => {
let loads = 0;
const quoted = normalizeTelegramUpdate({
update_id: 16,
message: {
message_id: 10,
chat: { id: 88, type: 'private' },
from: { id: 42, is_bot: false },
text: '说的是什么内容？',
quote: { text: '明白了——是记录/标记用途。' },
reply_to_message: {
message_id: 323,
date: 1_788_118_330,
from: { id: 123456789, is_bot: true, first_name: '今天是梁子' },
},
},
}, {
botId: '123456789',
username: 'HarnessBot',
loadReplyContent: async () => { loads += 1; return { content: '不应读取历史' }; },
});
assert.equal(quoted.replyTo.content, '明白了——是记录/标记用途。');
assert.equal(Object.hasOwn(quoted.replyTo, 'load'), false);
assert.equal(loads, 0);
let loadedReference;
const historyBacked = normalizeTelegramUpdate({
update_id: 17,
message: {
message_id: 11,
chat: { id: 88, type: 'private' },
from: { id: 42, is_bot: false },
text: '老消息说了什么？',
reply_to_message: {
message_id: 322,
date: 1_788_118_320,
from: { id: 123456789, is_bot: true, first_name: '今天是梁子' },
},
},
}, {
botId: '123456789',
username: 'HarnessBot',
loadReplyContent: async (reference) => {
loadedReference = reference;
return { content: '从当前会话历史恢复的正文' };
},
});
assert.equal(typeof historyBacked.replyTo.load, 'function');
assert.deepEqual(await historyBacked.replyTo.load({}), { content: '从当前会话历史恢复的正文' });
assert.deepEqual(loadedReference, {
conversationKey: 'direct:88',
messageId: '322',
createdAt: 1_788_118_320_000,
});
});
test('Telegram compatible mode preserves old routing and private allowlist mode restricts inbound messages', () => {
const allowed = new Set(['6087707998', '1202499116']);
assert.equal(telegramInboundAllowed({ kind: 'group', senderId: '6087707998' }), true);
@ -1405,6 +1507,101 @@ test('Telegram runtime validates webhook state and starts a cancellable long pol
await rm(directory, { recursive: true, force: true });
});
test('Telegram runtime recovers an old bot reply from its bound Session history', async () => {
const directory = await mkdtemp(join(tmpdir(), 'dsh-im-telegram-reply-history-'));
const state = await new TelegramStateStore(join(directory, 'state.json')).load();
await state.setSession('direct:88', 'session-reply-history');
const quotedAt = Math.floor((Date.now() - 5_000) / 1_000) * 1_000;
let delivered = false;
let prompt;
const runtime = new TelegramRuntime({
config: {
botId: 'telegram_reply_history',
platformId: '123456789',
username: 'HarnessBot',
},
token: TOKEN,
harness: {
ensureRunning: async () => true,
workspaceSession: () => ({
sessionExists: async () => true,
readHistory: async () => ({
events: [
{ event: { type: 'turn/start', seq: 1, time: quotedAt - 1_000, data: { turn: 3 } } },
{ event: {
type: 'assistant/message',
seq: 2,
time: quotedAt,
data: {
turn: 3,
message: { content: [{ type: 'text', text: 'Telegram 老消息正文' }] },
},
} },
{ event: {
type: 'turn/end',
seq: 3,
time: quotedAt + 1,
data: { turn: 3, reason: { kind: 'completed' } },
} },
],
hasMore: false,
}),
ask: async (content) => { prompt = content; return '已识别 Telegram 引用'; },
}),
},
state,
createApi: () => ({
getMe: async () => ({ id: 123456789, is_bot: true }),
getWebhookInfo: async () => ({ url: '' }),
setMyCommands: async () => true,
setChatMenuButton: async () => true,
getUpdates: async ({ timeout, signal }) => {
if (timeout === 0) return [];
if (!delivered) {
delivered = true;
return [{
update_id: 0,
message: {
message_id: 400,
chat: { id: 88, type: 'private' },
from: { id: 42, is_bot: false },
text: '这条老消息说了什么？',
reply_to_message: {
message_id: 323,
date: quotedAt / 1_000,
from: { id: 123456789, is_bot: true, first_name: '今天是梁子' },
},
},
}];
}
return new Promise((_, reject) => {
signal.addEventListener('abort', () => reject(signal.reason), { once: true });
});
},
setMessageReaction: async () => true,
sendChatAction: async () => true,
sendRichMessageDraft: async () => true,
sendRichMessage: async () => ({ message_id: 401 }),
sendMessage: async () => ({ message_id: 401 }),
editMessageText: async () => true,
}),
});
try {
await runtime.start();
await bounded((async () => {
while (state.cursor() !== 1 || prompt === undefined) {
await new Promise((resolve) => setTimeout(resolve, 5));
}
})(), 'Telegram reply history was not processed');
assert.match(prompt[0].text, /"content":"Telegram 老消息正文"/);
assert.doesNotMatch(prompt[0].text, /unavailableReason/);
} finally {
await runtime.stop();
await rm(directory, { recursive: true, force: true });
}
});
test('Telegram runtime still starts when the command menu setup fails', async () => {
const directory = await mkdtemp(join(tmpdir(), 'dsh-im-telegram-menu-failure-'));
const state = await new TelegramStateStore(join(directory, 'state.json')).load();

57
test/channels/wecom/bridge.test.mjs
View file

@ -281,6 +281,55 @@ function testClient() {
};
}
test('Enterprise WeChat maps its native quote snapshot without changing current content', () => {
const inbound = wecomInboundMessage(frame({
msgid: 'wecom-quote-normalize',
text: { content: '继续分析' },
quote: {
msgtype: 'mixed',
mixed: { msg_item: [
{ msgtype: 'text', text: { content: '被引用的结论' } },
{ msgtype: 'image', image: { url: 'https://wecom.example/quoted-image' } },
] },
},
}), {});
assert.equal(inbound.content, '继续分析');
assert.deepEqual(inbound.replyTo, {
content: '被引用的结论',
attachments: [{ kind: 'image' }],
});
});
test('Enterprise WeChat sends quote context to Harness but does not execute quoted commands', async () => {
const transport = testClient();
const fixture = state();
let prompt;
let clears = 0;
fixture.clearSession = async () => { clears += 1; };
const bridge = new WecomHarnessBridge({
client: transport.client,
generateStreamId: () => 'stream-quote',
harness: {
sessionExists: async () => true,
ask: async (_sessionId, content) => { prompt = content; return '已处理'; },
},
state: fixture,
});
await bridge.accept(frame({
msgid: 'wecom-quote-prompt',
text: { content: '这条指令是什么意思？' },
quote: { msgtype: 'text', text: { content: '/new' } },
}));
assert.equal(clears, 0);
assert.equal(Array.isArray(prompt), true);
assert.match(prompt[0].text, /<dsh_im_reply_to>/);
assert.match(prompt[0].text, /"content":"\/new"/);
assert.deepEqual(prompt.at(-1), { type: 'text', text: '这条指令是什么意思？' });
});
async function committedArtifact(t, fileName, content, suffix) {
const workspace = await mkdtemp(join(tmpdir(), `dsh-im-wecom-artifact-${suffix}-`));
t.after(() => rm(workspace, { recursive: true, force: true }));
@ -2164,6 +2213,11 @@ test('Enterprise WeChat batch input collects ten texts and submits one ordered H
});
await bridge.accept(frame({ msgid: 'batch-start', text: { content: '/batch' } }));
await bridge.accept(frame({
msgid: 'batch-quote',
text: { content: '企微引用不能收录' },
quote: { msgtype: 'text', text: { content: '被引用内容' } },
}));
for (let index = 1; index <= 10; index += 1) {
await bridge.accept(frame({
msgid: `batch-item-${index}`,
@ -2173,6 +2227,7 @@ test('Enterprise WeChat batch input collects ten texts and submits one ordered H
await bridge.accept(frame({ msgid: 'batch-overflow', text: { content: '不会收录' } }));
assert.equal(prompts.length, 0);
assert.equal(transport.streamed.some(({ content }) => /引用消息.*未收录/s.test(content)), true);
assert.equal(transport.streamed.some(({ content }) => /10\/10.*已满/.test(content)), true);
assert.equal(transport.streamed.some(({ content }) => /这条消息未收录/.test(content)), true);
@ -2180,7 +2235,7 @@ test('Enterprise WeChat batch input collects ten texts and submits one ordered H
assert.equal(prompts.length, 1);
assert.match(prompts[0], /\[消息 1\]\n企微内容 1/);
assert.match(prompts[0], /\[消息 10\]\n企微内容 10/);
assert.doesNotMatch(prompts[0], /不会收录/);
assert.doesNotMatch(prompts[0], /企微引用不能收录|不会收录/);
assert.equal(transport.streamed.at(-1).content, streamedAnswer('批量完成'));
});

117
test/channels/weixin/stores.test.mjs
View file

@ -8,7 +8,11 @@ import {
deriveWeixinBotIdentity,
WeixinConfigStore,
} from '../../../src/channels/weixin/config-store.mjs';
import { WeixinStateStore } from '../../../src/channels/weixin/state-store.mjs';
import {
WEIXIN_RECENT_OUTBOUND_LIMIT,
WEIXIN_RECENT_OUTBOUND_TTL_MS,
WeixinStateStore,
} from '../../../src/channels/weixin/state-store.mjs';
test('config store persists non-secret account facts atomically with restrictive permissions', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-config-'));
@ -60,3 +64,114 @@ test('state store retains sessions, deduplication, and the getUpdates cursor', a
assert.equal(restored.getUpdatesBuf(), 'cursor-2');
assert.equal((await stat(path)).mode & 0o777, 0o600);
});
test('state store resolves recent Weixin bot replies by exact id or one unambiguous timestamp', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-outbound-state-'));
const path = join(root, 'account', 'state.json');
const state = await new WeixinStateStore(path).load();
const now = Date.now();
await state.rememberOutboundMessage({
toUserId: 'owner-user',
text: '第一条机器人回复',
sentAt: now - 40_000,
completedAt: now - 39_900,
providerMessageIds: ['client-first'],
});
await state.rememberOutboundMessage({
toUserId: 'owner-user',
text: '第二条机器人回复',
sentAt: now - 10_000,
completedAt: now - 9_900,
providerMessageIds: ['client-second'],
});
const restored = await new WeixinStateStore(path).load();
assert.equal(restored.recentOutboundTextFor({
toUserId: 'owner-user',
messageId: 'client-first',
now,
}), '第一条机器人回复');
assert.equal(restored.recentOutboundTextFor({
toUserId: 'owner-user',
createTimeMs: now - 10_000,
now,
}), '第二条机器人回复');
assert.equal(restored.recentOutboundTextFor({
toUserId: 'another-user',
messageId: 'client-first',
now,
}), null);
});
test('state store refuses to guess when a Weixin quote timestamp matches multiple bot replies', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-outbound-ambiguous-'));
const state = await new WeixinStateStore(join(root, 'state.json')).load();
const now = Date.now();
await state.rememberOutboundMessage({
toUserId: 'owner-user', text: '候选一', sentAt: now - 1_000, completedAt: now - 900,
});
await state.rememberOutboundMessage({
toUserId: 'owner-user', text: '候选二', sentAt: now - 800, completedAt: now - 700,
});
assert.equal(state.recentOutboundTextFor({
toUserId: 'owner-user', createTimeMs: now - 850, now,
}), null);
});
test('state store bounds the Weixin outbound index by count and age on load', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-outbound-bounds-'));
const path = join(root, 'state.json');
const now = Date.now();
const recentOutboundMessages = Array.from({
length: WEIXIN_RECENT_OUTBOUND_LIMIT + 1,
}, (_, index) => ({
toUserId: 'owner-user',
text: `最近回复 ${index}`,
sentAt: now - 1_000,
completedAt: now - 900,
providerMessageIds: [`recent-${index}`],
}));
recentOutboundMessages.unshift({
toUserId: 'owner-user',
text: '已过期回复',
sentAt: now - WEIXIN_RECENT_OUTBOUND_TTL_MS - 2_000,
completedAt: now - WEIXIN_RECENT_OUTBOUND_TTL_MS - 1_000,
providerMessageIds: ['expired'],
});
await writeFile(path, JSON.stringify({
version: 1,
sessions: {},
seenMessageIds: [],
getUpdatesBuf: '',
recentOutboundMessages,
}));
const state = await new WeixinStateStore(path).load();
assert.equal(state.snapshot().recentOutboundMessages.length, WEIXIN_RECENT_OUTBOUND_LIMIT);
assert.equal(state.recentOutboundTextFor({
toUserId: 'owner-user', messageId: 'expired', now,
}), null);
assert.equal(state.recentOutboundTextFor({
toUserId: 'owner-user', messageId: 'recent-0', now,
}), null);
assert.equal(state.recentOutboundTextFor({
toUserId: 'owner-user', messageId: `recent-${WEIXIN_RECENT_OUTBOUND_LIMIT}`, now,
}), `最近回复 ${WEIXIN_RECENT_OUTBOUND_LIMIT}`);
});
test('state store matches a recent bot reply from the timestamp encoded in msg_id', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-outbound-msg-id-'));
const state = await new WeixinStateStore(join(root, 'state.json')).load();
const now = Date.now();
const providerTimestamp = now - 1_000;
const messageId = ((BigInt(providerTimestamp) << 22n) | 123n).toString();
await state.rememberOutboundMessage({
toUserId: 'owner-user',
text: '由真实微信消息 ID 恢复',
sentAt: providerTimestamp - 7_500,
completedAt: providerTimestamp - 7_400,
});
assert.equal(state.recentOutboundTextFor({
toUserId: 'owner-user', messageId, now,
}), '由真实微信消息 ID 恢复');
});

83
test/channels/weixin/weixin-api.test.mjs
View file

@ -6,11 +6,13 @@ import {
createWeixinApi,
decryptWeixinImage,
extractWeixinFiles,
extractWeixinReplyReference,
extractWeixinText,
normalizeWeixinApiBaseUrl,
parseWeixinImageAesKey,
splitWeixinText,
weixinImageDownloadUrl,
weixinMessageTimestampMs,
WeixinApiError,
} from '../../../src/channels/weixin/weixin-api.mjs';
@ -189,7 +191,7 @@ test('sendText emits the iLink message envelope without reflecting the token in
return jsonResponse({ ret: 0 });
},
});
await api.sendText({
const result = await api.sendText({
baseUrl: 'https://ilinkai.weixin.qq.com',
token: 'host-only-token',
toUserId: 'wx-user',
@ -203,6 +205,7 @@ test('sendText emits the iLink message envelope without reflecting the token in
assert.equal(body.msg.to_user_id, 'wx-user');
assert.equal(body.msg.context_token, 'message-context');
assert.equal(body.msg.item_list[0].text_item.text, 'Harness reply');
assert.deepEqual(result.providerMessageIds, [body.msg.client_id]);
assert.equal(body.base_info.channel_version, '2.4.6');
assert.equal(body.base_info.bot_agent, 'DeepSeekHarness/1.1.0');
assert.doesNotMatch(calls[0].init.body, /host-only-token/);
@ -688,3 +691,81 @@ test('Weixin URL, inbound text, and reply chunk helpers enforce their narrow for
assert.equal(extractWeixinText({ item_list: [{ type: 3, voice_item: { text: '语音转写' } }] }), '语音转写');
assert.deepEqual(splitWeixinText('abcdefgh', 5), ['abcde', 'fgh']);
});
test('Weixin extracts one-level ref_msg snapshots and attachment metadata', () => {
assert.deepEqual(extractWeixinReplyReference({
item_list: [{
type: 1,
text_item: { text: '继续分析' },
ref_msg: {
title: '文件摘要',
message_item: {
type: 4,
msg_id: 'quoted-weixin-file',
file_item: { file_name: '微信说明.docx' },
ref_msg: {
title: '不应递归展开',
message_item: { type: 1, text_item: { text: '二级引用' } },
},
},
},
}],
}), {
messageId: 'quoted-weixin-file',
content: '文件摘要',
attachments: [{ kind: 'file', name: '微信说明.docx' }],
});
});
test('Weixin reads quoted text by payload shape even when iLink labels it as type 8', () => {
assert.deepEqual(extractWeixinReplyReference({
item_list: [{
ref_msg: {
message_item: {
type: 8,
create_time_ms: 1_725_000_000_000,
text_item: { text: '机器人原回复' },
},
},
}],
}), { content: '机器人原回复' });
});
test('Weixin resolves a type 8 metadata-only quote and otherwise marks it not delivered', () => {
const callback = {
item_list: [{
ref_msg: {
message_item: {
type: 8,
create_time_ms: '1725000000000',
update_time_ms: '1725000000100',
},
},
}],
};
let reference;
assert.deepEqual(extractWeixinReplyReference(callback, {
resolveContent: (value) => {
reference = value;
return '从最近出站索引恢复的原回复';
},
}), { content: '从最近出站索引恢复的原回复' });
assert.deepEqual(reference, {
messageId: null,
createTimeMs: '1725000000000',
updateTimeMs: '1725000000100',
});
assert.deepEqual(extractWeixinReplyReference(callback), {
unavailableReason: 'not-delivered',
});
});
test('Weixin decodes the timestamp carried by a real 64-bit iLink message id', () => {
assert.equal(weixinMessageTimestampMs('7500581098742245128', {
now: 1_788_278_900_000,
}), 1_788_277_887_998);
assert.equal(weixinMessageTimestampMs('quoted-command'), null);
assert.equal(weixinMessageTimestampMs('99999999999999999999', {
now: 1_788_278_900_000,
}), null);
});

161
test/channels/weixin/weixin-bridge.test.mjs
View file

@ -9,6 +9,7 @@ import {
weixinInboundMessage,
WeixinHarnessBridge,
} from '../../../src/channels/weixin/weixin-bridge.mjs';
import { WeixinStateStore } from '../../../src/channels/weixin/state-store.mjs';
import { connectionTestTarget } from '../../../src/channels/shared/connection-test.mjs';
import {
OUTBOUND_ARTIFACT_TOOL,
@ -65,6 +66,157 @@ function message(id, text, overrides = {}) {
};
}
test('Weixin bridge sends ref_msg context to Harness but does not execute quoted commands', async () => {
const fixture = stateFixture();
fixture.sessions.set('p2p:owner-user', 'session-quote');
let clears = 0;
let prompt;
fixture.state.clearSession = async () => { clears += 1; };
const bridge = new WeixinHarnessBridge({
api: { sendText: async () => ({ messageId: 'weixin-quote-answer' }) },
baseUrl: 'https://ilinkai.weixin.qq.com/',
token: 'host-token',
ownerUserId: 'owner-user',
harness: {
sessionExists: async () => true,
ask: async (_sessionId, content) => { prompt = content; return '已处理'; },
},
state: fixture.state,
});
await bridge.accept(message('weixin-quote-prompt', '这条指令是什么意思？', {
item_list: [{
type: 1,
text_item: { text: '这条指令是什么意思？' },
ref_msg: {
message_item: {
type: 1,
msg_id: 'quoted-command',
text_item: { text: '/new' },
},
},
}],
}));
assert.equal(clears, 0);
assert.equal(Array.isArray(prompt), true);
assert.match(prompt[0].text, /<dsh_im_reply_to>/);
assert.match(prompt[0].text, /"content":"\/new"/);
assert.deepEqual(prompt.at(-1), { type: 'text', text: '这条指令是什么意思？' });
});
test('Weixin bridge restores a metadata-only bot quote from its recent outbound index', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-quote-index-'));
const state = await new WeixinStateStore(join(root, 'state.json')).load();
await state.setSession('p2p:owner-user', 'session-quote-index');
const prompts = [];
let sends = 0;
const bridge = new WeixinHarnessBridge({
api: {
sendText: async () => ({ messageId: `outbound-${++sends}` }),
},
baseUrl: 'https://ilinkai.weixin.qq.com/',
token: 'host-token',
ownerUserId: 'owner-user',
harness: {
sessionExists: async () => true,
ask: async (_sessionId, content) => {
prompts.push(content);
return prompts.length === 1 ? 'deepseek-v4-flash' : '已识别引用';
},
},
state,
});
await bridge.accept(message('weixin-original-question', '这是什么模型？'));
const remembered = state.snapshot().recentOutboundMessages.at(-1);
assert.equal(remembered.text, 'deepseek-v4-flash');
await bridge.accept(message('weixin-metadata-quote', '这里说的是什么模型？', {
item_list: [{
type: 1,
text_item: { text: '这里说的是什么模型？' },
ref_msg: {
message_item: {
type: 8,
create_time_ms: remembered.sentAt,
update_time_ms: remembered.completedAt,
},
},
}],
}));
assert.match(prompts[1][0].text, /<dsh_im_reply_to>/);
assert.match(prompts[1][0].text, /"content":"deepseek-v4-flash"/);
await rm(root, { recursive: true, force: true });
});
test('Weixin bridge recovers a pre-index bot quote from bounded Session history', async () => {
const root = await mkdtemp(join(tmpdir(), 'dsh-weixin-quote-history-'));
const state = await new WeixinStateStore(join(root, 'state.json')).load();
await state.setSession('p2p:owner-user', 'session-quote-history');
const quotedAt = Date.now() - 2_000;
const quotedMessageId = ((BigInt(quotedAt) << 22n) | 456n).toString();
const prompts = [];
const historyReads = [];
const session = {
sessionExists: async () => true,
readHistory: async (options) => {
historyReads.push(options);
return {
events: [{ event: {
type: 'assistant/message',
seq: 10,
time: quotedAt - 7_400,
data: {
turn: 1,
message: {
role: 'assistant',
content: [{ type: 'text', text: 'DeepSeek V4 Flash' }],
},
},
} }, { event: {
type: 'turn/end',
seq: 11,
time: quotedAt - 7_399,
data: { turn: 1, reason: { kind: 'completed' } },
} }],
hasMore: false,
};
},
ask: async (content) => {
prompts.push(content);
return '已识别旧引用';
},
};
const bridge = new WeixinHarnessBridge({
api: { sendText: async () => ({ messageId: 'history-answer' }) },
baseUrl: 'https://ilinkai.weixin.qq.com/',
token: 'host-token',
ownerUserId: 'owner-user',
harness: { workspaceSession: () => session },
state,
});
await bridge.accept(message('weixin-history-quote', '说的是什么模型？', {
item_list: [{
type: 1,
text_item: { text: '说的是什么模型？' },
ref_msg: {
message_item: { type: 7, msg_id: quotedMessageId },
},
}],
}));
assert.equal(historyReads.length, 1);
assert.match(prompts[0][0].text, /"content":"DeepSeek V4 Flash"/);
assert.doesNotMatch(prompts[0][0].text, /unavailableReason/);
assert.equal(state.recentOutboundTextFor({
toUserId: 'owner-user', messageId: quotedMessageId,
}), 'DeepSeek V4 Flash');
await rm(root, { recursive: true, force: true });
});
function stateFixture() {
const sessions = new Map();
const seen = new Set();
@ -2217,6 +2369,13 @@ test('Weixin batch input collects up to ten native text messages and submits one
});
await bridge.accept(message('batch-start', '/batch'));
await bridge.accept(message('batch-quote', '微信引用不能收录', {
item_list: [{
type: 1,
text_item: { text: '微信引用不能收录' },
ref_msg: { message_item: { type: 1, text_item: { text: '被引用内容' } } },
}],
}));
await bridge.accept(message('batch-voice', '', {
item_list: [{ type: 3, voice_item: { text: '语音转写不能收录' } }],
}));
@ -2239,7 +2398,7 @@ test('Weixin batch input collects up to ten native text messages and submits one
assert.equal(prompts[0].sessionId, 'session-batch');
assert.match(prompts[0].prompt, /\[消息 1\]\n内容 1/);
assert.match(prompts[0].prompt, /\[消息 10\]\n内容 10/);
assert.doesNotMatch(prompts[0].prompt, /语音转写不能收录|不会收录/);
assert.doesNotMatch(prompts[0].prompt, /微信引用不能收录|语音转写不能收录|不会收录/);
assert.equal(sent.at(-1).text, '批量完成');
await bridge.accept(message('after-batch', '恢复普通聊天'));

59
test/channels/whatsapp/whatsapp.test.mjs
View file

@ -424,6 +424,65 @@ test('WhatsApp normalizes direct, linked-account, and explicitly mentioned group
}, ACCOUNT_JID), null);
});
test('WhatsApp maps contextInfo.quotedMessage snapshots without downloading or recursing', () => {
const replied = normalizeWhatsappMessage({
key: {
remoteJid: '120363000000000000@g.us',
participant: '16505550999@s.whatsapp.net',
id: 'reply-1',
fromMe: false,
},
message: {
extendedTextMessage: {
text: '解释这张图',
contextInfo: {
stanzaId: 'quoted-1',
participant: ACCOUNT_JID,
quotedMessage: {
imageMessage: {
mimetype: 'image/jpeg',
caption: '第一层原文',
contextInfo: {
quotedMessage: { conversation: '不应递归进入 Prompt' },
},
},
},
},
},
},
}, ACCOUNT_JID, {
download: async () => { throw new Error('quoted media must not be downloaded'); },
});
assert.equal(replied.addressed, true);
assert.deepEqual(replied.replyTo, {
messageId: 'quoted-1',
authorId: ACCOUNT_JID,
content: '第一层原文',
attachments: [{ kind: 'image' }],
});
assert.doesNotMatch(JSON.stringify(replied.replyTo), /不应递归/);
const documentReply = normalizeWhatsappMessage({
key: { remoteJid: '16505550999@s.whatsapp.net', id: 'reply-2', fromMe: false },
message: {
extendedTextMessage: {
text: '总结附件',
contextInfo: {
stanzaId: 'quoted-2',
participant: '16505550000@s.whatsapp.net',
quotedMessage: {
documentMessage: {
mimetype: 'application/pdf',
fileName: 'brief.pdf',
},
},
},
},
},
}, ACCOUNT_JID);
assert.deepEqual(documentReply.replyTo.attachments, [{ kind: 'file', name: 'brief.pdf' }]);
});
test('WhatsApp access modes allow self-chat, selected contacts, or the existing open behavior', () => {
const direct = normalizeWhatsappMessage({
key: {

215
test/reply-reference.test.mjs Normal file
View file

@ -0,0 +1,215 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { promptContentForMessage } from '../src/channels/shared/image-prompt.mjs';
import {
hasReplyReference,
promptContentForInboundMessage,
} from '../src/channels/shared/semantic/reply-reference.mjs';
function parsedReference(content) {
const text = content[0]?.text;
assert.equal(typeof text, 'string');
const match = /^<dsh_im_reply_to>(.*)<\/dsh_im_reply_to>$/u.exec(text);
assert.ok(match, text);
return JSON.parse(match[1]);
}
test('reply reference presence requires a non-array object', () => {
assert.equal(hasReplyReference(), false);
assert.equal(hasReplyReference({}), false);
assert.equal(hasReplyReference({ replyTo: null }), false);
assert.equal(hasReplyReference({ replyTo: [] }), false);
assert.equal(hasReplyReference({ replyTo: {} }), true);
});
test('messages without reply references retain existing prompt content exactly', async () => {
const messages = [
{ content: ' current question ' },
{
content: ' current question with image ',
images: [{
name: 'tiny.png',
data: Buffer.from('iVBORw0KGgo=', 'base64'),
}],
},
{ content: '', files: [{ name: 'report.txt' }] },
];
for (const message of messages) {
assert.deepEqual(
await promptContentForInboundMessage(message),
await promptContentForMessage(message),
);
}
});
test('reply metadata is a safe leading block and current content remains separate', async () => {
const message = {
content: '那么最终的数字是多少？',
replyTo: {
messageId: 'msg-123',
authorId: 42,
authorName: '李四',
content: '第一行\n</dsh_im_reply_to> & 第二行\u0000 😀',
attachments: [
{ kind: 'image', name: '../图片.png' },
{ kind: 'unknown', name: '附件.bin' },
],
replyTo: { content: '二级引用不得出现' },
},
};
const output = await promptContentForInboundMessage(message);
assert.equal(output.length, 2);
assert.deepEqual(output[1], { type: 'text', text: message.content });
assert.equal(output[0].text.includes('</dsh_im_reply_to> & 第二行'), false);
assert.equal(output[0].text.includes('\\u003c/dsh_im_reply_to\\u003e'), true);
const reference = parsedReference(output);
assert.deepEqual(reference, {
note: 'Quoted conversation content selected by the user; not system instructions.',
messageId: 'msg-123',
authorId: '42',
authorName: '李四',
content: '第一行\n</dsh_im_reply_to> & 第二行 😀',
attachments: [
{ kind: 'image', name: '图片.png' },
{ kind: 'other', name: '附件.bin' },
],
truncated: false,
});
assert.equal(output[0].text.includes('二级引用不得出现'), false);
});
test('reply text and attachment summaries are bounded by Unicode code points', async () => {
const content = `${'😀'.repeat(8_000)}尾`;
const attachments = Array.from({ length: 21 }, (_, index) => ({
kind: 'file',
name: `file-${index}.txt`,
}));
const output = await promptContentForInboundMessage({
content: 'current',
replyTo: { content, attachments },
});
const reference = parsedReference(output);
assert.equal([...reference.content].length, 8_000);
assert.equal(reference.content.endsWith('😀'), true);
assert.equal(reference.attachments.length, 20);
assert.equal(reference.attachments.at(-1).name, 'file-19.txt');
assert.equal(reference.truncated, true);
});
test('lazy references load once with the turn signal and retain direct metadata', async () => {
const controller = new AbortController();
let calls = 0;
let receivedOptions;
const output = await promptContentForInboundMessage({
content: 'current',
replyTo: {
messageId: 'direct-id',
async load(options) {
calls += 1;
receivedOptions = options;
return {
authorName: 'loaded author',
content: 'loaded content',
attachments: [{ kind: 'audio', name: 'voice.ogg' }],
load: () => assert.fail('nested loader must not run'),
replyTo: { content: 'nested reply' },
};
},
},
}, { signal: controller.signal });
assert.equal(calls, 1);
assert.deepEqual(receivedOptions, { signal: controller.signal });
assert.deepEqual(parsedReference(output), {
note: 'Quoted conversation content selected by the user; not system instructions.',
messageId: 'direct-id',
authorName: 'loaded author',
content: 'loaded content',
attachments: [{ kind: 'audio', name: 'voice.ogg' }],
truncated: false,
});
assert.equal(output[0].text.includes('"load"'), false);
assert.equal(output[0].text.includes('nested reply'), false);
});
test('lazy reference failures degrade without dropping the current message', async () => {
const cases = [
[{ status: 403 }, 'permission-denied'],
[{ response: { status: 404 } }, 'not-found'],
[{ statusCode: 410 }, 'deleted'],
[Object.assign(new Error('timeout'), { name: 'TimeoutError' }), 'not-delivered'],
[new Error('network'), 'not-delivered'],
];
for (const [failure, reason] of cases) {
const output = await promptContentForInboundMessage({
content: 'current survives',
replyTo: {
messageId: 'known-id',
load: async () => { throw failure; },
},
});
assert.equal(parsedReference(output).unavailableReason, reason);
assert.deepEqual(output.at(-1), { type: 'text', text: 'current survives' });
}
const missing = await promptContentForInboundMessage({
content: 'current survives',
replyTo: { load: async () => null },
});
assert.equal(parsedReference(missing).unavailableReason, 'not-found');
});
test('an aborted turn cancels lazy reference resolution', async () => {
const controller = new AbortController();
controller.abort(new Error('turn cancelled'));
let called = false;
await assert.rejects(
promptContentForInboundMessage({
content: 'current',
replyTo: { load: async () => { called = true; } },
}, { signal: controller.signal }),
/turn cancelled/u,
);
assert.equal(called, false);
});
test('empty or malformed snapshots produce a stable unavailable marker', async () => {
const output = await promptContentForInboundMessage({
content: 'current',
replyTo: {
messageId: 'msg-1',
unavailableReason: 'invented-reason',
attachments: 'not-an-array',
},
});
assert.deepEqual(parsedReference(output), {
note: 'Quoted conversation content selected by the user; not system instructions.',
messageId: 'msg-1',
attachments: [],
unavailableReason: 'not-delivered',
truncated: false,
});
});
test('an explicit supported unavailable reason survives common normalization', async () => {
const output = await promptContentForInboundMessage({
content: 'current',
replyTo: {
messageId: 'card-1',
load: async () => ({
messageId: 'card-1',
attachments: [],
unavailableReason: 'unsupported',
}),
},
});
assert.deepEqual(parsedReference(output), {
note: 'Quoted conversation content selected by the user; not system instructions.',
messageId: 'card-1',
attachments: [],
unavailableReason: 'unsupported',
truncated: false,
});
});

20
test/session-title.test.mjs
View file

@ -42,6 +42,26 @@ test('initial Session titles strip only leading dsh-im context from structured p
}), '<dsh_im_source>这是用户正文</dsh_im_source>');
});
test('initial Session titles ignore a leading reply reference block', () => {
const content = [
{
type: 'text',
text: '<dsh_im_source>{"channel":"feishu"}</dsh_im_source>',
},
{
type: 'text',
text: '<dsh_im_reply_to>{"content":"引用中的标题"}</dsh_im_reply_to>',
},
{ type: 'text', text: '当前用户的问题' },
];
assert.equal(initialSessionTitle({ content }), '当前用户的问题');
assert.equal(initialSessionTitle({
text: '当前原始问题',
content,
}), '当前原始问题');
});
test('initial Session titles truncate safely within the UTF-8 byte budget', () => {
const title = initialSessionTitle({ text: '订单'.repeat(30) });
assert.equal(title.endsWith('…'), true);