larkin 0.2.70

package/dist/feishu/host-business-state.mjs

@@ -0,0 +1,462 @@
+import crypto from "node:crypto";
+import { createMessageEnvelope, targetAliases, targetFor, } from "./message-policy.mjs";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export function safeConversationExcerpt(value, max = 360) {
+    let text = String(value || "").replace(/\s+/g, " ").trim();
+    text = text
+        .replace(/\b(sk-[A-Za-z0-9_-]{12,})\b/g, "[已隐藏凭证]")
+        .replace(/\b(token|secret|password|passwd)\s*[:=]\s*[^\s,;]+/gi, "$1=[已隐藏]");
+    return text.length > max ? `${text.slice(0, Math.max(0, max - 1))}…` : text;
+}
+/** 距最后一次「连接建立或真实入站事件」的静默毫秒数；未连接返回 null。 */
+export function inboundSilenceMs(status, now) {
+    const connected = Date.parse(String(status.connectedAt || ""));
+    if (!Number.isFinite(connected))
+        return null;
+    const inbound = Date.parse(String(status.inboundVerifiedAt || ""));
+    const base = Number.isFinite(inbound) ? Math.max(connected, inbound) : connected;
+    return Math.max(0, now.getTime() - base);
+}
+/**
+ * 静默超阈值 → 该做预防性重连。两个不抢的例外：
+ * - connectedAt 早于 connectedAfterMs（status.json 里上一轮 daemon 的残留断言，本轮还没真正连上）；
+ * - SDK 自身正在重连（reconnectingAt 未过期）。
+ */
+export function shouldPreventiveReconnect(status, now, thresholdMs, connectedAfterMs = null) {
+    if (!(thresholdMs > 0))
+        return false;
+    if (connectedAfterMs !== null) {
+        const connected = Date.parse(String(status.connectedAt || ""));
+        if (!Number.isFinite(connected) || connected < connectedAfterMs)
+            return false;
+    }
+    const silence = inboundSilenceMs(status, now);
+    if (silence === null || silence < thresholdMs)
+        return false;
+    const reconnecting = Date.parse(String(status.reconnectingAt || ""));
+    if (Number.isFinite(reconnecting) && now.getTime() - reconnecting < thresholdMs)
+        return false;
+    // Maintenance reconnecting creates a fresh connectedAt, but that transport fact is not new
+    // inbound evidence. Keep the drought cycle closed until a real inbound event arrives later.
+    const persistedDroughtReconnect = Math.max(Date.parse(String(status.droughtReconnectAt || "")) || Number.NEGATIVE_INFINITY, Date.parse(String(status.droughtReconnectAbandonedAt || "")) || Number.NEGATIVE_INFINITY);
+    // A daemon restart opens a new maintenance cycle. Only a marker written during
+    // the current event-source epoch can suppress another attempt in this run.
+    const droughtReconnect = connectedAfterMs === null || persistedDroughtReconnect >= connectedAfterMs
+        ? persistedDroughtReconnect
+        : Number.NEGATIVE_INFINITY;
+    const inbound = Date.parse(String(status.inboundVerifiedAt || ""));
+    if (Number.isFinite(droughtReconnect) && (!Number.isFinite(inbound) || droughtReconnect >= inbound))
+        return false;
+    return true;
+}
+export class HostStateProjection {
+    storeFor;
+    log;
+    now;
+    constructor(storeFor, log = () => { }, now = () => new Date()) {
+        this.storeFor = storeFor;
+        this.log = log;
+        this.now = now;
+    }
+    stateFiles(agent) { return this.storeFor(agent).paths; }
+    readStatus(agent) {
+        try {
+            return asRecord(this.storeFor(agent).readJson("status", {}));
+        }
+        catch {
+            return {};
+        }
+    }
+    updateStatus(agent, patch) {
+        const next = { ...this.readStatus(agent), ...patch };
+        try {
+            this.storeFor(agent).writeJson("status", next);
+        }
+        catch (error) {
+            this.log(`status 写失败 agent=${agent.name}: ${error.message}`);
+        }
+    }
+    appendStatusLog(agent, key, entry, cap) {
+        const current = this.readStatus(agent);
+        const existing = Array.isArray(current[key]) ? current[key] : [];
+        const list = [...existing, entry].slice(-cap);
+        const latestKey = key === "activityLog" ? "lastActivity" : key === "deliverLog" ? "lastDeliver" : null;
+        this.updateStatus(agent, { [key]: list, ...(latestKey ? { [latestKey]: entry } : {}) });
+    }
+    recordStatusError(agent, text) {
+        this.appendStatusLog(agent, "recentErrors", { at: this.now().toISOString(), text: String(text).slice(0, 200) }, 20);
+    }
+    appendConversation(agent, item) {
+        try {
+            this.storeFor(agent).appendNdjson("conversation", { ...item, text: safeConversationExcerpt(item.text) });
+        }
+        catch (error) {
+            this.log(`conversation 写失败 agent=${agent.name}: ${error.message}`);
+        }
+    }
+    loadMap(agent) {
+        try {
+            return asRecord(this.storeFor(agent).readJson("map", {}));
+        }
+        catch {
+            return {};
+        }
+    }
+    saveMap(agent, map) {
+        try {
+            this.storeFor(agent).writeJson("map", map);
+        }
+        catch (error) {
+            this.log("saveMap 失败", error.message);
+        }
+    }
+    mapTargets(agent, targets, chatId) {
+        const map = this.loadMap(agent);
+        for (const target of targets)
+            if (target)
+                map[target] = chatId;
+        this.saveMap(agent, map);
+    }
+    saveReplyContext(agent, keys, chatId, replyTo, threadId) {
+        const aliases = Array.isArray(keys) ? keys : [keys];
+        let map = {};
+        try {
+            map = asRecord(this.storeFor(agent).readJson("replyctx", {}));
+        }
+        catch { /* first run or corrupt state retains historical fail-open behavior */ }
+        const entry = {
+            chat_id: chatId || null,
+            reply_to: replyTo || null,
+            thread_id: threadId || null,
+            in_topic: Boolean(threadId),
+        };
+        for (const alias of aliases)
+            if (alias)
+                map[alias] = entry;
+        if (chatId)
+            map[chatId] = entry;
+        try {
+            this.storeFor(agent).writeJson("replyctx", map);
+        }
+        catch (error) {
+            this.log("replyctx 写失败", error.message);
+        }
+    }
+    loadSenderProfiles(agent) {
+        try {
+            return asRecord(this.storeFor(agent).readJson("senderProfiles", {}));
+        }
+        catch {
+            return {};
+        }
+    }
+    saveSenderProfile(agent, senderId, profile) {
+        const all = this.loadSenderProfiles(agent);
+        all[senderId] = profile;
+        try {
+            this.storeFor(agent).writeJson("senderProfiles", all);
+        }
+        catch { /* signature cache persistence is best-effort by design */ }
+    }
+    recordReadReceipts(agent, reader, readAt, ids) {
+        let data = { receipts: [] };
+        try {
+            data = asRecord(this.storeFor(agent).readJson("readReceipts", data));
+        }
+        catch { /* first run */ }
+        data.receipts = [...(Array.isArray(data.receipts) ? data.receipts : []), { ids, reader, readAt }].slice(-200);
+        this.storeFor(agent).writeJson("readReceipts", data);
+    }
+}
+export class SenderIdentityCache {
+    options;
+    chatNames = new Map();
+    signatures = new Map();
+    now;
+    wait;
+    failureTtlMs;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.wait = options.wait ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+        this.failureTtlMs = options.signatureFailureTtlMs ?? 10 * 60 * 1000;
+    }
+    chatKey(agent, chatId) { return `${agent.agentId}:${chatId}`; }
+    signatureKey(agent, senderId) { return `${agent.agentId}:${senderId}`; }
+    ensureChatNames(agent, chatId, waitMs) {
+        if (!chatId || !agent.feishuProfile)
+            return Promise.resolve({});
+        const key = this.chatKey(agent, chatId);
+        const hit = this.chatNames.get(key);
+        if (hit && !(hit instanceof Promise))
+            return Promise.resolve(hit.names);
+        const pending = hit ?? this.options.fetchChatNames(agent, chatId).then((names) => {
+            if (names)
+                this.chatNames.set(key, { names, at: this.now() });
+            else
+                this.chatNames.delete(key);
+            return names ?? {};
+        });
+        if (!hit)
+            this.chatNames.set(key, pending);
+        if (!waitMs)
+            return Promise.resolve({});
+        return Promise.race([pending, this.wait(waitMs).then(() => ({}))]);
+    }
+    noteUnknownSender(agent, chatId, senderId) {
+        if (!senderId || !/^(ou_|cli_|app_)/.test(senderId))
+            return;
+        const key = this.chatKey(agent, chatId);
+        const hit = this.chatNames.get(key);
+        if (!hit || hit instanceof Promise || this.now() - hit.at < 60_000)
+            return;
+        this.chatNames.delete(key);
+        void this.ensureChatNames(agent, chatId, 0);
+    }
+    ensureSenderSignature(agent, senderId, waitMs) {
+        if (!senderId || !senderId.startsWith("ou_") || !agent.feishuProfile)
+            return Promise.resolve(null);
+        const key = this.signatureKey(agent, senderId);
+        const hit = this.signatures.get(key);
+        if (hit && !(hit instanceof Promise)) {
+            const fresh = this.now() - hit.at < (hit.ttl || this.failureTtlMs);
+            if (!fresh) {
+                this.signatures.delete(key);
+                void this.ensureSenderSignature(agent, senderId, 0);
+            }
+            return Promise.resolve(hit.desc);
+        }
+        const pending = hit ?? this.options.fetchSenderSignature(agent, senderId).then((result) => {
+            const entry = { ...result, at: this.now() };
+            this.signatures.set(key, entry);
+            if (result.ok)
+                this.options.state.saveSenderProfile(agent, senderId, {
+                    description: result.desc,
+                    name: result.name,
+                    at: entry.at,
+                });
+            return result.desc;
+        });
+        if (!hit)
+            this.signatures.set(key, pending);
+        return waitMs ? Promise.race([pending, this.wait(waitMs).then(() => null)]) : Promise.resolve(null);
+    }
+    warmSenderProfiles(agent) {
+        for (const [senderId, profile] of Object.entries(this.options.state.loadSenderProfiles(agent))) {
+            this.signatures.set(this.signatureKey(agent, senderId), {
+                desc: profile.description ?? null,
+                name: profile.name || null,
+                at: profile.at || 0,
+                ok: true,
+                ttl: 6 * 60 * 60 * 1000,
+            });
+        }
+    }
+}
+export class HostEnvelopeProjector {
+    state;
+    noteUnknownSender;
+    randomHex;
+    now;
+    agentCliExecutable;
+    sequenceByAgent = new Map();
+    constructor(state, noteUnknownSender, randomHex = (bytes) => crypto.randomBytes(bytes).toString("hex"), now = () => new Date(), agentCliExecutable = "larkin") {
+        this.state = state;
+        this.noteUnknownSender = noteUnknownSender;
+        this.randomHex = randomHex;
+        this.now = now;
+        this.agentCliExecutable = agentCliExecutable;
+    }
+    agentCommand(suffix) {
+        return `${this.agentCliExecutable} ${suffix}`;
+    }
+    larkCommand(suffix) {
+        return `${this.agentCliExecutable} ${suffix}`;
+    }
+    nextSequence(agentId) {
+        const next = (this.sequenceByAgent.get(agentId) || 0) + 1;
+        this.sequenceByAgent.set(agentId, next);
+        return next;
+    }
+    projectInbound(agent, event, options = {}) {
+        const target = targetFor(event);
+        const aliases = targetAliases(event, target);
+        this.state.mapTargets(agent, aliases, event.chat_id);
+        const messageId = event.message_id || `m_${this.randomHex(6)}`;
+        if (options.anchorReply !== false) {
+            this.state.saveReplyContext(agent, aliases, event.chat_id, messageId, event.thread_id || null);
+        }
+        const names = options.names || {};
+        if (!names[event.sender_id])
+            this.noteUnknownSender(agent, event.chat_id, event.sender_id);
+        return createMessageEnvelope({
+            agent,
+            event: { ...event, message_id: messageId },
+            seq: this.nextSequence(agent.agentId),
+            names,
+            signature: options.signature,
+        });
+    }
+    createReminderEnvelope(agentId, reminder, overdueMs, repeatDescription) {
+        const seq = this.nextSequence(agentId);
+        const anchorMessageId = typeof reminder.msgRef === "string" && /^om_[A-Za-z0-9_-]+$/.test(reminder.msgRef)
+            ? reminder.msgRef
+            : null;
+        const lines = [
+            `[定时提醒触发] ${reminder.title}`,
+            `提醒ID: #${reminder.reminderId.slice(0, 8)}` + (reminder.repeat && repeatDescription
+                ? `　重复: ${repeatDescription}（下次已自动排在 ${reminder.fireAt}）`
+                : "　类型: 一次性"),
+            overdueMs > 120_000 ? `注意: 原定时间已过 ${Math.round(overdueMs / 60_000)} 分钟（Runtime Host 离线期间错过，现补触发）` : null,
+            anchorMessageId ? `锚定消息: ${anchorMessageId}` : reminder.msgRef ? `历史锚点 ${String(reminder.msgRef)} 不是飞书 om_ message_id，不能用于回复` : null,
+            anchorMessageId
+                ? `回复原会话: ${this.larkCommand(`im +messages-reply --message-id ${anchorMessageId} ...`)}`
+                : null,
+            reminder.channel && /^oc_[A-Za-z0-9_-]+$/.test(reminder.channel)
+                ? `发送到原群: ${this.larkCommand(`im +messages-send --chat-id ${reminder.channel} ...`)}`
+                : reminder.channel
+                    ? `历史目标 ${reminder.channel} 不是 chat_id；${anchorMessageId ? "若不回复锚定消息，" : ""}先用 ${this.larkCommand("im +chat-search")} 查询并确认 oc_ chat_id，禁止按名称猜测发送目标`
+                    : anchorMessageId
+                        ? null
+                        : `本条存量提醒缺少可用的飞书 message_id/chat_id，无法安全推断原会话；请先用 ${this.larkCommand("im +chat-search")} 确认目标，禁止猜测发送`,
+            `这是你之前用 ${this.agentCommand("reminder schedule")} 设置的提醒，请按标题执行相应动作。管理: ${this.agentCommand("reminder list")} / ${this.agentCommand("reminder snooze")} / ${this.agentCommand("reminder cancel")}`,
+        ].filter((line) => Boolean(line));
+        return {
+            message_id: `rem_${reminder.reminderId.slice(0, 16)}_${seq}`,
+            seq,
+            sender_name: "定时提醒",
+            sender_type: "system",
+            channel_type: "dm",
+            channel_name: "system",
+            content: lines.join("\n"),
+            timestamp: this.now().toISOString(),
+            thread_id: null,
+            wake: true,
+        };
+    }
+    createRedeliveryEnvelope(agentId, wakeCount) {
+        const seq = this.nextSequence(agentId);
+        return {
+            message_id: `redeliver_${this.randomHex(6)}`,
+            seq,
+            sender_name: "系统",
+            sender_type: "system",
+            channel_type: "dm",
+            channel_name: "system",
+            content: `[启动补投] 服务重启期间有 ${wakeCount} 条本应唤醒你的消息未被读取（可能包含用户消息、@提及或定时提醒）。请先用 ${this.agentCommand("inbox check")} 看目标摘要，再用 ${this.agentCommand("inbox poll")} 领取完整消息；仅当 message_id 以 om_ 开头时才用 ${this.larkCommand("im +messages-reply")}，系统 rem_/redeliver_ ID 不可回复；有 chat_id 时可用 ${this.larkCommand("im +messages-send")}，否则先查询确认目标，禁止猜测。`,
+            timestamp: this.now().toISOString(),
+            thread_id: null,
+        };
+    }
+}
+export function countWakeEnvelopes(lines) {
+    return lines.filter((line) => {
+        try {
+            return JSON.parse(line).wake === true;
+        }
+        catch {
+            return false;
+        }
+    }).length;
+}
+/** Project daemon activity into dashboard state without changing or interpreting Runtime transport frames. */
+export function projectActivityStatus(current, message, runtime, resumeSession, now = new Date()) {
+    if (message.isHeartbeat)
+        return null;
+    const activityKind = message.activityKind || message.activity || "unknown";
+    const at = Number.isFinite(message.observedAtMs)
+        ? new Date(message.observedAtMs).toISOString()
+        : now.toISOString();
+    const entries = Array.isArray(message.entries) ? message.entries : [];
+    const tool = [...entries].reverse().find((entry) => entry?.kind === "tool_start" && entry.toolName)?.toolName || null;
+    const activityEntry = {
+        state: activityKind === "text" ? "working" : (message.activity || activityKind),
+        activityKind,
+        detail: activityKind === "thinking" ? null : (safeConversationExcerpt(message.detail, 180) || null),
+        detailKind: message.detailKind || "other",
+        tool,
+        at,
+        launchId: message.launchId || null,
+        clientSeq: Number.isFinite(message.clientSeq) ? message.clientSeq : null,
+    };
+    const activityLog = Array.isArray(current.activityLog) ? current.activityLog : [];
+    const previousActivity = current.lastActivity && typeof current.lastActivity === "object" && !Array.isArray(current.lastActivity)
+        ? current.lastActivity
+        : null;
+    const repeatedThinking = activityKind === "thinking"
+        && (previousActivity?.activityKind === "thinking" || previousActivity?.state === "thinking");
+    // Runtime adapters emit text/thinking once per streamed delta. Text is only a freshness signal;
+    // thinking is durable on transition, then coalesced until the next state. Persisting every frame
+    // otherwise evicts meaningful turn/tool/idle history from the Dashboard within milliseconds.
+    const appendToHistory = activityKind !== "text" && !repeatedThinking;
+    const patch = {
+        activityLog: appendToHistory ? [...activityLog, activityEntry].slice(-80) : activityLog,
+        lastActivity: activityEntry,
+    };
+    const entryKinds = new Set(entries.map((entry) => entry?.kind).filter(Boolean));
+    const compactStarted = activityEntry.detailKind === "compacting_context" || entryKinds.has("compaction_started");
+    const compactFinished = activityEntry.detailKind === "compaction_finished" || entryKinds.has("compaction_finished");
+    if (compactStarted || compactFinished) {
+        const previous = current.compaction || {};
+        const atMs = Date.parse(at);
+        const nearPreviousCompact = [previous.startedAt, previous.lastFinishedAt]
+            .map((value) => typeof value === "string" ? Date.parse(value) : Number.NaN)
+            .some((value) => Number.isFinite(value) && Number.isFinite(atMs) && Math.abs(atMs - value) <= 5000);
+        const sameEvent = Boolean(message.producerFactId) && previous.lastEventId === message.producerFactId;
+        const duplicateStart = Boolean(previous.active) || sameEvent || nearPreviousCompact;
+        const shouldCountStart = compactStarted && !duplicateStart;
+        patch.compaction = compactFinished ? {
+            ...previous,
+            sessionId: current.session?.id || previous.sessionId || null,
+            active: false,
+            count: Number(previous.count || 0) + (shouldCountStart ? 1 : 0),
+            startedAt: shouldCountStart ? at : (previous.startedAt || at),
+            lastFinishedAt: at,
+            lastEventId: message.producerFactId || null,
+        } : {
+            sessionId: current.session?.id || null,
+            active: true,
+            count: Number(previous.count || 0) + (duplicateStart ? 0 : 1),
+            startedAt: duplicateStart ? (previous.startedAt || at) : at,
+            lastFinishedAt: previous.lastFinishedAt || null,
+            lastEventId: message.producerFactId || null,
+        };
+    }
+    if (activityEntry.detailKind === "message_received" || activityEntry.detailKind === "turn_started") {
+        patch.session = {
+            ...(current.session || {}),
+            runtime,
+            id: current.session?.id || resumeSession || null,
+            startedAt: current.session?.startedAt || at,
+            lastTurnAt: at,
+            turns: Number(current.session?.turns || 0) + 1,
+        };
+    }
+    return patch;
+}
+export function projectSessionStatus(current, runtime, sessionId, launchId, now = new Date(), effective = {}) {
+    const sameSession = current.session?.id === sessionId;
+    const at = now.toISOString();
+    return {
+        session: {
+            runtime,
+            id: sessionId,
+            launchId: launchId || current.session?.launchId || null,
+            startedAt: sameSession ? (current.session?.startedAt || at) : at,
+            lastSeenAt: at,
+            lastTurnAt: sameSession ? (current.session?.lastTurnAt || null) : null,
+            turns: sameSession ? Number(current.session?.turns || 0) : 0,
+            ...((effective.model || (sameSession ? current.session?.model : null))
+                ? { model: effective.model || current.session?.model }
+                : {}),
+            ...((effective.reasoningEffort || (sameSession ? current.session?.reasoningEffort : null))
+                ? { reasoningEffort: effective.reasoningEffort || current.session?.reasoningEffort }
+                : {}),
+        },
+        ...(sameSession ? {} : {
+            compaction: { sessionId, active: false, count: 0, startedAt: null, lastFinishedAt: null, lastEventId: null },
+        }),
+    };
+}

package/dist/feishu/host-channel-business.cjs

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostChannelBusiness = void 0;
+const message_policy_js_1 = require("./message-policy.cjs");
+const channel_1 = require("@larksuite/channel");
+function messageOf(error) { return error instanceof Error ? error.message : String(error); }
+class HostChannelBusiness {
+    options;
+    log;
+    now;
+    constructor(options) {
+        this.options = options;
+        this.log = options.log ?? (() => { });
+        this.now = options.now ?? (() => new Date());
+    }
+    handlers(agent, channel) {
+        return {
+            message: (message) => {
+                try {
+                    const event = (0, message_policy_js_1.normalizeChannelMessage)(message);
+                    this.options.state.updateStatus(agent, { inboundVerifiedAt: this.now().toISOString() });
+                    const senderIsBot = message.senderIsBot === true;
+                    const decision = (0, message_policy_js_1.decideWake)({
+                        senderIsBot,
+                        mentionedBot: message.mentionedBot === true,
+                        mentionAll: message.mentionAll === true,
+                        isGroup: (message.chatType || "group") !== "p2p",
+                        mentionPolicy: senderIsBot ? "require" : this.options.mentionPolicy?.(agent.agentId, String(message.chatId || ""))
+                            || (Array.isArray(agent.noMentionChats) && agent.noMentionChats.includes(String(message.chatId || "")) ? "free" : "require"),
+                    });
+                    if (!decision.wake) {
+                        this.log(`${senderIsBot ? "bot 消息未点名@我" : "群消息未@bot"} → 只入箱不唤醒 agent=${agent.name} chat=${message.chatId}`);
+                    }
+                    void this.options.onMessage(agent, event, { wake: decision.wake });
+                }
+                catch (error) {
+                    this.log(`channel message 处理失败 agent=${agent.name}: ${messageOf(error)}`);
+                }
+            },
+            comment: async (event) => {
+                try {
+                    this.options.state.updateStatus(agent, {
+                        inboundVerifiedAt: this.now().toISOString(),
+                        documentCommentEventAt: this.now().toISOString(),
+                    });
+                    if (!channel || !this.options.onComment)
+                        return;
+                    await this.options.onComment(agent, event, channel);
+                }
+                catch (error) {
+                    this.log(`document comment 处理失败 agent=${agent.name}: ${messageOf(error)}`);
+                    this.options.state.recordStatusError(agent, `document comment: ${messageOf(error)}`);
+                }
+            },
+            cardAction: async (event) => {
+                if (!this.options.onCardAction)
+                    return { toast: { type: "error", content: "交互能力未启用，请重新运行 larkin setup 并重启 Larkin。" } };
+                return this.options.onCardAction(agent, event);
+            },
+            reconnecting: () => {
+                this.log(`ws 重连中… agent=${agent.name}`);
+                this.options.state.updateStatus(agent, { reconnectingAt: this.now().toISOString() });
+            },
+            reconnected: () => {
+                this.log(`ws 已恢复 agent=${agent.name}`);
+                const connectedAt = this.now().toISOString();
+                this.options.state.updateStatus(agent, { reconnectingAt: null, reconnectedAt: connectedAt, connectedAt });
+                if (channel && this.options.onReconnected) {
+                    void Promise.resolve(this.options.onReconnected(agent, channel)).catch((error) => {
+                        this.log(`document comment 恢复重放失败 agent=${agent.name}: ${messageOf(error)}`);
+                    });
+                }
+            },
+            error: () => {
+                this.log(`ws 错误 agent=${agent.name}`);
+                this.options.state.recordStatusError(agent, "channel ws 连接错误");
+            },
+        };
+    }
+    registerReadReceipts(agent, dispatcher) {
+        try {
+            dispatcher.register({
+                "im.message.message_read_v1": async (raw) => {
+                    try {
+                        const event = raw;
+                        const reader = event?.reader?.reader_id?.open_id || null;
+                        const readAt = event?.reader?.read_time || null;
+                        const ids = event?.message_id_list || [];
+                        this.options.state.recordReadReceipts(agent, reader, readAt, ids);
+                        this.log(`已读回执 agent=${agent.name} reader=${reader || "?"} msgs=${ids.length}`);
+                    }
+                    catch (error) {
+                        this.log(`已读回执处理失败 agent=${agent.name}: ${messageOf(error)}`);
+                    }
+                },
+            });
+        }
+        catch (error) {
+            this.log(`已读回执注册失败（不影响消息收发） agent=${agent.name}: ${messageOf(error)}`);
+        }
+    }
+    /**
+     * Replace the SDK's action-value TTL dedup handler after channel.connect().
+     * Durable callback event_id ownership lives in InteractionStateMachine, so
+     * retries receive the same response while later state-version clicks remain legal.
+     */
+    registerCardActions(agent, dispatcher) {
+        dispatcher.register({
+            "card.action.trigger": async (raw) => {
+                const event = (0, channel_1.normalizeCardAction)(raw, { includeRaw: true });
+                if (!event)
+                    return { toast: { type: "error", content: "无法解析卡片操作，请刷新后重试。" } };
+                return this.handlers(agent).cardAction(event);
+            },
+        });
+    }
+    persistBotIdentity(agent, openId, name, via, avatarUrl = null) {
+        agent.botOpenId = openId;
+        agent.botName = name || agent.botName || null;
+        try {
+            let previous = {};
+            try {
+                previous = this.options.stateStore(agent).readJson("botIdentity", {}) || {};
+            }
+            catch { /* first run */ }
+            this.options.stateStore(agent).writeJson("botIdentity", {
+                open_id: openId,
+                name: name || previous.name || null,
+                avatar_url: avatarUrl || previous.avatar_url || null,
+                updated_at: this.now().toISOString(),
+            });
+        }
+        catch (error) {
+            this.log(`bot-identity 写入失败 agent=${agent.name}: ${messageOf(error)}`);
+        }
+        this.log(`bot 身份就绪(${via}) agent=${agent.name} bot=${name || "?"}(${openId})`);
+        this.options.state.updateStatus(agent, { connectedAt: this.now().toISOString(), connectedVia: via, reconnectingAt: null });
+    }
+    async connected(agent, channel, onFatal) {
+        const identity = channel.botIdentity || null;
+        if (!identity?.openId) {
+            this.log(`createLarkChannel 已连接但未取到 botIdentity agent=${agent.name}`);
+            onFatal?.(new Error("bot identity unavailable"));
+            return;
+        }
+        let avatarUrl = null;
+        let botName = identity.name || null;
+        try {
+            const info = await channel.rawClient?.request({ url: "/open-apis/bot/v3/info", method: "GET" });
+            if (info?.bot?.open_id === identity.openId) {
+                avatarUrl = info.bot.avatar_url || null;
+                botName = info.bot.app_name || botName;
+            }
+        }
+        catch (error) {
+            this.log(`bot 头像刷新失败（不影响连接） agent=${agent.name}: ${messageOf(error)}`);
+        }
+        this.persistBotIdentity(agent, identity.openId, botName, "channel", avatarUrl);
+    }
+}
+exports.HostChannelBusiness = HostChannelBusiness;