@modelzen/feishu-codex-bridge 0.2.0 → 0.2.1

package/dist/cli.js

@@ -1961,8 +1961,8 @@ function card(elements, opts = {}) {
   if (opts.streaming) {
     config.streaming_mode = true;
     config.streaming_config = {
-      print_frequency_ms: { default: 70 },
-      print_step: { default: 1 },
+      print_frequency_ms: { default: 25 },
+      print_step: { default: 6 },
       print_strategy: "fast"
     };
   }
@@ -1984,6 +1984,9 @@ function card(elements, opts = {}) {
 function md(content) {
   return { tag: "markdown", content };
 }
+function mdStream(content, elementId) {
+  return { tag: "markdown", element_id: elementId, content };
+}
 function image(imgKey, alt = "") {
   return {
     tag: "img",
@@ -2533,6 +2536,7 @@ function escapeInline2(s) {
 var RC = {
   stop: "run.stop"
 };
+var ANSWER_EID = "answer";
 var REASONING_MAX = 1500;
 var COLLAPSE_TOOL_THRESHOLD = 3;
 var PROCESS_BODY_BUDGET = 22e3;
@@ -2546,14 +2550,19 @@ function renderRunning(state, rc) {
   const elements = [];
   const reasoning = reasoningContent(state);
   if (reasoning) elements.push(reasoningPanel(reasoning, state.reasoningActive));
-  const blocks = rc.showTools === false ? state.blocks.filter((b) => b.kind !== "tool") : state.blocks;
-  for (const group of groupBlocks(blocks)) {
-    if (group.kind === "text") {
-      if (group.content.trim()) elements.push(md(group.content));
-    } else {
-      elements.push(...renderToolGroup(group.tools, false));
+  const showTools = rc.showTools !== false;
+  const tools = [];
+  const textParts = [];
+  for (const b of state.blocks) {
+    if (b.kind === "tool") {
+      if (showTools) tools.push(b.tool);
+    } else if (b.content.trim()) {
+      textParts.push(b.content);
     }
   }
+  if (tools.length > 0) elements.push(...renderToolGroup(tools, false));
+  const answer = textParts.join("\n\n");
+  if (answer) elements.push(mdStream(answer, ANSWER_EID));
   if (state.footer) elements.push(footerStatus(state.footer));
   if (rc.cardKey) elements.push(actions([button("\u23F9 \u7EC8\u6B62", { a: RC.stop, m: rc.cardKey }, "danger")]));
   return elements;
@@ -2700,16 +2709,105 @@ function truncate4(s, n) {
 }
 
 // src/card/run-card-stream.ts
-var STREAM_THROTTLE_MS = 250;
+var STREAM_THROTTLE_MS = 150;
 var RunCardStream = class {
   cardId = "";
   _messageId = "";
   seq = 0;
   lastPush = 0;
   lastContent = "";
+  // Per-turn push counters — surfaced via stats() for the stream.timing log.
+  pushCount = 0;
+  cardPushes = 0;
+  // whole-card card.update (structure)
+  elPushes = 0;
+  // element cardElement.content (answer typewriter)
+  totalRttMs = 0;
+  maxRttMs = 0;
+  // Coalesced streaming. The consume loop records the latest {card, answerEid} in
+  // `pending`; a single pump() drains it — NON-BLOCKING, so consuming codex events
+  // never stalls on a round-trip (awaiting each push serially drained the backlog
+  // at one event per ~RTT → "已回完、飞书还在慢慢打字"). The pump pushes only the most
+  // recent snapshot per round-trip: when only the answer text grew it streams that
+  // via cardElement.content (typewriter), otherwise it whole-card updates.
+  pending = null;
+  pumpChannel = null;
+  pumpPromise = null;
+  // Baselines for the pump's route decision (structure unchanged + answer grew?).
+  lastStructureSig = "";
+  lastAnswerText = "";
   get messageId() {
     return this._messageId;
   }
+  /** Push counts (whole-card vs element) + round-trip stats for this card. */
+  stats() {
+    return {
+      pushCount: this.pushCount,
+      cardPushes: this.cardPushes,
+      elPushes: this.elPushes,
+      totalRttMs: this.totalRttMs,
+      maxRttMs: this.maxRttMs
+    };
+  }
+  /**
+   * Record the latest card and ensure the pump is running. Returns immediately;
+   * calls that arrive while a push is in flight collapse into a single push of
+   * the most recent card once that round-trip completes. Use this from the
+   * event-consume loop instead of awaiting {@link streamCard} per event.
+   */
+  streamCoalesced(channel, fullCard, answerEid) {
+    this.pending = { card: fullCard, answerEid };
+    this.pumpChannel = channel;
+    if (!this.pumpPromise) this.pumpPromise = this.pump();
+  }
+  /** Await any in-flight coalesced push so the final streaming frame lands (and
+   * `seq` stays ordered) before the terminal update. Call after the loop ends. */
+  async drain() {
+    if (this.pumpPromise) await this.pumpPromise;
+  }
+  async pump() {
+    try {
+      while (this.pending && this.pumpChannel) {
+        const { card: card2, answerEid } = this.pending;
+        this.pending = null;
+        const t0 = Date.now();
+        const answer = answerEid ? answerContent(card2, answerEid) : null;
+        const sig = structureSig(card2, answerEid);
+        if (answerEid && answer !== null && sig === this.lastStructureSig && answer !== this.lastAnswerText && answer.startsWith(this.lastAnswerText)) {
+          await this.streamElement(this.pumpChannel, answerEid, answer);
+          this.lastAnswerText = answer;
+        } else {
+          await this.streamCard(this.pumpChannel, card2, true);
+          this.lastStructureSig = sig;
+          this.lastAnswerText = answer ?? "";
+        }
+        const gap = STREAM_THROTTLE_MS - (Date.now() - t0);
+        if (this.pending && gap > 0) await new Promise((r) => setTimeout(r, gap));
+      }
+    } finally {
+      this.pumpPromise = null;
+    }
+  }
+  /** Element-level streaming push (cardkit.v1.cardElement.content): the answer
+   * element's accumulated full text. Feishu diffs the prefix and types the delta
+   * per the card's streaming_config. Needs streaming_mode on the card. */
+  async streamElement(channel, elementId, content) {
+    if (!this.cardId) return;
+    const t0 = Date.now();
+    try {
+      await channel.rawClient.cardkit.v1.cardElement.content({
+        path: { card_id: this.cardId, element_id: elementId },
+        data: { content, sequence: ++this.seq, uuid: `e_${this.cardId}_${this.seq}` }
+      });
+      const rtt = Date.now() - t0;
+      this.pushCount++;
+      this.elPushes++;
+      this.totalRttMs += rtt;
+      if (rtt > this.maxRttMs) this.maxRttMs = rtt;
+    } catch (err) {
+      log.fail("card", err, { phase: "run-stream-el", cardId: this.cardId, seq: this.seq });
+    }
+  }
   /** Create the entity from the initial (running) card and send a message
    * referencing it by card_id. Returns the carrier message id. */
   async create(channel, chatId, initialCard, opts) {
@@ -2751,11 +2849,17 @@ var RunCardStream = class {
     if (!force && now - this.lastPush < STREAM_THROTTLE_MS) return;
     this.lastPush = now;
     this.lastContent = data;
+    const t0 = Date.now();
     try {
       await channel.rawClient.cardkit.v1.card.update({
         path: { card_id: this.cardId },
         data: { card: { type: "card_json", data }, sequence: ++this.seq, uuid: `s_${this.cardId}_${this.seq}` }
       });
+      const rtt = Date.now() - t0;
+      this.pushCount++;
+      this.cardPushes++;
+      this.totalRttMs += rtt;
+      if (rtt > this.maxRttMs) this.maxRttMs = rtt;
     } catch (err) {
       log.fail("card", err, { phase: "run-stream", cardId: this.cardId, seq: this.seq });
     }
@@ -2785,6 +2889,21 @@ var RunCardStream = class {
     }
   }
 };
+function answerContent(card2, eid) {
+  const els = card2.body?.elements;
+  if (!Array.isArray(els)) return null;
+  for (const el of els) {
+    if (el && el.element_id === eid) return typeof el.content === "string" ? el.content : "";
+  }
+  return null;
+}
+function structureSig(card2, eid) {
+  const body = card2.body;
+  const els = body?.elements;
+  if (!eid || !Array.isArray(els)) return JSON.stringify(card2);
+  const blanked = els.map((el) => el && el.element_id === eid ? { ...el, content: "" } : el);
+  return JSON.stringify({ ...card2, body: { ...body, elements: blanked } });
+}
 
 // src/card/outbound-images.ts
 import { readFile as readFile5, stat as stat2 } from "fs/promises";
@@ -5104,11 +5223,29 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           },
           stopSignal
         );
+        const tStart = Date.now();
+        let firstEvAt = 0;
+        let firstTextAt = 0;
+        let lastEvAt = tStart;
+        let evCount = 0;
+        let textChars = 0;
         for await (const ev of guarded) {
+          const tEv = Date.now();
+          if (!firstEvAt) firstEvAt = tEv;
+          const et = ev.type;
+          if (et === "text_delta") {
+            if (!firstTextAt) firstTextAt = tEv;
+            const d = ev.delta;
+            if (typeof d === "string") textChars += d.length;
+          }
+          lastEvAt = tEv;
+          evCount++;
           render.apply(ev);
           rc.rs = render.snapshot();
-          await stream2.streamCard(channel, buildRunCard(rc));
+          stream2.streamCoalesced(channel, buildRunCard(rc), ANSWER_EID);
         }
+        const doneAt = Date.now();
+        await stream2.drain();
         state.interrupt = void 0;
         const killed = interrupted || timedOut;
         if (timedOut) render.timeout(Math.max(1, Math.round(idleMs / 6e4)));
@@ -5129,6 +5266,25 @@ ${tail}` }, { replyTo: evt.messageId }).catch(() => void 0);
           rc.images = await uploadOutboundImages(channel, imgSources, opts.cwd ?? fallbackCwd);
         }
         await stream2.updateCard(channel, buildRunCard(rc));
+        {
+          const terminalAt = Date.now();
+          const st = stream2.stats();
+          log.info("stream", "timing", {
+            firstEv: firstEvAt ? firstEvAt - tStart : -1,
+            firstText: firstTextAt ? firstTextAt - tStart : -1,
+            lastEv: lastEvAt - tStart,
+            done: doneAt - tStart,
+            terminal: terminalAt - tStart,
+            doneToTerminal: terminalAt - doneAt,
+            events: evCount,
+            textChars,
+            pushes: st.pushCount,
+            cardPushes: st.cardPushes,
+            elPushes: st.elPushes,
+            rttAvg: st.pushCount ? Math.round(st.totalRttMs / st.pushCount) : 0,
+            rttMax: st.maxRttMs
+          });
+        }
         runsByCard.delete(cardMsgId);
         promoteCard(finalMsgId, rc);
         for (const fence of fences) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelzen/feishu-codex-bridge",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Bridge Feishu/Lark messenger with local Codex via app-server (project=group, thread=session)",
   "type": "module",
   "bin": {