eve-lark 0.2.7 → 0.3.0

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 {
@@ -768,7 +807,7 @@ var DEFAULTS = {
   maxRetries: 2,
   tokenRefreshBufferMs: 5 * 60 * 1e3,
   signatureSkewMs: 5 * 60 * 1e3,
-  ackReaction: "TYPING",
+  ackReaction: "Typing",
   mode: "long-connection"
 };
 var ENV_KEYS = {
@@ -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({
@@ -1006,6 +1063,196 @@ async function loadLarkSdk() {
 }
 __name(loadLarkSdk, "loadLarkSdk");
 
+// src/feishu-emoji.ts
+var VALID_FEISHU_EMOJI_TYPES = /* @__PURE__ */ new Set([
+  "OK",
+  "THUMBSUP",
+  "THANKS",
+  "MUSCLE",
+  "FINGERHEART",
+  "APPLAUSE",
+  "FISTBUMP",
+  "JIAYI",
+  "DONE",
+  "SMILE",
+  "BLUSH",
+  "LAUGH",
+  "SMIRK",
+  "LOL",
+  "FACEPALM",
+  "LOVE",
+  "WINK",
+  "PROUD",
+  "WITTY",
+  "SMART",
+  "SCOWL",
+  "THINKING",
+  "SOB",
+  "CRY",
+  "ERROR",
+  "NOSEPICK",
+  "HAUGHTY",
+  "SLAP",
+  "SPITBLOOD",
+  "TOASTED",
+  "GLANCE",
+  "DULL",
+  "INNOCENTSMILE",
+  "JOYFUL",
+  "WOW",
+  "TRICK",
+  "YEAH",
+  "ENOUGH",
+  "TEARS",
+  "EMBARRASSED",
+  "KISS",
+  "SMOOCH",
+  "DROOL",
+  "OBSESSED",
+  "MONEY",
+  "TEASE",
+  "SHOWOFF",
+  "COMFORT",
+  "CLAP",
+  "PRAISE",
+  "STRIVE",
+  "XBLUSH",
+  "SILENT",
+  "WAVE",
+  "WHAT",
+  "FROWN",
+  "SHY",
+  "DIZZY",
+  "LOOKDOWN",
+  "CHUCKLE",
+  "WAIL",
+  "CRAZY",
+  "WHIMPER",
+  "HUG",
+  "BLUBBER",
+  "WRONGED",
+  "HUSKY",
+  "SHHH",
+  "SMUG",
+  "ANGRY",
+  "HAMMER",
+  "SHOCKED",
+  "TERROR",
+  "PETRIFIED",
+  "SKULL",
+  "SWEAT",
+  "SPEECHLESS",
+  "SLEEP",
+  "DROWSY",
+  "YAWN",
+  "SICK",
+  "PUKE",
+  "BETRAYED",
+  "HEADSET",
+  "EatingFood",
+  "MeMeMe",
+  "Sigh",
+  "Typing",
+  "SLIGHT",
+  "TONGUE",
+  "EYESCLOSED",
+  "RoarForYou",
+  "CALF",
+  "BEAR",
+  "BULL",
+  "RAINBOWPUKE",
+  "Lemon",
+  "ROSE",
+  "HEART",
+  "PARTY",
+  "LIPS",
+  "BEER",
+  "CAKE",
+  "GIFT",
+  "CUCUMBER",
+  "Drumstick",
+  "Pepper",
+  "CANDIEDHAWS",
+  "BubbleTea",
+  "Coffee",
+  "Get",
+  "LGTM",
+  "OnIt",
+  "OneSecond",
+  "VRHeadset",
+  "YouAreTheBest",
+  "SALUTE",
+  "SHAKE",
+  "HIGHFIVE",
+  "UPPERLEFT",
+  "ThumbsDown",
+  "Yes",
+  "No",
+  "OKR",
+  "CheckMark",
+  "CrossMark",
+  "MinusOne",
+  "Hundred",
+  "AWESOMEN",
+  "Pin",
+  "Alarm",
+  "Loudspeaker",
+  "Trophy",
+  "Fire",
+  "BOMB",
+  "Music",
+  "XmasTree",
+  "Snowman",
+  "XmasHat",
+  "FIREWORKS",
+  "2022",
+  "REDPACKET",
+  "FORTUNE",
+  "LUCK",
+  "FIRECRACKER",
+  "StickyRiceBalls",
+  "HEARTBROKEN",
+  "POOP",
+  "StatusFlashOfInspiration",
+  "18X",
+  "CLEAVER",
+  "Soccer",
+  "Basketball",
+  "GeneralDoNotDisturb",
+  "Status_PrivateMessage",
+  "GeneralInMeetingBusy",
+  "StatusReading",
+  "StatusInFlight",
+  "GeneralBusinessTrip",
+  "GeneralWorkFromHome",
+  "StatusEnjoyLife",
+  "GeneralTravellingCar",
+  "StatusBus",
+  "GeneralSun",
+  "GeneralMoonRest",
+  "MoonRabbit",
+  "Mooncake",
+  "JubilantRabbit",
+  "TV",
+  "Movie",
+  "Pumpkin",
+  "BeamingFace",
+  "Delighted",
+  "ColdSweat",
+  "FullMoonFace",
+  "Partying",
+  "GoGoGo",
+  "ThanksFace",
+  "SaluteFace",
+  "Shrug",
+  "ClownFace",
+  "HappyDragon"
+]);
+function isValidFeishuEmojiType(s) {
+  return VALID_FEISHU_EMOJI_TYPES.has(s);
+}
+__name(isValidFeishuEmojiType, "isValidFeishuEmojiType");
+
 // src/channel.ts
 var MAX_BODY_BYTES = 1e6;
 var STALE_SESSION_MS = 30 * 60 * 1e3;
@@ -1031,11 +1278,33 @@ function ackOk() {
 }
 __name(ackOk, "ackOk");
 function pickAckEmoji(reaction) {
-  if (typeof reaction === "string") return reaction;
+  if (reaction === false) return false;
+  if (typeof reaction === "string") {
+    if (!isValidFeishuEmojiType(reaction)) {
+      console.warn(
+        `[eve-lark] ackReaction "${reaction}" is not a valid Feishu emoji type (case-sensitive; e.g. "Typing" not "TYPING"). Skipping ack reaction. See VALID_FEISHU_EMOJI_TYPES for the full list.`
+      );
+      return false;
+    }
+    return reaction;
+  }
   if (Array.isArray(reaction)) {
-    if (reaction.length === 0) return false;
-    const idx = Math.floor(Math.random() * reaction.length);
-    return reaction[idx] ?? false;
+    const valid = reaction.filter(isValidFeishuEmojiType);
+    if (valid.length === 0) {
+      const sample = reaction.slice(0, 3).join(", ");
+      console.warn(
+        `[eve-lark] ackReaction array contains no valid Feishu emoji types (got [${sample}${reaction.length > 3 ? ", \u2026" : ""}]). Skipping ack reaction.`
+      );
+      return false;
+    }
+    if (valid.length < reaction.length) {
+      const dropped = reaction.filter((e) => !isValidFeishuEmojiType(e));
+      console.warn(
+        `[eve-lark] ackReaction array dropped ${dropped.length} invalid emoji type(s): ${dropped.slice(0, 3).join(", ")}`
+      );
+    }
+    const idx = Math.floor(Math.random() * valid.length);
+    return valid[idx] ?? false;
   }
   return false;
 }
@@ -1083,6 +1352,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) {
@@ -1219,8 +1490,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");
@@ -1273,12 +1565,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();
@@ -1289,6 +1586,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 = {
@@ -1330,7 +1665,191 @@ 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 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);
+    }
+  };
+  const channel = defineChannel({
     routes: [POST(options.webhookPath, webhookHandler)],
     fetchFile: /* @__PURE__ */ __name(async (url) => {
       if (!url.startsWith(options.baseUrl)) return null;
@@ -1342,85 +1861,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 {