@poncho-ai/messaging 0.5.1 → 0.7.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/messaging@0.5.1 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
+> @poncho-ai/messaging@0.7.0 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 45.94 KB
-ESM ⚡️ Build success in 66ms
+ESM dist/index.js 51.09 KB
+ESM ⚡️ Build success in 73ms
 DTS Build start
-DTS ⚡️ Build success in 5216ms
-DTS dist/index.d.ts 10.13 KB
+DTS ⚡️ Build success in 4701ms
+DTS dist/index.d.ts 11.24 KB

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @poncho-ai/messaging
 
+## 0.7.0
+
+### Minor Changes
+
+- [`26be28a`](https://github.com/cesr/poncho-ai/commit/26be28a958f2eb27dd78225f1cf80b67b16d673d) Thanks [@cesr](https://github.com/cesr)! - Add tool approval support in Telegram via inline keyboard buttons. When the agent needs approval for a tool call, the bot sends Approve/Deny buttons to the chat. After all decisions are made, the run resumes and the response is delivered. Approvals from the web UI for Telegram conversations are also routed back to the chat.
+
+## 0.6.0
+
+### Minor Changes
+
+- [`d1e1bfb`](https://github.com/cesr/poncho-ai/commit/d1e1bfbf35b18788ab79231ca675774e949f5116) Thanks [@cesr](https://github.com/cesr)! - Add proactive scheduled messaging via channel-targeted cron jobs. Cron jobs with `channel: telegram` (or `slack`) now automatically discover known conversations and send the agent's response directly to each chat, continuing the existing conversation history.
+
 ## 0.5.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -65,6 +65,8 @@ interface AgentRunner {
         platform: string;
         ownerId: string;
         title?: string;
+        channelId?: string;
+        platformThreadId?: string;
     }): Promise<{
         messages: Message[];
     }>;
@@ -104,6 +106,12 @@ interface AgentBridgeOptions {
     ownerId?: string;
 }
 
+/**
+ * Derive a deterministic UUID from a platform thread reference.
+ * SHA-256 hashes the composite key and formats 16 bytes as a UUID v4-shaped
+ * string, ensuring a valid UUID that's stable across requests for the same thread.
+ */
+declare const conversationIdFromThread: (platform: string, ref: ThreadRef) => string;
 declare class AgentBridge {
     private readonly adapter;
     private readonly runner;
@@ -192,6 +200,12 @@ declare class ResendAdapter implements MessagingAdapter {
     private fetchAndDownloadAttachments;
 }
 
+interface TelegramApprovalInfo {
+    approvalId: string;
+    tool: string;
+    input: Record<string, unknown>;
+}
+type TelegramApprovalDecisionHandler = (approvalId: string, approved: boolean, chatId: string) => Promise<void>;
 interface TelegramAdapterOptions {
     botTokenEnv?: string;
     webhookSecretEnv?: string;
@@ -209,7 +223,9 @@ declare class TelegramAdapter implements MessagingAdapter {
     private readonly webhookSecretEnv;
     private readonly allowedUserIds;
     private handler;
+    private approvalDecisionHandler;
     private readonly sessionCounters;
+    private readonly approvalMessageIds;
     private lastUpdateId;
     constructor(options?: TelegramAdapterOptions);
     initialize(): Promise<void>;
@@ -219,7 +235,13 @@ declare class TelegramAdapter implements MessagingAdapter {
         files?: FileAttachment[];
     }): Promise<void>;
     indicateProcessing(threadRef: ThreadRef): Promise<() => Promise<void>>;
+    onApprovalDecision(handler: TelegramApprovalDecisionHandler): void;
+    sendApprovalRequest(chatId: string, approvals: TelegramApprovalInfo[], opts?: {
+        message_thread_id?: number;
+    }): Promise<void>;
+    updateApprovalMessage(approvalId: string, decision: "approved" | "denied", tool: string): Promise<void>;
     private handleRequest;
+    private handleCallbackQuery;
     private sessionKey;
     private extractFiles;
 }
@@ -276,4 +298,4 @@ declare function markdownToEmailHtml(text: string): string;
  */
 declare function matchesSenderPattern(sender: string, patterns: string[] | undefined): boolean;
 
-export { AgentBridge, type AgentBridgeOptions, type AgentRunner, type FileAttachment, type IncomingMessage, type IncomingMessageHandler, type MessagingAdapter, ResendAdapter, type ResendAdapterOptions, type RouteHandler, type RouteRegistrar, SlackAdapter, type SlackAdapterOptions, TelegramAdapter, type TelegramAdapterOptions, type ThreadRef, buildReplyHeaders, buildReplySubject, deriveRootMessageId, extractDisplayName, extractEmailAddress, markdownToEmailHtml, matchesSenderPattern, parseReferences, stripQuotedReply };
+export { AgentBridge, type AgentBridgeOptions, type AgentRunner, type FileAttachment, type IncomingMessage, type IncomingMessageHandler, type MessagingAdapter, ResendAdapter, type ResendAdapterOptions, type RouteHandler, type RouteRegistrar, SlackAdapter, type SlackAdapterOptions, TelegramAdapter, type TelegramAdapterOptions, type TelegramApprovalDecisionHandler, type TelegramApprovalInfo, type ThreadRef, buildReplyHeaders, buildReplySubject, conversationIdFromThread, deriveRootMessageId, extractDisplayName, extractEmailAddress, markdownToEmailHtml, matchesSenderPattern, parseReferences, stripQuotedReply };

package/dist/index.js

@@ -65,7 +65,9 @@ ${message.text}`;
           {
             platform: message.platform,
             ownerId: this.ownerIdOverride ?? message.sender.id,
-            title
+            title,
+            channelId: message.threadRef.channelId,
+            platformThreadId: message.threadRef.platformThreadId
           }
         );
         const result = await this.runner.run(conversationId, {
@@ -1078,6 +1080,49 @@ var sendDocument = async (token, chatId, docData, opts) => {
     throw new Error(`Telegram sendDocument failed: ${result.description}`);
   }
 };
+var sendMessageWithKeyboard = async (token, chatId, text, keyboard, opts) => {
+  const body = {
+    chat_id: chatId,
+    text,
+    reply_markup: { inline_keyboard: keyboard }
+  };
+  if (opts?.reply_to_message_id) {
+    body.reply_parameters = {
+      message_id: opts.reply_to_message_id,
+      allow_sending_without_reply: true
+    };
+  }
+  if (opts?.message_thread_id) {
+    body.message_thread_id = opts.message_thread_id;
+  }
+  const result = await telegramFetch(token, "sendMessage", body);
+  if (!result.ok) {
+    throw new Error(`Telegram sendMessage (keyboard) failed: ${result.description}`);
+  }
+  const msg = result.result;
+  return msg.message_id;
+};
+var editMessageText = async (token, chatId, messageId, text, opts) => {
+  const body = {
+    chat_id: chatId,
+    message_id: messageId,
+    text
+  };
+  if (opts?.reply_markup) {
+    body.reply_markup = opts.reply_markup;
+  }
+  const result = await telegramFetch(token, "editMessageText", body);
+  if (!result.ok) {
+    throw new Error(`Telegram editMessageText failed: ${result.description}`);
+  }
+};
+var answerCallbackQuery = async (token, callbackQueryId, opts) => {
+  const body = {
+    callback_query_id: callbackQueryId
+  };
+  if (opts?.text) body.text = opts.text;
+  await telegramFetch(token, "answerCallbackQuery", body);
+};
 var sendChatAction = async (token, chatId, action) => {
   await telegramFetch(token, "sendChatAction", {
     chat_id: chatId,
@@ -1159,7 +1204,9 @@ var TelegramAdapter = class {
   webhookSecretEnv;
   allowedUserIds;
   handler;
+  approvalDecisionHandler;
   sessionCounters = /* @__PURE__ */ new Map();
+  approvalMessageIds = /* @__PURE__ */ new Map();
   lastUpdateId = 0;
   constructor(options = {}) {
     this.botTokenEnv = options.botTokenEnv ?? "TELEGRAM_BOT_TOKEN";
@@ -1231,6 +1278,72 @@ var TelegramAdapter = class {
     };
   }
   // -----------------------------------------------------------------------
+  // Approval support
+  // -----------------------------------------------------------------------
+  onApprovalDecision(handler) {
+    this.approvalDecisionHandler = handler;
+  }
+  async sendApprovalRequest(chatId, approvals, opts) {
+    const MAX_INPUT_LENGTH = 3500;
+    for (const approval of approvals) {
+      let inputSummary = Object.entries(approval.input).map(([k, v]) => `  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join("\n");
+      if (inputSummary.length > MAX_INPUT_LENGTH) {
+        inputSummary = inputSummary.slice(0, MAX_INPUT_LENGTH) + "\n  \u2026(truncated)";
+      }
+      const text = [
+        `\u{1F527} Tool approval required: ${approval.tool}`,
+        "",
+        inputSummary ? `Input:
+${inputSummary}` : "(no input)"
+      ].join("\n");
+      const keyboard = [
+        [
+          { text: "\u2705 Approve", callback_data: `a:${approval.approvalId}` },
+          { text: "\u274C Deny", callback_data: `d:${approval.approvalId}` }
+        ]
+      ];
+      try {
+        const messageId = await sendMessageWithKeyboard(
+          this.botToken,
+          chatId,
+          text,
+          keyboard,
+          { message_thread_id: opts?.message_thread_id }
+        );
+        this.approvalMessageIds.set(approval.approvalId, {
+          chatId,
+          messageId
+        });
+      } catch (err) {
+        console.error(
+          "[telegram-adapter] failed to send approval request:",
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
+  }
+  async updateApprovalMessage(approvalId, decision, tool) {
+    const tracked = this.approvalMessageIds.get(approvalId);
+    if (!tracked) return;
+    const icon = decision === "approved" ? "\u2705" : "\u274C";
+    const label = decision === "approved" ? "Approved" : "Denied";
+    const text = `${icon} ${label}: ${tool}`;
+    try {
+      await editMessageText(
+        this.botToken,
+        tracked.chatId,
+        tracked.messageId,
+        text
+      );
+    } catch (err) {
+      console.warn(
+        "[telegram-adapter] failed to update approval message:",
+        err instanceof Error ? err.message : err
+      );
+    }
+    this.approvalMessageIds.delete(approvalId);
+  }
+  // -----------------------------------------------------------------------
   // HTTP request handling
   // -----------------------------------------------------------------------
   async handleRequest(req, res) {
@@ -1257,6 +1370,17 @@ var TelegramAdapter = class {
       return;
     }
     this.lastUpdateId = payload.update_id;
+    if (payload.callback_query) {
+      res.writeHead(200);
+      res.end();
+      void this.handleCallbackQuery(payload.callback_query).catch((err) => {
+        console.error(
+          "[telegram-adapter] callback_query error:",
+          err instanceof Error ? err.message : err
+        );
+      });
+      return;
+    }
     const message = payload.message;
     if (!message) {
       res.writeHead(200);
@@ -1348,6 +1472,37 @@ var TelegramAdapter = class {
     });
   }
   // -----------------------------------------------------------------------
+  // Callback query handling
+  // -----------------------------------------------------------------------
+  async handleCallbackQuery(query) {
+    if (this.allowedUserIds && !this.allowedUserIds.includes(query.from.id)) {
+      await answerCallbackQuery(this.botToken, query.id, {
+        text: "You are not authorized to approve tools."
+      });
+      return;
+    }
+    const data = query.data;
+    if (!data) {
+      await answerCallbackQuery(this.botToken, query.id);
+      return;
+    }
+    const isApprove = data.startsWith("a:");
+    const isDeny = data.startsWith("d:");
+    if (!isApprove && !isDeny) {
+      await answerCallbackQuery(this.botToken, query.id);
+      return;
+    }
+    const approvalId = data.slice(2);
+    const approved = isApprove;
+    const chatId = query.message?.chat.id ? String(query.message.chat.id) : void 0;
+    await answerCallbackQuery(this.botToken, query.id, {
+      text: approved ? "Approved" : "Denied"
+    });
+    if (this.approvalDecisionHandler && chatId) {
+      await this.approvalDecisionHandler(approvalId, approved, chatId);
+    }
+  }
+  // -----------------------------------------------------------------------
   // Helpers
   // -----------------------------------------------------------------------
   sessionKey(message) {
@@ -1391,6 +1546,7 @@ export {
   TelegramAdapter,
   buildReplyHeaders,
   buildReplySubject,
+  conversationIdFromThread,
   deriveRootMessageId,
   extractDisplayName,
   extractEmailAddress,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/messaging",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Messaging platform adapters for Poncho agents (Slack, Telegram, etc.)",
   "repository": {
     "type": "git",

package/src/adapters/telegram/index.ts

@@ -9,15 +9,19 @@ import type {
 } from "../../types.js";
 import { verifyTelegramSecret } from "./verify.js";
 import {
+  type TelegramInlineKeyboardButton,
   type TelegramMessage,
   type TelegramUpdate,
+  answerCallbackQuery,
   downloadFile,
+  editMessageText,
   getFile,
   getMe,
   isBotMentioned,
   sendChatAction,
   sendDocument,
   sendMessage,
+  sendMessageWithKeyboard,
   sendPhoto,
   splitMessage,
   stripMention,
@@ -26,6 +30,18 @@ import {
 const TYPING_INTERVAL_MS = 4_000;
 const NEW_COMMAND_RE = /^\/new(?:@(\S+))?$/i;
 
+export interface TelegramApprovalInfo {
+  approvalId: string;
+  tool: string;
+  input: Record<string, unknown>;
+}
+
+export type TelegramApprovalDecisionHandler = (
+  approvalId: string,
+  approved: boolean,
+  chatId: string,
+) => Promise<void>;
+
 export interface TelegramAdapterOptions {
   botTokenEnv?: string;
   webhookSecretEnv?: string;
@@ -53,7 +69,9 @@ export class TelegramAdapter implements MessagingAdapter {
   private readonly webhookSecretEnv: string;
   private readonly allowedUserIds: number[] | undefined;
   private handler: IncomingMessageHandler | undefined;
+  private approvalDecisionHandler: TelegramApprovalDecisionHandler | undefined;
   private readonly sessionCounters = new Map<string, number>();
+  private readonly approvalMessageIds = new Map<string, { chatId: string; messageId: number }>();
   private lastUpdateId = 0;
 
   constructor(options: TelegramAdapterOptions = {}) {
@@ -148,6 +166,92 @@ export class TelegramAdapter implements MessagingAdapter {
     };
   }
 
+  // -----------------------------------------------------------------------
+  // Approval support
+  // -----------------------------------------------------------------------
+
+  onApprovalDecision(handler: TelegramApprovalDecisionHandler): void {
+    this.approvalDecisionHandler = handler;
+  }
+
+  async sendApprovalRequest(
+    chatId: string,
+    approvals: TelegramApprovalInfo[],
+    opts?: { message_thread_id?: number },
+  ): Promise<void> {
+    const MAX_INPUT_LENGTH = 3500;
+
+    for (const approval of approvals) {
+      let inputSummary = Object.entries(approval.input)
+        .map(([k, v]) => `  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`)
+        .join("\n");
+
+      if (inputSummary.length > MAX_INPUT_LENGTH) {
+        inputSummary = inputSummary.slice(0, MAX_INPUT_LENGTH) + "\n  …(truncated)";
+      }
+
+      const text = [
+        `🔧 Tool approval required: ${approval.tool}`,
+        "",
+        inputSummary ? `Input:\n${inputSummary}` : "(no input)",
+      ].join("\n");
+
+      const keyboard: TelegramInlineKeyboardButton[][] = [
+        [
+          { text: "✅ Approve", callback_data: `a:${approval.approvalId}` },
+          { text: "❌ Deny", callback_data: `d:${approval.approvalId}` },
+        ],
+      ];
+
+      try {
+        const messageId = await sendMessageWithKeyboard(
+          this.botToken,
+          chatId,
+          text,
+          keyboard,
+          { message_thread_id: opts?.message_thread_id },
+        );
+        this.approvalMessageIds.set(approval.approvalId, {
+          chatId,
+          messageId,
+        });
+      } catch (err) {
+        console.error(
+          "[telegram-adapter] failed to send approval request:",
+          err instanceof Error ? err.message : err,
+        );
+      }
+    }
+  }
+
+  async updateApprovalMessage(
+    approvalId: string,
+    decision: "approved" | "denied",
+    tool: string,
+  ): Promise<void> {
+    const tracked = this.approvalMessageIds.get(approvalId);
+    if (!tracked) return;
+
+    const icon = decision === "approved" ? "✅" : "❌";
+    const label = decision === "approved" ? "Approved" : "Denied";
+    const text = `${icon} ${label}: ${tool}`;
+
+    try {
+      await editMessageText(
+        this.botToken,
+        tracked.chatId,
+        tracked.messageId,
+        text,
+      );
+    } catch (err) {
+      console.warn(
+        "[telegram-adapter] failed to update approval message:",
+        err instanceof Error ? err.message : err,
+      );
+    }
+    this.approvalMessageIds.delete(approvalId);
+  }
+
   // -----------------------------------------------------------------------
   // HTTP request handling
   // -----------------------------------------------------------------------
@@ -187,6 +291,19 @@ export class TelegramAdapter implements MessagingAdapter {
     }
     this.lastUpdateId = payload.update_id;
 
+    // -- Callback query (inline keyboard button press) ---------------------
+    if (payload.callback_query) {
+      res.writeHead(200);
+      res.end();
+      void this.handleCallbackQuery(payload.callback_query).catch((err) => {
+        console.error(
+          "[telegram-adapter] callback_query error:",
+          err instanceof Error ? err.message : err,
+        );
+      });
+      return;
+    }
+
     const message = payload.message;
     if (!message) {
       res.writeHead(200);
@@ -313,6 +430,48 @@ export class TelegramAdapter implements MessagingAdapter {
     });
   }
 
+  // -----------------------------------------------------------------------
+  // Callback query handling
+  // -----------------------------------------------------------------------
+
+  private async handleCallbackQuery(
+    query: import("./utils.js").TelegramCallbackQuery,
+  ): Promise<void> {
+    if (this.allowedUserIds && !this.allowedUserIds.includes(query.from.id)) {
+      await answerCallbackQuery(this.botToken, query.id, {
+        text: "You are not authorized to approve tools.",
+      });
+      return;
+    }
+
+    const data = query.data;
+    if (!data) {
+      await answerCallbackQuery(this.botToken, query.id);
+      return;
+    }
+
+    const isApprove = data.startsWith("a:");
+    const isDeny = data.startsWith("d:");
+    if (!isApprove && !isDeny) {
+      await answerCallbackQuery(this.botToken, query.id);
+      return;
+    }
+
+    const approvalId = data.slice(2);
+    const approved = isApprove;
+    const chatId = query.message?.chat.id
+      ? String(query.message.chat.id)
+      : undefined;
+
+    await answerCallbackQuery(this.botToken, query.id, {
+      text: approved ? "Approved" : "Denied",
+    });
+
+    if (this.approvalDecisionHandler && chatId) {
+      await this.approvalDecisionHandler(approvalId, approved, chatId);
+    }
+  }
+
   // -----------------------------------------------------------------------
   // Helpers
   // -----------------------------------------------------------------------

package/src/adapters/telegram/utils.ts

@@ -55,9 +55,22 @@ export interface TelegramMessage {
   message_thread_id?: number;
 }
 
+export interface TelegramCallbackQuery {
+  id: string;
+  from: TelegramUser;
+  message?: TelegramMessage;
+  data?: string;
+}
+
+export interface TelegramInlineKeyboardButton {
+  text: string;
+  callback_data?: string;
+}
+
 export interface TelegramUpdate {
   update_id: number;
   message?: TelegramMessage;
+  callback_query?: TelegramCallbackQuery;
 }
 
 // ---------------------------------------------------------------------------
@@ -259,6 +272,72 @@ export const sendDocument = async (
   }
 };
 
+// ---------------------------------------------------------------------------
+// Inline keyboard messages
+// ---------------------------------------------------------------------------
+
+export const sendMessageWithKeyboard = async (
+  token: string,
+  chatId: number | string,
+  text: string,
+  keyboard: TelegramInlineKeyboardButton[][],
+  opts?: { reply_to_message_id?: number; message_thread_id?: number },
+): Promise<number> => {
+  const body: Record<string, unknown> = {
+    chat_id: chatId,
+    text,
+    reply_markup: { inline_keyboard: keyboard },
+  };
+  if (opts?.reply_to_message_id) {
+    body.reply_parameters = {
+      message_id: opts.reply_to_message_id,
+      allow_sending_without_reply: true,
+    };
+  }
+  if (opts?.message_thread_id) {
+    body.message_thread_id = opts.message_thread_id;
+  }
+  const result = await telegramFetch(token, "sendMessage", body);
+  if (!result.ok) {
+    throw new Error(`Telegram sendMessage (keyboard) failed: ${result.description}`);
+  }
+  const msg = result.result as { message_id: number };
+  return msg.message_id;
+};
+
+export const editMessageText = async (
+  token: string,
+  chatId: number | string,
+  messageId: number,
+  text: string,
+  opts?: { reply_markup?: { inline_keyboard: TelegramInlineKeyboardButton[][] } },
+): Promise<void> => {
+  const body: Record<string, unknown> = {
+    chat_id: chatId,
+    message_id: messageId,
+    text,
+  };
+  if (opts?.reply_markup) {
+    body.reply_markup = opts.reply_markup;
+  }
+  const result = await telegramFetch(token, "editMessageText", body);
+  if (!result.ok) {
+    throw new Error(`Telegram editMessageText failed: ${result.description}`);
+  }
+};
+
+export const answerCallbackQuery = async (
+  token: string,
+  callbackQueryId: string,
+  opts?: { text?: string },
+): Promise<void> => {
+  const body: Record<string, unknown> = {
+    callback_query_id: callbackQueryId,
+  };
+  if (opts?.text) body.text = opts.text;
+  await telegramFetch(token, "answerCallbackQuery", body);
+};
+
 // ---------------------------------------------------------------------------
 // Typing indicator
 // ---------------------------------------------------------------------------

package/src/bridge.ts

@@ -13,7 +13,7 @@ import type {
  * SHA-256 hashes the composite key and formats 16 bytes as a UUID v4-shaped
  * string, ensuring a valid UUID that's stable across requests for the same thread.
  */
-const conversationIdFromThread = (
+export const conversationIdFromThread = (
   platform: string,
   ref: ThreadRef,
 ): string => {
@@ -94,6 +94,8 @@ export class AgentBridge {
             platform: message.platform,
             ownerId: this.ownerIdOverride ?? message.sender.id,
             title,
+            channelId: message.threadRef.channelId,
+            platformThreadId: message.threadRef.platformThreadId,
           },
         );
 

package/src/index.ts

@@ -10,13 +10,17 @@ export type {
   ThreadRef,
 } from "./types.js";
 
-export { AgentBridge } from "./bridge.js";
+export { AgentBridge, conversationIdFromThread } from "./bridge.js";
 export { SlackAdapter } from "./adapters/slack/index.js";
 export type { SlackAdapterOptions } from "./adapters/slack/index.js";
 export { ResendAdapter } from "./adapters/resend/index.js";
 export type { ResendAdapterOptions } from "./adapters/resend/index.js";
 export { TelegramAdapter } from "./adapters/telegram/index.js";
-export type { TelegramAdapterOptions } from "./adapters/telegram/index.js";
+export type {
+  TelegramAdapterOptions,
+  TelegramApprovalInfo,
+  TelegramApprovalDecisionHandler,
+} from "./adapters/telegram/index.js";
 
 export {
   buildReplyHeaders,

package/src/types.ts

@@ -105,7 +105,13 @@ export interface MessagingAdapter {
 export interface AgentRunner {
   getOrCreateConversation(
     conversationId: string,
-    meta: { platform: string; ownerId: string; title?: string },
+    meta: {
+      platform: string;
+      ownerId: string;
+      title?: string;
+      channelId?: string;
+      platformThreadId?: string;
+    },
   ): Promise<{ messages: Message[] }>;
 
   run(