opencode-feishu-plugin 0.2.5 → 0.2.7

package/README.en.md

@@ -360,6 +360,7 @@ When the agent calls the `question` tool (or any form interaction), OpenCode cre
 
 - **Two equivalent ways to answer**: tap an option button, or just **send text in the topic** (no need to tap "✍️ reply directly" first). Text is matched intelligently — option label/value are matched to their value, booleans accept 是/否 & yes/no & 1/0, numbers are parsed, multiselect splits on commas, anything else counts as a **manual answer**;
 - multi-field forms can be answered with a mix of taps and a text reply; they submit automatically once every field is filled;
+- **Option-only questions** (options present, custom input not allowed): you may reply with the **option number/letter** (e.g. `1`, `B`) or the option label. Any **other** text is treated as "you meant something else": the plugin **skips that form** and passes your message to the AI as a **normal message** instead of a bogus answer.
 - **the card is recalled once answered/cancelled**; if it is past Feishu's recall window, it degrades to a "submitted/cancelled" result card instead.
 
 Without this relay, any clarifying question would stall the Feishu session forever and every later message would queue behind it — a common cause of "stuck sessions".
@@ -401,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

@@ -215,6 +215,7 @@ agent 调 `question` 等 form 类交互时，插件把它转成飞书卡片：
 
 - **两种作答方式等价**：直接点选项按钮，或**直接在话题里发文字**（无需先点「✍️ 直接回复答案」）。文本会智能匹配——命中选项 label/value 用选项值，`boolean` 认「是/否、yes/no、1/0」，`number`/`integer` 转数值，多选按顿号/逗号拆分，其余视为**手动输入**。
 - 多字段表单可以混合作答：点几个按钮 + 补一条文字，填满即自动提交。
+- **纯选项题**（有选项且不允许自填）：可以直接**回复序号/字母**（如 `1`、`B`）或选项原文；若你发的是**其它内容**，插件会视为「你想说别的」——**自动跳过该表单**并把这条消息当**普通消息**交给 AI 处理，不再被误当成答案。
 - **作答 / 取消后卡片会被撤回**（不再残留待填卡）；若超出飞书撤回时限，降级为「已提交 / 已取消」结果卡。
 - **没有这层转发，agent 一反问飞书会话就会永久卡住**——这也是会话卡死的常见原因。
 
@@ -262,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 |
 
@@ -283,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;
@@ -146737,14 +146849,24 @@ function buildFormCard(form, answers, opts = {}) {
       elements.push(cardButton("\u270D\uFE0F \u76F4\u63A5\u56DE\u590D\u7B54\u6848", "default", { f: form.id, k: field.key, free: true }));
     }
   }
-  const missing2 = missingFields(form, answers).map((k) => {
+  const missingKeys = missingFields(form, answers);
+  const missing2 = missingKeys.map((k) => {
     const f = form.fields.find((x) => x.key === k);
     return f ? fieldTitle(f) : k;
   });
+  const optionOnly = missingKeys.length > 0 && missingKeys.every((k) => {
+    const f = form.fields.find((x) => x.key === k);
+    return (f?.options?.length ?? 0) > 0 && f?.custom !== true;
+  });
   const hints = [];
   if (opts.notice) hints.push(opts.notice);
-  if (missing2.length > 0 && visible.length > 1) hints.push(`\u8FD8\u9700\u56DE\u7B54\uFF1A${missing2.join("\u3001")}\uFF08\u53EF\u76F4\u63A5\u53D1\u6587\u5B57\u56DE\u7B54\uFF09`);
-  else if (missing2.length > 0) hints.push("\u53EF\u76F4\u63A5\u53D1\u6587\u5B57\u56DE\u7B54\uFF0C\u6216\u70B9\u4E0A\u65B9\u9009\u9879\u3002");
+  if (missing2.length > 0 && visible.length > 1) {
+    hints.push(`\u8FD8\u9700\u56DE\u7B54\uFF1A${missing2.join("\u3001")}${optionOnly ? "\uFF08\u70B9\u9009\u9879\u6216\u56DE\u590D\u5E8F\u53F7\uFF09" : "\uFF08\u53EF\u76F4\u63A5\u53D1\u6587\u5B57\u56DE\u7B54\uFF09"}`);
+  } else if (missing2.length > 0) {
+    hints.push(
+      optionOnly ? "\u8BF7\u70B9\u51FB\u4E0A\u65B9\u9009\u9879\uFF08\u6216\u56DE\u590D\u5E8F\u53F7\uFF0C\u5982 1\uFF09\uFF1B\u53D1\u9001\u5176\u5B83\u5185\u5BB9\u4F1A\u4F5C\u4E3A\u666E\u901A\u6D88\u606F\u5904\u7406\u3002" : "\u53EF\u76F4\u63A5\u53D1\u6587\u5B57\u56DE\u7B54\uFF0C\u6216\u70B9\u4E0A\u65B9\u9009\u9879\u3002"
+    );
+  }
   if (hints.length > 0) elements.push({ tag: "markdown", content: truncateCardContent(hints.join("\n\n")) });
   const header = headerFor(form);
   return {
@@ -146889,6 +147011,17 @@ var FormRelay = class {
       return false;
     }
     const field = pending.form.fields.find((f) => f.key === fieldKey);
+    if (!fieldAcceptsText(field, text)) {
+      this.deps.log.info("\u9009\u9879\u9898\u6536\u5230\u975E\u9009\u9879\u6587\u672C\uFF0C\u8DF3\u8FC7\u8868\u5355\u5E76\u6309\u666E\u901A\u6D88\u606F\u5904\u7406", {
+        sessionID,
+        formID: pending.form.id,
+        fieldKey
+      });
+      this.awaiting.delete(sessionID);
+      this.forms.delete(pending.form.id);
+      void this.cancelPending(pending);
+      return false;
+    }
     pending.answers[fieldKey] = coerceAnswer(field, text);
     pending.awaitingField = void 0;
     this.awaiting.delete(sessionID);
@@ -146961,6 +147094,24 @@ var FormRelay = class {
     this.forms.delete(pending.form.id);
     await this.finish(pending, "answered");
   }
+  /** 取消 pending form（best-effort），随后撤回卡片。 */
+  async cancelPending(pending) {
+    if (this.deps.cancel) {
+      try {
+        await this.deps.cancel({
+          sessionID: pending.sessionID,
+          formID: pending.form.id,
+          ...pending.directory ? { directory: pending.directory } : {}
+        });
+      } catch (err2) {
+        this.deps.log.warn("form.cancel \u5931\u8D25\uFF08\u8BE5\u6D88\u606F\u53EF\u80FD\u4ECD\u6392\u961F\uFF09", {
+          formID: pending.form.id,
+          error: errorMessage(err2)
+        });
+      }
+    }
+    await this.finish(pending, "cancelled");
+  }
   /**
    * 表单收敛：**优先撤回卡片**（作答/取消后不再残留待填卡），撤回失败（超时限/无权限）
    * 才降级 patch 成结果卡，避免卡片永久停在待填态。
@@ -147011,9 +147162,28 @@ function coerceAnswer(field, text) {
       return matchOption(field, trimmed) ?? trimmed;
   }
 }
+function fieldAcceptsText(field, text) {
+  if (!field) return true;
+  const hasOptions = (field.options?.length ?? 0) > 0;
+  if (!hasOptions) return true;
+  if (field.custom === true) return true;
+  return matchOption(field, text) !== void 0;
+}
 function matchOption(field, text) {
   if (!field.options?.length) return void 0;
   const trimmed = text.trim();
+  const byNumber = /^(\d{1,2})[.、)）]?$/.exec(trimmed);
+  if (byNumber) {
+    const index2 = Number(byNumber[1]) - 1;
+    const option3 = field.options[index2];
+    if (option3) return option3.value;
+  }
+  const byLetter = /^([A-Za-z])[.、)）]?$/.exec(trimmed);
+  if (byLetter) {
+    const index2 = byLetter[1].toUpperCase().charCodeAt(0) - 65;
+    const option3 = field.options[index2];
+    if (option3) return option3.value;
+  }
   const lower = trimmed.toLowerCase();
   const hit = field.options.find(
     (o) => o.value === trimmed || o.label.trim() === trimmed || o.label.trim().toLowerCase() === lower
@@ -147060,6 +147230,27 @@ function authHeaders(service3) {
   const token = Buffer.from(`opencode:${service3.password}`, "utf8").toString("base64");
   return { authorization: `Basic ${token}` };
 }
+async function cancelFormOverHttp(input, deps) {
+  const discover = deps.discover ?? (() => discoverLocalService());
+  const doFetch = deps.fetchImpl ?? fetch;
+  const service3 = await discover();
+  if (!service3) throw new Error("\u672A\u53D1\u73B0\u672C\u673A opencode \u670D\u52A1\u6CE8\u518C\uFF08service.json \u7F3A\u5931\u6216\u635F\u574F\uFF09");
+  const path2 = `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`;
+  const headers = { ...authHeaders(service3) };
+  if (input.directory) headers["x-opencode-directory"] = encodeURIComponent(input.directory);
+  const response2 = await doFetch(`${service3.url}${path2}`, {
+    method: "DELETE",
+    headers,
+    signal: AbortSignal.timeout(deps.timeoutMs ?? 8e3)
+  });
+  if (!response2.ok) {
+    const detail = await response2.text().catch(() => "");
+    deps.log.debug("\u8868\u5355 HTTP \u53D6\u6D88\u5931\u8D25", { status: response2.status, formID: input.formID });
+    throw new Error(
+      `\u8868\u5355\u53D6\u6D88\u5931\u8D25 HTTP ${response2.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
+    );
+  }
+}
 async function replyFormOverHttp(input, deps) {
   const discover = deps.discover ?? (() => discoverLocalService());
   const doFetch = deps.fetchImpl ?? fetch;
@@ -151115,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),
@@ -151160,7 +151380,9 @@ async function start(ctx, config, log2, logSink) {
     log: log2,
     getLink: (sessionID) => sessionMap.resolveBySession(sessionID),
     isAllowed: (openId) => owner.isAllowed(openId),
-    reply: (input) => replyForm(ctx, input, log2)
+    reply: (input) => replyForm(ctx, input, log2),
+    // 选项题收到非选项文本 → 取消表单（解除阻塞），让该消息按普通 prompt 处理。
+    cancel: (input) => cancelFormOverHttp(input, { log: log2 })
   });
   const wizard = new WizardStore(storage, log2);
   const recent = new RecentStore(storage, log2, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-feishu-plugin",
-  "version": "0.2.5",
+  "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",