@zzzpyyy/dsh-bot-feishu 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,84 @@
-# Temporary Holding Version
+# 飞书机器人接入
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+DSH Bot 0.5.0 的「IM 接入 → 飞书」配置面板支持为每个 Bot 单独创建并绑定一个飞书机器人，也可以绑定已有应用。如流入口、凭据和会话继续保留。飞书插件是独立可选包 `@zzzpyyy/dsh-bot-feishu@0.1.0`，搭配 DSH `0.1.5-rc.2` 和 `@zzzpyyy/dsh-bot@0.5.0`。
+
+同一个 DSH Bot 可以同时启用飞书和如流绑定。在「IM 接入」的两个平台页分别选择同一个 Bot 并完成配置即可，不需要复制 Bot。两边的凭据、准入名单和启停开关独立；停用一个平台不影响另一个平台。消息记录、模型对话上下文和回复目的地按平台及具体聊天隔离，不自动同步或转发；私聊与群聊也分别保存。同名群不会跨平台合并。共用的是 Bot 指令、模型和工具配置；工具可访问的文件、外部服务及主动写入的记忆仍由部署配置决定，不属于会话隔离。
+
+## 一个 Bot，四种调用入口
+
+四个入口使用同一个 DSH Bot 的身份、指令和原生执行预设（模型、工具、技能及审批），回复返回发起请求的聊天。
+
+飞书机器人直接发送回复正文，不额外添加 DSH 内部的 `@botId` 行；发送者名称和头像标明回复身份。模型正文中的正常 @ 文本原样保留。
+
+| 入口 | 触发方式 | 回复位置 |
+| --- | --- | --- |
+| Web Bot 单聊 | 打开该 Bot，直接发消息 | 当前 Web 单聊 |
+| Web 群聊 | 将该 Bot 加入群，发送 `@botId 问题` | 当前 Web 群聊 |
+| 飞书 Bot 单聊 | 私聊绑定到该 Bot 的飞书机器人 | 当前飞书单聊 |
+| 飞书群聊 | 将机器人加入允许的群，用飞书原生 @ 选择该机器人后发消息 | 当前飞书群聊 |
+
+Bot 的身份和能力共用，聊天上下文按入口和聊天分别保存；Web 私聊内容不会自动带入飞书或群聊。同一飞书群在 DSH 中只显示一个群聊，成员共享公开消息，各 Bot 保留自己的原生 Session；飞书私聊仍按应用隔离。群里存在多个机器人时，只执行被真正 @ 到的机器人；同一条消息 @ 多个 Bot 时，DSH 只记录一条用户消息，并分别展示各 Bot 的回复。文本中手打同名字符串不能替代飞书的原生 @。审批仍在 DSH 完成。
+
+飞书连接已启用仍不代表所有群都开放。进入 **IM 接入 → 飞书 → 选择 Bot → 允许接入的群 Chat ID**，添加目标群的 `oc_…` 并保存；空名单不会响应群消息。手动接入已有群时，需要分别把群 ID 填入各 Bot 的配置；通过一键建群创建的新群会自动配置所选 Bot。私聊用户也必须在该应用的允许用户名单中。
+
+## 扫码创建并绑定
+
+1. 打开 **DSH Bots → IM 接入 → 飞书**，选择要接入的 Bot。
+2. 点击 **扫码创建并绑定**，使用飞书扫描二维码，或打开页面中的官方授权链接。
+3. 在飞书确认应用名称、租户和申请权限。此步骤需要你的授权；不是后台静默创建。
+4. 返回 DSH。App ID 和 App Secret 会由官方 SDK 返回，凭据直接写入 DSH 凭据库，页面不回显密钥。扫码用户的当前应用 Open ID 会作为默认私聊允许用户和管理员；不同应用的 Open ID 不能互换。
+5. 核对绑定结果，点击 **验证机器人**，再点击 **启用连接**。新绑定默认停用，确保先检查配置。
+
+新应用可能仍需发布或租户管理员审批。出现“暂未就绪”时，凭据已保留，去飞书开发者后台完成发布，然后再次验证即可，不要重复创建。
+
+## 绑定已有机器人
+
+选择对应 Bot，点击 **绑定已有机器人**，填写 App ID（`cli_` 开头）、App Secret、允许私聊用户（该应用的 `ou_` Open ID）和管理员。平台可选飞书或 Lark。点击 **验证并保存**，通过后启用连接。
+
+已保存密钥留空表示保留原值。一个 App ID 只能绑定一个 DSH Bot，防止两个 Bot 争抢同一应用事件。已有绑定不能直接换应用；为新应用创建一个新的 DSH Bot。
+
+## 消息、权限和群聊
+
+连接使用飞书官方长连接，不需要公网回调地址。应用需启用机器人能力，在「事件与回调」使用长连接，并订阅 `im.message.receive_v1`。接入申请以下应用权限：
+
+- `im:message.p2p_msg:readonly`：接收用户私聊。
+- `im:message.group_at_msg:readonly`：接收群中 @机器人的消息。
+- `im:message:send_as_bot`：以机器人身份发送回复。
+- `im:chat:create`：创建飞书群；已有应用可点击页面中的「开通建群权限」补齐。
+
+官方创建页的 `addons` 能力仍有灰度限制；若没有采用请求的配置，可能展示默认模板。以实际授权页为准，核对权限，并在开发者后台补齐消息事件、长连接和发布状态。不要同时在其他程序运行同一应用的接收连接。
+
+私聊只接受允许用户；群聊只接受允许群 ID（`oc_`）且明确 @当前机器人的文字消息。空名单表示不允许。将机器人加入已有飞书群后，把群 ID 填入该 Bot 的允许群列表并保存。支持文字回复及 `/help`、`/status`、`/stop`；审批仍在 DSH 中处理。
+
+## 一键创建飞书群聊
+
+在 **IM 接入 → 飞书 → 选择已启用的 Bot → 新建飞书群聊** 填写群名，勾选 1–6 个同企业、同平台且已启用的机器人，然后点击「创建」。普通「新建群聊」窗口也可以勾选「同时创建飞书群聊」。DSH 使用指定的建群机器人创建私有群，自动加入群主及所选机器人、补充各 Bot 的允许群列表，并创建对话记录。建群机器人需要 `im:chat:create`；其他被邀请的机器人只需原有消息权限。
+
+群主默认是建群机器人配置的第一位管理员，没有管理员时使用第一位允许私聊用户。高级设置可以填写该应用对应的群主 Open ID；不同应用的用户 Open ID 不能互换。群里用飞书原生 @ 选择机器人即可调用它。DSH 中以群名显示一个共享群聊，包含所有接入成员及其回复。此入口创建飞书群及其记录，不额外创建独立 Web 群。
+
+升级后会自动合并旧版按 Bot 拆开的同群记录，保留原生 Session、回复和待发队列；重复的同一条群消息合并为一条。首次继续执行时，各 Bot 会获得有上限的共享公开历史。原来保存的群聊入口仍可跳转到合并后的群。DSH 内可查看记录、停止响应和打开执行会话；发消息及 @ 操作在飞书完成。
+
+如果建群被明确拒绝（例如缺少 `im:chat:create`），弹窗会保留群名和成员并恢复编辑；可以从弹窗打开当前应用的权限页，或改用曾成功建群的机器人。已关闭的失败请求可在「IM 接入 → 飞书」群聊列表点击「修改后重试」恢复草稿。切换建群机器人会清空原应用的群主 Open ID，改用新机器人的默认群主。结果尚未确认或群已创建但接入未完成时，配置继续锁定，点击「继续完成」恢复同一次请求。
+
+建群记录先持久化请求 ID，再调用[飞书创建群 API](https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/chat/create.md)。失败时从飞书页面的群列表点击「继续完成」：已保存群 ID 的请求只补齐本地接入，未知结果在原请求的 9 小时内使用相同 UUID 和群主重试（飞书去重期限为 10 小时）；到期后须先确认远端结果，已有群可手动接入。服务重启不会自动重发建群。原有如流建群功能继续可用。
+
+## 取消、重启和重试
+
+取消只停止等待授权，不能撤销已经在飞书确认创建的应用。授权中服务重启后，不会自动重试创建；先检查飞书后台，若已存在应用，使用「绑定已有机器人」。二维码过期后可重新发起扫码。创建结果或本地保存失败也不会自动创建第二个应用。
+
+聊天接收、回复队列和去重记录保存在 DSH 原生存储。连接恢复可继续已接收任务。发送使用稳定的 UUID；飞书服务的去重有效期有限，长时间不确定的网络故障无法保证远端永不重复。
+
+## 安装与开发
+
+在兼容的 DSH `0.1.5-rc.2` Web profile 中，先安装主包，再安装飞书插件：
+
+```sh
+dsh plugin --profile web add @zzzpyyy/dsh-bot@0.5.0
+dsh plugin --profile web add @zzzpyyy/dsh-bot-feishu@0.1.0
+```
+
+Desktop 可在插件管理器中按相同顺序安装这两个精确版本。包使用 `next` 标签；使用与现有服务相同的 profile 和数据目录。升级前备份数据并停止 Host，升级后重启，再从「IM 接入 → 飞书」检查连接状态。
+
+构建后运行 `npm run pack:feishu`，得到独立伴随包。该包固定依赖公开的 `@larksuiteoapi/node-sdk@1.75.0` 和 `qrcode@1.5.4`。通过 DSH 原生插件包安装机制加载；Web 使用包内 `cordis.patch.yml`，与基础插件的 patch 一起放在命令行子命令之前。默认只启用管理页，不创建应用、不连接未启用的绑定。可调队列、重试与 HTTP 超时见 [示例配置](https://github.com/zzzpyyy/dsh-bot/blob/main/feishu/cordis.patch.example.yml)。
+
+官方依据：[SDK 应用注册](https://github.com/larksuite/node-sdk#app-registration)、[飞书官方扫码创建指南](https://www.feishu.cn/content/article/7613711414611463386)、[实现调研](https://github.com/zzzpyyy/dsh-bot/blob/main/docs/feishu-provisioning-research.zh.md)。

package/compatibility.json

@@ -0,0 +1,12 @@
+{
+  "dsh": "0.1.5-rc.2",
+  "commit": "c291e7961a515f6d7af9304e7fd1d257929aef26",
+  "botMode": {
+    "name": "@zzzpyyy/dsh-bot",
+    "version": "0.5.0"
+  },
+  "feishu": {
+    "name": "@zzzpyyy/dsh-bot-feishu",
+    "version": "0.1.0"
+  }
+}

package/cordis.patch.example.yml

@@ -0,0 +1,14 @@
+# Install the companion; no robot or authorization starts until requested in the page.
+- id: bot-feishu
+  disabled: false
+  config:
+    endpointTimeoutMs: 15000
+    pollMs: 1000
+    maxPending: 200
+    maxQueuePerRoom: 20
+    maxConcurrentRooms: 4
+    maxReceipts: 100000
+    maxOutbox: 10000
+    chunkSize: 3000
+    retryMs: 5000
+    maxRetryMs: 120000

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: bot-feishu
+      name: ./feishu.js

package/domain-OHZklmI3.js

@@ -0,0 +1,520 @@
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { z } from "zod";
+import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
+//#region lib/types/infoflow/messages.js
+/** Decode the SDK's external wire payloads without coercing unsafe numeric IDs. */
+const record = z.record(z.string(), z.unknown());
+function object(value) {
+	return record.safeParse(value).data ?? {};
+}
+function id(value) {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return String(value);
+}
+function text(value) {
+	return typeof value === "string" ? value : "";
+}
+/** Match an exact robot AT; name-only and @everyone events cannot start a turn.
+* @param event - SDK event name.
+* @param value - untrusted SDK envelope.
+* @param accountId - configured application ID.
+* @param robotId - configured group mention identity.
+* @returns a text message or null for irrelevant/unsupported events.
+*/
+function decodeMessage(event, value, accountId, robotId) {
+	const raw = object(object(object(value).data).raw);
+	if (event === "private.text" || event === "private.markdown") {
+		const sender = id(raw.FromUserId ?? raw.fromUserId);
+		const receipt = id(raw.MsgId ?? raw.msgId);
+		const content = text(raw.Content ?? raw.content ?? raw.Text ?? raw.text).trim();
+		if (!sender || sender === robotId || !receipt || !content) return null;
+		return {
+			conversation: {
+				provider: "infoflow",
+				accountId,
+				kind: "private",
+				id: sender
+			},
+			message: {
+				id: receipt,
+				sender: {
+					id: sender,
+					name: sender
+				}
+			},
+			text: content
+		};
+	}
+	if (![
+		"group.text",
+		"group.markdown",
+		"group.mixed"
+	].includes(event)) return null;
+	if (raw.eventtype !== void 0 && raw.eventtype !== "MESSAGE_RECEIVE") return null;
+	const group = id(raw.groupid ?? raw.groupId);
+	const message = object(raw.message);
+	const header = object(message.header);
+	if (header.role === "robot") return null;
+	const sender = id(header.fromuserid ?? header.fromUserId ?? raw.fromuserid);
+	const receipt = id(header.messageid ?? raw.messageid);
+	const blocks = Array.isArray(message.body) ? message.body.map(object) : [];
+	if (!group || !sender || sender === robotId || !receipt || !blocks.some((block) => text(block.type).toUpperCase() === "AT" && id(block.robotid) === robotId)) return null;
+	const content = blocks.flatMap((block) => {
+		const type = text(block.type).toUpperCase();
+		if ([
+			"TEXT",
+			"MD",
+			"MARKDOWN"
+		].includes(type)) return [text(block.content ?? block.text)];
+		if (type === "LINK") return [text(block.label ?? block.url ?? block.href)];
+		return [];
+	}).join("\n").trim();
+	if (!content) return null;
+	return {
+		conversation: {
+			provider: "infoflow",
+			accountId,
+			kind: "group",
+			id: group
+		},
+		message: {
+			id: receipt,
+			sender: {
+				id: sender,
+				name: text(header.fromusername) || sender
+			}
+		},
+		text: content
+	};
+}
+/** Unambiguous key for receipts and per-conversation ordering.
+* @param conversation - stable external identity.
+* @returns serialized tuple, with no numeric conversion.
+*/
+function conversationKey(conversation) {
+	return JSON.stringify([
+		conversation.provider,
+		conversation.accountId,
+		conversation.kind,
+		conversation.id
+	]);
+}
+/** Split at Unicode code points, retaining exact content for retry.
+* @param content - outbound text.
+* @param limit - configured platform payload limit in code points.
+* @returns ordered nonempty parts.
+*/
+function splitMessage(content, limit) {
+	const points = Array.from(content);
+	const chunks = [];
+	for (let i = 0; i < points.length; i += limit) chunks.push(points.slice(i, i + limit).join(""));
+	return chunks;
+}
+/** Exact platform mentions route a shared group receipt across robot connections. */
+function mentionedRobots(value) {
+	const body = object(object(object(object(value).data).raw).message).body;
+	return Array.isArray(body) ? body.map(object).filter((block) => text(block.type).toUpperCase() === "AT").map((block) => id(block.robotid)).filter((value) => value !== void 0) : [];
+}
+//#endregion
+//#region lib/types/infoflow/bridge.js
+/** One configured robot. All persistence writes are serialized, including SDK callbacks. */
+var InfoFlowBridge = class {
+	bots;
+	store;
+	sender;
+	config;
+	report;
+	state;
+	tail = Promise.resolve();
+	operations = Promise.resolve();
+	worker;
+	dirty = false;
+	closed = false;
+	/** @param bots - same Host's Bot owner. @param store - durable native domain. @param sender - SDK adapter.
+	* @param config - validated deployment settings. @param report - contained error reporting, without message bodies or secrets.
+	*/
+	constructor(bots, store, sender, config, report) {
+		this.bots = bots;
+		this.store = store;
+		this.sender = sender;
+		this.config = config;
+		this.report = report;
+		this.state = structuredClone(store.get());
+	}
+	change(action) {
+		const operation = this.tail.then(async () => {
+			const draft = structuredClone(this.state);
+			const result = action(draft);
+			await this.store.set(draft);
+			this.state = draft;
+			return result;
+		});
+		this.tail = operation.catch(() => {});
+		return operation;
+	}
+	exclusive(action) {
+		const operation = this.operations.then(action);
+		this.operations = operation.catch(() => {});
+		return operation;
+	}
+	room(input) {
+		return this.bots.snapshot().rooms.find((room) => room.external && (conversationKey(room.external) === conversationKey(input.conversation) || room.external.provider === "feishu" && input.conversation.provider === "feishu" && room.external.kind === "group" && input.conversation.kind === "group" && room.external.id === input.conversation.id));
+	}
+	enqueue(state, key, input, content, botId = input.targets?.[0] ?? this.config.defaultBot) {
+		const parts = splitMessage(content, this.config.chunkSize);
+		if (state.outbox.length + parts.length > this.config.maxOutbox) throw new Error("External chat outbox is full; delivery must recover before accepting more results");
+		for (const [index, text] of parts.entries()) state.outbox.push({
+			id: `${key}:${index}`,
+			conversation: input.conversation,
+			user: input.message.sender.id,
+			botId,
+			text,
+			attempts: 0,
+			nextAt: 0
+		});
+	}
+	/** Persist authorization-approved input and its receipt in the same write.
+	* @param input - validated SDK text event.
+	* @returns accepted, duplicate, or ignored; a full queue throws before claiming the receipt.
+	*/
+	async receive(input) {
+		return this.exclusive(() => this.admit(input));
+	}
+	async admit(input) {
+		if (this.closed) throw new Error("External chat is stopping");
+		const { conversation, message, text } = input;
+		if (conversation.provider !== (this.config.provider ?? "infoflow") || conversation.accountId !== this.config.accountId) return "ignored";
+		if (conversation.kind === "private" ? !this.config.allowUsers.includes(message.sender.id) : !(conversation.provider === "infoflow" && this.config.allowAllGroups === true) && !this.config.allowGroups.includes(conversation.id)) return "ignored";
+		const key = JSON.stringify([conversationKey(conversation), message.id]);
+		const outcome = await this.change((state) => {
+			if (state.receipts.includes(key)) return "duplicate";
+			if (state.receipts.length >= this.config.maxReceipts) throw new Error("External chat receipt capacity reached; raise maxReceipts before continuing");
+			state.receipts.push(key);
+			const room = this.room(input);
+			const command = text.trim().split(/\s+/)[0];
+			if (text.length > 32e3) {
+				this.enqueue(state, key, input, "消息过长，请缩短到 32000 字符以内。");
+				return "accepted";
+			}
+			if (command.startsWith("/")) {
+				if (command === "/help") this.enqueue(state, key, input, "直接发送文字开始对话。群内先 @对应机器人。\n/bots 查看 Bot\n/status 查看当前会话\n/stop 停止自己在当前会话的请求（管理员可停止全部）\n审批与执行详情请由部署者在 DSH 中处理。");
+				else if (command === "/bots") this.enqueue(state, key, input, this.bots.snapshot().bots.filter((bot) => this.config.botIds.includes(bot.id)).map((bot) => `@${bot.id} ${bot.name}`).join("\n"));
+				else if (command === "/status") {
+					const pending = state.pending.filter((item) => conversationKey(item.input.conversation) === conversationKey(conversation));
+					const active = room?.messages.filter((item) => item.status === "running") ?? [];
+					this.enqueue(state, key, input, `排队：${pending.filter((item) => !item.submitted && !item.stop).length}；执行中：${active.length}。\n${active.length ? "执行进度与人工审批请在 DSH 的对应外部聊天中打开执行会话查看。" : "当前没有正在执行的 Bot。"}`);
+				} else if (command === "/stop") {
+					const admin = this.config.admins.includes(message.sender.id);
+					const mayStop = (sender) => admin || sender === message.sender.id;
+					const canceled = state.pending.filter((item) => !item.submitted && !item.stop && conversationKey(item.input.conversation) === conversationKey(conversation) && mayStop(item.input.message.sender.id) && !room?.messages.some((message) => message.external?.id === item.input.message.id));
+					for (const item of canceled) this.enqueue(state, `${item.key}:canceled`, item.input, "请求已在开始执行前取消。");
+					state.pending = state.pending.filter((item) => !canceled.includes(item));
+					const shared = conversation.provider === "feishu" && conversation.kind === "group";
+					const attemptIds = room?.messages.filter((item) => {
+						if (item.status !== "running" || !item.replyTo || shared && (!item.botId || !this.config.botIds.includes(item.botId))) return false;
+						const external = room.messages.find((parent) => parent.id === item.replyTo)?.external;
+						return mayStop((shared ? external?.sources?.find((source) => source.accountId === this.config.accountId)?.senderId : external?.sender.id) ?? "");
+					}).map((item) => item.id) ?? [];
+					if (room && attemptIds.length) state.pending.push({
+						key,
+						input,
+						binding: this.binding(input),
+						stop: {
+							roomId: room.id,
+							attemptIds
+						}
+					});
+					else this.enqueue(state, key, input, canceled.length ? "已取消排队中的请求。" : "当前没有你可以停止的请求。");
+				} else this.enqueue(state, key, input, "不支持此命令。发送 /help 查看用法。");
+				return "accepted";
+			}
+			if (state.pending.length >= this.config.maxPending || state.pending.filter((item) => conversationKey(item.input.conversation) === conversationKey(conversation)).length >= this.config.maxQueuePerRoom) throw new Error("External chat request queue is full; retry later");
+			state.pending.push({
+				key,
+				input,
+				binding: this.binding(input)
+			});
+			this.enqueue(state, `${key}:received`, input, "已接收，按当前聊天的顺序处理。");
+			return "accepted";
+		});
+		this.wake();
+		return outcome;
+	}
+	binding(input) {
+		const privateChat = input.conversation.kind === "private";
+		return {
+			conversation: input.conversation,
+			title: `${input.conversation.provider === "feishu" ? "飞书" : "如流"} · ${privateChat ? input.message.sender.name : input.conversation.id}`,
+			botIds: privateChat ? [this.config.defaultBot] : this.config.botIds,
+			defaultBot: this.config.defaultBot
+		};
+	}
+	/** Coalesce feed, timer, and inbound callbacks into one worker.
+	* @returns completion of currently signaled work; retry deadlines never busy-loop.
+	*/
+	wake() {
+		if (this.closed) return Promise.resolve();
+		this.dirty = true;
+		this.worker ??= this.work().finally(() => {
+			this.worker = void 0;
+			if (this.dirty && !this.closed) this.wake();
+		});
+		return this.worker;
+	}
+	async work() {
+		while (this.dirty && !this.closed) {
+			this.dirty = false;
+			try {
+				await this.exclusive(() => this.dispatch());
+			} catch {
+				this.report("External chat processing failed; durable work is retained for the next retry");
+			}
+			try {
+				await this.deliver();
+			} catch {
+				this.report("External chat delivery settlement failed; durable replies are retained");
+			}
+		}
+	}
+	async finish(item, content) {
+		await this.change((state) => {
+			if (!state.pending.some((current) => current.key === item.key)) return;
+			this.enqueue(state, `${item.key}:result`, item.input, content);
+			state.pending = state.pending.filter((current) => current.key !== item.key);
+		});
+	}
+	async dispatch() {
+		for (const item of [...this.state.pending].filter((item) => item.stop)) {
+			if (this.closed) return;
+			if (item.input.conversation.accountId !== this.config.accountId) continue;
+			for (const messageId of item.stop.attemptIds) await this.bots.stop({
+				roomId: item.stop.roomId,
+				messageId
+			});
+			await this.finish(item, "已处理停止请求，请在 DSH 中查看执行记录。");
+		}
+		const blocked = /* @__PURE__ */ new Set();
+		for (const item of [...this.state.pending].filter((item) => !item.stop)) {
+			if (this.closed) return;
+			if (item.input.conversation.accountId !== this.config.accountId) continue;
+			if (item.submitted) {
+				const room = this.bots.snapshot().rooms.find((room) => room.id === item.submitted.roomId || room.aliases?.includes(item.submitted.roomId));
+				if (!room) throw new Error("Submitted external room is missing");
+				const responses = item.submitted.attemptIds.map((id) => room.messages.find((message) => message.id === id));
+				if (responses.some((message) => !message)) throw new Error("Submitted external response is missing");
+				if (responses.every((message) => message.status !== "running")) await this.change((state) => {
+					for (const message of responses) {
+						const response = message;
+						const content = response.status === "complete" ? response.text || "本次执行完成，没有文字回复。" : response.status === "interrupted" ? "执行已中断，未自动重跑。请部署者在 DSH 中检查执行记录。" : response.status === "canceled" ? "执行已停止。" : "执行失败，请部署者在 DSH 中检查执行记录。";
+						const text = this.config.labelReplies ? `@${response.botId}\n${content}` : content;
+						this.enqueue(state, `${item.key}:result:${response.id}`, item.input, text, response.botId ?? this.config.defaultBot);
+					}
+					state.pending = state.pending.filter((current) => current.key !== item.key);
+				});
+				continue;
+			}
+			const key = conversationKey(item.input.conversation);
+			if (blocked.has(key)) continue;
+			blocked.add(key);
+			if (this.bots.snapshot().rooms.filter((room) => room.external && room.messages.some((message) => message.status === "running")).length >= this.config.maxConcurrentRooms) continue;
+			const known = this.bots.snapshot().bots.map((bot) => bot.id);
+			if (item.binding.botIds.some((id) => !known.includes(id))) {
+				await this.finish(item, "配置的 Bot 不存在，请部署者检查机器人配置。");
+				continue;
+			}
+			try {
+				const room = await this.bots.ensureExternalRoom(item.binding);
+				const accepted = await this.bots.submitExternalMessage({
+					roomId: room.id,
+					text: item.input.text,
+					external: item.input.message,
+					sourceAccountId: item.input.conversation.accountId,
+					...item.input.targets ? { targets: item.input.targets } : {}
+				});
+				if (accepted.status === "rejected") {
+					await this.finish(item, accepted.reason === "room-full" ? "该聊天的历史容量已满，请部署者调整 DSH Bot 的 maxMessages 配置。" : "消息无法提交，请检查文字和 @Bot 是否属于当前聊天。");
+					continue;
+				}
+				if (accepted.status === "accepted") await this.change((state) => {
+					const current = state.pending.find((current) => current.key === item.key);
+					if (current) current.submitted = {
+						roomId: room.id,
+						attemptIds: accepted.attemptIds
+					};
+				});
+			} catch {
+				this.report("External chat admission failed; check Bot configuration/storage and retained queue");
+				await this.change((state) => {
+					const notice = `${item.key}:admission-error`;
+					if (state.notices.includes(notice)) return;
+					this.enqueue(state, notice, item.input, "请求暂未提交，请部署者检查 Bot 配置或存储。消息已保留，系统会重试。");
+					state.notices.push(notice);
+				});
+			}
+		}
+	}
+	async deliver() {
+		const blockedRecipients = /* @__PURE__ */ new Set();
+		for (const delivery of [...this.state.outbox]) {
+			if (this.closed) return;
+			if (delivery.conversation.accountId !== this.config.accountId) {
+				this.report("Retained delivery belongs to another External chat account; restore the original configuration");
+				continue;
+			}
+			const key = conversationKey(delivery.conversation);
+			if (blockedRecipients.has(key)) continue;
+			if (delivery.nextAt > Date.now()) {
+				blockedRecipients.add(key);
+				continue;
+			}
+			try {
+				await this.sender.send(delivery);
+			} catch {
+				blockedRecipients.add(key);
+				await this.change((state) => {
+					const current = state.outbox.find((item) => item.id === delivery.id);
+					if (current) {
+						current.attempts++;
+						current.nextAt = Date.now() + Math.min(this.config.maxRetryMs, this.config.retryMs * 2 ** Math.min(current.attempts - 1, 20));
+					}
+				});
+				this.report("External chat send failed; the reply remains queued");
+				continue;
+			}
+			await this.change((state) => {
+				state.outbox = state.outbox.filter((item) => item.id !== delivery.id);
+			});
+		}
+	}
+	/** Notify the original destination about native human interaction without answering it.
+	* @param sessionId - native Session requesting attention.
+	* @param noticeId - stable approval/tool identifier for deduplication.
+	*/
+	async attention(sessionId, noticeId) {
+		if (this.closed) return;
+		const room = this.bots.snapshot().rooms.find((room) => room.members.some((member) => member.sessionId === sessionId));
+		if (!room?.external || room.external.provider !== (this.config.provider ?? "infoflow")) return;
+		const shared = room.external.provider === "feishu" && room.external.kind === "group";
+		if (!shared && room.external.accountId !== this.config.accountId) return;
+		const member = room.members.find((member) => member.sessionId === sessionId);
+		if (shared && !this.config.botIds.includes(member.botId)) return;
+		const attempt = room.messages.find((message) => message.botId === member.botId && message.status === "running");
+		if (!attempt) return;
+		const parent = room.messages.find((message) => message.id === attempt.replyTo);
+		const senderId = parent?.external?.sources?.find((source) => source.accountId === this.config.accountId)?.senderId ?? parent?.external?.sender.id;
+		const input = this.state.pending.find((item) => item.submitted?.attemptIds.includes(attempt.id))?.input ?? (parent?.external && senderId ? {
+			conversation: {
+				...room.external,
+				accountId: this.config.accountId
+			},
+			message: {
+				...parent.external,
+				sender: {
+					...parent.external.sender,
+					id: senderId
+				}
+			},
+			text: parent.text,
+			targets: [member.botId]
+		} : void 0);
+		if (!input) return;
+		const key = `${sessionId}:${attempt.id}:${noticeId}`;
+		await this.change((state) => {
+			if (state.notices.includes(key)) return;
+			this.enqueue(state, `attention:${key}`, input, `@${member.botId} 请求了人工处理。请部署者在 DSH 对应外部聊天中打开执行会话。`);
+			state.notices.push(key);
+		});
+		this.wake();
+	}
+	/** Stop taking work and await in-flight persistence/sending; Bot execution remains owned by DSH. */
+	async close() {
+		this.closed = true;
+		await this.worker;
+		await this.operations;
+		await this.tail;
+	}
+};
+//#endregion
+//#region lib/types/infoflow/domain.js
+/** Connector-owned durable admission queue and outbound delivery records. */
+const conversation = z.object({
+	provider: z.enum(["infoflow", "feishu"]),
+	accountId: z.string().min(1),
+	kind: z.enum(["private", "group"]),
+	id: z.string().min(1)
+});
+const message = z.object({
+	id: z.string().min(1),
+	sender: z.object({
+		id: z.string().min(1),
+		name: z.string()
+	})
+});
+const attempts = z.object({
+	roomId: z.string().transform(brandString),
+	attemptIds: z.array(z.string().transform(brandString))
+});
+const bridgeSchema = z.object({
+	receipts: z.array(z.string()),
+	notices: z.array(z.string()),
+	pending: z.array(z.object({
+		key: z.string(),
+		input: z.object({
+			conversation,
+			message,
+			text: z.string(),
+			targets: z.array(z.string().transform(brandString)).optional()
+		}),
+		binding: z.object({
+			conversation,
+			title: z.string(),
+			botIds: z.array(z.string().transform(brandString)),
+			defaultBot: z.string().transform(brandString)
+		}),
+		submitted: attempts.optional(),
+		stop: attempts.optional()
+	})),
+	outbox: z.array(z.object({
+		id: z.string(),
+		conversation,
+		user: z.string(),
+		text: z.string(),
+		attempts: z.number().int().nonnegative(),
+		nextAt: z.number(),
+		botId: z.string().transform(brandString).optional()
+	}))
+});
+/** Separate authoritative state; no SDK credentials or native execution logs are copied here. */
+const infoflowDomain = defineDomain({
+	name: "bot_infoflow",
+	version: 1,
+	tables: {},
+	global: {
+		schema: bridgeSchema,
+		initial: {
+			receipts: [],
+			pending: [],
+			outbox: [],
+			notices: []
+		}
+	}
+});
+/** Each managed robot or shared group owns an independent queue. */
+function bridgeDomain(name) {
+	return defineDomain({
+		name,
+		version: 1,
+		tables: {},
+		global: {
+			schema: bridgeSchema,
+			initial: {
+				receipts: [],
+				pending: [],
+				outbox: [],
+				notices: []
+			}
+		}
+	});
+}
+//#endregion
+export { mentionedRobots as a, decodeMessage as i, infoflowDomain as n, InfoFlowBridge as r, bridgeDomain as t };