opencode-feishu-plugin 0.2.6 → 0.2.7

package/README.en.md

@@ -402,9 +402,21 @@ Without this relay, any clarifying question would stall the Feishu session forev
 | `topicStatusInTitle` | boolean | `false` | Add a status emoji prefix to the root card title (e.g. `🟡 session name`). Off by default: the topic name shows in the sidebar, and flipping it would be noisy |
 | `topicStatusThrottleMs` | number | `1000` | Min root-card status refresh interval (clamped 500–10000); patched only when the kind changes |
 | `cardMaxTables` | number | `4` | Max markdown tables kept per card (clamped 1–5); tables beyond it are degraded **cumulatively per card** into fenced code blocks (no content lost) to avoid Feishu 400 `code=230099` |
+| `runnerCardMaxTools` | number | `12` | Max tool blocks kept on the run card (1–50); older ones collapse into "…omitted N tool calls" |
+| `runnerCardTextMax` | number | `2048` | Per-text-block character cap on the run card (512–8192) |
+| `finalAnswerMinChars` | number | `600` | Final answers at least this long are sent **as their own card/file** (`0` disables splitting) |
+| `finalAnswerFileMinBytes` | number | `20480` | Final answers at least this many bytes are delivered as a `.md` file (8192–102400) |
 | `keepalive` | boolean | `true` | **Location keep-alive**: periodically emits activity so OpenCode does not evict the idle Location after 60 minutes (which unloads the plugin and closes the Feishu long connection) |
 | `keepaliveIntervalMs` | number | `1200000` | Keep-alive interval (default 20 min, clamped 5–45); must stay well below OpenCode's hardcoded 60-minute TTL |
 
+### Long answers (run-card slimming + separate final answer)
+
+A long turn (dozens of tool calls) can push a single run card to its limits (28KB / 200 elements), triggering degradation and **dropping the oldest blocks** — the card looks "full" and earlier content disappears. Default strategy:
+
+1. **The run card is progress-only**: keep the last `runnerCardMaxTools` (default 12) tool blocks, collapsing older ones into "…omitted N tool calls"; each text block is capped at `runnerCardTextMax` (default 2KB).
+2. **The final answer is sent separately**: when a turn ends and the trailing text is at least `finalAnswerMinChars` (default 600 chars), it is sent as its own "✅ 完整回答" card; the run card keeps only a short notice.
+3. **Very long answers become files**: at least `finalAnswerFileMinBytes` (default 20KB) → delivered as a `.md` file (preview/download), never truncated.
+
 ### Location keep-alive (on by default)
 
 OpenCode **evicts idle Locations**, which unloads plugins and closes the Feishu long connection:

package/README.md

@@ -263,6 +263,10 @@ agent 调 `question` 等 form 类交互时，插件把它转成飞书卡片：
 | `topicStatusInTitle` | boolean | `false` | 是否在根卡标题加状态 emoji 前缀 |
 | `topicStatusThrottleMs` | number | `1000` | 根卡状态刷新最小间隔（500–10000） |
 | `cardMaxTables` | number | `4` | 单卡最多保留的 markdown 表格数（1–5）；超出按整卡累计降级为围栏代码块，避免飞书 400 `code=230099` |
+| `runnerCardMaxTools` | number | `12` | 运行卡最多保留的工具块数（1–50）；更早的合并为「已省略前 N 次工具调用」 |
+| `runnerCardTextMax` | number | `2048` | 运行卡单个文本块字符上限（512–8192） |
+| `finalAnswerMinChars` | number | `600` | 最终回答 ≥ 该长度即**单独成卡/成文件**（0 = 关闭拆分） |
+| `finalAnswerFileMinBytes` | number | `20480` | 最终回答 ≥ 该字节数转为 `.md` 文件发送（8192–102400） |
 | `keepalive` | boolean | `true` | **位置保活**：周期性向 opencode 发一次活动，阻止 60 分钟空闲回收 location（会关掉飞书长连接、机器人失联） |
 | `keepaliveIntervalMs` | number | `1200000` | 保活间隔（默认 20 分钟，夹取 5–45）；必须显著小于 opencode 硬编码的 60 分钟 TTL |
 
@@ -284,6 +288,16 @@ permission.evaluate (插件 hook)               permission.asked (事件流)
 - **三重单人边界**：可用范围「仅本人」+ 不申请群权限 + 代码层 open_id 白名单。
 - **`always` 语义**：仅当请求带 `save[]` 时才持久化，否则等价于「允许一次」。
 
+### 长回答处理（运行卡瘦身 + 最终答案独立）
+
+长任务（几十次工具调用）会把单张运行卡撑到上限（28KB / 200 元素），触发降级与**丢弃最旧块**——用户会看到"卡被撑满、前面内容消失"。默认策略：
+
+1. **运行卡只做进度**：最多保留最近 `runnerCardMaxTools`（默认 12）个工具块，更早的合并为「…已省略前 N 次工具调用」；单个文本块上限 `runnerCardTextMax`（默认 2KB）。
+2. **最终答案独立发送**：一轮结束时末尾文本 ≥ `finalAnswerMinChars`（默认 600 字符）→ 单独发一张「✅ 完整回答」卡（不与被工具噪声塞满的运行卡抢空间）；运行卡内只留「完整回答已单独发送」提示。
+3. **超长转文件**：最终回答 ≥ `finalAnswerFileMinBytes`（默认 20KB）→ 作为 `.md` 文件发送（可预览/下载），内容不截断、不丢失。
+
+> 想要"完整轨迹保留、不省略工具调用"：把 `runnerCardMaxTools` 调到足够大并接受卡片消息变多（或提高 `finalAnswerMinChars` 降低拆分频率）。
+
 ### 位置保活（防空闲失联，默认开启）
 
 opencode 会**回收空闲的 location**，这会连带卸载插件、关闭飞书长连接：

package/dist/index.js

@@ -144025,6 +144025,10 @@ function resolveConfig2(raw, env = process.env, deps = {}) {
   const topicStatusThrottleMs = clamp4(asNumber(merged.topicStatusThrottleMs, 1e3), 500, 1e4);
   const cardMaxTables = clamp4(asNumber(merged.cardMaxTables, 4), 1, 5);
   const keepalive = asBoolean(merged.keepalive, true);
+  const runnerCardMaxTools = clamp4(asNumber(merged.runnerCardMaxTools, 12), 1, 50);
+  const runnerCardTextMax = clamp4(asNumber(merged.runnerCardTextMax, 2048), 512, 8192);
+  const finalAnswerMinChars = clamp4(asNumber(merged.finalAnswerMinChars, 600), 0, 2e4);
+  const finalAnswerFileMinBytes = clamp4(asNumber(merged.finalAnswerFileMinBytes, 20 * 1024), 8192, 102400);
   const keepaliveIntervalMs = clamp4(
     asNumber(merged.keepaliveIntervalMs, 20 * 60 * 1e3),
     5 * 60 * 1e3,
@@ -144081,7 +144085,11 @@ function resolveConfig2(raw, env = process.env, deps = {}) {
     topicStatusThrottleMs,
     cardMaxTables,
     keepalive,
-    keepaliveIntervalMs
+    keepaliveIntervalMs,
+    runnerCardMaxTools,
+    runnerCardTextMax,
+    finalAnswerMinChars,
+    finalAnswerFileMinBytes
   };
 }
 function loadConfigFile(env, deps, warnings) {
@@ -145173,6 +145181,29 @@ function createFeishuSender(client, log2, options2 = {}) {
         return void 0;
       }
     },
+    async sendFile(chatId, fileName, content, replyToMessageId) {
+      try {
+        const uploaded = await client.im.file.create({
+          data: { file_type: "stream", file_name: fileName, file: content }
+        });
+        const fileKey = uploaded?.file_key ?? "";
+        if (!fileKey) return { ok: false, error: "missing file_key" };
+        const payload = { msg_type: "file", content: JSON.stringify({ file_key: fileKey }) };
+        const res = replyToMessageId ? await client.im.message.reply({ path: { message_id: replyToMessageId }, data: payload }) : await client.im.message.create({
+          params: { receive_id_type: "chat_id" },
+          data: { receive_id: chatId, ...payload }
+        });
+        if (res?.code && res.code !== 0) {
+          log2.warn("\u53D1\u9001\u6587\u4EF6\u5931\u8D25", { chatId, fileName, code: res.code, msg: res.msg });
+          return { ok: false, error: `code=${res.code} msg=${res.msg ?? ""}` };
+        }
+        const messageId = res?.data?.message_id ?? "";
+        return messageId ? { ok: true, messageId } : { ok: true };
+      } catch (err2) {
+        log2.warn("\u53D1\u9001\u6587\u4EF6\u5F02\u5E38", { chatId, fileName, error: describeLarkError(err2) });
+        return { ok: false, error: describeLarkError(err2) };
+      }
+    },
     async deleteMessage(messageId) {
       if (!messageId) return { ok: false, error: "missing messageId" };
       try {
@@ -145885,6 +145916,8 @@ function reduce6(state, event) {
         status: "error",
         output: event.output
       }));
+    case "final.separated":
+      return { ...state, finalSeparated: true };
     default:
       return state;
   }
@@ -146061,6 +146094,14 @@ function closeCodeFences(text) {
   if (fences && fences.length % 2 !== 0) return `${text}${CODE_FENCE}`;
   return text;
 }
+function buildFinalAnswerCard(text) {
+  return {
+    schema: "2.0",
+    config: { update_multi: true },
+    header: { title: { tag: "plain_text", content: "\u2705 \u5B8C\u6574\u56DE\u7B54" }, template: "green" },
+    body: { elements: [{ tag: "markdown", content: truncateCardContent(text, 24 * 1024) }] }
+  };
+}
 
 // src/feishu/run-renderer.ts
 var COLLAPSE_TOOL_THRESHOLD = 3;
@@ -146068,11 +146109,30 @@ var HEADER_SUMMARY_MAX = 80;
 var TOOL_INPUT_MAX = 600;
 var OUTPUT_FIRST_LINE_MAX = 200;
 var TEXT_ELEMENT_MAX = 8 * 1024;
+var DEFAULT_MAX_TOOLS = 12;
+var DEFAULT_TEXT_MAX = 2 * 1024;
 function renderRunCard(state, stopValue, options2 = {}) {
   const elements = [];
-  for (const group of groupBlocks(state.blocks)) {
+  const maxTools = options2.maxTools ?? DEFAULT_MAX_TOOLS;
+  const textMax = options2.textMax ?? DEFAULT_TEXT_MAX;
+  const capped = capToolBlocks(state.blocks, maxTools);
+  if (capped.omitted > 0) {
+    elements.push(note(`\u2026\u5DF2\u7701\u7565\u524D ${capped.omitted} \u6B21\u5DE5\u5177\u8C03\u7528\uFF08\u5B8C\u6574\u8BB0\u5F55\u89C1 opencode \u4F1A\u8BDD\uFF09`));
+  }
+  const groups = groupBlocks(capped.blocks);
+  const lastTextIndex = groups.reduce(
+    (acc, g, i) => g.kind === "text" && g.content.trim() ? i : acc,
+    -1
+  );
+  for (let i = 0; i < groups.length; i += 1) {
+    const group = groups[i];
     if (group.kind === "text") {
-      if (group.content.trim()) elements.push(markdown(truncateCardContent(group.content, TEXT_ELEMENT_MAX)));
+      if (!group.content.trim()) continue;
+      if (state.finalSeparated && i === lastTextIndex) {
+        elements.push(note("\u2705 \u5B8C\u6574\u56DE\u7B54\u5DF2\u5355\u72EC\u53D1\u9001\uFF08\u89C1\u4E0B\u65B9\u5361\u7247 / \u9644\u4EF6\uFF09"));
+        continue;
+      }
+      elements.push(markdown(truncateCardContent(group.content, Math.min(textMax, TEXT_ELEMENT_MAX))));
     } else {
       elements.push(...renderToolGroup(group.tools, state.terminal !== "running"));
     }
@@ -146109,6 +146169,20 @@ function renderRunCard(state, stopValue, options2 = {}) {
   }
   return enforceSize(guarded);
 }
+function capToolBlocks(blocks, maxTools) {
+  const total2 = blocks.reduce((n, b) => n + (b.kind === "tool" ? 1 : 0), 0);
+  if (maxTools <= 0 || total2 <= maxTools) return { blocks: [...blocks], omitted: 0 };
+  let toDrop = total2 - maxTools;
+  const out = [];
+  for (const block of blocks) {
+    if (block.kind === "tool" && toDrop > 0) {
+      toDrop -= 1;
+      continue;
+    }
+    out.push(block);
+  }
+  return { blocks: out, omitted: total2 - maxTools };
+}
 function groupBlocks(blocks) {
   const groups = [];
   let toolBuf = [];
@@ -146295,6 +146369,19 @@ function byteLength(value3) {
 }
 
 // src/feishu/run-controller.ts
+function trailingText(blocks) {
+  const parts = [];
+  for (let i = blocks.length - 1; i >= 0; i -= 1) {
+    const block = blocks[i];
+    if (block.kind === "tool") {
+      if (parts.length > 0) break;
+      continue;
+    }
+    if (block.content.trim()) parts.unshift(block.content);
+    else if (parts.length > 0) break;
+  }
+  return parts.join("\n\n").trim();
+}
 function createRunController(deps) {
   const sessions = /* @__PURE__ */ new Map();
   const throttlers = /* @__PURE__ */ new Map();
@@ -146312,6 +146399,8 @@ function createRunController(deps) {
   };
   const renderCard = (sessionID, state) => renderRunCard(state, deps.buildStopValue?.(sessionID), {
     maxTables: deps.cardMaxTables,
+    maxTools: deps.runnerCardMaxTools,
+    textMax: deps.runnerCardTextMax,
     onLimit: (report) => {
       deps.log.warn("\u8FD0\u884C\u5361\u5185\u5BB9\u8D85\u9650\uFF0C\u5DF2\u964D\u7EA7", {
         sessionID,
@@ -146389,7 +146478,8 @@ function createRunController(deps) {
         state,
         chain: Promise.resolve(),
         finalized: false,
-        queuedAt: Date.now()
+        queuedAt: Date.now(),
+        ...input.replyToMessageId ? { replyToMessageId: input.replyToMessageId } : {}
       };
       if (input.delivery === "queue") {
         runs.queued.push(card);
@@ -146419,7 +146509,29 @@ function createRunController(deps) {
       }
       const card = runs.active;
       if (!card) return;
-      if (event.type === "execution.succeeded" || event.type === "execution.failed") {
+      if (event.type === "execution.succeeded") {
+        const text = trailingText(card.state.blocks);
+        const long = deps.sendFinalAnswer !== void 0 && deps.finalAnswer !== void 0 && text.length >= deps.finalAnswer.minChars;
+        if (long) {
+          card.state = reduce6(reduce6(card.state, { type: "final.separated" }), event);
+          finalize2(card);
+          runs.active = void 0;
+          void deps.sendFinalAnswer({
+            sessionID,
+            chatId: card.chatId,
+            ...card.replyToMessageId ? { replyToMessageId: card.replyToMessageId } : {},
+            text
+          }).catch((err2) => {
+            deps.log.warn("\u6700\u7EC8\u7B54\u6848\u53D1\u9001\u5931\u8D25", { sessionID, error: errorMessage(err2) });
+          });
+          return;
+        }
+        update2(card, event, true);
+        finalize2(card);
+        runs.active = void 0;
+        return;
+      }
+      if (event.type === "execution.failed") {
         update2(card, event, true);
         finalize2(card);
         runs.active = void 0;
@@ -151194,9 +151306,38 @@ async function start(ctx, config, log2, logSink) {
     enabled: config.stream,
     throttleMs: config.streamThrottleMs,
     cardMaxTables: config.cardMaxTables,
+    runnerCardMaxTools: config.runnerCardMaxTools,
+    runnerCardTextMax: config.runnerCardTextMax,
+    finalAnswer: { minChars: config.finalAnswerMinChars },
+    // 长回答单独成卡/成文件：运行卡只留「完整回答已单独发送」提示。
+    sendFinalAnswer: (input) => sendFinalAnswer(input),
     // 每次 patch 重签强停 token（`stop` 在下方定义，闭包运行时才求值）。
     buildStopValue: (sessionID) => stop.buildStopValue(sessionID)
   });
+  async function sendFinalAnswer(input) {
+    const bytes = Buffer.byteLength(input.text, "utf8");
+    if (bytes > config.finalAnswerFileMinBytes) {
+      const fileName = `opencode-${input.sessionID.slice(-6)}.md`;
+      const res2 = await sender.sendFile(
+        input.chatId,
+        fileName,
+        Buffer.from(input.text, "utf8"),
+        input.replyToMessageId
+      );
+      if (res2.ok) {
+        log2.info("\u6700\u7EC8\u7B54\u6848\u5DF2\u8F6C\u4E3A\u6587\u4EF6\u53D1\u9001", { sessionID: input.sessionID, bytes, fileName });
+        return;
+      }
+      log2.warn("\u6700\u7EC8\u7B54\u6848\u8F6C\u6587\u4EF6\u5931\u8D25\uFF0C\u964D\u7EA7\u4E3A\u5361\u7247", { sessionID: input.sessionID, error: res2.error ?? "unknown" });
+    }
+    const card = buildFinalAnswerCard(input.text);
+    const res = input.replyToMessageId ? await sender.replyCard(input.replyToMessageId, card) : await sender.sendCard(input.chatId, card);
+    if (!res.ok) {
+      log2.warn("\u6700\u7EC8\u7B54\u6848\u5361\u7247\u53D1\u9001\u5931\u8D25", { sessionID: input.sessionID, error: res.error ?? "unknown" });
+      return;
+    }
+    log2.info("\u6700\u7EC8\u7B54\u6848\u5DF2\u5355\u72EC\u6210\u5361", { sessionID: input.sessionID, bytes });
+  }
   const recovery = createSessionRecovery({
     log: log2,
     resolveLink: (sessionID) => sessionMap.resolveBySession(sessionID),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-feishu-plugin",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Feishu/Lark plugin for OpenCode V2 — single-user topics as sessions, in-card permission approvals, streaming cards. Minimal permissions, no public endpoint.",
   "type": "module",
   "main": "index.js",