eve-lark 0.4.2 → 0.4.4

package/dist/index.js

@@ -531,6 +531,15 @@ function parseInbound(event, botOpenId) {
 __name(parseInbound, "parseInbound");
 
 // src/card.ts
+function renderToolCalls(calls) {
+  if (calls.length === 0) return void 0;
+  return calls.map((c) => {
+    if (c.state === "running") return `<font color='blue'>\u23F3 ${c.name}</font>`;
+    if (c.state === "failed") return `<font color='red'>\u2717 ${c.name}</font>`;
+    return `<font color='green'>\u2713 ${c.name}</font>`;
+  }).join("\n");
+}
+__name(renderToolCalls, "renderToolCalls");
 var BASE_CONFIG = {
   wide_screen_mode: true,
   update_multi: true
@@ -595,14 +604,35 @@ function buildTextCard(text) {
 __name(buildTextCard, "buildTextCard");
 function buildStreamingCard(opts) {
   const lines = [];
+  const toolLine = renderToolCalls(opts.toolCalls ?? []);
+  if (toolLine) lines.push(toolLine);
   if (opts.status) {
     lines.push(`<font color='grey'>${opts.status}</font>`);
   }
   lines.push(opts.buffer.length > 0 ? opts.buffer : "_\u2026_");
-  return {
-    config: { ...BASE_CONFIG },
-    elements: [{ tag: "div", text: { tag: "lark_md", content: lines.join("\n\n") } }]
-  };
+  if (opts.askRequest) {
+    lines.push(`**${opts.askRequest.prompt}**`);
+    if (opts.askRequest.allowFreeform && (opts.askRequest.options?.length ?? 0) === 0) {
+      lines.push(`<font color='grey'>_Reply to this chat with your answer_</font>`);
+    }
+  }
+  const elements = [
+    { tag: "div", text: { tag: "lark_md", content: lines.join("\n\n") } }
+  ];
+  if (opts.askRequest?.options && opts.askRequest.options.length > 0) {
+    const buttons = opts.askRequest.options.map((opt) => ({
+      tag: "button",
+      text: { tag: "plain_text", content: opt.label },
+      type: opt.style ?? "default",
+      value: {
+        [ASK_BUTTON_VALUE_MARKER]: true,
+        requestId: opts.askRequest.requestId,
+        optionId: opt.id
+      }
+    }));
+    elements.push({ tag: "action", actions: buttons });
+  }
+  return { config: { ...BASE_CONFIG }, elements };
 }
 __name(buildStreamingCard, "buildStreamingCard");
 function buildErrorCard(message) {
@@ -670,10 +700,12 @@ function buildAskCard(request) {
   return { config: { ...BASE_CONFIG }, elements };
 }
 __name(buildAskCard, "buildAskCard");
-function buildAskAnsweredCard(request, selected) {
-  const elements = [
-    { tag: "div", text: { tag: "lark_md", content: request.prompt } }
-  ];
+function buildAskAnsweredCard(request, selected, priorBuffer) {
+  const elements = [];
+  if (priorBuffer && priorBuffer.length > 0) {
+    elements.push({ tag: "div", text: { tag: "lark_md", content: priorBuffer } });
+  }
+  elements.push({ tag: "div", text: { tag: "lark_md", content: request.prompt } });
   const summary = selected.kind === "option" ? `<font color='green'>\u2713 ${escapeMarkdown(selected.label)}</font>` : `<font color='green'>\u2713 ${escapeMarkdown(selected.text)}</font>`;
   elements.push({ tag: "div", text: { tag: "lark_md", content: summary } });
   return { config: { ...BASE_CONFIG }, elements };
@@ -685,10 +717,34 @@ function escapeMarkdown(s) {
 __name(escapeMarkdown, "escapeMarkdown");
 function buildCardKitStreamingCard(opts) {
   const lines = [];
+  const toolLine = renderToolCalls(opts.toolCalls ?? []);
+  if (toolLine) lines.push(toolLine);
   if (opts.status) {
     lines.push(`<font color='grey'>${opts.status}</font>`);
   }
   lines.push(opts.buffer.length > 0 ? opts.buffer : "_\u2026_");
+  if (opts.askRequest) {
+    lines.push(`**${opts.askRequest.prompt}**`);
+    if (opts.askRequest.allowFreeform && (opts.askRequest.options?.length ?? 0) === 0) {
+      lines.push(`<font color='grey'>_Reply to this chat with your answer_</font>`);
+    }
+  }
+  const elements = [
+    { tag: "markdown", content: lines.join("\n\n") }
+  ];
+  if (opts.askRequest?.options && opts.askRequest.options.length > 0) {
+    const buttons = opts.askRequest.options.map((opt) => ({
+      tag: "button",
+      text: { tag: "plain_text", content: opt.label },
+      type: opt.style ?? "default",
+      value: {
+        [ASK_BUTTON_VALUE_MARKER]: true,
+        requestId: opts.askRequest.requestId,
+        optionId: opt.id
+      }
+    }));
+    elements.push({ tag: "action", actions: buttons });
+  }
   return {
     schema: "2.0",
     config: {
@@ -696,23 +752,38 @@ function buildCardKitStreamingCard(opts) {
       wide_screen_mode: true,
       update_multi: true
     },
-    body: {
-      elements: [
-        { tag: "div", text: { tag: "lark_md", content: lines.join("\n\n") } }
-      ]
-    }
+    body: { elements }
   };
 }
 __name(buildCardKitStreamingCard, "buildCardKitStreamingCard");
-function buildCardKitFinalCard(text) {
+function buildCardKitFinalCard(text, toolCalls, askRequest) {
+  const lines = [];
+  const toolLine = renderToolCalls(toolCalls ?? []);
+  if (toolLine) lines.push(toolLine);
+  lines.push(text);
+  if (askRequest) {
+    lines.push(`**${askRequest.prompt}**`);
+  }
+  const elements = [
+    { tag: "markdown", content: lines.join("\n\n") }
+  ];
+  if (askRequest?.options && askRequest.options.length > 0) {
+    const buttons = askRequest.options.map((opt) => ({
+      tag: "button",
+      text: { tag: "plain_text", content: opt.label },
+      type: opt.style ?? "default",
+      value: {
+        [ASK_BUTTON_VALUE_MARKER]: true,
+        requestId: askRequest.requestId,
+        optionId: opt.id
+      }
+    }));
+    elements.push({ tag: "action", actions: buttons });
+  }
   return {
     schema: "2.0",
     config: { streaming_mode: false, wide_screen_mode: true, update_multi: true },
-    body: {
-      elements: [
-        { tag: "div", text: { tag: "lark_md", content: text } }
-      ]
-    }
+    body: { elements }
   };
 }
 __name(buildCardKitFinalCard, "buildCardKitFinalCard");
@@ -729,6 +800,13 @@ var StreamingCardController = class {
   status;
   messageId;
   fallbackToText = false;
+  /** Active HITL input request, when set via `setAskRequest`. The card
+   *  builder appends prompt + buttons to the same streaming card so the
+   *  user can answer inline instead of getting a separate ask-card. */
+  askRequest = null;
+  /** Tool calls made during this turn, in order. Rendered above the buffer
+   *  so users can see what the agent is doing / has done, Claude-Code-style. */
+  toolCalls = [];
   createTimer = null;
   patchTimer = null;
   patchInFlight = null;
@@ -754,6 +832,112 @@ var StreamingCardController = class {
       this.schedulePatch();
     }
   }
+  /**
+   * Record the start of a tool call. Renders as `🔧 name` (or `⏳ name` while
+   * running). Persistent across patches — won't be lost if the tool completes
+   * between throttled patches.
+   *
+   * Schedules a patch regardless of state (idle/creating/streaming) so the
+   * user sees the call even when no text has streamed yet, which is the
+   * common case (model often calls a tool before any visible output).
+   */
+  addToolCall(name) {
+    if (this.state === "completed" || this.state === "aborted") return;
+    if (this.toolCalls.some((t) => t.name === name && t.state === "running")) {
+      return;
+    }
+    this.toolCalls.push({ name, state: "running" });
+    if (this.state === "idle") {
+      this.scheduleCreate();
+    } else if (this.state === "streaming") {
+      this.schedulePatch();
+    }
+  }
+  /**
+   * Mark the most-recently-started running entry for `name` as done/failed.
+   * Rendered as `✓ name` (green) or `✗ name` (red). Stays visible — the
+   * entry is not removed, so the user sees the full tool history at the
+   * end of the turn.
+   */
+  completeToolCall(name, failed = false) {
+    for (let i = this.toolCalls.length - 1; i >= 0; i--) {
+      const entry = this.toolCalls[i];
+      if (entry && entry.name === name && entry.state === "running") {
+        entry.state = failed ? "failed" : "done";
+        break;
+      }
+    }
+    if (this.state === "streaming") {
+      this.schedulePatch();
+    }
+  }
+  /** Read-only view of tool calls (for card builders). */
+  getToolCalls() {
+    return this.toolCalls;
+  }
+  /** Current streaming buffer (for handleCardAction to preserve when patching
+   *  the "answered" state of an inline ask card). */
+  getBuffer() {
+    return this.buffer;
+  }
+  /** Card message id (so input.requested can reuse the existing card instead
+   *  of creating a separate ask-card). */
+  getMessageId() {
+    return this.messageId;
+  }
+  /** Active HITL request being rendered inline on this card, or null. */
+  getAskRequest() {
+    return this.askRequest;
+  }
+  /**
+   * Render an `ask_question` request inline on this card by appending prompt
+   * + option buttons below the streaming text. Patches immediately so the
+   * user sees the buttons as soon as the agent asks.
+   *
+   * If the prior turn already finalized (state="completed"), transition back
+   * to "streaming" so the next patch can update the same card. The card
+   * keeps its messageId — no new card is sent.
+   */
+  setAskRequest(req) {
+    if (this.state === "aborted") return;
+    this.askRequest = req;
+    if (this.state === "completed" && this.messageId) {
+      this.state = "streaming";
+    }
+    if (this.state === "streaming") {
+      this.schedulePatch();
+    }
+  }
+  /** Clear the inline ask request (e.g. after the user clicked an option). */
+  clearAskRequest() {
+    this.askRequest = null;
+  }
+  /**
+   * Reset per-turn state for the next turn within the same session. Clears
+   * the streaming buffer, tool-call history, status, and any inline ask —
+   * but keeps the card messageId and transitions back to "streaming" so the
+   * next message.appended patches the SAME card. Without this, the second
+   * turn's message.completed would create a brand-new card and the user
+   * would see N cards for N turns within one logical conversation.
+   *
+   * Called from the channel's `turn.started` event handler.
+   */
+  resetForNewTurn() {
+    this.buffer = "";
+    this.status = void 0;
+    this.toolCalls = [];
+    this.askRequest = null;
+    this.fallbackToText = false;
+    this.cancelCreateTimer();
+    this.cancelPatchTimer();
+    this.patchInFlight = null;
+    this.patchScheduled = false;
+    if (this.messageId) {
+      this.state = "streaming";
+    } else {
+      this.state = "idle";
+    }
+  }
   async finalize(fullText) {
     if (this.state === "completed" || this.state === "aborted") return;
     this.cancelCreateTimer();
@@ -773,7 +957,7 @@ var StreamingCardController = class {
       try {
         const res = await this.client.sendCard({
           chatId: this.deps.chatId,
-          card: this.deps.useCardKitV2 ? buildCardKitFinalCard(fullText) : buildTextCard(fullText),
+          card: this.deps.useCardKitV2 ? buildCardKitFinalCard(fullText, this.toolCalls, this.askRequest) : buildTextCard(fullText),
           rootId: this.deps.rootId,
           parentId: this.deps.parentId
         });
@@ -799,7 +983,7 @@ var StreamingCardController = class {
     }
     await this.client.patchCard({
       messageId: this.messageId,
-      card: this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: fullText, streamingMode: false }) : buildStreamingCard({ buffer: fullText, status: void 0 })
+      card: this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: fullText, streamingMode: false, toolCalls: this.toolCalls, askRequest: this.askRequest }) : buildStreamingCard({ buffer: fullText, status: void 0, toolCalls: this.toolCalls, askRequest: this.askRequest })
     });
     this.state = "completed";
   }
@@ -851,7 +1035,7 @@ var StreamingCardController = class {
     try {
       const res = await this.client.sendCard({
         chatId: this.deps.chatId,
-        card: this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: this.buffer, status: this.status, streamingMode: true }) : buildStreamingCard({ buffer: this.buffer, status: this.status }),
+        card: this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: this.buffer, status: this.status, streamingMode: true, toolCalls: this.toolCalls, askRequest: this.askRequest }) : buildStreamingCard({ buffer: this.buffer, status: this.status, toolCalls: this.toolCalls, askRequest: this.askRequest }),
         rootId: this.deps.rootId,
         parentId: this.deps.parentId
       });
@@ -889,7 +1073,7 @@ var StreamingCardController = class {
     if (this.state !== "streaming") return;
     if (this.patchInFlight) return;
     if (this.messageId === void 0) return;
-    const card = this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: this.buffer, status: this.status, streamingMode: true }) : buildStreamingCard({ buffer: this.buffer, status: this.status });
+    const card = this.deps.useCardKitV2 ? buildCardKitStreamingCard({ buffer: this.buffer, status: this.status, streamingMode: true, toolCalls: this.toolCalls, askRequest: this.askRequest }) : buildStreamingCard({ buffer: this.buffer, status: this.status, toolCalls: this.toolCalls, askRequest: this.askRequest });
     this.patchInFlight = this.client.patchCard({ messageId: this.messageId, card }).catch((e) => {
       console.warn(
         "[eve-lark] streaming card patch failed:",
@@ -1546,11 +1730,6 @@ function createLarkChannel(optionsInput) {
     return ctrl;
   }
   __name(getController, "getController");
-  function dropController(sessionId) {
-    controllers.delete(sessionId);
-    sessionMeta.delete(sessionId);
-  }
-  __name(dropController, "dropController");
   async function cleanupAckReaction(sessionId) {
     const meta = sessionMeta.get(sessionId);
     if (!meta?.ackReactionId || !meta.messageId) return;
@@ -1920,14 +2099,18 @@ function createLarkChannel(optionsInput) {
     helpers.waitUntil(
       (async () => {
         if (pending.cardMessageId && selectedOpt) {
+          const ctrlForBuffer = controllers.get(pending.sessionId);
+          const priorBuffer = ctrlForBuffer?.getBuffer() ?? void 0;
           try {
             await client.patchCard({
               messageId: pending.cardMessageId,
-              card: buildAskAnsweredCard(pending.request, {
-                kind: "option",
-                label: selectedOpt.label
-              })
+              card: buildAskAnsweredCard(
+                pending.request,
+                { kind: "option", label: selectedOpt.label },
+                priorBuffer
+              )
             });
+            ctrlForBuffer?.clearAskRequest();
           } catch (e) {
             console.warn(
               "[eve-lark] patchCard after ask-answer failed:",
@@ -1987,30 +2170,39 @@ function createLarkChannel(optionsInput) {
       const ctrl = getController(sessionId, info);
       ctrl.appendDelta(d.messageDelta);
     },
-    // Model is about to call tools. Update the streaming card status so the
-    // user sees what's happening mid-turn instead of a static typing dot.
-    // Only fires when replyMode is "streaming" (cards exist). Post/static
-    // modes have no live surface to update.
+    // Model is about to call tools. Record each call on the streaming
+    // controller so it shows up in the card as ⏳ name. The controller
+    // creates the card immediately if it doesn't exist yet, so the user
+    // sees the tool call even before any text has streamed (which is the
+    // common case — model often calls tools before producing visible
+    // output). Only fires for streaming modes; post/static have no live
+    // surface to update.
     async "actions.requested"(data, _channel, ctx) {
       if (options.replyMode !== "streaming" && options.replyMode !== "streaming-v2") return;
       const sessionId = ctx.session.id;
-      const ctrl = controllers.get(sessionId);
-      if (!ctrl) return;
+      const info = sessionInfoFromCtx(ctx);
+      if (!info) return;
       const d = data;
       const names = (d.actions ?? []).map((a) => a.toolName).filter((n) => typeof n === "string");
       if (names.length === 0) return;
-      const label = names.length === 1 ? `\u{1F527} ${names[0]}` : `\u{1F527} ${names.join(", ")}`;
-      ctrl.setStatus(label);
+      const ctrl = getController(sessionId, info);
+      for (const name of names) {
+        ctrl.addToolCall(name);
+      }
     },
-    // A tool finished. Clear the status (the next message.appended or
-    // message.completed will overwrite anyway, but clearing here gives
-    // snappier feedback for long tool chains). Best-effort.
-    async "action.result"(_data, _channel, ctx) {
+    // A tool finished. Mark its entry ✓ (or ✗ on failure). Stays visible —
+    // the user keeps the tool history at the top of the card through end
+    // of turn. Best-effort: if we can't find the controller (e.g. post
+    // mode, or session already cleaned up), no-op.
+    async "action.result"(data, _channel, ctx) {
       if (options.replyMode !== "streaming" && options.replyMode !== "streaming-v2") return;
       const sessionId = ctx.session.id;
       const ctrl = controllers.get(sessionId);
       if (!ctrl) return;
-      ctrl.setStatus("");
+      const d = data;
+      const name = d.result?.toolName;
+      if (!name) return;
+      ctrl.completeToolCall(name, d.result?.status === "failed");
     },
     // eve's ask_question (and similar HITL tools) fire this event with a
     // list of input requests. Each request becomes a Feishu card with
@@ -2029,22 +2221,29 @@ function createLarkChannel(optionsInput) {
         `[eve-lark] input.requested sessionId=${sessionId} chatId=${info.chatId} count=${requests.length}`
       );
       for (const req of requests) {
-        const card = buildAskCard(req);
+        const existingCtrl = controllers.get(sessionId);
+        const canPatchExisting = existingCtrl && existingCtrl.getMessageId() && (options.replyMode === "streaming" || options.replyMode === "streaming-v2");
         let cardMessageId;
-        try {
-          const res = await client.sendCard({
-            chatId: info.chatId,
-            card,
-            rootId: info.rootId,
-            parentId: info.parentId
-          });
-          cardMessageId = res.messageId;
-        } catch (e) {
-          console.error(
-            `[eve-lark] ask card send failed (requestId=${req.requestId}):`,
-            e instanceof Error ? e.message : e
-          );
-          continue;
+        if (canPatchExisting && existingCtrl) {
+          existingCtrl.setAskRequest(req);
+          cardMessageId = existingCtrl.getMessageId();
+        } else {
+          const card = buildAskCard(req);
+          try {
+            const res = await client.sendCard({
+              chatId: info.chatId,
+              card,
+              rootId: info.rootId,
+              parentId: info.parentId
+            });
+            cardMessageId = res.messageId;
+          } catch (e) {
+            console.error(
+              `[eve-lark] ask card send failed (requestId=${req.requestId}):`,
+              e instanceof Error ? e.message : e
+            );
+            continue;
+          }
         }
         const pending = {
           requestId: req.requestId,
@@ -2083,7 +2282,6 @@ function createLarkChannel(optionsInput) {
         await deliverReply(sessionId, info, text);
       } finally {
         await cleanupAckReaction(sessionId);
-        dropController(sessionId);
       }
     },
     async "turn.failed"(data, _channel, ctx) {
@@ -2124,7 +2322,6 @@ function createLarkChannel(optionsInput) {
         }
       }
       await cleanupAckReaction(sessionId);
-      dropController(sessionId);
     },
     async "session.failed"(data) {
       const userText = formatFailureMessage(data, "session failed", { sentence: "session" });
@@ -2133,11 +2330,23 @@ function createLarkChannel(optionsInput) {
         `[eve-lark] session.failed: ${userText}` + (errorId ? ` (errorId=${errorId})` : "")
       );
     },
+    // A new turn is starting within an existing session (e.g. user clicked
+    // an inline ask button, eve resumed with their InputResponse). Reset
+    // the controller's per-turn state so the new turn's text replaces the
+    // prior turn's text on the SAME card — instead of creating a fresh
+    // card per turn.
+    async "turn.started"(_data, _channel, ctx) {
+      const sessionId = ctx?.session?.id;
+      if (!sessionId) return;
+      const ctrl = controllers.get(sessionId);
+      if (ctrl) {
+        ctrl.resetForNewTurn();
+      }
+    },
     // Turn ended cleanly. eve fires this after the final message.completed
     // (or instead of it when the assistant step ended in tool-calls with no
-    // visible text). Either way, free this session's controller + ack
-    // reaction so we don't leak waiting for a message.completed that's
-    // never coming.
+    // visible text). Just clean up the ack reaction — the controller stays
+    // for the next turn (cleaned by stale-sweep if the session goes quiet).
     async "turn.completed"(data, _channel, ctx) {
       const sessionId = ctx?.session?.id;
       if (!sessionId) return;
@@ -2145,7 +2354,6 @@ function createLarkChannel(optionsInput) {
         await cleanupAckReaction(sessionId);
       } catch {
       }
-      dropController(sessionId);
     },
     // The agent needs the user to sign in to an external service (e.g.
     // GitHub, Slack, Linear). Render a card with a "Sign in with <X>"