opencode-feishu 0.7.13 → 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);
@@ -99238,30 +99244,41 @@ function unregisterPending(sessionId) {
 function extractErrorFields(error) {
   if (typeof error === "string") return [error];
   if (error && typeof error === "object") {
-    const e = error;
-    const explicit = [e.message, e.type, e.name];
-    const enumerable = Object.values(e);
-    const fields = [...explicit, ...enumerable].filter((v) => typeof v === "string" && v.length > 0);
-    if (e.data && typeof e.data === "object" && "message" in e.data) {
-      const dataMsg = e.data.message;
-      if (typeof dataMsg === "string" && dataMsg.length > 0) fields.push(dataMsg);
-    }
-    if (e.data && typeof e.data === "object" && "error" in e.data) {
-      const dataErr = e.data.error;
-      if (dataErr && typeof dataErr === "object") {
-        const errStrings = Object.values(dataErr).filter((v) => typeof v === "string" && v.length > 0);
-        fields.push(...errStrings);
-      }
-    }
+    const fields = [];
+    collectStrings(error, fields, 3);
     return [...new Set(fields)];
   }
   return [String(error)];
 }
+function collectStrings(obj, out, maxDepth) {
+  if (maxDepth <= 0 || !obj || typeof obj !== "object") return;
+  const e = obj;
+  for (const key of ["message", "type", "name"]) {
+    const v = e[key];
+    if (typeof v === "string" && v.length > 0) out.push(v);
+  }
+  for (const v of Object.values(e)) {
+    if (typeof v === "string" && v.length > 0) out.push(v);
+    else if (Array.isArray(v)) {
+      for (const item of v) collectStrings(item, out, maxDepth - 1);
+    } else if (v && typeof v === "object") collectStrings(v, out, maxDepth - 1);
+  }
+}
 function isModelError(fields) {
-  const patterns = ["model not found", "modelnotfound", "model not supported", "model_not_supported", "model is not supported"];
+  const exactPatterns = [
+    "model not found",
+    "modelnotfound",
+    "model_not_found",
+    "model not supported",
+    "model_not_supported",
+    "model is not supported"
+  ];
+  const negativeWords = ["not", "unsupported", "invalid", "unavailable", "unknown", "does not", "doesn't", "cannot", "\u4E0D\u652F\u6301", "\u4E0D\u5B58\u5728", "\u65E0\u6548"];
   return fields.some((f) => {
     const l = f.toLowerCase();
-    return patterns.some((p) => l.includes(p));
+    if (exactPatterns.some((p) => l.includes(p))) return true;
+    if (l.includes("model") && negativeWords.some((w) => l.includes(w))) return true;
+    return false;
   });
 }
 async function handleEvent(event, deps) {
@@ -99273,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;
@@ -99332,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;
@@ -99370,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;
@@ -99400,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 }
@@ -99477,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,
@@ -99492,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", {
@@ -99538,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,
@@ -99561,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", {
@@ -99596,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);
@@ -99707,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) {
@@ -99791,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,
@@ -99812,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(() => {
@@ -99873,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,