@poncho-ai/messaging 0.2.0 → 0.2.2

package/dist/index.js

@@ -4,11 +4,13 @@ var AgentBridge = class {
   adapter;
   runner;
   waitUntil;
+  ownerIdOverride;
   constructor(options) {
     this.adapter = options.adapter;
     this.runner = options.runner;
     this.waitUntil = options.waitUntil ?? ((_p) => {
     });
+    this.ownerIdOverride = options.ownerId;
   }
   /** Wire the adapter's message handler and initialise. */
   async start() {
@@ -21,33 +23,59 @@ var AgentBridge = class {
   }
   async handleMessage(message) {
     let cleanup;
+    this.adapter.resetRequestState?.();
     try {
       cleanup = await this.adapter.indicateProcessing(message.threadRef);
       const conversationId = conversationIdFromThread(
         message.platform,
         message.threadRef
       );
+      const titleParts = [message.sender.id];
+      if (message.subject) titleParts.push(message.subject);
+      const title = titleParts.join(" \u2014 ") || `${message.platform} thread`;
       const conversation = await this.runner.getOrCreateConversation(
         conversationId,
         {
           platform: message.platform,
-          ownerId: message.sender.id,
-          title: `${message.platform} thread`
+          ownerId: this.ownerIdOverride ?? message.sender.id,
+          title
         }
       );
+      const senderLine = message.sender.name ? `From: ${message.sender.name} <${message.sender.id}>` : `From: ${message.sender.id}`;
+      const subjectLine = message.subject ? `Subject: ${message.subject}` : "";
+      const header = [senderLine, subjectLine].filter(Boolean).join("\n");
+      const task = `${header}
+
+${message.text}`;
       const result = await this.runner.run(conversationId, {
-        task: message.text,
-        messages: conversation.messages
+        task,
+        messages: conversation.messages,
+        files: message.files,
+        metadata: {
+          platform: message.platform,
+          sender: message.sender,
+          threadId: message.threadRef.platformThreadId
+        }
       });
-      await this.adapter.sendReply(message.threadRef, result.response);
+      if (this.adapter.autoReply) {
+        await this.adapter.sendReply(message.threadRef, result.response, {
+          files: result.files
+        });
+      } else if (!this.adapter.hasSentInCurrentRequest) {
+        console.warn("[agent-bridge] tool mode completed without send_email being called; no reply sent");
+      }
     } catch (error) {
-      const snippet = error instanceof Error ? error.message : "Unknown error";
-      try {
-        await this.adapter.sendReply(
-          message.threadRef,
-          `Sorry, something went wrong: ${snippet}`
-        );
-      } catch {
+      console.error("[agent-bridge] handleMessage error:", error instanceof Error ? error.message : error);
+      if (!this.adapter.hasSentInCurrentRequest) {
+        const snippet = error instanceof Error ? error.message : "Unknown error";
+        try {
+          await this.adapter.sendReply(
+            message.threadRef,
+            `Sorry, something went wrong: ${snippet}`
+          );
+        } catch (replyError) {
+          console.error("[agent-bridge] failed to send error reply:", replyError instanceof Error ? replyError.message : replyError);
+        }
       }
     } finally {
       if (cleanup) {
@@ -154,6 +182,8 @@ var collectBody = (req) => new Promise((resolve, reject) => {
 });
 var SlackAdapter = class {
   platform = "slack";
+  autoReply = true;
+  hasSentInCurrentRequest = false;
   botToken = "";
   signingSecret = "";
   botTokenEnv;
@@ -190,7 +220,7 @@ var SlackAdapter = class {
       (req, res) => this.handleRequest(req, res)
     );
   }
-  async sendReply(threadRef, content) {
+  async sendReply(threadRef, content, _options) {
     const chunks = splitMessage(content);
     for (const chunk of chunks) {
       await postMessage(
@@ -284,7 +314,590 @@ var SlackAdapter = class {
     res.end();
   }
 };
+
+// src/adapters/resend/index.ts
+import { createHmac as createHmac2 } from "crypto";
+
+// src/adapters/email/utils.ts
+import { createHash } from "crypto";
+var ADDR_RE = /<([^>]+)>/;
+function extractEmailAddress(formatted) {
+  const match = ADDR_RE.exec(formatted);
+  return (match ? match[1] : formatted).trim().toLowerCase();
+}
+function extractDisplayName(formatted) {
+  const idx = formatted.indexOf("<");
+  if (idx <= 0) return void 0;
+  const name = formatted.slice(0, idx).trim().replace(/^["']|["']$/g, "");
+  return name || void 0;
+}
+var MSG_ID_RE = /<[^>]+>/g;
+function parseReferences(headers) {
+  if (!headers) return [];
+  let refValue;
+  if (Array.isArray(headers)) {
+    const entry = headers.find((h) => h.name.toLowerCase() === "references");
+    refValue = entry?.value;
+  } else if (typeof headers === "object") {
+    const key = Object.keys(headers).find((k) => k.toLowerCase() === "references");
+    refValue = key ? headers[key] : void 0;
+  }
+  if (!refValue) return [];
+  const matches = refValue.match(MSG_ID_RE);
+  return matches ?? [];
+}
+function deriveRootMessageId(references, currentMessageId, fallback) {
+  if (references.length > 0) return references[0];
+  if (fallback) {
+    const normalised = normaliseSubject(fallback.subject) + "\0" + fallback.sender.toLowerCase();
+    const hash = createHash("sha256").update(normalised).digest("hex").slice(0, 16);
+    return `<fallback:${hash}>`;
+  }
+  return currentMessageId;
+}
+function normaliseSubject(subject) {
+  return subject.replace(/^(?:re|fwd?|aw|sv|vs)\s*:\s*/gi, "").trim();
+}
+function buildReplySubject(subject) {
+  if (/^re\s*:/i.test(subject)) return subject;
+  return `Re: ${subject}`;
+}
+function buildReplyHeaders(inReplyTo, existingReferences) {
+  const refs = [...existingReferences];
+  if (!refs.includes(inReplyTo)) refs.push(inReplyTo);
+  return {
+    "In-Reply-To": inReplyTo,
+    "References": refs.join(" ")
+  };
+}
+function stripQuotedReply(text) {
+  const lines = text.split("\n");
+  let cutIndex = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (/^on\s+.+wrote:\s*$/i.test(line)) {
+      cutIndex = i;
+      break;
+    }
+    if (/^-{2,}\s*original message\s*-{2,}$/i.test(line)) {
+      cutIndex = i;
+      break;
+    }
+    if (/^from:\s/i.test(line) && i > 0 && lines[i - 1].trim() === "") {
+      const nextLine = lines[i + 1]?.trim() ?? "";
+      if (/^(sent|to|cc|subject|date):\s/i.test(nextLine)) {
+        cutIndex = i;
+        break;
+      }
+    }
+    if (line.startsWith(">")) {
+      if (i === 0 || lines[i - 1].trim() === "" || /wrote:\s*$/i.test(lines[i - 1])) {
+        cutIndex = i;
+        break;
+      }
+    }
+  }
+  return lines.slice(0, cutIndex).join("\n").trimEnd();
+}
+function markdownToEmailHtml(text) {
+  const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  let html = escaped;
+  html = html.replace(
+    /```(?:\w*)\n([\s\S]*?)```/g,
+    (_m, code) => `<pre style="background:#f5f5f5;padding:12px;border-radius:4px;overflow-x:auto;font-family:monospace;font-size:13px;">${code.trimEnd()}</pre>`
+  );
+  html = html.replace(
+    /`([^`]+)`/g,
+    '<code style="background:#f5f5f5;padding:2px 4px;border-radius:3px;font-family:monospace;font-size:13px;">$1</code>'
+  );
+  html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  html = html.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, "<em>$1</em>");
+  html = html.replace(/^### (.+)$/gm, '<h3 style="margin:16px 0 8px;">$1</h3>');
+  html = html.replace(/^## (.+)$/gm, '<h2 style="margin:16px 0 8px;">$1</h2>');
+  html = html.replace(/^# (.+)$/gm, '<h1 style="margin:16px 0 8px;">$1</h1>');
+  html = html.replace(
+    /(?:^[*-] .+(?:\n|$))+/gm,
+    (block) => {
+      const items = block.trim().split("\n").map((l) => `<li>${l.replace(/^[*-] /, "")}</li>`);
+      return `<ul style="margin:8px 0;padding-left:24px;">${items.join("")}</ul>`;
+    }
+  );
+  html = html.replace(
+    /(?:^\d+\. .+(?:\n|$))+/gm,
+    (block) => {
+      const items = block.trim().split("\n").map((l) => `<li>${l.replace(/^\d+\. /, "")}</li>`);
+      return `<ol style="margin:8px 0;padding-left:24px;">${items.join("")}</ol>`;
+    }
+  );
+  html = html.split(/\n{2,}/).map((p) => {
+    const trimmed = p.trim();
+    if (!trimmed) return "";
+    if (/^<(?:h[1-6]|ul|ol|pre|blockquote)/i.test(trimmed)) return trimmed;
+    return `<p style="margin:8px 0;">${trimmed.replace(/\n/g, "<br>")}</p>`;
+  }).join("\n");
+  return `<div style="font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;font-size:14px;line-height:1.6;color:#1a1a1a;">${html}</div>`;
+}
+function matchesSenderPattern(sender, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  const addr = sender.toLowerCase();
+  return patterns.some((pattern) => {
+    const p = pattern.toLowerCase();
+    if (p.startsWith("*@")) {
+      return addr.endsWith(p.slice(1));
+    }
+    return addr === p;
+  });
+}
+
+// src/adapters/resend/index.ts
+function verifySvixSignature(rawBody, svixId, svixTimestamp, svixSignature, secret) {
+  const now = Math.floor(Date.now() / 1e3);
+  const ts = parseInt(svixTimestamp, 10);
+  const tolerance = 5 * 60;
+  if (isNaN(ts) || Math.abs(now - ts) > tolerance) {
+    throw new Error("Timestamp outside tolerance");
+  }
+  const secretBytes = Buffer.from(
+    secret.startsWith("whsec_") ? secret.slice(6) : secret,
+    "base64"
+  );
+  const toSign = `${svixId}.${svixTimestamp}.${rawBody}`;
+  const expected = createHmac2("sha256", secretBytes).update(toSign).digest("base64");
+  const candidates = svixSignature.split(" ").map((sig) => {
+    const parts = sig.split(",");
+    return parts.length === 2 ? parts[1] : parts[0];
+  });
+  if (!candidates.some((c) => c === expected)) {
+    throw new Error("Signature mismatch");
+  }
+}
+var LruSet = class {
+  max;
+  set = /* @__PURE__ */ new Set();
+  constructor(max = 1e3) {
+    this.max = max;
+  }
+  has(key) {
+    return this.set.has(key);
+  }
+  add(key) {
+    if (this.set.size >= this.max) {
+      const first = this.set.values().next().value;
+      this.set.delete(first);
+    }
+    this.set.add(key);
+  }
+};
+var DATA_URI_RE = /^data:[^;]+;base64,/;
+function toResendAttachment(f) {
+  const filename = f.filename ?? "attachment";
+  const data = f.data;
+  if (data.startsWith("poncho-upload://")) {
+    console.warn("[resend-adapter] skipping poncho-upload:// attachment (not resolvable from adapter):", filename);
+    return null;
+  }
+  if (data.startsWith("https://") || data.startsWith("http://")) {
+    return { filename, path: data, contentType: f.mediaType };
+  }
+  if (DATA_URI_RE.test(data)) {
+    return { filename, content: data.replace(DATA_URI_RE, ""), contentType: f.mediaType };
+  }
+  return { filename, content: data, contentType: f.mediaType };
+}
+var collectBody2 = (req) => new Promise((resolve, reject) => {
+  const chunks = [];
+  req.on("data", (chunk) => chunks.push(chunk));
+  req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  req.on("error", reject);
+});
+var ResendAdapter = class {
+  platform = "resend";
+  autoReply;
+  hasSentInCurrentRequest = false;
+  resend;
+  apiKey = "";
+  webhookSecret = "";
+  fromAddress = "";
+  apiKeyEnv;
+  webhookSecretEnv;
+  fromEnv;
+  allowedSenders;
+  allowedRecipients;
+  maxSendsPerRun;
+  mode;
+  handler;
+  sendCount = 0;
+  /** Request-scoped thread metadata for sendReply. */
+  threadMeta = /* @__PURE__ */ new Map();
+  /** Deduplication set for svix-id headers. */
+  processed = new LruSet(1e3);
+  constructor(options = {}) {
+    this.apiKeyEnv = options.apiKeyEnv ?? "RESEND_API_KEY";
+    this.webhookSecretEnv = options.webhookSecretEnv ?? "RESEND_WEBHOOK_SECRET";
+    this.fromEnv = options.fromEnv ?? "RESEND_FROM";
+    this.allowedSenders = options.allowedSenders;
+    this.mode = options.mode ?? "auto-reply";
+    this.autoReply = this.mode !== "tool";
+    this.allowedRecipients = options.allowedRecipients;
+    this.maxSendsPerRun = options.maxSendsPerRun ?? 10;
+  }
+  resetRequestState() {
+    this.hasSentInCurrentRequest = false;
+    this.sendCount = 0;
+  }
+  // -----------------------------------------------------------------------
+  // MessagingAdapter implementation
+  // -----------------------------------------------------------------------
+  async initialize() {
+    this.apiKey = process.env[this.apiKeyEnv] ?? "";
+    this.webhookSecret = process.env[this.webhookSecretEnv] ?? "";
+    this.fromAddress = process.env[this.fromEnv] ?? "";
+    if (!this.apiKey) {
+      throw new Error(
+        `Resend messaging: ${this.apiKeyEnv} environment variable is not set`
+      );
+    }
+    if (!this.webhookSecret) {
+      throw new Error(
+        `Resend messaging: ${this.webhookSecretEnv} environment variable is not set`
+      );
+    }
+    if (!this.fromAddress) {
+      throw new Error(
+        `Resend messaging: ${this.fromEnv} environment variable is not set`
+      );
+    }
+    try {
+      const mod = await import("resend");
+      const ResendClass = mod.Resend;
+      this.resend = new ResendClass(this.apiKey);
+    } catch {
+      throw new Error(
+        "ResendAdapter requires the 'resend' package. Install it: npm install resend"
+      );
+    }
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  registerRoutes(router) {
+    router(
+      "POST",
+      "/api/messaging/resend",
+      (req, res) => this.handleRequest(req, res)
+    );
+  }
+  async sendReply(threadRef, content, options) {
+    if (!this.resend) throw new Error("ResendAdapter not initialised");
+    const meta = this.threadMeta.get(threadRef.platformThreadId);
+    this.threadMeta.delete(threadRef.platformThreadId);
+    const subject = meta ? buildReplySubject(meta.subject) : "Re: (no subject)";
+    const headers = meta ? buildReplyHeaders(threadRef.messageId ?? threadRef.platformThreadId, meta.references) : {};
+    const attachments = options?.files?.map((f) => toResendAttachment(f)).filter((a) => a !== null);
+    console.log("[resend-adapter] sendReply \u2192", {
+      from: this.fromAddress,
+      to: threadRef.channelId,
+      subject
+    });
+    const result = await this.resend.emails.send({
+      from: this.fromAddress,
+      to: [threadRef.channelId],
+      subject,
+      text: content,
+      html: markdownToEmailHtml(content),
+      headers,
+      attachments: attachments && attachments.length > 0 ? attachments : void 0
+    });
+    if (result.error) {
+      console.error("[resend-adapter] send failed:", JSON.stringify(result.error));
+      throw new Error(`Resend send failed: ${JSON.stringify(result.error)}`);
+    }
+    console.log("[resend-adapter] email sent:", result.data);
+  }
+  async indicateProcessing(_threadRef) {
+    return async () => {
+    };
+  }
+  getToolDefinitions() {
+    if (this.mode !== "tool") return [];
+    const adapter = this;
+    return [
+      {
+        name: "send_email",
+        description: "Send an email via Resend. The body is written in markdown and will be converted to HTML. To thread as a reply, provide in_reply_to with the original message ID. Omit it for a new standalone email.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            to: {
+              type: "array",
+              items: { type: "string" },
+              description: "Recipient email addresses"
+            },
+            subject: {
+              type: "string",
+              description: "Email subject line"
+            },
+            body: {
+              type: "string",
+              description: "Email body in markdown (converted to HTML)"
+            },
+            cc: {
+              type: "array",
+              items: { type: "string" },
+              description: "CC recipient email addresses"
+            },
+            bcc: {
+              type: "array",
+              items: { type: "string" },
+              description: "BCC recipient email addresses"
+            },
+            in_reply_to: {
+              type: "string",
+              description: "Message-ID to thread this email under (for replies). Omit for a new email."
+            }
+          },
+          required: ["to", "subject", "body"]
+        },
+        handler: async (input) => {
+          return adapter.handleSendEmailTool(input);
+        }
+      }
+    ];
+  }
+  async handleSendEmailTool(input) {
+    if (!this.resend) {
+      return { success: false, error: "ResendAdapter not initialised" };
+    }
+    if (this.sendCount >= this.maxSendsPerRun) {
+      return {
+        success: false,
+        error: `Send limit reached (${this.maxSendsPerRun} per run). Cannot send more emails in this run.`
+      };
+    }
+    const to = input.to;
+    const subject = input.subject;
+    const body = input.body;
+    const cc = input.cc;
+    const bcc = input.bcc;
+    const inReplyTo = input.in_reply_to;
+    const allRecipients = [...to, ...cc ?? [], ...bcc ?? []];
+    if (this.allowedRecipients && this.allowedRecipients.length > 0) {
+      for (const addr of allRecipients) {
+        if (!matchesSenderPattern(addr, this.allowedRecipients)) {
+          return {
+            success: false,
+            error: `Recipient "${addr}" is not in the allowed recipients list. Allowed patterns: ${this.allowedRecipients.join(", ")}`
+          };
+        }
+      }
+    }
+    const headers = {};
+    if (inReplyTo) {
+      headers["In-Reply-To"] = inReplyTo;
+      headers["References"] = inReplyTo;
+    }
+    console.log("[resend-adapter] send_email tool \u2192", {
+      from: this.fromAddress,
+      to,
+      subject,
+      cc: cc ?? void 0,
+      bcc: bcc ?? void 0,
+      inReplyTo: inReplyTo ?? void 0
+    });
+    const result = await this.resend.emails.send({
+      from: this.fromAddress,
+      to,
+      subject,
+      text: body,
+      html: markdownToEmailHtml(body),
+      cc: cc && cc.length > 0 ? cc : void 0,
+      bcc: bcc && bcc.length > 0 ? bcc : void 0,
+      headers: Object.keys(headers).length > 0 ? headers : void 0
+    });
+    if (result.error) {
+      console.error("[resend-adapter] send_email tool failed:", JSON.stringify(result.error));
+      return { success: false, error: JSON.stringify(result.error) };
+    }
+    this.sendCount++;
+    this.hasSentInCurrentRequest = true;
+    console.log("[resend-adapter] send_email tool sent:", result.data);
+    return { success: true, id: result.data?.id };
+  }
+  // -----------------------------------------------------------------------
+  // HTTP request handling
+  // -----------------------------------------------------------------------
+  async handleRequest(req, res) {
+    if (!this.resend) {
+      res.writeHead(500);
+      res.end("Adapter not initialised");
+      return;
+    }
+    const rawBody = await collectBody2(req);
+    const svixId = req.headers["svix-id"];
+    const svixTimestamp = req.headers["svix-timestamp"];
+    const svixSignature = req.headers["svix-signature"];
+    if (!svixId || !svixTimestamp || !svixSignature) {
+      console.warn("[resend-adapter] 401: missing svix headers", {
+        hasSvixId: !!svixId,
+        hasSvixTimestamp: !!svixTimestamp,
+        hasSvixSignature: !!svixSignature
+      });
+      res.writeHead(401);
+      res.end("Missing signature headers");
+      return;
+    }
+    try {
+      verifySvixSignature(rawBody, svixId, svixTimestamp, svixSignature, this.webhookSecret);
+    } catch (err) {
+      console.warn("[resend-adapter] 401: signature verification failed", err instanceof Error ? err.message : err);
+      res.writeHead(401);
+      res.end("Invalid signature");
+      return;
+    }
+    if (this.processed.has(svixId)) {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    this.processed.add(svixId);
+    let payload;
+    try {
+      payload = JSON.parse(rawBody);
+    } catch {
+      res.writeHead(400);
+      res.end("Invalid JSON");
+      return;
+    }
+    if (payload.type !== "email.received") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    res.writeHead(200);
+    res.end();
+    const data = payload.data;
+    if (!data || !this.handler) return;
+    try {
+      await this.processInboundEmail(data, payload);
+    } catch (err) {
+      console.error("[resend-adapter] error processing inbound email", err);
+    }
+  }
+  async processInboundEmail(data, payload) {
+    if (!this.handler) return;
+    const fromRaw = String(data.from ?? "");
+    const senderEmail = extractEmailAddress(fromRaw);
+    const senderName = extractDisplayName(fromRaw);
+    if (!matchesSenderPattern(senderEmail, this.allowedSenders)) {
+      return;
+    }
+    const emailId = String(data.email_id ?? "");
+    const messageId = String(data.message_id ?? "");
+    const subject = String(data.subject ?? "");
+    let text = "";
+    let emailHeaders;
+    if (emailId) {
+      try {
+        const resp = await fetch(
+          `https://api.resend.com/emails/receiving/${emailId}`,
+          { headers: { Authorization: `Bearer ${this.apiKey}` } }
+        );
+        if (resp.ok) {
+          const emailData = await resp.json();
+          text = emailData.text ?? "";
+          emailHeaders = emailData.headers;
+        } else {
+          const body = await resp.text().catch(() => "");
+          console.error(
+            `[resend-adapter] failed to fetch email body: ${resp.status} ${resp.statusText}`,
+            `
+  URL: https://api.resend.com/emails/receiving/${emailId}`,
+            `
+  Key: ${this.apiKey.slice(0, 6)}...${this.apiKey.slice(-4)}`,
+            body ? `
+  Response: ${body.slice(0, 200)}` : ""
+          );
+        }
+      } catch (err) {
+        console.error("[resend-adapter] failed to fetch email body", err);
+      }
+    }
+    const cleanText = stripQuotedReply(text).trim();
+    if (!cleanText) return;
+    const references = parseReferences(emailHeaders);
+    this.threadMeta.set(messageId, {
+      subject,
+      senderEmail,
+      references: [...references, messageId].filter(Boolean)
+    });
+    const webhookAttachments = data.attachments;
+    const files = await this.fetchAndDownloadAttachments(emailId, webhookAttachments);
+    const message = {
+      text: cleanText,
+      subject: subject || void 0,
+      files: files.length > 0 ? files : void 0,
+      threadRef: {
+        channelId: senderEmail,
+        platformThreadId: messageId,
+        messageId
+      },
+      sender: { id: senderEmail, name: senderName },
+      platform: "resend",
+      raw: payload
+    };
+    await this.handler(message);
+  }
+  // -----------------------------------------------------------------------
+  // Attachment helpers
+  // -----------------------------------------------------------------------
+  async fetchAndDownloadAttachments(emailId, webhookAttachments) {
+    if (!emailId || !webhookAttachments || webhookAttachments.length === 0) return [];
+    let attachments = [];
+    try {
+      const resp = await fetch(
+        `https://api.resend.com/emails/receiving/${emailId}/attachments`,
+        { headers: { Authorization: `Bearer ${this.apiKey}` } }
+      );
+      if (resp.ok) {
+        const body = await resp.json();
+        attachments = Array.isArray(body) ? body : body.data ?? [];
+      } else {
+        console.error("[resend-adapter] failed to list attachments:", resp.status, resp.statusText);
+        return [];
+      }
+    } catch (err) {
+      console.error("[resend-adapter] failed to list attachments", err);
+      return [];
+    }
+    const results = [];
+    for (const att of attachments) {
+      if (!att.download_url) continue;
+      try {
+        const resp = await fetch(att.download_url);
+        if (!resp.ok) continue;
+        const buf = Buffer.from(await resp.arrayBuffer());
+        results.push({
+          data: buf.toString("base64"),
+          mediaType: att.content_type ?? "application/octet-stream",
+          filename: att.filename
+        });
+      } catch {
+      }
+    }
+    return results;
+  }
+};
 export {
   AgentBridge,
-  SlackAdapter
+  ResendAdapter,
+  SlackAdapter,
+  buildReplyHeaders,
+  buildReplySubject,
+  deriveRootMessageId,
+  extractDisplayName,
+  extractEmailAddress,
+  markdownToEmailHtml,
+  matchesSenderPattern,
+  parseReferences,
+  stripQuotedReply
 };