@botcord/daemon 0.2.58 → 0.2.60

package/dist/gateway/dispatcher.js

@@ -78,6 +78,7 @@ export class Dispatcher {
     resolveHubUrl;
     transcript;
     queues = new Map();
+    deferredMultimodal = new Map();
     /**
      * Last `/hub/typing` ping timestamp per (accountId, conversationId).
      * Used to debounce cancel-previous bursts so we don't trip Hub's 20/min
@@ -125,6 +126,10 @@ export class Dispatcher {
             await this.safeAck(envelope);
             return;
         }
+        const managed = this.managedRoutes ? Array.from(this.managedRoutes.values()) : undefined;
+        const route = resolveRoute(msg, this.config, managed);
+        const mode = resolveQueueMode(route, msg.conversation.kind);
+        const queueKey = buildQueueKey(msg);
         // Pre-skip: empty/whitespace text.
         const rawText = typeof msg.text === "string" ? msg.text.trim() : "";
         if (!rawText) {
@@ -135,20 +140,76 @@ export class Dispatcher {
         // From here on, the inbound is a real conversation event — generate a
         // turnId and write the inbound transcript record.
         const turnId = randomUUID();
-        const managed = this.managedRoutes ? Array.from(this.managedRoutes.values()) : undefined;
-        const route = resolveRoute(msg, this.config, managed);
-        const mode = resolveQueueMode(route, msg.conversation.kind);
-        const queueKey = buildQueueKey(msg);
+        // Multimodal-only arrivals (files/images without sender-authored text)
+        // should not wake the runtime on their own. Ack them, record the inbound
+        // event, and prepend them to the next text-bearing turn for this queue.
+        if (isMultimodalOnlyMessage(msg)) {
+            await this.safeAck(envelope);
+            this.emitInbound(turnId, msg);
+            this.deferMultimodal(queueKey, { route, msg, channel, turnId, queuedAt: Date.now() });
+            this.log.info("dispatcher: deferred multimodal-only inbound", {
+                agentId: msg.accountId,
+                roomId: msg.conversation.id,
+                topicId: msg.conversation.threadId ?? null,
+                turnId,
+                messageId: msg.id,
+                senderId: msg.sender.id,
+                senderKind: msg.sender.kind,
+                mode,
+                queueKey,
+            });
+            if (this.onInbound) {
+                try {
+                    await this.onInbound(msg);
+                }
+                catch (err) {
+                    this.log.warn("dispatcher: onInbound threw — continuing", {
+                        messageId: msg.id,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            return;
+        }
+        const deferred = this.takeDeferredMultimodal(queueKey);
+        let dispatchMsg = msg;
+        let dispatchTurnId = turnId;
+        let dispatchRoute = route;
+        let dispatchChannel = channel;
+        let text = rawText;
+        let mergedFromDeferredTurnIds = [];
+        if (deferred.length > 0) {
+            const merged = this.mergeSerialBuffer([...deferred, { route, msg, channel, turnId }], queueKey);
+            if (merged) {
+                dispatchMsg = merged.msg;
+                dispatchTurnId = merged.turnId;
+                dispatchRoute = merged.route;
+                dispatchChannel = merged.channel;
+                text = merged.text;
+                mergedFromDeferredTurnIds = deferred.map((e) => e.turnId);
+                for (const entry of deferred) {
+                    this.transcript.write({
+                        ts: nowIso(),
+                        kind: "dropped",
+                        turnId: entry.turnId,
+                        agentId: entry.msg.accountId,
+                        roomId: entry.msg.conversation.id,
+                        topicId: entry.msg.conversation.threadId ?? null,
+                        reason: "batch_merged",
+                        supersededBy: dispatchTurnId,
+                    });
+                }
+            }
+        }
         // Compose the final user-turn text only for cancel-previous mode, where
         // the dispatcher consumes the pre-composed text directly. Serial mode
         // re-runs the composer at drain time on the merged message (so it sees
         // the full coalesced batch instead of any single arrival), so calling
         // the composer here would just be redundant work.
-        let text = rawText;
         let composeFailedError;
         if (mode === "cancel-previous" && this.composeUserTurn) {
             try {
-                const composed = this.composeUserTurn(msg);
+                const composed = this.composeUserTurn(dispatchMsg);
                 if (typeof composed === "string" && composed.length > 0) {
                     text = composed;
                 }
@@ -156,7 +217,7 @@ export class Dispatcher {
             catch (err) {
                 composeFailedError = err instanceof Error ? err.message : String(err);
                 this.log.warn("dispatcher: composeUserTurn threw — using raw text", {
-                    messageId: msg.id,
+                    messageId: dispatchMsg.id,
                     error: composeFailedError,
                 });
             }
@@ -197,29 +258,29 @@ export class Dispatcher {
         if (this.attentionGate) {
             let wake = true;
             try {
-                const result = this.attentionGate(msg);
+                const result = this.attentionGate(dispatchMsg);
                 wake = result instanceof Promise ? await result : result;
             }
             catch (err) {
                 this.log.warn("dispatcher: attentionGate threw — waking", {
-                    messageId: msg.id,
+                    messageId: dispatchMsg.id,
                     error: err instanceof Error ? err.message : String(err),
                 });
                 wake = true;
             }
             if (!wake) {
                 this.log.debug("dispatcher skip turn: attention policy", {
-                    messageId: msg.id,
-                    accountId: msg.accountId,
-                    conversationId: msg.conversation.id,
+                    messageId: dispatchMsg.id,
+                    accountId: dispatchMsg.accountId,
+                    conversationId: dispatchMsg.conversation.id,
                 });
                 this.transcript.write({
                     ts: nowIso(),
                     kind: "attention_skipped",
-                    turnId,
-                    agentId: msg.accountId,
-                    roomId: msg.conversation.id,
-                    topicId: msg.conversation.threadId ?? null,
+                    turnId: dispatchTurnId,
+                    agentId: dispatchMsg.accountId,
+                    roomId: dispatchMsg.conversation.id,
+                    topicId: dispatchMsg.conversation.threadId ?? null,
                     reason: "attention_gate_false",
                 });
                 return;
@@ -229,19 +290,19 @@ export class Dispatcher {
             this.transcript.write({
                 ts: nowIso(),
                 kind: "compose_failed",
-                turnId,
-                agentId: msg.accountId,
-                roomId: msg.conversation.id,
-                topicId: msg.conversation.threadId ?? null,
+                turnId: dispatchTurnId,
+                agentId: dispatchMsg.accountId,
+                roomId: dispatchMsg.conversation.id,
+                topicId: dispatchMsg.conversation.threadId ?? null,
                 error: composeFailedError,
                 fallback: "raw_text",
             });
         }
         if (mode === "cancel-previous") {
-            await this.runCancelPrevious(queueKey, route, text, msg, channel, turnId);
+            await this.runCancelPrevious(queueKey, dispatchRoute, text, dispatchMsg, dispatchChannel, dispatchTurnId, mergedFromDeferredTurnIds);
         }
         else {
-            await this.runSerial(queueKey, route, text, msg, channel, turnId);
+            await this.runSerial(queueKey, dispatchRoute, text, dispatchMsg, dispatchChannel, dispatchTurnId, mergedFromDeferredTurnIds);
         }
     }
     /** Snapshot of currently running turns keyed by queue key. */
@@ -283,7 +344,37 @@ export class Dispatcher {
         }
         return q;
     }
-    async runCancelPrevious(queueKey, route, text, msg, channel, turnId) {
+    deferMultimodal(queueKey, entry) {
+        const list = this.deferredMultimodal.get(queueKey) ?? [];
+        list.push(entry);
+        while (list.length > MAX_BATCH_BUFFER_ENTRIES) {
+            const dropped = list.shift();
+            this.log.warn("dispatcher: deferred multimodal buffer overflow — dropped oldest", {
+                queueKey,
+                droppedMessageId: dropped.msg.id,
+                bufferCap: MAX_BATCH_BUFFER_ENTRIES,
+            });
+            this.transcript.write({
+                ts: nowIso(),
+                kind: "dropped",
+                turnId: dropped.turnId,
+                agentId: dropped.msg.accountId,
+                roomId: dropped.msg.conversation.id,
+                topicId: dropped.msg.conversation.threadId ?? null,
+                reason: "queue_overflow",
+                supersededBy: null,
+            });
+        }
+        this.deferredMultimodal.set(queueKey, list);
+    }
+    takeDeferredMultimodal(queueKey) {
+        const list = this.deferredMultimodal.get(queueKey);
+        if (!list || list.length === 0)
+            return [];
+        this.deferredMultimodal.delete(queueKey);
+        return list;
+    }
+    async runCancelPrevious(queueKey, route, text, msg, channel, turnId, mergedFromTurnIds = []) {
         const q = this.getQueue(queueKey);
         // Bump the generation on every arrival. Older arrivals still awaiting
         // the prior turn's teardown will observe `myGen !== q.cancelGen` when
@@ -342,7 +433,7 @@ export class Dispatcher {
             });
             return;
         }
-        await this.runTurn(queueKey, route, text, msg, channel, turnId, []);
+        await this.runTurn(queueKey, route, text, msg, channel, turnId, mergedFromTurnIds);
     }
     /**
      * Serial mode with coalesce-on-drain semantics:
@@ -362,7 +453,7 @@ export class Dispatcher {
      * merged message so the runtime sees a single coherent prompt covering all
      * coalesced messages.
      */
-    async runSerial(queueKey, route, _text, msg, channel, turnId) {
+    async runSerial(queueKey, route, _text, msg, channel, turnId, mergedFromTurnIds = []) {
         const q = this.getQueue(queueKey);
         q.serialBuffer.push({ route, msg, channel, turnId });
         while (q.serialBuffer.length > MAX_BATCH_BUFFER_ENTRIES) {
@@ -409,8 +500,10 @@ export class Dispatcher {
                         });
                     }
                 }
-                const mergedFromTurnIds = drained.length > 1 ? drained.slice(0, -1).map((e) => e.turnId) : [];
-                await this.runTurn(queueKey, merged.route, merged.text, merged.msg, merged.channel, merged.turnId, mergedFromTurnIds);
+                const mergedTurnIds = drained.length > 1
+                    ? [...mergedFromTurnIds, ...drained.slice(0, -1).map((e) => e.turnId)]
+                    : mergedFromTurnIds;
+                await this.runTurn(queueKey, merged.route, merged.text, merged.msg, merged.channel, merged.turnId, mergedTurnIds);
             }
         }
         finally {
@@ -478,8 +571,13 @@ export class Dispatcher {
         const latestRaw = latest.msg.raw ?? {};
         const mergedRaw = { ...latestRaw, batch: items };
         const anyMentioned = entries.some((e) => e.msg.mentioned === true);
+        const mergedText = entries
+            .map((e) => (typeof e.msg.text === "string" ? e.msg.text.trim() : ""))
+            .filter((s) => s.length > 0)
+            .join("\n");
         const mergedMsg = {
             ...latest.msg,
+            ...(mergedText ? { text: mergedText } : {}),
             mentioned: anyMentioned,
             raw: mergedRaw,
         };
@@ -905,6 +1003,7 @@ export class Dispatcher {
             // own loop-risk accounting downstream.
             const isOwnerChat = isOwnerChatRoom(msg);
             const canDeliverRuntimeText = isOwnerChat || !isBotCordChannel(channel);
+            const canDeliverRuntimeDiagnostics = canDeliverRuntimeText || isBotCordChannel(channel);
             if (slot.timedOut) {
                 this.transcript.write({
                     ts: nowIso(),
@@ -917,7 +1016,7 @@ export class Dispatcher {
                     error: `runtime timeout after ${this.turnTimeoutMs}ms`,
                     durationMs: Date.now() - slot.dispatchedAt,
                 });
-                if (canDeliverRuntimeText) {
+                if (canDeliverRuntimeDiagnostics) {
                     await this.sendReply(channel, {
                         channel: msg.channel,
                         accountId: msg.accountId,
@@ -962,7 +1061,7 @@ export class Dispatcher {
                     error: errMsg,
                     durationMs: Date.now() - slot.dispatchedAt,
                 });
-                if (canDeliverRuntimeText) {
+                if (canDeliverRuntimeDiagnostics) {
                     await this.sendReply(channel, {
                         channel: msg.channel,
                         accountId: msg.accountId,
@@ -1052,7 +1151,7 @@ export class Dispatcher {
                         runtime: route.runtime,
                         error: result.error,
                     });
-                    if (canDeliverRuntimeText) {
+                    if (canDeliverRuntimeDiagnostics) {
                         const sendResult = await this.sendReply(channel, {
                             channel: msg.channel,
                             accountId: msg.accountId,
@@ -1296,6 +1395,67 @@ function isOwnerChatRoom(msg) {
 function isBotCordChannel(channel) {
     return channel.type === "botcord" || channel.id === "botcord";
 }
+function isMultimodalOnlyMessage(msg) {
+    if (!hasMultimodalContent(msg.raw))
+        return false;
+    return !hasAuthoredText(msg.raw);
+}
+function hasAuthoredText(raw) {
+    if (!raw || typeof raw !== "object")
+        return false;
+    const obj = raw;
+    const batch = obj.batch;
+    if (Array.isArray(batch))
+        return batch.some((item) => hasAuthoredText(item));
+    if (typeof obj.text === "string" && obj.text.trim().length > 0) {
+        // BotCord's /hub/inbox `text` may be synthesized from attachment metadata
+        // when payload text is empty, so prefer envelope payload below when present.
+        if (!obj.envelope || typeof obj.envelope !== "object")
+            return true;
+    }
+    const envelope = obj.envelope;
+    const payload = envelope?.payload;
+    if (payload) {
+        for (const key of ["text", "body", "message"]) {
+            const value = payload[key];
+            if (typeof value === "string" && value.trim().length > 0)
+                return true;
+        }
+        return false;
+    }
+    const itemList = obj.item_list;
+    if (Array.isArray(itemList)) {
+        return itemList.some((item) => {
+            if (!item || typeof item !== "object")
+                return false;
+            const textItem = item.text_item;
+            return typeof textItem?.text === "string" && textItem.text.trim().length > 0;
+        });
+    }
+    return typeof obj.text === "string" && obj.text.trim().length > 0;
+}
+function hasMultimodalContent(raw) {
+    if (!raw || typeof raw !== "object")
+        return false;
+    const obj = raw;
+    const batch = obj.batch;
+    if (Array.isArray(batch))
+        return batch.some((item) => hasMultimodalContent(item));
+    const envelope = obj.envelope;
+    const payload = envelope?.payload;
+    const attachments = payload?.attachments;
+    if (Array.isArray(attachments) && attachments.length > 0)
+        return true;
+    const itemList = obj.item_list;
+    if (Array.isArray(itemList)) {
+        return itemList.some((item) => {
+            if (!item || typeof item !== "object")
+                return false;
+            return item.type !== 1;
+        });
+    }
+    return false;
+}
 function resolveQueueMode(route, kind) {
     if (route.queueMode)
         return route.queueMode;

package/dist/gateway/policy-resolver.d.ts

@@ -22,25 +22,29 @@
  * the agent is revoked or the cache must rebuild from scratch.
  */
 import type { AttentionPolicy } from "@botcord/protocol-core";
+export type DaemonAttentionPolicy = Omit<AttentionPolicy, "mode"> & {
+    mode: AttentionPolicy["mode"] | "allowed_senders";
+    allowedSenderIds?: string[];
+};
 /** Public surface — kept narrow so the dispatcher can mock easily in tests. */
 export interface PolicyResolverLike {
-    resolve(agentId: string, roomId: string | null): Promise<AttentionPolicy>;
+    resolve(agentId: string, roomId: string | null): Promise<DaemonAttentionPolicy>;
     invalidate(agentId: string, roomId?: string): void;
     /**
      * Install (or replace) the cached policy entry for an agent / room. Used
      * by the `policy_updated` control-frame handler to apply embedded policy
      * payloads without forcing a refetch.
      */
-    put(agentId: string, roomId: string | null, policy: AttentionPolicy): void;
+    put(agentId: string, roomId: string | null, policy: DaemonAttentionPolicy): void;
 }
 export interface PolicyResolverOptions {
     /** Fetcher for the per-agent default. Returning `undefined` means "no policy known"; the resolver falls back to `mode=always`. */
-    fetchGlobal: (agentId: string) => Promise<AttentionPolicy | undefined>;
+    fetchGlobal: (agentId: string) => Promise<DaemonAttentionPolicy | undefined>;
     /**
      * Optional per-room fetcher. PR2 supplies this; PR3 leaves it
      * unimplemented and the resolver collapses to the global policy.
      */
-    fetchEffective?: (agentId: string, roomId: string) => Promise<AttentionPolicy | undefined>;
+    fetchEffective?: (agentId: string, roomId: string) => Promise<DaemonAttentionPolicy | undefined>;
     /** Cache TTL in milliseconds. Defaults to 5 minutes. */
     ttlMs?: number;
 }
@@ -50,8 +54,8 @@ export declare class PolicyResolver implements PolicyResolverLike {
     private readonly ttlMs;
     private readonly cache;
     constructor(opts: PolicyResolverOptions);
-    resolve(agentId: string, roomId: string | null): Promise<AttentionPolicy>;
+    resolve(agentId: string, roomId: string | null): Promise<DaemonAttentionPolicy>;
     private safeFetch;
     invalidate(agentId: string, roomId?: string): void;
-    put(agentId: string, roomId: string | null, policy: AttentionPolicy): void;
+    put(agentId: string, roomId: string | null, policy: DaemonAttentionPolicy): void;
 }

package/dist/gateway/types.d.ts

@@ -171,7 +171,7 @@ export interface ChannelStatusSnapshot {
     lastStopAt?: number;
     lastError?: string | null;
     /** Third-party provider id when this channel is not the built-in BotCord. */
-    provider?: "wechat" | "telegram";
+    provider?: "wechat" | "telegram" | "feishu";
     /** Last time the adapter polled the upstream provider (ms epoch). */
     lastPollAt?: number;
     /** Last time the adapter accepted an inbound message (ms epoch). */

package/dist/gateway-control.d.ts

@@ -13,9 +13,10 @@ import type { Gateway } from "./gateway/index.js";
 import { type DaemonConfig } from "./config.js";
 import { LoginSessionStore } from "./gateway/channels/login-session.js";
 import { getBotQrcode, getQrcodeStatus } from "./gateway/channels/wechat-login.js";
+import { pollFeishuRegistration, startFeishuRegistration } from "./gateway/channels/feishu-registration.js";
 import type { FetchLike } from "./gateway/channels/http-types.js";
 type AckBody = Omit<ControlAck, "id">;
-type GatewayProvider = "telegram" | "wechat";
+type GatewayProvider = "telegram" | "wechat" | "feishu";
 interface UpsertGatewayParams {
     id: string;
     type: GatewayProvider;
@@ -28,6 +29,7 @@ interface UpsertGatewayParams {
     };
     settings?: {
         baseUrl?: string;
+        domain?: "feishu" | "lark";
         allowedSenderIds?: string[];
         allowedChatIds?: string[];
         splitAt?: number;
@@ -45,6 +47,7 @@ interface GatewayLoginStartParams {
     accountId: string;
     gatewayId?: string;
     baseUrl?: string;
+    domain?: "feishu" | "lark";
 }
 interface GatewayLoginStatusParams {
     provider: GatewayProvider;
@@ -75,6 +78,10 @@ export interface GatewayControlContext {
         getBotQrcode: typeof getBotQrcode;
         getQrcodeStatus: typeof getQrcodeStatus;
     };
+    feishuLoginClient?: {
+        startFeishuRegistration: typeof startFeishuRegistration;
+        pollFeishuRegistration: typeof pollFeishuRegistration;
+    };
     /** Override the global fetch — used by `test_gateway` for Telegram getMe. */
     fetchImpl?: FetchLike;
 }