eve-lark 0.2.8 → 0.3.1

package/dist/index.js

@@ -563,6 +563,45 @@ function buildErrorCard(message) {
   };
 }
 __name(buildErrorCard, "buildErrorCard");
+var ASK_BUTTON_VALUE_MARKER = "__eveLarkAsk";
+function buildAskCard(request) {
+  const elements = [
+    { tag: "div", text: { tag: "lark_md", content: request.prompt } }
+  ];
+  if (request.options && request.options.length > 0) {
+    const buttons = request.options.map((opt) => ({
+      tag: "button",
+      text: { tag: "plain_text", content: opt.label },
+      type: opt.style ?? "default",
+      value: {
+        [ASK_BUTTON_VALUE_MARKER]: true,
+        requestId: request.requestId,
+        optionId: opt.id
+      },
+      ...opt.description ? { confirm: { title: { tag: "plain_text", content: opt.label }, text: { tag: "plain_text", content: opt.description } } } : {}
+    }));
+    elements.push({ tag: "action", actions: buttons });
+  }
+  if (request.allowFreeform) {
+    const hint = request.options && request.options.length > 0 ? "_\u2026or reply to this chat with your own answer_" : "_Reply to this chat with your answer_";
+    elements.push({ tag: "div", text: { tag: "lark_md", content: hint } });
+  }
+  return { config: { ...BASE_CONFIG }, elements };
+}
+__name(buildAskCard, "buildAskCard");
+function buildAskAnsweredCard(request, selected) {
+  const elements = [
+    { 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 };
+}
+__name(buildAskAnsweredCard, "buildAskAnsweredCard");
+function escapeMarkdown(s) {
+  return s.replace(/[*_`~\[\]]/g, (m) => `\\${m}`);
+}
+__name(escapeMarkdown, "escapeMarkdown");
 
 // src/streaming-controller.ts
 var StreamingCardController = class {
@@ -979,7 +1018,25 @@ async function doStartLongConnection(args) {
       } catch (e) {
         logError(`forward failed (event dropped)`, e);
       }
-    }, "im.message.receive_v1")
+    }, "im.message.receive_v1"),
+    // Card-button clicks. Feishu's card.action.trigger fires when a user
+    // taps a button on a card we rendered. Forward to the channel webhook
+    // — the webhook handler dispatches by event_type and feeds the click
+    // back into eve as an InputResponse.
+    "card.action.trigger": /* @__PURE__ */ __name(async (data) => {
+      try {
+        const envelope = rebuildEnvelopeFromSdkEvent("card.action.trigger", data, {
+          appId: args.resolved.appId,
+          verificationToken: args.resolved.verificationToken
+        });
+        await postEventToWebhookRetry(envelope, {
+          eveWebhookUrl: args.eveWebhookUrl,
+          encryptKey: args.resolved.encryptKey
+        });
+      } catch (e) {
+        logError(`card action forward failed (event dropped)`, e);
+      }
+    }, "card.action.trigger")
   });
   const domain = args.resolved.baseUrl.includes("larksuite.com") ? sdk.Domain.Lark : sdk.Domain.Feishu;
   const wsClient = new sdk.WSClient({
@@ -1270,17 +1327,39 @@ function buildUserContent(text, files, options, messageId) {
   return parts;
 }
 __name(buildUserContent, "buildUserContent");
-function errMsgFrom(data, fallback) {
-  if (typeof data !== "object" || data === null) return fallback;
-  const err = data.error;
-  if (typeof err === "string") return err;
-  if (typeof err === "object" && err !== null) {
-    const msg = err.message;
-    if (typeof msg === "string") return msg;
-  }
-  return fallback;
+function formatErrorHint(data) {
+  if (typeof data !== "object" || data === null) return "";
+  const d = data;
+  const detailsName = typeof d.details === "object" && d.details !== null ? d.details.name : void 0;
+  const name = typeof detailsName === "string" && detailsName.length > 0 ? detailsName : void 0;
+  const message = typeof d.message === "string" ? d.message.trim() : "";
+  if (name && message.length > 0) return ` (${name}: ${truncateForDisplay(message)})`;
+  if (name) return ` (${name})`;
+  if (message.length > 0) return ` (${truncateForDisplay(message)})`;
+  return "";
 }
-__name(errMsgFrom, "errMsgFrom");
+__name(formatErrorHint, "formatErrorHint");
+function extractErrorId(details) {
+  if (typeof details === "object" && details !== null) {
+    const id = details.errorId;
+    return typeof id === "string" && id.length > 0 ? id : void 0;
+  }
+  return void 0;
+}
+__name(extractErrorId, "extractErrorId");
+function truncateForDisplay(s, max = 160) {
+  return s.length <= max ? s : `${s.slice(0, max - 1).trimEnd()}\u2026`;
+}
+__name(truncateForDisplay, "truncateForDisplay");
+function formatFailureMessage(data, fallback, opts = { sentence: "turn" }) {
+  const hint = formatErrorHint(data);
+  const errorId = extractErrorId(data?.details);
+  const lead = opts.sentence === "session" ? "This session couldn't recover from an error" : "I hit an error while handling your request";
+  const idSuffix = errorId ? ` (Error id: ${errorId})` : "";
+  if (!hint && !errorId) return `\u26A0 ${fallback}`;
+  return `\u26A0 ${lead}${hint}.${idSuffix}`;
+}
+__name(formatFailureMessage, "formatFailureMessage");
 function createLarkChannel(optionsInput) {
   const options = resolveOptions(optionsInput);
   const client = new LarkClient(options);
@@ -1295,6 +1374,8 @@ function createLarkChannel(optionsInput) {
   }
   const controllers = /* @__PURE__ */ new Map();
   const sessionMeta = /* @__PURE__ */ new Map();
+  const pendingInputsByRequestId = /* @__PURE__ */ new Map();
+  const pendingInputsByChatToken = /* @__PURE__ */ new Map();
   function getController(sessionId, meta) {
     let ctrl = controllers.get(sessionId);
     if (!ctrl) {
@@ -1431,8 +1512,29 @@ function createLarkChannel(optionsInput) {
         sessionMeta.delete(id);
       }
     }
+    for (const [reqId, p] of pendingInputsByRequestId) {
+      if (p.touchedAt < cutoff) {
+        pendingInputsByRequestId.delete(reqId);
+        const tokenKey = chatTokenKey(p.chatId, p.rootId, p.parentId);
+        if (pendingInputsByChatToken.get(tokenKey)?.requestId === reqId) {
+          pendingInputsByChatToken.delete(tokenKey);
+        }
+      }
+    }
   }
   __name(maybeSweep, "maybeSweep");
+  function chatTokenKey(chatId, rootId, parentId) {
+    return `${chatId}:${parentId ?? rootId ?? "_"}`;
+  }
+  __name(chatTokenKey, "chatTokenKey");
+  function dropPendingInput(p) {
+    pendingInputsByRequestId.delete(p.requestId);
+    const tokenKey = chatTokenKey(p.chatId, p.rootId, p.parentId);
+    if (pendingInputsByChatToken.get(tokenKey)?.requestId === p.requestId) {
+      pendingInputsByChatToken.delete(tokenKey);
+    }
+  }
+  __name(dropPendingInput, "dropPendingInput");
   const webhookHandler = /* @__PURE__ */ __name(async (req, helpers) => {
     maybeSweep();
     const contentLength = Number(req.headers.get("content-length") ?? "0");
@@ -1485,12 +1587,17 @@ function createLarkChannel(optionsInput) {
     if (body.header?.token !== options.verificationToken) {
       return new Response("verification token mismatch", { status: 401 });
     }
-    const dedupKey = body.header?.event_id ?? body.event?.message?.message_id;
+    const evtMsg = body.event;
+    const dedupKey = body.header?.event_id ?? evtMsg?.message?.message_id ?? evtMsg?.open_message_id;
     if (dedupKey) {
       if (dedup.has(dedupKey)) return ackOk();
       dedup.set(dedupKey);
     }
-    if (body.header?.event_type !== "im.message.receive_v1") {
+    const eventType = body.header?.event_type;
+    if (eventType === "card.action.trigger") {
+      return handleCardAction(body.event, helpers);
+    }
+    if (eventType !== "im.message.receive_v1") {
       return ackOk();
     }
     if (!body.event) return ackOk();
@@ -1501,6 +1608,44 @@ function createLarkChannel(optionsInput) {
     if (parsed.text === "" && parsed.files.length === 0) {
       return ackOk();
     }
+    const tokenKey = chatTokenKey(parsed.chatId, parsed.rootId ?? void 0, parsed.parentId ?? void 0);
+    const pending = pendingInputsByChatToken.get(tokenKey);
+    if (pending && pending.awaitingFreeform && parsed.text.length > 0) {
+      const resp = { requestId: pending.requestId, text: parsed.text };
+      const resumeAuth = {
+        authenticator: "lark",
+        principalType: "user",
+        principalId: parsed.senderOpenId,
+        attributes: {
+          chatId: parsed.chatId,
+          rootMessageId: parsed.rootId,
+          messageId: parsed.messageId,
+          chatType: parsed.chatType
+        }
+      };
+      const resumeToken = larkContinuationToken(parsed.chatId, parsed.parentId ?? parsed.rootId);
+      try {
+        await helpers.send(
+          { inputResponses: [resp] },
+          { auth: resumeAuth, continuationToken: resumeToken }
+        );
+        if (pending.cardMessageId) {
+          try {
+            await client.patchCard({
+              messageId: pending.cardMessageId,
+              card: buildAskAnsweredCard(pending.request, { kind: "freeform", text: parsed.text })
+            });
+          } catch (e) {
+            console.warn("[eve-lark] patchCard after freeform answer failed:", e instanceof Error ? e.message : e);
+          }
+        }
+      } catch (e) {
+        console.error("[eve-lark] freeform input-response send failed:", e instanceof Error ? e.message : e);
+      } finally {
+        dropPendingInput(pending);
+      }
+      return ackOk();
+    }
     const userContent = buildUserContent(parsed.text, parsed.files, options, parsed.messageId);
     const continuationToken = larkContinuationToken(parsed.chatId, parsed.parentId ?? parsed.rootId);
     const auth = {
@@ -1542,7 +1687,194 @@ function createLarkChannel(optionsInput) {
     }
     return ackOk();
   }, "webhookHandler");
-  return defineChannel({
+  async function handleCardAction(evt, helpers) {
+    const value = evt.action?.value;
+    if (!value || value[ASK_BUTTON_VALUE_MARKER] !== true) {
+      return ackOk();
+    }
+    const requestId = typeof value.requestId === "string" ? value.requestId : "";
+    const optionId = typeof value.optionId === "string" ? value.optionId : "";
+    if (!requestId) return ackOk();
+    const pending = pendingInputsByRequestId.get(requestId);
+    if (!pending) {
+      console.warn(`[eve-lark] card action for unknown requestId=${requestId} (already answered or expired)`);
+      return ackOk();
+    }
+    const resp = { requestId, optionId: optionId || void 0 };
+    const resumeToken = larkContinuationToken(pending.chatId, pending.parentId ?? pending.rootId ?? null);
+    const resumeAuth = {
+      authenticator: "lark",
+      principalType: "user",
+      principalId: evt.open_id,
+      attributes: {
+        chatId: pending.chatId,
+        rootMessageId: pending.rootId,
+        messageId: evt.open_message_id,
+        chatType: pending.request.display === "confirmation" ? "p2p" : "group"
+      }
+    };
+    try {
+      await helpers.send(
+        { inputResponses: [resp] },
+        { auth: resumeAuth, continuationToken: resumeToken }
+      );
+      console.log(`[eve-lark] ask answered via button click requestId=${requestId} optionId=${optionId}`);
+    } catch (e) {
+      console.error(
+        `[eve-lark] ask input-response send failed (requestId=${requestId}):`,
+        e instanceof Error ? e.message : e
+      );
+    }
+    const selectedOpt = pending.request.options?.find((o) => o.id === optionId);
+    if (pending.cardMessageId && selectedOpt) {
+      try {
+        await client.patchCard({
+          messageId: pending.cardMessageId,
+          card: buildAskAnsweredCard(pending.request, { kind: "option", label: selectedOpt.label })
+        });
+      } catch (e) {
+        console.warn("[eve-lark] patchCard after ask-answer failed:", e instanceof Error ? e.message : e);
+      }
+    }
+    dropPendingInput(pending);
+    return ackOk();
+  }
+  __name(handleCardAction, "handleCardAction");
+  const channelEvents = {
+    // Streaming delta — patch the card.
+    "message.appended"(data, _channel, ctx) {
+      if (options.replyMode !== "streaming") return;
+      const sessionId = ctx.session.id;
+      const info = sessionInfoFromCtx(ctx);
+      if (!info) return;
+      const d = data;
+      if (typeof d.messageDelta !== "string") return;
+      const ctrl = getController(sessionId, info);
+      ctrl.appendDelta(d.messageDelta);
+    },
+    // eve's ask_question (and similar HITL tools) fire this event with a
+    // list of input requests. Each request becomes a Feishu card with
+    // buttons (one per option) plus optional freeform hint.
+    async "input.requested"(data, _channel, ctx) {
+      const sessionId = ctx.session.id;
+      const info = sessionInfoFromCtx(ctx);
+      if (!info) {
+        console.warn(`[eve-lark] input.requested: no session info (sessionId=${sessionId})`);
+        return;
+      }
+      const d = data;
+      const requests = d.requests ?? [];
+      if (requests.length === 0) return;
+      console.log(
+        `[eve-lark] input.requested sessionId=${sessionId} chatId=${info.chatId} count=${requests.length}`
+      );
+      for (const req of requests) {
+        const card = buildAskCard(req);
+        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;
+        }
+        const pending = {
+          requestId: req.requestId,
+          sessionId,
+          chatId: info.chatId,
+          rootId: info.rootId,
+          parentId: info.parentId,
+          cardMessageId,
+          request: req,
+          createdAt: Date.now(),
+          touchedAt: Date.now(),
+          awaitingFreeform: req.allowFreeform === true
+        };
+        pendingInputsByRequestId.set(req.requestId, pending);
+        if (pending.awaitingFreeform) {
+          const tokenKey = chatTokenKey(info.chatId, info.rootId, info.parentId);
+          pendingInputsByChatToken.set(tokenKey, pending);
+        }
+      }
+    },
+    // Terminal — deliver the final reply, then clean up the ack reaction.
+    async "message.completed"(data, _channel, ctx) {
+      const sessionId = ctx.session.id;
+      const info = sessionInfoFromCtx(ctx);
+      if (!info) {
+        console.warn(`[eve-lark] message.completed: no session info, cannot deliver (sessionId=${sessionId})`);
+        return;
+      }
+      const d = data;
+      const rawText = typeof d.message === "string" ? d.message : "";
+      console.log(
+        `[eve-lark] message.completed sessionId=${sessionId} chatId=${info.chatId} msgLen=${rawText.length}`
+      );
+      const text = rawText.length > 0 ? rawText : EMPTY_REPLY_TEXT;
+      try {
+        await deliverReply(sessionId, info, text);
+      } finally {
+        await cleanupAckReaction(sessionId);
+        dropController(sessionId);
+      }
+    },
+    async "turn.failed"(data, _channel, ctx) {
+      const sessionId = ctx?.session?.id;
+      if (!sessionId) {
+        console.warn("[eve-lark] turn.failed: no sessionId on ctx");
+        return;
+      }
+      const info = sessionInfoFromCtx(ctx);
+      if (!info) {
+        console.warn(`[eve-lark] turn.failed: no session info (sessionId=${sessionId})`);
+        return;
+      }
+      const userText = formatFailureMessage(data, "turn failed", { sentence: "turn" });
+      const errorId = extractErrorId(data?.details);
+      console.warn(
+        `[eve-lark] turn.failed sessionId=${sessionId} chatId=${info.chatId} err="${userText.slice(0, 200)}"` + (errorId ? ` errorId=${errorId}` : "")
+      );
+      const ctrl = controllers.get(sessionId);
+      if (ctrl) {
+        try {
+          await ctrl.abort(userText);
+          console.log(`[eve-lark] error shown via streaming abort (sessionId=${sessionId})`);
+        } catch (e) {
+          console.warn(
+            `[eve-lark] turn.failed: streaming abort failed, will deliver fresh error (sessionId=${sessionId}):`,
+            e instanceof Error ? e.message : e
+          );
+          try {
+            await deliverReply(sessionId, info, userText);
+          } catch {
+          }
+        }
+      } else {
+        try {
+          await deliverReply(sessionId, info, userText);
+        } catch {
+        }
+      }
+      await cleanupAckReaction(sessionId);
+      dropController(sessionId);
+    },
+    async "session.failed"(data) {
+      const userText = formatFailureMessage(data, "session failed", { sentence: "session" });
+      const errorId = extractErrorId(data?.details);
+      console.error(
+        `[eve-lark] session.failed: ${userText}` + (errorId ? ` (errorId=${errorId})` : "")
+      );
+    }
+  };
+  const channel = defineChannel({
     routes: [POST(options.webhookPath, webhookHandler)],
     fetchFile: /* @__PURE__ */ __name(async (url) => {
       if (!url.startsWith(options.baseUrl)) return null;
@@ -1554,85 +1886,10 @@ function createLarkChannel(optionsInput) {
         type: m[3]
       });
     }, "fetchFile"),
-    events: {
-      // Streaming delta — patch the card.
-      "message.appended"(data, _channel, ctx) {
-        if (options.replyMode !== "streaming") return;
-        const sessionId = ctx.session.id;
-        const info = sessionInfoFromCtx(ctx);
-        if (!info) return;
-        const d = data;
-        if (typeof d.messageDelta !== "string") return;
-        const ctrl = getController(sessionId, info);
-        ctrl.appendDelta(d.messageDelta);
-      },
-      // Terminal — deliver the final reply, then clean up the ack reaction.
-      async "message.completed"(data, _channel, ctx) {
-        const sessionId = ctx.session.id;
-        const info = sessionInfoFromCtx(ctx);
-        if (!info) {
-          console.warn(`[eve-lark] message.completed: no session info, cannot deliver (sessionId=${sessionId})`);
-          return;
-        }
-        const d = data;
-        const rawText = typeof d.message === "string" ? d.message : "";
-        console.log(
-          `[eve-lark] message.completed sessionId=${sessionId} chatId=${info.chatId} msgLen=${rawText.length}`
-        );
-        const text = rawText.length > 0 ? rawText : EMPTY_REPLY_TEXT;
-        try {
-          await deliverReply(sessionId, info, text);
-        } finally {
-          await cleanupAckReaction(sessionId);
-          dropController(sessionId);
-        }
-      },
-      async "turn.failed"(data, _channel, ctx) {
-        const sessionId = ctx?.session?.id;
-        if (!sessionId) {
-          console.warn("[eve-lark] turn.failed: no sessionId on ctx");
-          return;
-        }
-        const info = sessionInfoFromCtx(ctx);
-        if (!info) {
-          console.warn(`[eve-lark] turn.failed: no session info (sessionId=${sessionId})`);
-          return;
-        }
-        const errMsg = errMsgFrom(data, "turn failed");
-        console.warn(
-          `[eve-lark] turn.failed sessionId=${sessionId} chatId=${info.chatId} err="${errMsg.slice(0, 200)}"`
-        );
-        const userText = `\u26A0 ${errMsg}`;
-        const ctrl = controllers.get(sessionId);
-        if (ctrl) {
-          try {
-            await ctrl.abort(errMsg);
-            console.log(`[eve-lark] error shown via streaming abort (sessionId=${sessionId})`);
-          } catch (e) {
-            console.warn(
-              `[eve-lark] turn.failed: streaming abort failed, will deliver fresh error (sessionId=${sessionId}):`,
-              e instanceof Error ? e.message : e
-            );
-            try {
-              await deliverReply(sessionId, info, userText);
-            } catch {
-            }
-          }
-        } else {
-          try {
-            await deliverReply(sessionId, info, userText);
-          } catch {
-          }
-        }
-        await cleanupAckReaction(sessionId);
-        dropController(sessionId);
-      },
-      async "session.failed"(data) {
-        const errMsg = errMsgFrom(data, "session failed");
-        console.error("[eve-lark] session.failed:", errMsg);
-      }
-    }
+    events: channelEvents
   });
+  channel.__testEvents = channelEvents;
+  return channel;
 }
 __name(createLarkChannel, "createLarkChannel");
 export {