@agenticmail/enterprise 0.5.436 → 0.5.438

package/dist/agent-heartbeat-XV3SGPBB.js

@@ -0,0 +1,518 @@
+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-6SKEEVVJ.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 {
+    }
+    try {
+      const activeCount = this.config.runtime.getActiveSessionCount?.() ?? 0;
+      if (activeCount > 0) {
+        console.log(`[heartbeat] Deferring action dispatch \u2014 ${activeCount} active session(s) running`);
+        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
+};