@ycodium-ai/plugin-im 0.2.2570 → 0.2.2588

package/README.md

@@ -30,18 +30,32 @@ is HTTP long-polling.
 The default is one message per finished turn. A single turn can produce dozens
 of assistant messages, mostly commentary between tool calls.
 
-On Lark, the reply to a thread this plugin opened is one card that is patched
-as the agent works (`thread.turn-progress` ticks, reply text read with
-`getThreadMessage`) and settled when the turn ends; threads opened elsewhere
-still get the per-turn or per-message text. Platforms that cannot edit a sent
-message keep sending text. Approval cards are posted for every pending request
-and replaced with a settled notice when the request is answered, here or
-elsewhere (`thread.request-resolved`). Cards that were still open when the
-plugin restarted are marked interrupted. The card pieces are pure and
-separate: `turnView.ts` (ticks to a view model), `larkCards.ts` (view model
-to card JSON), `larkMarkdown.ts`, `larkCardStream.ts` (throttle, one patch in
-flight, newest snapshot wins), `turnCards.ts` (per-thread queue and card
-lifecycle).
+The reply to a thread this plugin opened is written as the agent works
+(`thread.turn-progress` ticks, reply text read with `getThreadMessage`) and
+settled when the turn ends; threads opened elsewhere still get the per-turn or
+per-message text. How depends on the platform:
+
+- **Lark** patches one card.
+- **Telegram** edits one message (`editMessageText`, plain text) and, when the
+  reply outgrows a single message, freezes it and continues in the next one.
+  A `message is not modified` answer counts as success; a 429 waits the
+  `retry_after` it names, once.
+- **WeCom** keeps sending frames of one `stream.id` (`finish: false`) on the
+  inbound message's `req_id` and closes with `finish: true`. With no inbound
+  message to reply to, or after the platform rejects the stream, the settled text
+  goes out as ordinary messages instead.
+
+An adapter opts in with the optional `turnCards` surface (`src/adapter.ts`).
+Approval messages are posted for every pending request on platforms with
+buttons and replaced with a settled notice when the request is answered, here or
+elsewhere (`thread.request-resolved`); WeCom, which answers by number, posts only
+the first and just stops accepting its number. Cards that were still open when the
+plugin restarted are marked interrupted. The pieces are pure and separate:
+`turnView.ts` (ticks to a view model), `larkCards.ts` (view model to card JSON),
+`larkMarkdown.ts`, `larkCardStream.ts` (throttle, one update in flight, newest
+snapshot wins), `turnCards.ts` (per-thread queue and lifecycle),
+`plainTurnText.ts` (view model to plain text), `telegramTurn.ts` (message
+rollover).
 
 A group keeps its place across restarts. Which thread a group is talking in, the
 team it is pointed at, the model and plan mode set from the group, the threads
@@ -55,9 +69,11 @@ Chat commands: `/stop`, `/status`, `/new`, `/sessions`, `/resume`, `/model`,
 switch threads this plugin opened, since the host lets a plugin send only into
 its own threads.
 
-On Lark, `/panel` sends a command panel card (`/help` stays text and ends with a pointer to it; other platforms' `/help` does not mention it): every command above
-is a button, and the ones that take an argument (a thread, a team, a model) open
-a second view on the same card with a Back button. Each card keeps its own view
+On Lark and Telegram, `/panel` sends a command panel (`/help` stays text and ends with a pointer to it; on WeCom, which has no panel, it does not): every command above
+is a button (a card on Lark, an inline keyboard on Telegram), and the ones that take an argument (a thread, a team, a model) open
+a second view on the same message with a Back button. Telegram buttons carry only
+a short `pn:<version>:<index>` token (`callback_data` is capped at 64 bytes);
+the action stays in memory and a tap on an older keyboard version counts as expired. Each card keeps its own view
 stack in memory (`src/panelController.ts`), so after a restart an old card only
 answers that it has expired. A tap runs the same handler as the typed command and
 waits in the same per-group queue as typed messages. Another platform opts in by

package/dist/index.js

@@ -133399,12 +133399,16 @@ var POLL_TIMEOUT_SECONDS = 45;
 var TELEGRAM_TEXT_MAX_CHARS = 4e3;
 var TelegramApiError = class extends Error {
   code;
-  constructor(method, code2, description) {
+  /** 限流（429）时平台给的等待秒数；别的错误没有。 */
+  retryAfterSeconds;
+  constructor(method, code2, description, retryAfterSeconds) {
     super(`telegram ${method} failed (${String(code2 ?? "?")}): ${description}`);
     this.name = "TelegramApiError";
     this.code = code2;
+    this.retryAfterSeconds = retryAfterSeconds;
   }
 };
+var isNotModified = (error) => error instanceof TelegramApiError && error.code === 400 && error.message.toLowerCase().includes("message is not modified");
 var PHOTO_NAME = "photo.jpg";
 var PHOTO_MIME = "image/jpeg";
 var mimeFromName2 = (name) => {
@@ -133463,10 +133467,20 @@ var makeTelegramApi = (input) => {
     });
     const envelope = await response.json();
     if (envelope.ok !== true) {
-      throw new TelegramApiError(method, envelope.error_code, envelope.description ?? "no reason");
+      throw new TelegramApiError(
+        method,
+        envelope.error_code,
+        envelope.description ?? "no reason",
+        envelope.parameters?.retry_after
+      );
     }
     return envelope.result;
   };
+  const keyboard = (rows) => ({
+    inline_keyboard: rows.map(
+      (row) => row.map((button) => ({ text: button.text, callback_data: button.data }))
+    )
+  });
   return {
     /** 机器人自己是谁；群里的命令靠它的 `username` 认出是不是发给自己的。 */
     getMe: () => call("getMe", {}),
@@ -133486,16 +133500,45 @@ var makeTelegramApi = (input) => {
         await call("sendMessage", { chat_id: chatId, text: chunk });
       }
     },
-    /** 带按钮的消息。一行一个按钮，审批选项通常不多。 */
-    sendButtons: (chatId, text2, buttons) => call("sendMessage", {
-      chat_id: chatId,
-      text: text2,
-      reply_markup: {
-        inline_keyboard: buttons.map((button) => [
-          { text: button.label, callback_data: button.token }
-        ])
+    /**
+     * 发一条消息，回它的 id。调用方保证 `text` 不超过单条上限（边写边更新的回复要自己
+     * 在上限处翻篇，这里不替它切）。带 `rows` 就挂一块内联键盘。
+     */
+    sendOne: async (chatId, text2, rows) => {
+      const sent = await call("sendMessage", {
+        chat_id: chatId,
+        text: text2,
+        ...rows === void 0 ? {} : { reply_markup: keyboard(rows) }
+      });
+      return sent?.message_id === void 0 ? null : String(sent.message_id);
+    },
+    /**
+     * 改一条已发出的消息。内容没变（`message is not modified`）当成功。`rows` 不给就是
+     * 去掉按钮：改了文字又要保留按钮的调用方得自己再传一次。
+     */
+    editMessage: async (chatId, messageId, text2, rows = []) => {
+      try {
+        await call("editMessageText", {
+          chat_id: chatId,
+          message_id: Number(messageId),
+          text: text2,
+          reply_markup: keyboard(rows)
+        });
+      } catch (error) {
+        if (!isNotModified(error)) throw error;
       }
-    }),
+    },
+    /** 带按钮的审批消息，一行一个按钮；回消息 id，之后才改得了它（平台没给就是 null）。 */
+    sendButtons: async (chatId, text2, buttons) => {
+      const sent = await call("sendMessage", {
+        chat_id: chatId,
+        text: text2,
+        reply_markup: keyboard(
+          buttons.map((button) => [{ text: button.label, data: button.token }])
+        )
+      });
+      return sent?.message_id === void 0 ? null : String(sent.message_id);
+    },
     /** 答完点击，不然客户端上那个按钮一直转圈。带 `text` 时点击者会看到一句提示。 */
     answerCallback: (callbackQueryId, text2) => call("answerCallbackQuery", {
       callback_query_id: callbackQueryId,
@@ -133536,16 +133579,168 @@ var makeTelegramApi = (input) => {
   };
 };
 
+// src/telegramPanel.ts
+var PANEL_DATA_PREFIX = "pn:";
+var renderPanel = (card, version) => {
+  const actions = [];
+  const rowOf = (buttons) => buttons.map((button) => {
+    actions.push(button.action);
+    return {
+      text: button.label,
+      data: `${PANEL_DATA_PREFIX}${String(version)}:${String(actions.length - 1)}`
+    };
+  });
+  const rows = [];
+  for (const group of card.groups) {
+    if (group.buttons.length > 0) rows.push(rowOf(group.buttons));
+  }
+  if (card.nav.length > 0) rows.push(rowOf(card.nav));
+  return {
+    text: [card.title, card.text].filter((part) => part !== "").join("\n\n"),
+    rows,
+    actions
+  };
+};
+var parsePanelData = (data) => {
+  const match = /^pn:(\d+):(\d+)$/.exec(data);
+  if (match === null) return null;
+  return { version: Number(match[1]), index: Number(match[2]) };
+};
+
+// src/plainTurnText.ts
+var RUNNING_LABEL_MAX_CHARS = 200;
+var clip2 = (text2, max) => {
+  const chars = Array.from(text2);
+  return chars.length <= max ? text2 : `${chars.slice(0, max - 1).join("")}\u2026`;
+};
+var turnTextParts = (view, t) => {
+  const names = view.steps.map((kind) => t(`card.step.${kind}`));
+  if (view.omitted > 0) names.unshift(t("card.step.omitted", { count: view.omitted }));
+  const headLines = [view.title === "" ? t("card.untitled") : view.title];
+  if (names.length > 0) headLines.push(names.join(" \u2192 "));
+  if (view.running !== null) headLines.push(`\u{1F527} ${clip2(view.running, RUNNING_LABEL_MAX_CHARS)}`);
+  const body = view.body.trim();
+  const footLines = [];
+  if (view.status === "working") {
+    if (body === "" && names.length === 0) footLines.push(t("card.status.working"));
+  } else {
+    footLines.push(t(`card.status.${view.status}`));
+    if (view.errorText !== null && view.errorText !== "") footLines.push(view.errorText);
+  }
+  return { head: headLines.join("\n"), body, foot: footLines.join("\n") };
+};
+var joinParts = (...parts) => parts.filter((part) => part !== "").join("\n\n");
+
+// src/telegramTurn.ts
+var makeTurnWriter = (deps) => {
+  let first = deps.resume ?? null;
+  let live = deps.resume ?? null;
+  let liveText = null;
+  let frozen = 0;
+  let consumed = 0;
+  const put = async (text2) => {
+    const bounded = text2.length <= deps.limit ? text2 : text2.slice(0, deps.limit);
+    if (live === null) {
+      const id = await deps.messages.send(bounded);
+      if (id === null) throw new Error("telegram sent a message without an id");
+      live = id;
+      first ??= id;
+    } else if (bounded === liveText) {
+      return;
+    } else {
+      await deps.messages.edit(live, bounded);
+    }
+    liveText = bounded;
+  };
+  return {
+    firstId: () => first,
+    write: async (view) => {
+      const { head, body, foot } = turnTextParts(view, deps.t);
+      consumed = Math.min(consumed, body.length);
+      for (; ; ) {
+        const rest = body.slice(consumed);
+        const prefix = frozen === 0 ? head.slice(0, Math.floor(deps.limit / 2)) : "";
+        const whole = joinParts(prefix, rest, foot);
+        if (whole.length <= deps.limit) {
+          if (whole !== "") await put(whole);
+          return;
+        }
+        const room = deps.limit - prefix.length - 2;
+        const chunk = splitMessage(rest, room)[0] ?? "";
+        if (chunk === "") {
+          await put(whole);
+          return;
+        }
+        await put(joinParts(prefix, chunk));
+        frozen += 1;
+        consumed += chunk.length;
+        consumed += body.slice(consumed).length - body.slice(consumed).trimStart().length;
+        live = null;
+        liveText = null;
+      }
+    }
+  };
+};
+
 // src/telegramAdapter.ts
 var COLUMNS2 = [
   { key: "telegramToken", kind: "password", labelKey: "column.telegramToken.label" }
 ];
 var BACKOFF_START_MS = 1e3;
 var BACKOFF_MAX_MS = 6e4;
+var TELEGRAM_CARD_THROTTLE_MS = 1200;
+var FLOOD_WAIT_MAX_SECONDS = 30;
+var REMEMBERED_CARD_LIMIT = 200;
 var tokenOf = (binding) => binding.values["telegramToken"] ?? "";
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var makeTelegramAdapter = (deps) => {
   const apis = /* @__PURE__ */ new Map();
+  const sleep = deps.sleep ?? defaultSleep;
+  const t = deps.translate;
+  const withFloodWait = async (run) => {
+    try {
+      return await run();
+    } catch (error) {
+      if (error instanceof TelegramApiError && error.code === 429 && error.retryAfterSeconds !== void 0 && error.retryAfterSeconds <= FLOOD_WAIT_MAX_SECONDS) {
+        await sleep(error.retryAfterSeconds * 1e3);
+        return run();
+      }
+      throw error;
+    }
+  };
+  const remembering = () => {
+    const entries = /* @__PURE__ */ new Map();
+    return {
+      get: (key) => entries.get(key),
+      set: (key, value) => {
+        entries.delete(key);
+        entries.set(key, value);
+        if (entries.size > REMEMBERED_CARD_LIMIT) {
+          const oldest = entries.keys().next().value;
+          if (oldest !== void 0) entries.delete(oldest);
+        }
+      },
+      delete: (key) => entries.delete(key)
+    };
+  };
+  const turnWriters = remembering();
+  const panelKeyboards = remembering();
+  const panelClick = (callback, operatorId, handlers) => {
+    const messageId = callback.message?.message_id;
+    const chatId = callback.message?.chat.id;
+    if (messageId === void 0 || chatId === void 0) return t("panel.expired");
+    const keyboard = panelKeyboards.get(`${String(chatId)}:${String(messageId)}`);
+    const parsed = parsePanelData(callback.data ?? "");
+    const action = keyboard === void 0 || parsed === null || parsed.version !== keyboard.version ? void 0 : keyboard.actions[parsed.index];
+    if (action === void 0) return t("panel.expired");
+    return handlers.onPanelClick?.({
+      chatId: String(chatId),
+      cardId: String(messageId),
+      operatorId,
+      op: action.op,
+      arg: action.arg ?? null
+    }) ?? null;
+  };
   const apiFor = async (binding) => {
     const existing = apis.get(binding.rowId);
     if (existing !== void 0) return existing;
@@ -133554,6 +133749,15 @@ var makeTelegramAdapter = (deps) => {
     apis.set(binding.rowId, api);
     return api;
   };
+  const makeWriter = (api, chatId, resume) => makeTurnWriter({
+    t,
+    limit: TELEGRAM_TEXT_MAX_CHARS,
+    ...resume === void 0 ? {} : { resume },
+    messages: {
+      send: (text2) => withFloodWait(() => api.sendOne(chatId, text2)),
+      edit: (messageId, text2) => withFloodWait(() => api.editMessage(chatId, messageId, text2))
+    }
+  });
   return {
     platform: "telegram",
     icon: "telegram",
@@ -133581,10 +133785,8 @@ var makeTelegramAdapter = (deps) => {
             for (const update of updates) {
               const callback = update.callback_query;
               if (callback?.data !== void 0) {
-                const notice = handlers.onApproval(
-                  callback.data,
-                  callback.from === void 0 ? null : String(callback.from.id)
-                );
+                const operatorId = callback.from === void 0 ? null : String(callback.from.id);
+                const notice = callback.data.startsWith(PANEL_DATA_PREFIX) ? panelClick(callback, operatorId, handlers) : handlers.onApproval(callback.data, operatorId);
                 await api.answerCallback(callback.id, notice ?? void 0).catch(() => void 0);
                 continue;
               }
@@ -133637,8 +133839,72 @@ var makeTelegramAdapter = (deps) => {
     },
     askApproval: async (binding, request) => {
       const api = await apiFor(binding);
-      await api.sendButtons(binding.chatId, request.body, request.options);
-      return null;
+      return api.sendButtons(binding.chatId, request.body, request.options);
+    },
+    settleApproval: async (binding, cardId, settlement) => {
+      const api = await apiFor(binding);
+      const line = settlement.kind === "chosen" ? t("card.approval.chosen", { label: settlement.label }) : t("card.approval.elsewhere");
+      await withFloodWait(
+        () => api.editMessage(
+          binding.chatId,
+          cardId,
+          `${t("card.approval.doneTitle")}
+${line}`
+        )
+      );
+    },
+    turnCards: {
+      throttleMs: TELEGRAM_CARD_THROTTLE_MS,
+      open: async (binding, view) => {
+        const api = await apiFor(binding);
+        const writer = makeWriter(api, binding.chatId);
+        try {
+          await writer.write(view);
+        } catch (error) {
+          if (writer.firstId() === null) throw error;
+          deps.log.warn("telegram could not finish the first card write", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        const cardId = writer.firstId();
+        if (cardId !== null && view.status === "working") {
+          turnWriters.set(`${binding.chatId}:${cardId}`, writer);
+        }
+        return cardId;
+      },
+      update: async (binding, cardId, view) => {
+        const key = `${binding.chatId}:${cardId}`;
+        const writer = turnWriters.get(key) ?? makeWriter(await apiFor(binding), binding.chatId, cardId);
+        await writer.write(view);
+        if (view.status !== "working") turnWriters.delete(key);
+        else turnWriters.set(key, writer);
+      }
+    },
+    panel: {
+      open: async (binding, card) => {
+        const api = await apiFor(binding);
+        const rendered = renderPanel(card, 1);
+        const cardId = await withFloodWait(
+          () => api.sendOne(binding.chatId, rendered.text, rendered.rows)
+        );
+        if (cardId !== null) {
+          panelKeyboards.set(`${binding.chatId}:${cardId}`, {
+            version: 1,
+            actions: rendered.actions
+          });
+        }
+        return cardId;
+      },
+      update: async (binding, cardId, card) => {
+        const api = await apiFor(binding);
+        const key = `${binding.chatId}:${cardId}`;
+        const version = (panelKeyboards.get(key)?.version ?? 0) + 1;
+        const rendered = renderPanel(card, version);
+        await withFloodWait(
+          () => api.editMessage(binding.chatId, cardId, rendered.text, rendered.rows)
+        );
+        panelKeyboards.set(key, { version, actions: rendered.actions });
+      }
     },
     fetchResource: async (binding, input) => {
       const api = await apiFor(binding);
@@ -133908,6 +134174,7 @@ var runWecomClient = (input) => {
   const nextRequestId = (kind) => `${kind}_${++sequence}`;
   const pendingAcks = /* @__PURE__ */ new Map();
   const pendingRequests = /* @__PURE__ */ new Map();
+  const openStreams = /* @__PURE__ */ new Map();
   const subscribeId = nextRequestId("aibot_subscribe");
   let missedPong = 0;
   let closed = false;
@@ -133937,6 +134204,8 @@ var runWecomClient = (input) => {
         return;
       }
       const error = typeof frame.errcode === "number" && frame.errcode !== 0 ? new Error(`WeCom ack failed: ${String(frame.errcode)} ${frame.errmsg ?? ""}`) : null;
+      const stream = openStreams.get(requestId);
+      if (stream !== void 0 && error !== null) stream.failed = true;
       settleAck(requestId, error);
       return;
     }
@@ -133948,6 +134217,7 @@ var runWecomClient = (input) => {
     if (finished) return;
     finished = true;
     clearInterval(heartbeat);
+    openStreams.clear();
     void input.socket.close().catch(() => void 0);
     for (const requestId of pendingAcks.keys()) {
       settleAck(requestId, new Error("WeCom connection closed"));
@@ -134035,8 +134305,38 @@ var runWecomClient = (input) => {
       }
     }
   };
+  const openStream = (chatId) => {
+    const requestId = pendingRequests.get(chatId);
+    if (requestId === void 0) return null;
+    pendingRequests.delete(chatId);
+    const id = nextRequestId("stream");
+    const state = { failed: false, finished: false };
+    openStreams.set(requestId, state);
+    return {
+      id,
+      send: async (content, finish2) => {
+        if (state.failed) return false;
+        if (state.finished) return true;
+        if (finish2) state.finished = true;
+        try {
+          await send({
+            cmd: "aibot_respond_msg",
+            headers: { req_id: requestId },
+            body: { msgtype: "stream", stream: { id, finish: finish2, content } }
+          });
+        } catch (error) {
+          state.failed = true;
+          openStreams.delete(requestId);
+          throw error;
+        }
+        if (finish2) openStreams.delete(requestId);
+        return true;
+      }
+    };
+  };
   return {
     sendText,
+    openStream,
     rememberRequest: (chatId, requestId) => {
       if (requestId !== null) pendingRequests.set(chatId, requestId);
     },
@@ -134051,6 +134351,8 @@ var runWecomClient = (input) => {
 };
 
 // src/wecomAdapter.ts
+var WECOM_CARD_THROTTLE_MS = 400;
+var LIVE_STREAM_LIMIT = 200;
 var BACKOFF_START_MS2 = 1e3;
 var BACKOFF_MAX_MS2 = 6e4;
 var COLUMNS3 = [
@@ -134071,6 +134373,36 @@ var optionIndexFrom = (text2, count) => {
 };
 var makeWecomAdapter = (deps) => {
   const clients = /* @__PURE__ */ new Map();
+  const t = deps.translate;
+  const liveStreams = /* @__PURE__ */ new Map();
+  const rememberStream = (key, entry) => {
+    liveStreams.set(key, entry);
+    if (liveStreams.size > LIVE_STREAM_LIMIT) {
+      const oldest = liveStreams.keys().next().value;
+      if (oldest !== void 0) liveStreams.delete(oldest);
+    }
+  };
+  const emit = async (entry, view) => {
+    const { head, body, foot } = turnTextParts(view, t);
+    if (view.status === "working") {
+      let shown = body;
+      const whole = joinParts(head, body, foot);
+      if (whole.length > WECOM_TEXT_MAX_CHARS) {
+        const marker = t("card.truncated", { count: 9999999 });
+        const room = WECOM_TEXT_MAX_CHARS - head.length - foot.length - marker.length - 6;
+        const kept = room > 0 ? body.slice(Math.max(0, body.length - room)) : "";
+        shown = `${t("card.truncated", { count: body.length - kept.length })}
+${kept}`;
+      }
+      await entry.stream.send(joinParts(head, shown, foot), false);
+      return;
+    }
+    const chunks = splitForWecom(joinParts(head, body, foot));
+    const delivered = await entry.stream.send(chunks[0] ?? "", true);
+    for (const chunk of delivered ? chunks.slice(1) : chunks) {
+      await entry.client.sendText(entry.chatId, chunk);
+    }
+  };
   return {
     platform: "wecom",
     icon: "wecom",
@@ -134169,6 +134501,25 @@ var makeWecomAdapter = (deps) => {
       await (clients.get(binding.rowId)?.sendText(binding.chatId, lines.join("\n")) ?? Promise.resolve());
       return null;
     },
+    turnCards: {
+      throttleMs: WECOM_CARD_THROTTLE_MS,
+      open: async (binding, view) => {
+        const client = clients.get(binding.rowId);
+        const stream = client?.openStream(binding.chatId) ?? null;
+        if (client === void 0 || stream === null) return null;
+        const entry = { stream, client, chatId: binding.chatId };
+        await emit(entry, view);
+        if (view.status === "working") rememberStream(`${binding.rowId}:${stream.id}`, entry);
+        return stream.id;
+      },
+      update: async (binding, cardId, view) => {
+        const key = `${binding.rowId}:${cardId}`;
+        const entry = liveStreams.get(key);
+        if (entry === void 0) return;
+        await emit(entry, view);
+        if (view.status !== "working") liveStreams.delete(key);
+      }
+    },
     answerByText: (_binding, text2, options) => {
       const index = optionIndexFrom(text2, options.length);
       return index === null ? null : options[index - 1]?.token ?? null;
@@ -134222,6 +134573,7 @@ var imPlugin = definePlugin({
         // Telegram 在不少网络里要绕代理，而绕不绕、绕哪个是按行配的 —— 这是插件面上
         // `ctx.proxies` 的第一个真实消费者。
         fetchVia: (proxy) => ctx.proxies.fetch(proxy),
+        translate: t,
         log: {
           info: (message, fields) => ctx.log.info(message, fields),
           warn: (message, fields) => ctx.log.warn(message, fields)
@@ -134230,6 +134582,7 @@ var imPlugin = definePlugin({
       makeWecomAdapter({
         // 企微不需要厂商 SDK：全程 JSON over WebSocket，走插件面那条出网长连接。
         connectSocket: (url) => ctx.socket.connect({ url }),
+        translate: t,
         log: {
           info: (message, fields) => ctx.log.info(message, fields),
           warn: (message, fields) => ctx.log.warn(message, fields)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/plugin-im",
-  "version": "0.2.2570",
+  "version": "0.2.2588",
   "description": "Talk to your agents from Telegram, WeCom or Lark.",
   "keywords": [
     "im",
@@ -27,7 +27,7 @@
     "esbuild": "0.28.1",
     "markdown-it": "^15.0.2",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.2570"
+    "@ycodium-ai/plugin-api": "0.2.2588"
   },
   "ycodium": {
     "plugin": "./dist/index.js",