@agenticmail/enterprise 0.5.325 → 0.5.326

package/dist/agent-heartbeat-4RWHZR7H.js

@@ -1,510 +0,0 @@
-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-LRRLXIZR.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
-};