opencode-feishu 0.7.14 → 0.7.15

package/dist/index.js

@@ -99175,6 +99175,12 @@ async function updateMessage(client, messageId, text2) {
     return { ok: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
+async function deleteMessage(client, messageId) {
+  try {
+    await client.im.message.delete({ path: { message_id: messageId } });
+  } catch {
+  }
+}
 
 // src/handler/event.ts
 var pendingBySession = /* @__PURE__ */ new Map();
@@ -99230,7 +99236,7 @@ function setSessionError(sessionId, message, fields) {
   sessionErrorTimeouts.set(sessionId, timeoutId);
 }
 function registerPending(sessionId, payload) {
-  pendingBySession.set(sessionId, { ...payload, textBuffer: "" });
+  pendingBySession.set(sessionId, { ...payload, textBuffer: "", expectedMessageId: void 0 });
 }
 function unregisterPending(sessionId) {
   pendingBySession.delete(sessionId);
@@ -99284,6 +99290,16 @@ async function handleEvent(event, deps) {
       if (!sessionId) break;
       const payload = pendingBySession.get(sessionId);
       if (!payload) break;
+      const messageId = part.messageID;
+      if (messageId) {
+        if (!payload.expectedMessageId) {
+          payload.expectedMessageId = messageId;
+        } else if (payload.expectedMessageId !== messageId) {
+          break;
+        }
+      } else if (payload.expectedMessageId) {
+        break;
+      }
       const delta = event.properties.delta;
       if (delta) {
         payload.textBuffer += delta;
@@ -99343,6 +99359,9 @@ function buildSessionKey(chatType, id) {
 function generateSessionTitle(sessionKey) {
   return `${TITLE_PREFIX}-${sessionKey}-${Date.now()}`;
 }
+function getCachedSession(sessionKey) {
+  return sessionCache.get(sessionKey);
+}
 async function getOrCreateSession(client, sessionKey, directory) {
   const cached = sessionCache.get(sessionKey);
   if (cached) return cached;
@@ -99381,9 +99400,8 @@ async function getOrCreateSession(client, sessionKey, directory) {
 }
 
 // src/handler/chat.ts
-var SSE_RACE_WAIT_MS = 100;
 var activeAutoPrompts = /* @__PURE__ */ new Map();
-async function handleChat(ctx, deps) {
+async function handleChat(ctx, deps, signal) {
   const { content, chatId, chatType, senderId, shouldReply, messageType, rawContent, messageId } = ctx;
   if (!content.trim() && messageType === "text") return;
   const { config, client, feishuClient, log, directory } = deps;
@@ -99411,7 +99429,7 @@ async function handleChat(ctx, deps) {
   const baseBody = { parts };
   if (!shouldReply) {
     try {
-      await client.session.prompt({
+      await client.session.promptAsync({
         path: { id: session.id },
         query,
         body: { ...baseBody, noReply: true }
@@ -99488,12 +99506,12 @@ async function handleChat(ctx, deps) {
   }
   try {
     clearSessionError(session.id);
-    await client.session.prompt({
+    await client.session.promptAsync({
       path: { id: session.id },
       query,
       body: baseBody
     });
-    const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query });
+    const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query, signal });
     log("info", "\u6A21\u578B\u54CD\u5E94\u5B8C\u6210", {
       sessionKey,
       sessionId: session.id,
@@ -99503,21 +99521,21 @@ async function handleChat(ctx, deps) {
     await replyOrUpdate(feishuClient, chatId, placeholderId, finalText || "\u26A0\uFE0F \u54CD\u5E94\u8D85\u65F6");
     await runAutoPromptLoop(session.id);
   } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      log("info", "\u5904\u7406\u88AB\u4E2D\u65AD", { sessionKey, sessionId: session.id });
+      if (placeholderId) {
+        await deleteMessage(feishuClient, placeholderId).catch(() => {
+        });
+      }
+      return;
+    }
     let sessionError;
     if (err instanceof SessionErrorDetected) {
       sessionError = err.sessionError;
       clearSessionError(session.id);
     } else {
-      await new Promise((r) => setTimeout(r, SSE_RACE_WAIT_MS));
       sessionError = getSessionError(session.id);
       clearSessionError(session.id);
-      if (!sessionError) {
-        const thrownFields = extractErrorFields(err);
-        if (isModelError(thrownFields)) {
-          const thrownMsg = err instanceof Error ? err.message : String(err);
-          sessionError = { message: thrownMsg, fields: thrownFields };
-        }
-      }
     }
     if (sessionError) {
       log("info", "\u9519\u8BEF\u5B57\u6BB5\u68C0\u67E5", {
@@ -99549,12 +99567,12 @@ async function handleChat(ctx, deps) {
               modelID: modelOverride.modelID
             });
             clearSessionError(session.id);
-            await client.session.prompt({
+            await client.session.promptAsync({
               path: { id: session.id },
               query,
               body: { ...baseBody, model: modelOverride }
             });
-            const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query });
+            const finalText = await pollForResponse(client, session.id, { timeout, pollInterval, stablePolls, query, signal });
             log("info", "\u6A21\u578B\u6062\u590D\u540E\u54CD\u5E94\u5B8C\u6210", {
               sessionKey,
               sessionId: session.id,
@@ -99572,19 +99590,25 @@ async function handleChat(ctx, deps) {
             return;
           }
         } catch (recoveryErr) {
+          if (recoveryErr instanceof Error && recoveryErr.name === "AbortError") {
+            log("info", "\u6A21\u578B\u6062\u590D\u88AB\u4E2D\u65AD", { sessionKey });
+            if (placeholderId) {
+              await deleteMessage(feishuClient, placeholderId).catch(() => {
+              });
+            }
+            return;
+          }
           const errMsg = recoveryErr instanceof Error ? recoveryErr.message : String(recoveryErr);
           if (recoveryErr instanceof SessionErrorDetected) {
             sessionError = recoveryErr.sessionError;
             clearSessionError(session.id);
           } else {
-            await new Promise((r) => setTimeout(r, SSE_RACE_WAIT_MS));
             const sseError = getSessionError(session.id);
             if (sseError) {
               sessionError = sseError;
               clearSessionError(session.id);
             } else {
-              const thrownFields = extractErrorFields(recoveryErr);
-              sessionError = { message: errMsg, fields: thrownFields };
+              sessionError = { message: errMsg, fields: [] };
             }
           }
           log("error", "\u6A21\u578B\u6062\u590D\u5931\u8D25", {
@@ -99607,7 +99631,7 @@ async function handleChat(ctx, deps) {
       sessionKey,
       chatType,
       error: thrownError,
-      ...sessionError ? { sessionError: sessionError.message } : { sseRaceMiss: true }
+      ...sessionError ? { sessionError: sessionError.message } : {}
     });
     const msg = "\u274C " + errorMessage;
     await replyOrUpdate(feishuClient, chatId, placeholderId, msg);
@@ -99718,6 +99742,113 @@ function extractLastAssistantText(messages) {
   return parts.filter((p) => p.type === "text").map((p) => p.text ?? "").join("\n").trim();
 }
 
+// src/handler/session-queue.ts
+var states = /* @__PURE__ */ new Map();
+function getOrCreateState(sessionKey) {
+  const existing = states.get(sessionKey);
+  if (existing) return existing;
+  const state = {
+    controller: null,
+    currentTask: null,
+    queue: [],
+    processing: false
+  };
+  states.set(sessionKey, state);
+  return state;
+}
+function cleanupStateIfIdle(sessionKey, state) {
+  if (!state.processing && state.queue.length === 0) {
+    states.delete(sessionKey);
+  }
+}
+async function enqueueMessage(ctx, deps) {
+  if (!ctx.shouldReply) {
+    await handleChat(ctx, deps);
+    return;
+  }
+  const sessionKey = buildSessionKey(
+    ctx.chatType,
+    ctx.chatType === "p2p" ? ctx.senderId : ctx.chatId
+  );
+  if (ctx.chatType === "p2p") {
+    await handleP2PMessage(sessionKey, ctx, deps);
+  } else {
+    await handleGroupMessage(sessionKey, ctx, deps);
+  }
+}
+async function handleP2PMessage(sessionKey, ctx, deps) {
+  const state = getOrCreateState(sessionKey);
+  while (state.processing) {
+    if (state.controller) {
+      state.controller.abort();
+      await abortServerSession(sessionKey, deps);
+    }
+    if (state.currentTask) {
+      await state.currentTask.catch(() => {
+      });
+    }
+  }
+  const controller = new AbortController();
+  state.controller = controller;
+  state.processing = true;
+  const task = processMessage(ctx, deps, controller.signal).finally(() => {
+    state.processing = false;
+    state.controller = null;
+    state.currentTask = null;
+    cleanupStateIfIdle(sessionKey, state);
+  });
+  state.currentTask = task;
+  await task;
+}
+async function handleGroupMessage(sessionKey, ctx, deps) {
+  const state = getOrCreateState(sessionKey);
+  state.queue.push({ ctx, deps });
+  if (state.processing) return;
+  await drainLoop(sessionKey, state);
+}
+async function drainLoop(sessionKey, state) {
+  state.processing = true;
+  try {
+    while (state.queue.length > 0) {
+      const item = state.queue.shift();
+      if (!item) break;
+      const controller = new AbortController();
+      state.controller = controller;
+      try {
+        await processMessage(item.ctx, item.deps, controller.signal);
+      } catch (err) {
+        item.deps.log("error", "\u7FA4\u804A\u961F\u5217\u6D88\u606F\u5904\u7406\u5931\u8D25", {
+          sessionKey,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      } finally {
+        state.controller = null;
+      }
+    }
+  } finally {
+    state.processing = false;
+    cleanupStateIfIdle(sessionKey, state);
+  }
+}
+async function processMessage(ctx, deps, signal) {
+  await handleChat(ctx, deps, signal);
+}
+async function abortServerSession(sessionKey, deps) {
+  const { client, log, directory } = deps;
+  const query = directory ? { directory } : void 0;
+  const cached = getCachedSession(sessionKey);
+  if (!cached) return;
+  try {
+    await client.session.abort({ path: { id: cached.id }, query });
+    log("info", "\u5DF2\u4E2D\u65AD\u5F53\u524D\u4F1A\u8BDD\u5904\u7406", { sessionKey, sessionId: cached.id });
+  } catch (err) {
+    log("warn", "\u4E2D\u65AD\u4F1A\u8BDD\u5931\u8D25", {
+      sessionKey,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+
 // src/feishu/history.ts
 var DEFAULT_PAGE_SIZE = 50;
 async function ingestGroupHistory(feishuClient, opencodeClient, chatId, options) {
@@ -99802,6 +99933,7 @@ ${body}`;
 
 // src/index.ts
 var SERVICE_NAME = "opencode-feishu";
+var LOG_PREFIX = "[feishu]";
 var isDebug = !!process.env.FEISHU_DEBUG;
 var DEFAULT_CONFIG = {
   timeout: 12e4,
@@ -99823,14 +99955,15 @@ var FeishuPlugin = async (ctx) => {
   const { client } = ctx;
   let gateway = null;
   const log = (level, message, extra) => {
+    const prefixed = `${LOG_PREFIX} ${message}`;
     if (isDebug) {
-      console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), service: SERVICE_NAME, level, message, ...extra }));
+      console.error(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), service: SERVICE_NAME, level, message: prefixed, ...extra }));
     }
     client.app.log({
       body: {
         service: SERVICE_NAME,
         level,
-        message,
+        message: prefixed,
         extra
       }
     }).catch(() => {
@@ -99884,7 +100017,7 @@ var FeishuPlugin = async (ctx) => {
     botOpenId,
     onMessage: async (msgCtx) => {
       if (!msgCtx.content.trim() || !gateway) return;
-      await handleChat(msgCtx, {
+      await enqueueMessage(msgCtx, {
         config: resolvedConfig,
         client,
         feishuClient: gateway.client,