@ganglion/weacpx-channel-feishu 0.2.1 → 0.3.0

package/README.md

@@ -72,3 +72,20 @@ While the agent is processing, the user can send `stop`, `/stop`, `abort`, `停
 2. Renders an "已停止" final state on the streaming card, or sends a "已停止当前任务。" reply in static mode.
 3. Removes the typing reaction added to the user's original message.
 
+## Real-time session switching & background execution
+
+Each inbound prompt is **bound at dispatch time** to whatever session the chat is currently on, then runs on a **per-session lane**:
+
+- **Different sessions run concurrently.** Switching to another session (`/use`/`/ss`) while a task is in flight lets you use the new session immediately — turns on different sessions don't block each other.
+- **Same-session turns serialize**, preserving order within a session.
+- **Switch and cancel commands preempt.** `/use`, `/ss`, `/cancel`, `/stop` run on a **control lane**, so they take effect right away even while a prompt is running (the running prompt keeps going in the background — see below).
+
+When you switch away from a running session, its turn keeps executing in the background. Feishu uses **"B-semantics"**, which differs from the WeChat channel:
+
+- The backgrounded session has its **own streaming card** that keeps refreshing **to completion in the chat timeline** — it is *not* gated/suppressed. The result simply stays on that card.
+- On completion, a short ping is sent to the chat: `✅ <alias> 已完成` (or `⚠️ <alias> 失败`). Unlike WeChat, there is **no `/use 查看结果`** suffix — there is nothing to replay, because the card already holds the result.
+- Switching **back** to that session does **not** re-send the result.
+- `/sessions` marks sessions with an unfinished/unread background completion using `●`.
+
+`/cancel <alias>` (and `/stop <alias>`) target a specific session's in-flight turn by alias — fuzzy alias resolution applies, the same as `/use`.
+

package/dist/channel.d.ts

@@ -15,6 +15,9 @@ export declare class FeishuChannel implements MessageChannelRuntime {
     private agent;
     private quota;
     private logger;
+    private sessions;
+    private activeTurns;
+    private readonly executor;
     private readonly activeTasks;
     private readonly permissionNotifier;
     private readonly config;
@@ -50,6 +53,7 @@ export declare class FeishuChannel implements MessageChannelRuntime {
      * mark it suppressed.
      */
     private registerActiveTask;
+    private sendBackgroundCompletionNotice;
     private runTurn;
     private trySeedStreamingCard;
     private deliverResponse;

package/dist/completion-notice.d.ts

@@ -0,0 +1 @@
+export declare function buildFeishuCompletionNotice(displayAlias: string, status: "done" | "error"): string;

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

@@ -77967,6 +77967,7 @@ var require_lib2 = __commonJS((exports) => {
 
 // packages/channel-feishu/src/channel.ts
 import path5 from "node:path";
+import { createConversationExecutor, resolveTurnLane, toDisplaySessionAlias } from "weacpx/plugin-api";
 
 // packages/channel-feishu/src/tuning.ts
 var DEFAULT_FEISHU_TUNING = {
@@ -78269,19 +78270,6 @@ var queues = new Map;
 function buildFeishuQueueKey(accountId, chatId, threadId) {
   return threadId ? `${accountId}:${chatId}:thread:${threadId}` : `${accountId}:${chatId}`;
 }
-function enqueueFeishuChatTask(input) {
-  const key = buildFeishuQueueKey(input.accountId, input.chatId, input.threadId);
-  const previous = queues.get(key) ?? Promise.resolve();
-  const status = queues.has(key) ? "queued" : "immediate";
-  const promise = previous.then(input.task, input.task);
-  queues.set(key, promise);
-  const cleanup = () => {
-    if (queues.get(key) === promise)
-      queues.delete(key);
-  };
-  promise.then(cleanup, cleanup);
-  return { status, promise };
-}
 function clearFeishuQueueForAccount(accountId) {
   const prefix = `${accountId}:`;
   for (const key of queues.keys()) {
@@ -78290,6 +78278,11 @@ function clearFeishuQueueForAccount(accountId) {
   }
 }
 
+// packages/channel-feishu/src/completion-notice.ts
+function buildFeishuCompletionNotice(displayAlias, status) {
+  return status === "done" ? `✅ ${displayAlias} 已完成` : `⚠️ ${displayAlias} 失败`;
+}
+
 // packages/channel-feishu/src/inbound.ts
 function parseFeishuText(raw) {
   try {
@@ -78312,6 +78305,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) {
@@ -80276,6 +80278,9 @@ class FeishuChannel {
   agent = null;
   quota = null;
   logger = null;
+  sessions = null;
+  activeTurns = null;
+  executor = createConversationExecutor();
   activeTasks = new Map;
   permissionNotifier;
   config;
@@ -80311,6 +80316,8 @@ class FeishuChannel {
     this.agent = input.agent;
     this.quota = input.quota;
     this.logger = input.logger;
+    this.sessions = input.sessions ?? null;
+    this.activeTurns = input.activeTurns ?? null;
     const eligible = this.config.accounts.filter((account) => account.enabled && account.configured);
     await input.logger.info("feishu.start", "starting feishu channel", {
       accountCount: eligible.length,
@@ -80543,33 +80550,34 @@ class FeishuChannel {
       initialSkipped: converted.skippedNotes
     });
     const requestText = appendSkippedAttachmentNotes(decision.text, skipped);
+    const isSlash = requestText.trim().startsWith("/");
+    const boundAlias = isSlash ? undefined : this.sessions?.peekCurrentSessionAlias(chatKey) ?? undefined;
+    const lane = resolveTurnLane(requestText);
     const { active, abortController } = this.registerActiveTask({
       accountId,
       chatId,
       messageId,
       queueKey,
       senderOpenId: event.sender?.sender_id?.open_id,
-      chatType: event.message.chat_type
+      chatType: event.message.chat_type,
+      boundAlias
     });
-    const run = enqueueFeishuChatTask({
+    if (boundAlias)
+      this.activeTurns?.markActive(chatKey, boundAlias);
+    await this.executor.run(chatKey, lane, () => this.runTurn({
+      runtime,
       accountId,
       chatId,
-      ...threadId ? { threadId } : {},
-      task: () => this.runTurn({
-        runtime,
-        accountId,
-        chatId,
-        chatType: event.message.chat_type,
-        chatKey,
-        queueKey,
-        messageId,
-        requestText,
-        media,
-        active,
-        abortController
-      })
-    });
-    await run.promise;
+      chatType: event.message.chat_type,
+      chatKey,
+      queueKey,
+      messageId,
+      requestText,
+      media,
+      active,
+      abortController,
+      boundAlias
+    }), boundAlias);
   }
   async tryHandleAbortTrigger(input) {
     const { event, runtime, queueKey, accountId, chatId, messageId } = input;
@@ -80604,7 +80612,7 @@ class FeishuChannel {
     return false;
   }
   registerActiveTask(input) {
-    const { accountId, chatId, messageId, queueKey, senderOpenId, chatType } = input;
+    const { accountId, chatId, messageId, queueKey, senderOpenId, chatType, boundAlias } = input;
     const abortController = new AbortController;
     const active = {
       accountId,
@@ -80612,6 +80620,7 @@ class FeishuChannel {
       messageId,
       senderOpenId,
       chatType,
+      boundAlias,
       typingState: { messageId, reactionId: null },
       abortController,
       suppressed: false,
@@ -80622,8 +80631,26 @@ class FeishuChannel {
     this.activeTasks.set(queueKey, stack);
     return { active, abortController };
   }
+  async sendBackgroundCompletionNotice(input) {
+    const text = buildFeishuCompletionNotice(toDisplaySessionAlias(input.boundAlias), input.status);
+    try {
+      await this.sendReplyWithGuard({
+        runtime: input.runtime,
+        chatId: input.chatId,
+        replyToMessageId: input.messageId,
+        text
+      });
+    } catch (error) {
+      await this.logger?.error("feishu.bg_notice.failed", "failed to send background completion notice", {
+        chatId: input.chatId,
+        boundAlias: input.boundAlias,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   async runTurn(input) {
-    const { runtime, accountId, chatId, chatType, chatKey, queueKey, messageId, requestText, media, active, abortController } = input;
+    const { runtime, accountId, chatId, chatType, chatKey, queueKey, messageId, requestText, media, active, abortController, boundAlias } = input;
+    let turnStatus = "skipped";
     try {
       if (!this.agent)
         return;
@@ -80670,6 +80697,10 @@ class FeishuChannel {
           text: requestText,
           ...media.length > 0 ? { media } : {},
           replyContextToken: messageId,
+          metadata: {
+            ...buildFeishuRouteMetadata({ chatType, senderOpenId: active.senderOpenId, chatId }),
+            ...boundAlias ? { boundSessionAlias: boundAlias } : {}
+          },
           reply: safeReply,
           ...active.cardController ? {
             onToolEvent: (event) => {
@@ -80688,13 +80719,26 @@ class FeishuChannel {
         if (active.suppressed)
           return;
         await this.deliverResponse({ runtime, accountId, chatId, messageId, active, response });
+        turnStatus = "done";
       } catch (error) {
         if (active.cardController && !active.cardController.isTerminated()) {
           await active.cardController.fail(error instanceof Error ? error.message : String(error));
         }
+        turnStatus = "error";
         throw error;
       }
     } finally {
+      if (boundAlias) {
+        this.activeTurns?.markInactive(chatKey, boundAlias);
+        if (turnStatus !== "skipped" && this.sessions && this.sessions.peekCurrentSessionAlias(chatKey) !== boundAlias) {
+          await this.sessions.setBackgroundResult(chatKey, boundAlias, {
+            text: "",
+            status: turnStatus,
+            finished_at: new Date().toISOString()
+          });
+          await this.sendBackgroundCompletionNotice({ runtime, chatId, messageId, boundAlias, status: turnStatus });
+        }
+      }
       const stack = this.activeTasks.get(queueKey);
       if (stack) {
         const i = stack.indexOf(active);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/weacpx-channel-feishu",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Feishu channel plugin for weacpx.",
   "license": "MIT",
   "keywords": ["weacpx", "feishu", "channel", "plugin"],
@@ -20,7 +20,7 @@
   },
   "files": ["dist", "README.md"],
   "peerDependencies": {
-    "weacpx": ">=0.5.0-0"
+    "weacpx": ">=0.7.0-0"
   },
   "peerDependenciesMeta": {
     "weacpx": {