@agenticmail/enterprise 0.5.378 → 0.5.379

package/dist/agent-heartbeat-VKF257FY.js

@@ -0,0 +1,510 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/engine/agent-heartbeat.ts
+var DEFAULT_SETTINGS = {
+  enabled: true,
+  baseIntervalMs: 5 * 6e4,
+  // 5 minutes
+  maxIntervalMs: 30 * 6e4,
+  // 30 minutes
+  dampingFactor: 0.5,
+  maxBatchSize: 5,
+  quietHoursStart: 23,
+  quietHoursEnd: 8
+};
+function createUnreadEmailCheck() {
+  return {
+    id: "unread_emails",
+    name: "Unread Emails",
+    intervalMs: 10 * 6e4,
+    // 10 minutes
+    priority: "high",
+    requiresClockIn: false,
+    // emails can be urgent outside hours
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_memory 
+           WHERE agent_id = $1 
+           AND category = 'processed_email' 
+           AND created_at > NOW() - INTERVAL '4 hours'`,
+          [ctx.agentId]
+        );
+        const processedRecently = parseInt(rows?.[0]?.cnt || "0");
+        const lastProcessed = await ctx.db.query(
+          `SELECT MAX(created_at) as last_at FROM agent_memory 
+           WHERE agent_id = $1 AND category = 'processed_email'`,
+          [ctx.agentId]
+        );
+        const lastAt = lastProcessed?.[0]?.last_at;
+        if (ctx.isWorkHours && processedRecently === 0 && ctx.hour >= 10) {
+          return {
+            needsAction: true,
+            summary: "No emails processed in the last 4 hours during work hours. Check inbox.",
+            priority: "medium",
+            data: { lastProcessedAt: lastAt }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createUpcomingEventsCheck() {
+  return {
+    id: "upcoming_events",
+    name: "Upcoming Calendar Events",
+    intervalMs: 15 * 6e4,
+    // 15 minutes
+    priority: "high",
+    requiresClockIn: false,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const _twoHoursFromNow = new Date(ctx.now.getTime() + 2 * 60 * 60 * 1e3).toISOString();
+        const rows = await ctx.db.query(
+          `SELECT content FROM agent_memory 
+           WHERE agent_id = $1 
+           AND category = 'context' 
+           AND content LIKE '%meeting%' 
+           AND created_at > NOW() - INTERVAL '24 hours'
+           ORDER BY created_at DESC LIMIT 5`,
+          [ctx.agentId]
+        );
+        const upcomingMeetings = (rows || []).filter((r) => {
+          const content = r.content || "";
+          return content.includes("meeting") || content.includes("event");
+        });
+        if (upcomingMeetings.length > 0) {
+          return {
+            needsAction: true,
+            summary: `${upcomingMeetings.length} potential upcoming event(s). Agent should check Google Calendar.`,
+            priority: "high",
+            data: { count: upcomingMeetings.length }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createStaleSessionsCheck() {
+  return {
+    id: "stale_sessions",
+    name: "Stale Sessions",
+    intervalMs: 30 * 6e4,
+    // 30 minutes
+    priority: "medium",
+    requiresClockIn: true,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 
+           AND status = 'active' 
+           AND updated_at < NOW() - INTERVAL '2 hours'`,
+          [ctx.agentId]
+        );
+        const staleCount = parseInt(rows?.[0]?.cnt || "0");
+        if (staleCount > 0) {
+          return {
+            needsAction: true,
+            summary: `${staleCount} stale session(s) detected (active > 2 hours with no updates). May need cleanup.`,
+            priority: "medium",
+            data: { staleCount }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createMemoryHealthCheck() {
+  return {
+    id: "memory_health",
+    name: "Memory Health",
+    intervalMs: 60 * 6e4,
+    // 1 hour
+    priority: "low",
+    requiresClockIn: true,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_memory 
+           WHERE agent_id = $1 AND created_at > NOW() - INTERVAL '24 hours'`,
+          [ctx.agentId]
+        );
+        const recentCount = parseInt(rows?.[0]?.cnt || "0");
+        if (recentCount > 200) {
+          return {
+            needsAction: true,
+            summary: `Memory flood detected: ${recentCount} memories in 24h (threshold: 200). Consider pruning.`,
+            priority: "medium",
+            data: { recentCount }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createUnansweredChatCheck() {
+  return {
+    id: "unanswered_chat",
+    name: "Unanswered Chat Messages",
+    intervalMs: 5 * 6e4,
+    // 5 minutes
+    priority: "high",
+    requiresClockIn: false,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 
+           AND status = 'failed'
+           AND metadata::text LIKE '%chat%'
+           AND created_at > NOW() - INTERVAL '1 hour'`,
+          [ctx.agentId]
+        );
+        const failedChats = parseInt(rows?.[0]?.cnt || "0");
+        if (failedChats > 0) {
+          return {
+            needsAction: true,
+            summary: `${failedChats} failed chat session(s) in the last hour. Messages may be unanswered.`,
+            priority: "urgent",
+            data: { failedChats }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createTaskDeadlineCheck() {
+  return {
+    id: "task_deadlines",
+    name: "Task Deadlines",
+    intervalMs: 60 * 6e4,
+    // 1 hour
+    priority: "medium",
+    requiresClockIn: true,
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const rows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_memory 
+           WHERE agent_id = $1 
+           AND category = 'context'
+           AND importance = 'high'
+           AND content LIKE '%deadline%'
+           AND created_at > NOW() - INTERVAL '48 hours'`,
+          [ctx.agentId]
+        );
+        const urgentTasks = parseInt(rows?.[0]?.cnt || "0");
+        if (urgentTasks > 0) {
+          return {
+            needsAction: true,
+            summary: `${urgentTasks} task(s) with approaching deadlines. Agent should review and prioritize.`,
+            priority: "high",
+            data: { urgentTasks }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+function createErrorRateCheck() {
+  return {
+    id: "error_rate",
+    name: "Error Rate Monitor",
+    intervalMs: 15 * 6e4,
+    // 15 minutes
+    priority: "high",
+    requiresClockIn: false,
+    // errors can happen anytime
+    consecutiveNoOps: 0,
+    enabled: true,
+    check: async (ctx) => {
+      try {
+        const totalRows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 AND created_at > NOW() - INTERVAL '1 hour'`,
+          [ctx.agentId]
+        );
+        const failedRows = await ctx.db.query(
+          `SELECT COUNT(*) as cnt FROM agent_sessions 
+           WHERE agent_id = $1 AND status = 'failed' AND created_at > NOW() - INTERVAL '1 hour'`,
+          [ctx.agentId]
+        );
+        const total = parseInt(totalRows?.[0]?.cnt || "0");
+        const failed = parseInt(failedRows?.[0]?.cnt || "0");
+        if (total >= 3 && failed / total > 0.5) {
+          return {
+            needsAction: true,
+            summary: `High error rate: ${failed}/${total} sessions failed in the last hour (${Math.round(failed / total * 100)}%). Possible infrastructure issue.`,
+            priority: "urgent",
+            data: { total, failed, rate: failed / total }
+          };
+        }
+        return { needsAction: false, priority: "low" };
+      } catch {
+        return { needsAction: false, priority: "low" };
+      }
+    }
+  };
+}
+var AgentHeartbeatManager = class {
+  config;
+  settings;
+  checks = /* @__PURE__ */ new Map();
+  tickTimer = null;
+  globalConsecutiveNoOps = 0;
+  lastActionTimestamp = 0;
+  stats = {
+    totalTicks: 0,
+    totalChecksRun: 0,
+    totalActionsTriggered: 0,
+    totalTokensSaved: 0,
+    // estimated tokens NOT spent due to no-op ticks
+    startedAt: Date.now()
+  };
+  constructor(config, settings) {
+    this.config = config;
+    this.settings = { ...DEFAULT_SETTINGS, ...settings };
+    this.registerCheck(createUnreadEmailCheck());
+    this.registerCheck(createUpcomingEventsCheck());
+    this.registerCheck(createStaleSessionsCheck());
+    this.registerCheck(createMemoryHealthCheck());
+    this.registerCheck(createUnansweredChatCheck());
+    this.registerCheck(createTaskDeadlineCheck());
+    this.registerCheck(createErrorRateCheck());
+    if (config.enabledChecks) {
+      for (const [id, enabled] of Object.entries(config.enabledChecks)) {
+        const check = this.checks.get(id);
+        if (check) check.enabled = enabled;
+      }
+    }
+  }
+  registerCheck(check) {
+    this.checks.set(check.id, check);
+  }
+  async start() {
+    if (!this.settings.enabled) {
+      console.log("[heartbeat] Disabled, skipping");
+      return;
+    }
+    console.log(`[heartbeat] Starting with ${this.checks.size} checks, base interval ${this.settings.baseIntervalMs / 1e3}s`);
+    setTimeout(() => this.tick(), 6e4);
+    this.scheduleNextTick();
+  }
+  stop() {
+    if (this.tickTimer) {
+      clearTimeout(this.tickTimer);
+      this.tickTimer = null;
+    }
+    console.log(`[heartbeat] Stopped. Stats: ${this.stats.totalTicks} ticks, ${this.stats.totalChecksRun} checks, ${this.stats.totalActionsTriggered} actions, ~${this.stats.totalTokensSaved} tokens saved`);
+  }
+  getStats() {
+    return {
+      ...this.stats,
+      uptimeMs: Date.now() - this.stats.startedAt,
+      currentIntervalMs: this.calculateInterval(),
+      globalConsecutiveNoOps: this.globalConsecutiveNoOps,
+      checks: Array.from(this.checks.values()).map((c) => ({
+        id: c.id,
+        name: c.name,
+        enabled: c.enabled,
+        lastRunAt: c.lastRunAt,
+        lastActionAt: c.lastActionAt,
+        consecutiveNoOps: c.consecutiveNoOps
+      }))
+    };
+  }
+  // ─── Core Tick Logic ────────────────────────────────
+  async tick() {
+    this.stats.totalTicks++;
+    const now = /* @__PURE__ */ new Date();
+    const tz = this.config.timezone || "UTC";
+    const localTime = new Date(now.toLocaleString("en-US", { timeZone: tz }));
+    const hour = localTime.getHours();
+    const minute = localTime.getMinutes();
+    const dayOfWeek = localTime.getDay();
+    const isWorkHours = this.isWithinWorkHours(hour, minute, dayOfWeek);
+    const isQuietHours = this.isQuietHours(hour);
+    const isClockedIn = this.config.isClockedIn();
+    const ctx = {
+      agentId: this.config.agentId,
+      orgId: this.config.orgId,
+      agentName: this.config.agentName,
+      role: this.config.role,
+      managerEmail: this.config.managerEmail,
+      timezone: tz,
+      db: this.config.db,
+      now,
+      localTime,
+      hour,
+      minute,
+      dayOfWeek,
+      isWorkHours,
+      isClockedIn
+    };
+    const actionableItems = [];
+    for (const check of this.checks.values()) {
+      if (!check.enabled) continue;
+      if (check.requiresClockIn && !isClockedIn) continue;
+      if (isQuietHours && check.priority !== "high") continue;
+      const adaptiveInterval = Math.min(
+        check.intervalMs * (1 + this.settings.dampingFactor * check.consecutiveNoOps),
+        this.settings.maxIntervalMs
+      );
+      const timeSinceLastRun = now.getTime() - (check.lastRunAt || 0);
+      if (timeSinceLastRun < adaptiveInterval) continue;
+      this.stats.totalChecksRun++;
+      check.lastRunAt = now.getTime();
+      try {
+        const result = await check.check(ctx);
+        if (result.needsAction) {
+          actionableItems.push({ check, result });
+          check.consecutiveNoOps = 0;
+          check.lastActionAt = now.getTime();
+        } else {
+          check.consecutiveNoOps++;
+          this.stats.totalTokensSaved += 500;
+        }
+      } catch (err) {
+        console.warn(`[heartbeat] Check ${check.id} error: ${err.message}`);
+        check.consecutiveNoOps++;
+      }
+    }
+    if (actionableItems.length > 0) {
+      this.globalConsecutiveNoOps = 0;
+      this.lastActionTimestamp = now.getTime();
+      this.stats.totalActionsTriggered++;
+      const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+      actionableItems.sort((a, b) => priorityOrder[a.result.priority] - priorityOrder[b.result.priority]);
+      const batch = actionableItems.slice(0, this.settings.maxBatchSize);
+      await this.dispatchBatch(batch, ctx);
+    } else {
+      this.globalConsecutiveNoOps++;
+    }
+    this.scheduleNextTick();
+  }
+  /**
+   * Calculate next tick interval using damped oscillator model:
+   *   interval = base * (1 + damping * consecutiveNoOps)
+   * 
+   * With fibonacci-like acceleration:
+   *   After 0 no-ops:  5min  (base)
+   *   After 1 no-op:   7.5min
+   *   After 2 no-ops:  10min
+   *   After 4 no-ops:  15min
+   *   After 8 no-ops:  25min
+   *   After 10 no-ops: 30min (max)
+   * 
+   * Resets to base immediately when action is detected.
+   */
+  calculateInterval() {
+    const base = this.settings.baseIntervalMs;
+    const max = this.settings.maxIntervalMs;
+    const damping = this.settings.dampingFactor;
+    const noOps = this.globalConsecutiveNoOps;
+    return Math.min(base * (1 + damping * noOps), max);
+  }
+  scheduleNextTick() {
+    if (this.tickTimer) clearTimeout(this.tickTimer);
+    const interval = this.calculateInterval();
+    this.tickTimer = setTimeout(() => this.tick(), interval);
+    this.tickTimer.unref();
+  }
+  isWithinWorkHours(hour, minute, dayOfWeek) {
+    const schedule = this.config.schedule;
+    if (!schedule) return true;
+    const isWorkday = schedule.days.includes(dayOfWeek);
+    const timeStr = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+    const isWithinHours = timeStr >= schedule.start && timeStr < schedule.end;
+    return isWorkday && isWithinHours;
+  }
+  isQuietHours(hour) {
+    const start = this.settings.quietHoursStart;
+    const end = this.settings.quietHoursEnd;
+    if (start === void 0 || end === void 0) return false;
+    if (start > end) {
+      return hour >= start || hour < end;
+    }
+    return hour >= start && hour < end;
+  }
+  /**
+   * Dispatch a batch of actionable items to the agent via one LLM session.
+   * This is the ONLY place tokens are spent.
+   */
+  async dispatchBatch(items, ctx) {
+    if (!this.config.runtime) {
+      console.warn("[heartbeat] No runtime \u2014 cannot dispatch actions");
+      return;
+    }
+    try {
+      const { guardrails } = await import("./routes-K2GAVUXI.js");
+      const status = await guardrails.getStatus(ctx.agentId);
+      if (status.paused || status.offDuty) {
+        console.log(`[heartbeat] Skipping action dispatch \u2014 agent is ${status.offDuty ? "off duty" : "paused"}`);
+        return;
+      }
+    } catch {
+    }
+    const summaries = items.map(
+      (item, i) => `${i + 1}. [${item.result.priority.toUpperCase()}] ${item.check.name}: ${item.result.summary}`
+    ).join("\n");
+    const prompt = `HEARTBEAT ALERT \u2014 The following ${items.length} item(s) need your attention:
+
+${summaries}
+
+For each item, take the appropriate action:
+- For unread emails: Check your inbox with gmail_search and respond to any urgent ones.
+- For upcoming events: Check google_calendar_list for the next 2 hours and prepare.
+- For stale sessions: Review and close any stuck sessions.
+- For unanswered chats: Check Google Chat and respond.
+- For error rate issues: Investigate recent failures and notify your manager if critical.
+- For task deadlines: Review google_tasks_list and prioritize.
+- For memory health: Consider pruning old or low-importance memories.
+
+Be efficient \u2014 handle what you can and note what needs human intervention.
+If something needs your manager's attention, email ${ctx.managerEmail || "your manager"}.`;
+    const systemPrompt = `You are ${ctx.agentName}, a ${ctx.role}. This is an automated heartbeat check \u2014 items flagged as needing attention. Handle them efficiently. Don't create unnecessary work \u2014 only act on what's genuinely important.`;
+    try {
+      const session = await this.config.runtime.spawnSession({
+        agentId: ctx.agentId,
+        message: prompt,
+        systemPrompt
+      });
+      console.log(`[heartbeat] \u2705 Action session ${session.id} dispatched (${items.length} items: ${items.map((i) => i.check.id).join(", ")})`);
+    } catch (err) {
+      console.error(`[heartbeat] Failed to dispatch action: ${err.message}`);
+    }
+  }
+};
+export {
+  AgentHeartbeatManager
+};

package/dist/{agent-tools-GJUIPPHV.js → agent-tools-2XUSIG4S.js}

@@ -28,11 +28,11 @@ import {
 import {
   createTelegramTools,
   init_telegram
-} from "./chunk-EX6FQSEV.js";
+} from "./chunk-REAJCMQE.js";
 import {
   createWhatsAppTools,
   init_whatsapp
-} from "./chunk-4WLIQQ5L.js";
+} from "./chunk-BUKTZ35L.js";
 import {
   MemorySearchIndex,
   init_text_search

package/dist/{chunk-VPWGFA5K.js → chunk-ACP7QSXU.js}

@@ -7103,7 +7103,7 @@ function createAgentRoutes(opts) {
       }
       const managedAgent = await lifecycle2.createAgent(orgId, config, actor);
       try {
-        const { knowledgeBase: kbEngine } = await import("./routes-NIQHEAV2.js");
+        const { knowledgeBase: kbEngine } = await import("./routes-K2GAVUXI.js");
         const allKbs = kbEngine.getAllKnowledgeBases();
         const clientOrgId = managedAgent?.clientOrgId || config?.clientOrgId || null;
         let kbAssigned = 0;
@@ -8862,7 +8862,7 @@ function createAgentRoutes(opts) {
     try {
       const body = await c.req.json().catch(() => ({}));
       const mode = body.mode || "";
-      const { createWhatsAppTools } = await import("./whatsapp-32CNVRFX.js");
+      const { createWhatsAppTools } = await import("./whatsapp-RAQUV6ZL.js");
       const dataDir = process.env.DATA_DIR || "/tmp/agenticmail-data";
       const connId = mode === "business" ? `biz-${agentId}` : agentId;
       const connDir = mode === "business" ? `${dataDir}/agents/${agentId}/whatsapp-business` : `${dataDir}/agents/${agentId}/whatsapp`;
@@ -8879,7 +8879,7 @@ function createAgentRoutes(opts) {
     const agentId = c.req.param("id");
     const mode = c.req.query("mode") || "";
     try {
-      const { getConnectionStatus } = await import("./whatsapp-32CNVRFX.js");
+      const { getConnectionStatus } = await import("./whatsapp-RAQUV6ZL.js");
       const connId = mode === "business" ? `biz-${agentId}` : agentId;
       return c.json(getConnectionStatus(connId));
     } catch {
@@ -8892,7 +8892,7 @@ function createAgentRoutes(opts) {
       const body = await c.req.json().catch(() => ({}));
       const mode = body.mode || "";
       const connId = mode === "business" ? `biz-${agentId}` : agentId;
-      const { sendTestMessage } = await import("./whatsapp-32CNVRFX.js");
+      const { sendTestMessage } = await import("./whatsapp-RAQUV6ZL.js");
       const result = await sendTestMessage(connId, body.to);
       return c.json(result);
     } catch (err) {
@@ -8903,7 +8903,7 @@ function createAgentRoutes(opts) {
     const agentId = c.req.param("id");
     try {
       const body = await c.req.json();
-      const { getConnection } = await import("./whatsapp-32CNVRFX.js");
+      const { getConnection } = await import("./whatsapp-RAQUV6ZL.js");
       const conn = getConnection(agentId);
       if (!conn?.connected) return c.json({ error: "Not connected" }, 503);
       const toJid = (to) => to?.includes("@") ? to : (to || "").replace(/[^0-9]/g, "") + "@s.whatsapp.net";
@@ -8947,7 +8947,7 @@ function createAgentRoutes(opts) {
     try {
       const body = await c.req.json().catch(() => ({}));
       const mode = body.mode || "";
-      const { createWhatsAppTools } = await import("./whatsapp-32CNVRFX.js");
+      const { createWhatsAppTools } = await import("./whatsapp-RAQUV6ZL.js");
       const dataDir = process.env.DATA_DIR || "/tmp/agenticmail-data";
       const connId = mode === "business" ? `biz-${agentId}` : agentId;
       const connDir = mode === "business" ? `${dataDir}/agents/${agentId}/whatsapp-business` : `${dataDir}/agents/${agentId}/whatsapp`;
@@ -22917,7 +22917,7 @@ var init_messaging_poller = __esm({
             await this.startWhatsApp(ep);
           }
           try {
-            var { autoStartConnections } = await import("./whatsapp-32CNVRFX.js");
+            var { autoStartConnections } = await import("./whatsapp-RAQUV6ZL.js");
             await autoStartConnections(agentEndpoints.map((a) => ({ id: a.id, dataDir: a.dataDir })));
           } catch (err) {
             console.error("[messaging] WhatsApp auto-start failed:", err.message);
@@ -22995,7 +22995,7 @@ var init_messaging_poller = __esm({
       // ─── WhatsApp (event-driven — Baileys WebSocket) ──
       async startWhatsApp(agent) {
         try {
-          var { onWhatsAppMessage } = await import("./whatsapp-32CNVRFX.js");
+          var { onWhatsAppMessage } = await import("./whatsapp-RAQUV6ZL.js");
           var unsub = onWhatsAppMessage(agent.id, (msg) => {
             var waMediaFiles;
             if (msg.mediaPath && msg.mediaType) {
@@ -23021,7 +23021,7 @@ var init_messaging_poller = __esm({
       }
       // ─── Telegram (webhook preferred, polling fallback) ─
       async startTelegram(botToken, agent) {
-        var { setTelegramWebhook, deleteTelegramWebhook, getTelegramWebhookInfo } = await import("./telegram-QRNGRT5M.js");
+        var { setTelegramWebhook, deleteTelegramWebhook, getTelegramWebhookInfo } = await import("./telegram-NG7PNNIN.js");
         var { randomBytes: randomBytes2 } = await import("crypto");
         var webhookSecret = randomBytes2(32).toString("hex");
         if (this.config.publicUrl && this.config.app) {
@@ -23092,7 +23092,7 @@ var init_messaging_poller = __esm({
           offset = await loadOffset();
           while (running && this.running) {
             try {
-              var { pollTelegramUpdates } = await import("./telegram-QRNGRT5M.js");
+              var { pollTelegramUpdates } = await import("./telegram-NG7PNNIN.js");
               var { updates, nextOffset } = await pollTelegramUpdates(botToken, offset, 25);
               if (nextOffset > offset) {
                 offset = nextOffset;
@@ -23468,7 +23468,7 @@ ${desc}` : desc;
             var typingJson = await typingResp.json();
             console.log(`[messaging] Telegram typing sent to ${chatId}: ${JSON.stringify(typingJson)}`);
           } else if (ctx.source === "whatsapp") {
-            var { getConnection } = await import("./whatsapp-32CNVRFX.js");
+            var { getConnection } = await import("./whatsapp-RAQUV6ZL.js");
             var conn = getConnection(agent.id);
             if (!conn?.connected) return;
             var jid = ctx.senderId.includes("@") ? ctx.senderId : ctx.senderId.replace(/[^0-9]/g, "") + "@s.whatsapp.net";
@@ -23483,7 +23483,7 @@ ${desc}` : desc;
       async sendDirectReply(agent, ctx, text) {
         try {
           if (ctx.source === "whatsapp") {
-            var { getConnection } = await import("./whatsapp-32CNVRFX.js");
+            var { getConnection } = await import("./whatsapp-RAQUV6ZL.js");
             var conn = getConnection(agent.id);
             if (!conn?.connected) return;
             var jid = ctx.senderId.includes("@") ? ctx.senderId : ctx.senderId.replace(/[^0-9]/g, "") + "@s.whatsapp.net";

package/dist/{chunk-4WLIQQ5L.js → chunk-BUKTZ35L.js}

@@ -6,6 +6,10 @@ import {
 import { join } from "path";
 import { mkdir, readFile, stat } from "fs/promises";
 import { EventEmitter } from "events";
+function stripMarkdown(text) {
+  if (!text) return text;
+  return text.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/~~(.+?)~~/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/```[\s\S]*?```/g, (m) => m.replace(/```\w*\n?/g, "").trim()).replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim();
+}
 async function hasAuthState(config) {
   try {
     var authDir = join(config.dataDir, "auth");
@@ -274,11 +278,12 @@ function createWhatsAppTools(config) {
         var conn = connections.get(config.agentId);
         if (conn?.connected) {
           var jid = toJid(input.to);
+          var cleanText = stripMarkdown(input.text);
           try {
             await conn?.sock?.sendPresenceUpdate("composing", jid);
           } catch {
           }
-          var r = await conn.sock.sendMessage(jid, { text: input.text });
+          var r = await conn.sock.sendMessage(jid, { text: cleanText });
           try {
             await conn?.sock?.sendPresenceUpdate("paused", jid);
           } catch {
@@ -289,7 +294,7 @@ function createWhatsAppTools(config) {
           }
           return { ok: true, id: r?.key?.id };
         }
-        return proxySend(config.agentId, { to: input.to, text: input.text });
+        return proxySend(config.agentId, { to: input.to, text: stripMarkdown(input.text) });
       }
     },
     {