@ganglion/weacpx-channel-feishu 0.2.0 → 0.2.2

package/dist/inbound.d.ts

@@ -7,6 +7,24 @@ export declare function parseFeishuConversationId(chatKey: string): {
     chatId: string;
     threadId?: string;
 } | null;
+/**
+ * Builds the chat-route metadata weacpx records for the current coordinator
+ * session. The host requires `chatType` to be `"direct"` or `"group"`, but
+ * Feishu reports `chat_type` as `"p2p"` (direct) or `"group"`, so `"p2p"` and
+ * any unexpected value normalize to `"direct"`. Without this, interactive
+ * Feishu turns recorded a route with no `chatType`, which blocked the in-session
+ * scheduled_create/list/cancel tools and group-owner command authorization.
+ */
+export declare function buildFeishuRouteMetadata(input: {
+    chatType: string | undefined;
+    senderOpenId?: string;
+    chatId: string;
+}): {
+    channel: "feishu";
+    chatType: "direct" | "group";
+    senderId?: string;
+    groupId?: string;
+};
 export declare function shouldHandleFeishuMessage(input: {
     event: FeishuMessageEvent;
     botOpenId?: string;

package/dist/index.js

@@ -78312,6 +78312,15 @@ function parseFeishuConversationId(chatKey) {
   }
   return { accountId: parts[1], chatId: parts[2] };
 }
+function buildFeishuRouteMetadata(input) {
+  const isGroup = input.chatType === "group";
+  return {
+    channel: "feishu",
+    chatType: isGroup ? "group" : "direct",
+    ...input.senderOpenId ? { senderId: input.senderOpenId } : {},
+    ...isGroup ? { groupId: input.chatId } : {}
+  };
+}
 function shouldHandleFeishuMessage(input) {
   const text = input.parsedText ?? parseFeishuText(input.event.message.content);
   if (input.event.message.message_type !== "text" && !input.allowMediaOnly && text.trim().length === 0) {
@@ -80373,7 +80382,8 @@ class FeishuChannel {
     if (input.accountId && input.accountId !== route.accountId) {
       throw new Error(`scheduled Feishu accountId "${input.accountId}" does not match chatKey account "${route.accountId}"`);
     }
-    if (!this.accounts.has(route.accountId)) {
+    const runtime = this.accounts.get(route.accountId);
+    if (!runtime) {
       throw new Error(`feishu account "${route.accountId}" is not started; check channel.options.accounts and enabled flags`);
     }
     const deliverText = async (text) => {
@@ -80385,6 +80395,22 @@ class FeishuChannel {
       await this.sendRouteText(input.chatKey, input.replyContextToken, trimmed);
     };
     await this.sendRouteText(input.chatKey, input.replyContextToken, input.noticeText);
+    const effectiveReplyMode = resolveEffectiveReplyMode(runtime.account.replyMode, undefined);
+    const cardController = effectiveReplyMode === "streaming" ? await this.trySeedStreamingCard({
+      runtime,
+      accountId: route.accountId,
+      chatId: route.chatId,
+      ...input.replyContextToken ? { replyToMessageId: input.replyContextToken } : {}
+    }) : null;
+    const deliverReply = async (text) => {
+      if (input.abortSignal?.aborted)
+        return;
+      if (cardController) {
+        cardController.appendStream(text);
+        return;
+      }
+      await deliverText(text);
+    };
     try {
       const response = await this.agent.chat({
         accountId: route.accountId,
@@ -80393,10 +80419,26 @@ class FeishuChannel {
         ...input.replyContextToken ? { replyContextToken: input.replyContextToken } : {},
         ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
         metadata: { channel: "feishu", scheduledSessionAlias: input.sessionAlias },
-        reply: deliverText
+        reply: deliverReply,
+        ...cardController ? {
+          onToolEvent: (event) => {
+            if (input.abortSignal?.aborted)
+              return;
+            cardController.recordToolEvent(event);
+          },
+          onThought: (chunk) => {
+            if (input.abortSignal?.aborted)
+              return;
+            cardController.appendReasoning(chunk);
+          }
+        } : {}
       });
-      if (input.abortSignal?.aborted)
+      if (input.abortSignal?.aborted) {
+        if (cardController && !cardController.isTerminated()) {
+          await cardController.abort(abortAck()).catch(() => {});
+        }
         return;
+      }
       const media = normalizeMediaArray(response.media);
       if (media.length > 0) {
         await this.logger.error("feishu.scheduled.media_unsupported", "scheduled feishu media responses are not supported", {
@@ -80407,11 +80449,23 @@ class FeishuChannel {
           count: media.length
         });
       }
-      await deliverText(response.text);
+      if (cardController) {
+        const responseText = response.text?.trim() ?? "";
+        await cardController.complete(responseText.length > 0 ? response.text : undefined);
+        if (cardController.isDegraded() && responseText.length > 0) {
+          await deliverText(response.text);
+        }
+      } else {
+        await deliverText(response.text);
+      }
     } catch (error) {
-      try {
-        await deliverText(formatScheduledFailureText(input, error));
-      } catch {}
+      if (cardController && !cardController.isTerminated()) {
+        await cardController.fail(error instanceof Error ? error.message : String(error)).catch(() => {});
+      } else {
+        try {
+          await deliverText(formatScheduledFailureText(input, error));
+        } catch {}
+      }
       throw error;
     }
   }
@@ -80593,7 +80647,7 @@ class FeishuChannel {
         return;
       const effectiveReplyMode = resolveEffectiveReplyMode(runtime.account.replyMode, chatType);
       if (effectiveReplyMode === "streaming") {
-        await this.trySeedStreamingCard({ runtime, accountId, chatId, messageId, active });
+        active.cardController = await this.trySeedStreamingCard({ runtime, accountId, chatId, replyToMessageId: messageId });
       }
       if (active.suppressed) {
         if (active.cardController && !active.cardController.isTerminated()) {
@@ -80625,6 +80679,7 @@ class FeishuChannel {
           text: requestText,
           ...media.length > 0 ? { media } : {},
           replyContextToken: messageId,
+          metadata: buildFeishuRouteMetadata({ chatType, senderOpenId: active.senderOpenId, chatId }),
           reply: safeReply,
           ...active.cardController ? {
             onToolEvent: (event) => {
@@ -80666,7 +80721,7 @@ class FeishuChannel {
     }
   }
   async trySeedStreamingCard(input) {
-    const { runtime, accountId, chatId, messageId, active } = input;
+    const { runtime, accountId, chatId } = input;
     try {
       const controller = new StreamingCardController({
         client: runtime.client.sdk,
@@ -80681,8 +80736,8 @@ class FeishuChannel {
           this.logger?.error("feishu.card.degraded", "streaming card updates failing; will deliver answer via plain reply", { accountId, chatId, consecutiveFailures, bufferChars: buffer.length });
         }
       });
-      await controller.seed({ to: chatId, replyToMessageId: messageId });
-      active.cardController = controller;
+      await controller.seed({ to: chatId, ...input.replyToMessageId ? { replyToMessageId: input.replyToMessageId } : {} });
+      return controller;
     } catch (error) {
       const permErr = extractPermissionError(error);
       await this.logger.info("feishu.streaming.fallback", "streaming card seed failed; falling back to static", {
@@ -80693,7 +80748,7 @@ class FeishuChannel {
       });
       if (permErr)
         await this.maybeNotifyPermissionError({ runtime, chatId, error });
-      active.cardController = null;
+      return null;
     }
   }
   async deliverResponse(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/weacpx-channel-feishu",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Feishu channel plugin for weacpx.",
   "license": "MIT",
   "keywords": ["weacpx", "feishu", "channel", "plugin"],