@agenticmail/enterprise 0.5.404 → 0.5.405

package/dist/chunk-MCVGSZJE.js

@@ -0,0 +1,4984 @@
+import {
+  buildRemotonPrompt
+} from "./chunk-WPM52NBU.js";
+import {
+  PROVIDER_REGISTRY,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-UF3ZJMJO.js";
+
+// src/runtime/index.ts
+import { nanoid as nanoid3 } from "nanoid";
+
+// src/runtime/session-manager.ts
+import { nanoid } from "nanoid";
+var SessionManager = class {
+  db;
+  constructor(config) {
+    this.db = config.engineDb;
+  }
+  /**
+   * Create a new session.
+   */
+  async createSession(agentId, orgId, parentSessionId) {
+    var id = nanoid(21);
+    var now = Date.now();
+    await this.db.run(
+      `INSERT INTO agent_sessions (id, agent_id, org_id, status, token_count, turn_count, parent_session_id, created_at, updated_at)
+       VALUES (?, ?, ?, 'active', 0, 0, ?, ?, ?)`,
+      [id, agentId, orgId, parentSessionId || null, now, now]
+    );
+    return {
+      id,
+      agentId,
+      orgId,
+      messages: [],
+      status: "active",
+      tokenCount: 0,
+      turnCount: 0,
+      createdAt: now,
+      updatedAt: now,
+      parentSessionId
+    };
+  }
+  /**
+   * Get a session by ID, including all messages.
+   */
+  async getSession(sessionId) {
+    var rows = await this.db.query(
+      `SELECT * FROM agent_sessions WHERE id = ?`,
+      [sessionId]
+    );
+    if (!rows || rows.length === 0) return null;
+    var row = rows[0];
+    var messages = await this.getMessages(sessionId);
+    return {
+      id: row.id,
+      agentId: row.agent_id,
+      orgId: row.org_id,
+      messages,
+      status: row.status,
+      tokenCount: row.token_count || 0,
+      turnCount: row.turn_count || 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      lastHeartbeatAt: row.last_heartbeat_at || row.updated_at,
+      parentSessionId: row.parent_session_id || void 0
+    };
+  }
+  /**
+   * Update session metadata (status, token count, turn count).
+   */
+  async updateSession(sessionId, updates) {
+    var setClauses = [];
+    var values = [];
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.tokenCount !== void 0) {
+      setClauses.push("token_count = ?");
+      values.push(updates.tokenCount);
+    }
+    if (updates.turnCount !== void 0) {
+      setClauses.push("turn_count = ?");
+      values.push(updates.turnCount);
+    }
+    if (updates.lastHeartbeatAt !== void 0) {
+      setClauses.push("last_heartbeat_at = ?");
+      values.push(updates.lastHeartbeatAt);
+    }
+    setClauses.push("updated_at = ?");
+    values.push(Date.now());
+    values.push(sessionId);
+    if (setClauses.length > 1) {
+      await this.db.run(
+        `UPDATE agent_sessions SET ${setClauses.join(", ")} WHERE id = ?`,
+        values
+      );
+    }
+  }
+  /**
+   * Append a message to a session.
+   */
+  async appendMessage(sessionId, message) {
+    var id = nanoid(21);
+    var now = Date.now();
+    var contentStr = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    var toolCallsStr = message.tool_calls ? JSON.stringify(message.tool_calls) : null;
+    var toolResultsStr = message.tool_results ? JSON.stringify(message.tool_results) : null;
+    await this.db.run(
+      `INSERT INTO agent_session_messages (id, session_id, role, content, tool_calls, tool_results, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [id, sessionId, message.role, contentStr, toolCallsStr, toolResultsStr, now]
+    );
+    await this.db.run(
+      `UPDATE agent_sessions SET updated_at = ? WHERE id = ?`,
+      [now, sessionId]
+    );
+  }
+  /**
+   * Append multiple messages at once.
+   */
+  async appendMessages(sessionId, messages) {
+    for (var msg of messages) {
+      await this.appendMessage(sessionId, msg);
+    }
+  }
+  /**
+   * List sessions for an agent.
+   */
+  async listSessions(agentId, opts) {
+    var conditions = ["agent_id = ?"];
+    var values = [agentId];
+    if (opts?.status) {
+      conditions.push("status = ?");
+      values.push(opts.status);
+    }
+    var limit = opts?.limit ?? 50;
+    var offset = opts?.offset ?? 0;
+    var rows = await this.db.query(
+      `SELECT * FROM agent_sessions WHERE ${conditions.join(" AND ")} ORDER BY updated_at DESC LIMIT ? OFFSET ?`,
+      [...values, limit, offset]
+    );
+    return (rows || []).map(function(row) {
+      return {
+        id: row.id,
+        agentId: row.agent_id,
+        orgId: row.org_id,
+        status: row.status,
+        tokenCount: row.token_count || 0,
+        turnCount: row.turn_count || 0,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        lastHeartbeatAt: row.last_heartbeat_at || row.updated_at,
+        parentSessionId: row.parent_session_id || void 0
+      };
+    });
+  }
+  /**
+   * Delete a session and all its messages.
+   */
+  async deleteSession(sessionId) {
+    await this.db.run(
+      `DELETE FROM agent_session_messages WHERE session_id = ?`,
+      [sessionId]
+    );
+    await this.db.run(
+      `DELETE FROM agent_sessions WHERE id = ?`,
+      [sessionId]
+    );
+  }
+  /**
+   * Compact a session by removing old messages and keeping a summary.
+   */
+  async compactSession(sessionId, keepLastN) {
+    var messages = await this.getMessages(sessionId);
+    var keep = keepLastN ?? 10;
+    if (messages.length <= keep) return;
+    await this.db.run(
+      `DELETE FROM agent_session_messages WHERE session_id = ?`,
+      [sessionId]
+    );
+    var recentMessages = messages.slice(-keep);
+    for (var msg of recentMessages) {
+      await this.appendMessage(sessionId, msg);
+    }
+  }
+  /**
+   * Replace all messages in a session.
+   */
+  async replaceMessages(sessionId, messages) {
+    await this.db.run(
+      `DELETE FROM agent_session_messages WHERE session_id = ?`,
+      [sessionId]
+    );
+    await this.appendMessages(sessionId, messages);
+  }
+  /**
+   * Find all active sessions (for resume on startup).
+   */
+  async findActiveSessions() {
+    var cutoff = new Date(Date.now() - 10 * 60 * 1e3).toISOString();
+    var rows = await this.db.query(
+      `SELECT * FROM agent_sessions WHERE status = 'active' OR status = 'resuming' OR (status = 'failed' AND updated_at > ?) ORDER BY updated_at DESC`,
+      [cutoff]
+    );
+    return (rows || []).map(function(row) {
+      return {
+        id: row.id,
+        agentId: row.agent_id,
+        orgId: row.org_id,
+        status: row.status,
+        tokenCount: row.token_count || 0,
+        turnCount: row.turn_count || 0,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        lastHeartbeatAt: row.last_heartbeat_at || row.updated_at,
+        parentSessionId: row.parent_session_id || void 0
+      };
+    });
+  }
+  /**
+   * Touch a session (heartbeat) — updates the heartbeat and updated_at timestamps.
+   */
+  async touchSession(sessionId, updates) {
+    var now = Date.now();
+    var setClauses = ["updated_at = ?", "last_heartbeat_at = ?"];
+    var values = [now, now];
+    if (updates?.tokenCount !== void 0) {
+      setClauses.push("token_count = ?");
+      values.push(updates.tokenCount);
+    }
+    if (updates?.turnCount !== void 0) {
+      setClauses.push("turn_count = ?");
+      values.push(updates.turnCount);
+    }
+    values.push(sessionId);
+    await this.db.run(
+      `UPDATE agent_sessions SET ${setClauses.join(", ")} WHERE id = ?`,
+      values
+    );
+  }
+  /**
+   * Mark sessions as failed if they haven't sent a heartbeat within the timeout period.
+   * Returns the IDs of sessions that were marked stale.
+   */
+  async markStaleSessions(timeoutMs) {
+    var cutoff = Date.now() - timeoutMs;
+    var rows = await this.db.query(
+      `SELECT id FROM agent_sessions WHERE status = 'active' AND (last_heartbeat_at < ? OR (last_heartbeat_at IS NULL AND updated_at < ?))`,
+      [cutoff, cutoff]
+    );
+    var staleIds = (rows || []).map(function(r) {
+      return r.id;
+    });
+    for (var id of staleIds) {
+      await this.db.run(
+        `UPDATE agent_sessions SET status = 'failed', updated_at = ? WHERE id = ?`,
+        [Date.now(), id]
+      );
+    }
+    return staleIds;
+  }
+  // ─── Private ─────────────────────────────────────
+  async getMessages(sessionId) {
+    var rows = await this.db.query(
+      `SELECT * FROM agent_session_messages WHERE session_id = ? ORDER BY created_at ASC`,
+      [sessionId]
+    );
+    return (rows || []).map(function(row) {
+      var content;
+      if (typeof row.content === "object" && row.content !== null) {
+        content = row.content;
+      } else {
+        try {
+          content = JSON.parse(row.content);
+        } catch {
+          content = row.content;
+        }
+      }
+      var toolCalls;
+      if (row.tool_calls) {
+        toolCalls = typeof row.tool_calls === "object" ? row.tool_calls : void 0;
+        if (!toolCalls) {
+          try {
+            toolCalls = JSON.parse(row.tool_calls);
+          } catch {
+          }
+        }
+      }
+      var toolResults;
+      if (row.tool_results) {
+        toolResults = typeof row.tool_results === "object" ? row.tool_results : void 0;
+        if (!toolResults) {
+          try {
+            toolResults = JSON.parse(row.tool_results);
+          } catch {
+          }
+        }
+      }
+      return {
+        role: row.role,
+        content,
+        tool_calls: toolCalls || void 0,
+        tool_results: toolResults || void 0
+      };
+    });
+  }
+};
+
+// src/runtime/hooks.ts
+var permissionCache = /* @__PURE__ */ new Map();
+var PERMISSION_CACHE_TTL_MS = 3e4;
+function getCachedPermission(cacheKey) {
+  var cached = permissionCache.get(cacheKey);
+  if (cached && cached.expires > Date.now()) return cached.result;
+  permissionCache.delete(cacheKey);
+  return null;
+}
+function setCachedPermission(cacheKey, result) {
+  permissionCache.set(cacheKey, { result, expires: Date.now() + PERMISSION_CACHE_TTL_MS });
+}
+var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
+  "ent_http_request",
+  "ent_http_graphql",
+  "ent_http_batch",
+  "ent_http_download",
+  "ent_email_send",
+  "ent_notification_send",
+  "ent_notification_broadcast",
+  "ent_notification_webhook",
+  "ent_notification_escalate",
+  "ent_workflow_request",
+  "ent_workflow_remind",
+  "ent_finance_expense",
+  "ent_finance_invoice",
+  "web_fetch",
+  "web_search",
+  "browser",
+  "agenticmail_reply",
+  "agenticmail_send",
+  "agenticmail_forward",
+  "bash"
+]);
+var COMMUNICATION_TOOLS = /* @__PURE__ */ new Set([
+  "agenticmail_reply",
+  "agenticmail_send",
+  "agenticmail_forward",
+  "ent_notification_send",
+  "ent_notification_broadcast",
+  "agent_message_send",
+  "agent_message_broadcast"
+]);
+function createRuntimeHooks(deps) {
+  var failMode = deps.failMode ?? "open";
+  return {
+    // ─── Before LLM Call ────────────────────────────
+    async beforeLLMCall(messages, agentId, _sessionId) {
+      var injectedMessages = [...messages];
+      if (deps.knowledgeBaseEnabled !== false) {
+        try {
+          var { knowledgeBase } = await import("./routes-UIUIEZKQ.js");
+          var kbs = await knowledgeBase.listForAgent(agentId);
+          if (kbs.length > 0) {
+            var contextParts = [];
+            for (var kb of kbs) {
+              var lastUserMsg = "";
+              for (var i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === "user") {
+                  lastUserMsg = typeof messages[i].content === "string" ? messages[i].content : "";
+                  break;
+                }
+              }
+              if (lastUserMsg) {
+                var results = await knowledgeBase.search(kb.id, lastUserMsg, { limit: 3 });
+                for (var r of results) {
+                  contextParts.push(`[KB: ${kb.name}] ${r.content}`);
+                }
+              }
+            }
+            if (contextParts.length > 0) {
+              var kbContext = `[Knowledge Base Context]
+${contextParts.join("\n\n")}`;
+              injectedMessages.splice(injectedMessages.length - 1, 0, {
+                role: "system",
+                content: kbContext
+              });
+            }
+          }
+        } catch {
+        }
+      }
+      if (deps.memoryEnabled !== false) {
+        try {
+          var { memoryManager } = await import("./routes-UIUIEZKQ.js");
+          var memories = await memoryManager.queryMemories({
+            agentId,
+            limit: 10,
+            sortBy: "importance"
+          });
+          if (memories.length > 0) {
+            var memoryContext = `[Agent Memory]
+${memories.map(function(m) {
+              return `- [${m.category}] ${m.title}: ${m.content.slice(0, 200)}`;
+            }).join("\n")}`;
+            injectedMessages.splice(injectedMessages.length - 1, 0, {
+              role: "system",
+              content: memoryContext
+            });
+          }
+        } catch {
+        }
+      }
+      if (deps.policyEnabled !== false) {
+        try {
+          var { policyEngine } = await import("./routes-UIUIEZKQ.js");
+          var policies = await policyEngine.getAgentPolicies(agentId, deps.orgId);
+          if (policies.length > 0) {
+            var policyText = policies.map(function(p) {
+              return `[Policy: ${p.name}] (${p.enforcement}) ${p.content.slice(0, 300)}`;
+            }).join("\n\n");
+            var policyContext = `[Organization Policies]
+You must follow these policies:
+
+${policyText}`;
+            var insertIdx = 0;
+            for (var j = 0; j < injectedMessages.length; j++) {
+              if (injectedMessages[j].role === "system") insertIdx = j + 1;
+              else break;
+            }
+            injectedMessages.splice(insertIdx, 0, { role: "system", content: policyContext });
+          }
+        } catch {
+        }
+      }
+      return injectedMessages;
+    },
+    // ─── Budget Check ──────────────────────────────
+    async checkBudget(agentId, _orgId, _estimatedTokens) {
+      try {
+        var { lifecycle } = await import("./routes-UIUIEZKQ.js");
+        var now = Date.now();
+        var cacheKey = `budget_sync_${agentId}`;
+        var lastSync = globalThis[cacheKey] || 0;
+        if (now - lastSync > 6e4) {
+          globalThis[cacheKey] = now;
+          try {
+            var freshAgent = await lifecycle.loadAgentFromDb(agentId);
+            if (freshAgent) {
+              var existingAgent = lifecycle.getAgent(agentId);
+              if (existingAgent) {
+                if (freshAgent.budgetConfig) {
+                  existingAgent.budgetConfig = freshAgent.budgetConfig;
+                }
+                if (freshAgent.usage) {
+                  existingAgent.usage = freshAgent.usage;
+                }
+                console.log(`[budget] Synced from DB \u2014 budget: daily=${freshAgent.budgetConfig?.dailyTokenCap || freshAgent.budgetConfig?.dailyTokens || 0}, monthly=${freshAgent.budgetConfig?.monthlyTokenCap || freshAgent.budgetConfig?.monthlyTokens || 0}, usage: tokensToday=${freshAgent.usage?.tokensToday || 0}, tokensMonth=${freshAgent.usage?.tokensThisMonth || freshAgent.usage?.monthlyTokens || 0}`);
+              }
+            }
+          } catch {
+          }
+        }
+        var usage = lifecycle.getUsage(agentId);
+        if (usage) {
+          var lastUpdated = usage.lastUpdated || "";
+          var todayKey = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+          var lastKey = lastUpdated ? new Date(lastUpdated).toISOString().slice(0, 10) : todayKey;
+          if (lastKey < todayKey) {
+            console.log(`[budget] Daily reset triggered for agent ${agentId} (last update: ${lastKey}, today: ${todayKey})`);
+            usage.tokensToday = 0;
+            usage.costToday = 0;
+            usage.errorsToday = 0;
+            usage.toolCallsToday = 0;
+            usage.externalActionsToday = 0;
+            usage.totalSessionsToday = 0;
+          }
+        }
+        var budget = lifecycle.getBudget(agentId);
+        if (!budget) return { allowed: true };
+        if (!usage) return { allowed: true };
+        var u = usage;
+        var b = budget;
+        var dailySpend = u.costToday ?? u.dailyCostUsd ?? 0;
+        var monthlySpend = u.costThisMonth ?? u.monthlyCostUsd ?? 0;
+        var _weeklySpend = u.costThisWeek ?? 0;
+        var dailyTokens = u.tokensToday ?? u.dailyTokens ?? 0;
+        var monthlyTokens = u.tokensThisMonth ?? u.monthlyTokens ?? 0;
+        var dailyCostLimit = b.dailyCostCap || b.dailyCost || b.dailyLimitUsd || 0;
+        var monthlyCostLimit = b.monthlyCostCap || b.monthlyCost || b.monthlyLimitUsd || 0;
+        var dailyTokenLimit = b.dailyTokenCap || b.dailyTokens || 0;
+        var monthlyTokenLimit = b.monthlyTokenCap || b.monthlyTokens || 0;
+        if (dailyCostLimit > 0 && dailySpend >= dailyCostLimit) {
+          return {
+            allowed: false,
+            reason: `Daily cost budget exceeded: $${dailySpend.toFixed(2)} / $${dailyCostLimit.toFixed(2)}`,
+            remainingUsd: 0
+          };
+        }
+        if (monthlyCostLimit > 0 && monthlySpend >= monthlyCostLimit) {
+          return {
+            allowed: false,
+            reason: `Monthly cost budget exceeded: $${monthlySpend.toFixed(2)} / $${monthlyCostLimit.toFixed(2)}`,
+            remainingUsd: 0
+          };
+        }
+        if (dailyTokenLimit > 0 && dailyTokens >= dailyTokenLimit) {
+          return {
+            allowed: false,
+            reason: `Daily token budget exceeded: ${(dailyTokens / 1e6).toFixed(1)}M / ${(dailyTokenLimit / 1e6).toFixed(1)}M tokens`,
+            remainingUsd: 0
+          };
+        }
+        if (monthlyTokenLimit > 0 && monthlyTokens >= monthlyTokenLimit) {
+          return {
+            allowed: false,
+            reason: `Monthly token budget exceeded: ${(monthlyTokens / 1e6).toFixed(1)}M / ${(monthlyTokenLimit / 1e6).toFixed(1)}M tokens`,
+            remainingUsd: 0
+          };
+        }
+        var remaining = Infinity;
+        if (dailyCostLimit > 0) remaining = Math.min(remaining, dailyCostLimit - dailySpend);
+        if (monthlyCostLimit > 0) remaining = Math.min(remaining, monthlyCostLimit - monthlySpend);
+        if (remaining === Infinity) remaining = 100;
+        return { allowed: true, remainingUsd: remaining };
+      } catch (err) {
+        console.error(`[hooks] Budget check failed: ${err.message}`);
+        return { allowed: false, reason: "Budget check error \u2014 denying for safety" };
+      }
+    },
+    // ─── Record LLM Usage ──────────────────────────
+    async recordLLMUsage(agentId, orgId, usage) {
+      try {
+        var { lifecycle } = await import("./routes-UIUIEZKQ.js");
+        console.log(`[hooks] recordLLMUsage: agent=${agentId}, input=${usage.inputTokens}, output=${usage.outputTokens}`);
+        await lifecycle.recordLLMUsage(agentId, {
+          inputTokens: usage.inputTokens,
+          outputTokens: usage.outputTokens,
+          costUsd: usage.costUsd
+        });
+      } catch (recordErr) {
+        console.log(`[hooks] recordLLMUsage error: ${recordErr.message}`);
+      }
+      try {
+        var { activity } = await import("./routes-UIUIEZKQ.js");
+        await activity.record({
+          agentId,
+          orgId,
+          type: "llm_call",
+          data: {
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            costUsd: usage.costUsd
+          }
+        });
+      } catch {
+      }
+    },
+    // ─── Model Pricing Lookup ──────────────────────
+    async getModelPricing(provider, modelId) {
+      try {
+        var adminDb = deps.engineDb;
+        var rows = await adminDb.query(
+          `SELECT model_pricing_config FROM company_settings LIMIT 1`,
+          []
+        );
+        if (rows && rows.length > 0) {
+          var raw = rows[0].model_pricing_config;
+          if (raw) {
+            var config = typeof raw === "string" ? JSON.parse(raw) : raw;
+            var models = config.models || [];
+            var match = models.find(function(m) {
+              return m.provider === provider && m.modelId === modelId;
+            });
+            if (match) {
+              return {
+                inputCostPerMillion: match.inputCostPerMillion,
+                outputCostPerMillion: match.outputCostPerMillion
+              };
+            }
+          }
+        }
+      } catch {
+      }
+      return null;
+    },
+    // ─── Before Tool Call ───────────────────────────
+    async beforeToolCall(ctx) {
+      try {
+        var cacheKey = `${ctx.agentId}:${ctx.toolName}`;
+        var cached = getCachedPermission(cacheKey);
+        if (cached) return cached;
+        var { permissionEngine } = await import("./routes-UIUIEZKQ.js");
+        var permResult = await permissionEngine.checkPermission(ctx.agentId, ctx.toolName);
+        var result = {
+          allowed: permResult.allowed,
+          reason: permResult.reason || "Permission check",
+          requiresApproval: permResult.requiresApproval || false
+        };
+        if (result.allowed && deps.guardrailsEnabled !== false) {
+          try {
+            var { guardrails } = await import("./routes-UIUIEZKQ.js");
+            var status = await guardrails.getStatus(ctx.agentId);
+            if (status.paused || status.offDuty) {
+              result.allowed = false;
+              result.reason = status.offDuty ? "Agent is off duty \u2014 outside scheduled working hours" : "Agent is paused by guardrail intervention";
+              return result;
+            }
+          } catch {
+          }
+        }
+        if (result.allowed && deps.dlpEnabled !== false && ctx.parameters) {
+          try {
+            var { dlp } = await import("./routes-UIUIEZKQ.js");
+            var dlpResult = await dlp.scanParameters({
+              orgId: ctx.orgId,
+              agentId: ctx.agentId,
+              toolId: ctx.toolName,
+              parameters: ctx.parameters
+            });
+            if (dlpResult && !dlpResult.allowed) {
+              result.allowed = false;
+              result.reason = dlpResult.reason || "Blocked by DLP policy";
+              return result;
+            }
+            if (dlpResult?.modifiedContent) {
+              result.modifiedParameters = dlpResult.modifiedContent;
+            }
+          } catch {
+          }
+        }
+        if (result.requiresApproval && result.allowed) {
+          try {
+            var { approvals } = await import("./routes-UIUIEZKQ.js");
+            var approval = await approvals.createAndWait({
+              agentId: ctx.agentId,
+              orgId: ctx.orgId,
+              toolId: ctx.toolName,
+              toolName: ctx.toolName,
+              parameters: ctx.parameters,
+              reason: `Agent ${ctx.agentId} requests approval for ${ctx.toolName}`
+            });
+            if (approval && (approval.status === "denied" || approval.status === "expired")) {
+              result.allowed = false;
+              result.reason = approval.status === "expired" ? "Approval request expired" : `Denied: ${approval.decision?.reason || "No reason"}`;
+            }
+            if (approval) result.approvalId = approval.id;
+          } catch {
+          }
+        }
+        setCachedPermission(cacheKey, result);
+        return result;
+      } catch (err) {
+        var allowed = failMode === "open";
+        return {
+          allowed,
+          reason: allowed ? `Hook error (fail-open): ${err.message}` : `Hook error (fail-closed): ${err.message}`
+        };
+      }
+    },
+    // ─── After Tool Call ────────────────────────────
+    async afterToolCall(ctx, result) {
+      try {
+        var { activity } = await import("./routes-UIUIEZKQ.js");
+        await activity.record({
+          agentId: ctx.agentId,
+          orgId: ctx.orgId,
+          sessionId: ctx.sessionId,
+          type: result.success ? "tool_call_end" : "tool_call_error",
+          data: {
+            toolId: ctx.toolName,
+            toolName: ctx.toolName,
+            success: result.success,
+            error: result.error,
+            durationMs: result.durationMs
+          }
+        });
+      } catch {
+      }
+      try {
+        var { lifecycle } = await import("./routes-UIUIEZKQ.js");
+        await lifecycle.recordToolCall(ctx.agentId, {
+          toolId: ctx.toolName,
+          tokensUsed: 0,
+          costUsd: 0,
+          isExternalAction: EXTERNAL_TOOLS.has(ctx.toolName),
+          error: !result.success
+        });
+      } catch {
+      }
+      if (result.success && EXTERNAL_TOOLS.has(ctx.toolName)) {
+        try {
+          var { journal } = await import("./routes-UIUIEZKQ.js");
+          await journal.record({
+            orgId: ctx.orgId,
+            agentId: ctx.agentId,
+            sessionId: ctx.sessionId,
+            toolId: ctx.toolName,
+            toolName: ctx.toolName,
+            parameters: ctx.parameters,
+            result: result.output
+          });
+        } catch {
+        }
+      }
+      if (result.success && COMMUNICATION_TOOLS.has(ctx.toolName)) {
+        try {
+          var { commBus } = await import("./routes-UIUIEZKQ.js");
+          await commBus.observeMessage({
+            orgId: ctx.orgId,
+            agentId: ctx.agentId,
+            toolId: ctx.toolName,
+            parameters: ctx.parameters
+          });
+        } catch {
+        }
+      }
+    },
+    // ─── Session Lifecycle ──────────────────────────
+    async onSessionStart(sessionId, agentId, orgId) {
+      try {
+        var { activity } = await import("./routes-UIUIEZKQ.js");
+        await activity.record({
+          agentId,
+          orgId,
+          sessionId,
+          type: "session_start",
+          data: { sessionId }
+        });
+      } catch {
+      }
+    },
+    async onSessionEnd(sessionId, agentId, orgId) {
+      try {
+        var { activity } = await import("./routes-UIUIEZKQ.js");
+        await activity.record({
+          agentId,
+          orgId,
+          sessionId,
+          type: "session_end",
+          data: { sessionId }
+        });
+      } catch {
+      }
+    },
+    // ─── Context Compaction ─────────────────────────
+    async onContextCompaction(sessionId, agentId, summary) {
+      try {
+        var { memoryManager } = await import("./routes-UIUIEZKQ.js");
+        await memoryManager.createMemory({
+          agentId,
+          orgId: deps.orgId,
+          category: "session_learning",
+          title: `Context compaction \u2014 session ${sessionId || "unknown"} (${(/* @__PURE__ */ new Date()).toISOString()})`,
+          content: summary.slice(0, 1e4),
+          // Keep up to 10K chars of summary
+          source: "context_compaction",
+          importance: "high"
+          // High importance — this is the agent's working memory
+        });
+      } catch (err) {
+        console.warn(`[hooks] Failed to persist compaction summary: ${err?.message}`);
+      }
+      try {
+        var { TaskQueueManager } = await import("./task-queue-Y2ERCCRY.js");
+        var tq = new TaskQueueManager();
+        tq.db = deps.engineDb;
+        await tq.init();
+        var sessionTask = await tq.getTaskBySessionId(sessionId);
+        if (sessionTask) {
+          await tq.updateTask(sessionTask.id, {
+            activityLog: [...sessionTask.activityLog || [], {
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              type: "compaction",
+              agent: agentId,
+              detail: `Context compacted (${summary.length} chars summary). Agent continues from compacted state.`
+            }]
+          });
+          console.log(`[hooks] Task ${sessionTask.id.slice(0, 8)} updated with compaction event`);
+        }
+      } catch {
+      }
+    }
+  };
+}
+function createNoopHooks() {
+  return {
+    async beforeLLMCall(messages) {
+      return messages;
+    },
+    async checkBudget() {
+      return { allowed: true };
+    },
+    async recordLLMUsage() {
+    },
+    async getModelPricing() {
+      return null;
+    },
+    async beforeToolCall() {
+      return { allowed: true, reason: "no-op" };
+    },
+    async afterToolCall() {
+    },
+    async onSessionStart() {
+    },
+    async onSessionEnd() {
+    },
+    async onContextCompaction() {
+    }
+  };
+}
+
+// src/runtime/llm-client.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateMessageTokens(messages) {
+  var total = 0;
+  for (var msg of messages) {
+    if (typeof msg.content === "string") {
+      total += estimateTokens(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (var block of msg.content) {
+        if (block.type === "text") total += estimateTokens(block.text);
+        else if (block.type === "thinking") total += estimateTokens(block.thinking);
+        else if (block.type === "tool_use") total += estimateTokens(JSON.stringify(block.input));
+        else if (block.type === "tool_result") {
+          var resultContent = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+          total += estimateTokens(resultContent);
+        }
+      }
+    }
+    if (msg.tool_calls) {
+      for (var tc of msg.tool_calls) {
+        total += estimateTokens(tc.name + JSON.stringify(tc.input));
+      }
+    }
+    if (msg.tool_results) {
+      for (var tr of msg.tool_results) {
+        total += estimateTokens(tr.content);
+      }
+    }
+  }
+  return total;
+}
+function convertToAnthropicMessages(messages) {
+  var result = [];
+  for (var msg of messages) {
+    if (msg.role === "system") continue;
+    if (msg.role === "user") {
+      if (msg.tool_results && msg.tool_results.length > 0) {
+        var toolResultBlocks = msg.tool_results.map(function(tr) {
+          return {
+            type: "tool_result",
+            tool_use_id: tr.tool_use_id,
+            content: tr.content,
+            is_error: tr.is_error || false
+          };
+        });
+        result.push({ role: "user", content: toolResultBlocks });
+      } else {
+        result.push({
+          role: "user",
+          content: typeof msg.content === "string" ? msg.content : msg.content
+        });
+      }
+    } else if (msg.role === "assistant") {
+      var content = [];
+      if (typeof msg.content === "string") {
+        if (msg.content) content.push({ type: "text", text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        content = msg.content.filter((b) => b.type !== "thinking");
+      }
+      if (msg.tool_calls) {
+        var existingToolIds = new Set(content.filter((b) => b.type === "tool_use").map((b) => b.id));
+        for (var tc of msg.tool_calls) {
+          if (!existingToolIds.has(tc.id)) {
+            content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+          }
+        }
+      }
+      if (content.length > 0) {
+        result.push({ role: "assistant", content });
+      }
+    }
+  }
+  return result;
+}
+function extractSystemPrompt(messages) {
+  var systemParts = [];
+  for (var msg of messages) {
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") {
+        systemParts.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (var block of msg.content) {
+          if (block.type === "text") systemParts.push(block.text);
+        }
+      }
+    }
+  }
+  return systemParts.join("\n\n");
+}
+async function callAnthropic(config, messages, tools, options, onEvent) {
+  var Anthropic;
+  try {
+    var mod = await import("@anthropic-ai/sdk");
+    Anthropic = mod.default || mod.Anthropic;
+  } catch {
+    throw new Error(
+      "Anthropic SDK not installed. Run: npm install @anthropic-ai/sdk"
+    );
+  }
+  var isOAuthToken = config.apiKey?.includes("sk-ant-oat") || false;
+  var useTokenAuth = config.authMode === "token" || isOAuthToken;
+  var clientOpts = {};
+  if (useTokenAuth) {
+    clientOpts.apiKey = null;
+    clientOpts.authToken = config.apiKey;
+    clientOpts.defaultHeaders = {
+      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+      "user-agent": "claude-cli/1.0.0 (external, cli)",
+      "x-app": "cli"
+    };
+  } else {
+    clientOpts.apiKey = config.apiKey;
+  }
+  if (config.baseUrl) {
+    clientOpts.baseURL = config.baseUrl;
+  }
+  var client = new Anthropic(clientOpts);
+  var systemPrompt = extractSystemPrompt(messages);
+  var anthropicMessages = convertToAnthropicMessages(messages);
+  var requestBody = {
+    model: config.modelId,
+    max_tokens: options.maxTokens,
+    temperature: options.temperature,
+    messages: anthropicMessages
+  };
+  if (systemPrompt) {
+    requestBody.system = systemPrompt;
+  }
+  if (tools.length > 0) {
+    requestBody.tools = tools.map(function(t) {
+      return { name: t.name, description: t.description, input_schema: t.input_schema };
+    });
+  }
+  if (config.thinkingLevel && config.thinkingLevel !== "off") {
+    var budgetMap = { low: 2048, medium: 8192, high: 16384 };
+    var budgetTokens = budgetMap[config.thinkingLevel] || 8192;
+    requestBody.thinking = {
+      type: "enabled",
+      budget_tokens: budgetTokens
+    };
+    if (requestBody.max_tokens <= budgetTokens) {
+      requestBody.max_tokens = budgetTokens + 4096;
+    }
+    requestBody.temperature = 1;
+  }
+  var events = [];
+  var toolCalls = [];
+  var textParts = [];
+  var thinkingParts = [];
+  var stopReason = "end_turn";
+  var usage = { inputTokens: 0, outputTokens: 0 };
+  var stream = client.messages.stream(requestBody, {
+    signal: options.signal
+  });
+  for await (var event of stream) {
+    if (event.type === "content_block_delta") {
+      var delta = event.delta;
+      if (delta.type === "text_delta") {
+        textParts.push(delta.text);
+        var textEvent = { type: "text_delta", text: delta.text };
+        events.push(textEvent);
+        onEvent?.(textEvent);
+      } else if (delta.type === "thinking_delta") {
+        thinkingParts.push(delta.thinking);
+        var thinkEvent = { type: "thinking_delta", text: delta.thinking };
+        events.push(thinkEvent);
+        onEvent?.(thinkEvent);
+      } else if (delta.type === "input_json_delta") {
+      }
+    } else if (event.type === "content_block_start") {
+      var block = event.content_block;
+      if (block?.type === "tool_use") {
+        var tcStartEvent = {
+          type: "tool_call_start",
+          toolName: block.name,
+          toolCallId: block.id
+        };
+        events.push(tcStartEvent);
+        onEvent?.(tcStartEvent);
+      }
+    } else if (event.type === "message_delta") {
+      var msgDelta = event.delta;
+      if (msgDelta.stop_reason) {
+        stopReason = msgDelta.stop_reason;
+      }
+      if (event.usage) {
+        usage.outputTokens += event.usage.output_tokens || 0;
+      }
+    } else if (event.type === "message_start") {
+      var message = event.message;
+      if (message?.usage) {
+        usage.inputTokens = message.usage.input_tokens || 0;
+        usage.outputTokens = message.usage.output_tokens || 0;
+      }
+    }
+  }
+  var finalMessage = await stream.finalMessage();
+  if (finalMessage.content) {
+    for (var block of finalMessage.content) {
+      if (block.type === "tool_use") {
+        var tuBlock = block;
+        toolCalls.push({
+          id: tuBlock.id,
+          name: tuBlock.name,
+          input: tuBlock.input || {}
+        });
+      }
+    }
+  }
+  if (finalMessage.usage) {
+    usage.inputTokens = finalMessage.usage.input_tokens;
+    usage.outputTokens = finalMessage.usage.output_tokens;
+  }
+  stopReason = finalMessage.stop_reason;
+  return {
+    events,
+    toolCalls,
+    textContent: textParts.join(""),
+    thinkingContent: thinkingParts.join(""),
+    stopReason,
+    usage
+  };
+}
+function convertToOpenAIMessages(messages) {
+  var result = [];
+  for (var msg of messages) {
+    if (msg.role === "system") {
+      result.push({
+        role: "system",
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+      });
+    } else if (msg.role === "user") {
+      if (msg.tool_results && msg.tool_results.length > 0) {
+        for (var tr of msg.tool_results) {
+          result.push({
+            role: "tool",
+            tool_call_id: tr.tool_use_id,
+            content: tr.content
+          });
+        }
+      } else {
+        result.push({
+          role: "user",
+          content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+        });
+      }
+    } else if (msg.role === "assistant") {
+      var entry = {
+        role: "assistant",
+        content: typeof msg.content === "string" ? msg.content : null
+      };
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        entry.tool_calls = msg.tool_calls.map(function(tc) {
+          return {
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.input) }
+          };
+        });
+      }
+      result.push(entry);
+    }
+  }
+  return result;
+}
+async function callOpenAICompatible(config, messages, tools, options, onEvent) {
+  var OpenAI;
+  try {
+    var mod = await import("openai");
+    OpenAI = mod.default || mod.OpenAI;
+  } catch {
+    throw new Error(
+      "OpenAI SDK not installed. Run: npm install openai"
+    );
+  }
+  var clientOpts = { apiKey: config.apiKey || "not-needed" };
+  if (config.baseURL) clientOpts.baseURL = config.baseURL;
+  if (config.headers) clientOpts.defaultHeaders = config.headers;
+  var client = new OpenAI(clientOpts);
+  var openaiMessages = convertToOpenAIMessages(messages);
+  var requestBody = {
+    model: config.modelId,
+    max_tokens: options.maxTokens,
+    temperature: options.temperature,
+    messages: openaiMessages,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+  if (tools.length > 0) {
+    requestBody.tools = tools.map(function(t) {
+      return {
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.input_schema
+        }
+      };
+    });
+  }
+  var events = [];
+  var toolCalls = [];
+  var textParts = [];
+  var stopReason = "end_turn";
+  var usage = { inputTokens: 0, outputTokens: 0 };
+  var partialToolCalls = /* @__PURE__ */ new Map();
+  var stream = await client.chat.completions.create(requestBody, {
+    signal: options.signal
+  });
+  for await (var chunk of stream) {
+    var choice = chunk.choices?.[0];
+    if (!choice) continue;
+    var delta = choice.delta;
+    if (delta?.content) {
+      textParts.push(delta.content);
+      var textEvent = { type: "text_delta", text: delta.content };
+      events.push(textEvent);
+      onEvent?.(textEvent);
+    }
+    if (delta?.tool_calls) {
+      for (var tcDelta of delta.tool_calls) {
+        var idx = tcDelta.index ?? 0;
+        if (!partialToolCalls.has(idx)) {
+          partialToolCalls.set(idx, {
+            id: tcDelta.id || "",
+            name: tcDelta.function?.name || "",
+            args: ""
+          });
+          if (tcDelta.function?.name) {
+            var tcStartEvent = {
+              type: "tool_call_start",
+              toolName: tcDelta.function.name,
+              toolCallId: tcDelta.id || ""
+            };
+            events.push(tcStartEvent);
+            onEvent?.(tcStartEvent);
+          }
+        }
+        var partial = partialToolCalls.get(idx);
+        if (tcDelta.id) partial.id = tcDelta.id;
+        if (tcDelta.function?.name) partial.name = tcDelta.function.name;
+        if (tcDelta.function?.arguments) partial.args += tcDelta.function.arguments;
+      }
+    }
+    if (choice.finish_reason) {
+      if (choice.finish_reason === "tool_calls") stopReason = "tool_use";
+      else if (choice.finish_reason === "length") stopReason = "max_tokens";
+      else if (choice.finish_reason === "stop") stopReason = "end_turn";
+    }
+    if (chunk.usage) {
+      usage.inputTokens = chunk.usage.prompt_tokens || 0;
+      usage.outputTokens = chunk.usage.completion_tokens || 0;
+    }
+  }
+  for (var [, partial] of partialToolCalls) {
+    var parsedInput = {};
+    try {
+      parsedInput = JSON.parse(partial.args || "{}");
+    } catch {
+    }
+    toolCalls.push({ id: partial.id, name: partial.name, input: parsedInput });
+  }
+  return {
+    events,
+    toolCalls,
+    textContent: textParts.join(""),
+    thinkingContent: "",
+    stopReason,
+    usage
+  };
+}
+function convertToGeminiContents(messages) {
+  var systemParts = [];
+  var contents = [];
+  for (var msg of messages) {
+    if (msg.role === "system") {
+      var text = typeof msg.content === "string" ? msg.content : "";
+      if (Array.isArray(msg.content)) {
+        for (var b of msg.content) {
+          if (b.type === "text") text += (text ? "\n" : "") + b.text;
+        }
+      }
+      if (text) systemParts.push({ text });
+      continue;
+    }
+    if (msg.role === "user") {
+      if (msg.tool_results && msg.tool_results.length > 0) {
+        var frParts = msg.tool_results.map(function(tr) {
+          return {
+            functionResponse: {
+              name: tr.tool_use_id,
+              response: { content: tr.content }
+            }
+          };
+        });
+        contents.push({ role: "user", parts: frParts });
+      } else {
+        var userText = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        contents.push({ role: "user", parts: [{ text: userText }] });
+      }
+    } else if (msg.role === "assistant") {
+      var parts = [];
+      if (typeof msg.content === "string" && msg.content) {
+        parts.push({ text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        for (var block of msg.content) {
+          if (block.type === "text") parts.push({ text: block.text });
+        }
+      }
+      if (msg.tool_calls) {
+        for (var tc of msg.tool_calls) {
+          parts.push({ functionCall: { name: tc.name, args: tc.input } });
+        }
+      }
+      if (parts.length > 0) contents.push({ role: "model", parts });
+    }
+  }
+  return {
+    systemInstruction: systemParts.length > 0 ? { parts: systemParts } : void 0,
+    contents
+  };
+}
+async function callGoogle(config, messages, tools, options, onEvent) {
+  var { systemInstruction, contents } = convertToGeminiContents(messages);
+  var requestBody = {
+    contents,
+    generationConfig: {
+      maxOutputTokens: options.maxTokens,
+      temperature: options.temperature
+    }
+  };
+  if (systemInstruction) {
+    requestBody.systemInstruction = systemInstruction;
+  }
+  if (tools.length > 0) {
+    requestBody.tools = [{
+      functionDeclarations: tools.map(function(t) {
+        return {
+          name: t.name,
+          description: t.description,
+          parameters: t.input_schema
+        };
+      })
+    }];
+  }
+  var url = `https://generativelanguage.googleapis.com/v1beta/models/${config.modelId}:streamGenerateContent?key=${config.apiKey}&alt=sse`;
+  var resp = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(requestBody),
+    signal: options.signal
+  });
+  if (!resp.ok) {
+    var errText = await resp.text().catch(function() {
+      return "";
+    });
+    var err = new Error(`Gemini API error ${resp.status}: ${errText}`);
+    err.status = resp.status;
+    throw err;
+  }
+  var events = [];
+  var toolCalls = [];
+  var textParts = [];
+  var stopReason = "end_turn";
+  var usage = { inputTokens: 0, outputTokens: 0 };
+  var toolCallCounter = 0;
+  var reader = resp.body.getReader();
+  var decoder = new TextDecoder();
+  var buffer = "";
+  while (true) {
+    var { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    var lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (var line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      var jsonStr = line.slice(6).trim();
+      if (!jsonStr || jsonStr === "[DONE]") continue;
+      var chunk;
+      try {
+        chunk = JSON.parse(jsonStr);
+      } catch {
+        continue;
+      }
+      var candidate = chunk.candidates?.[0];
+      if (!candidate) continue;
+      var cParts = candidate.content?.parts || [];
+      for (var part of cParts) {
+        if (part.text) {
+          textParts.push(part.text);
+          var textEvent = { type: "text_delta", text: part.text };
+          events.push(textEvent);
+          onEvent?.(textEvent);
+        }
+        if (part.functionCall) {
+          var tcId = "gemini_tc_" + ++toolCallCounter;
+          var tcStartEvent = {
+            type: "tool_call_start",
+            toolName: part.functionCall.name,
+            toolCallId: tcId
+          };
+          events.push(tcStartEvent);
+          onEvent?.(tcStartEvent);
+          toolCalls.push({
+            id: tcId,
+            name: part.functionCall.name,
+            input: part.functionCall.args || {}
+          });
+        }
+      }
+      if (candidate.finishReason) {
+        if (candidate.finishReason === "STOP") stopReason = "end_turn";
+        else if (candidate.finishReason === "MAX_TOKENS") stopReason = "max_tokens";
+        else if (candidate.finishReason === "TOOL_USE" || toolCalls.length > 0) stopReason = "tool_use";
+      }
+      if (chunk.usageMetadata) {
+        usage.inputTokens = chunk.usageMetadata.promptTokenCount || 0;
+        usage.outputTokens = chunk.usageMetadata.candidatesTokenCount || 0;
+      }
+    }
+  }
+  if (toolCalls.length > 0 && stopReason === "end_turn") {
+    stopReason = "tool_use";
+  }
+  return {
+    events,
+    toolCalls,
+    textContent: textParts.join(""),
+    thinkingContent: "",
+    stopReason,
+    usage
+  };
+}
+function convertToOllamaMessages(messages) {
+  var result = [];
+  for (var msg of messages) {
+    if (msg.role === "system") {
+      var text = typeof msg.content === "string" ? msg.content : "";
+      if (Array.isArray(msg.content)) {
+        for (var b of msg.content) {
+          if (b.type === "text") text += (text ? "\n" : "") + b.text;
+        }
+      }
+      result.push({ role: "system", content: text });
+    } else if (msg.role === "user") {
+      if (msg.tool_results && msg.tool_results.length > 0) {
+        for (var tr of msg.tool_results) {
+          result.push({ role: "tool", content: tr.content });
+        }
+      } else {
+        var userText = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        result.push({ role: "user", content: userText });
+      }
+    } else if (msg.role === "assistant") {
+      var entry = {
+        role: "assistant",
+        content: typeof msg.content === "string" ? msg.content : ""
+      };
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        entry.tool_calls = msg.tool_calls.map(function(tc) {
+          return {
+            function: { name: tc.name, arguments: tc.input }
+          };
+        });
+      }
+      result.push(entry);
+    }
+  }
+  return result;
+}
+async function callOllama(config, messages, tools, options, onEvent) {
+  var baseURL = config.baseURL || "http://localhost:11434";
+  var ollamaMessages = convertToOllamaMessages(messages);
+  var requestBody = {
+    model: config.modelId,
+    messages: ollamaMessages,
+    stream: true,
+    options: {
+      temperature: options.temperature,
+      num_predict: options.maxTokens
+    }
+  };
+  if (tools.length > 0) {
+    requestBody.tools = tools.map(function(t) {
+      return {
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.input_schema
+        }
+      };
+    });
+  }
+  var resp = await fetch(baseURL + "/api/chat", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(requestBody),
+    signal: options.signal
+  });
+  if (!resp.ok) {
+    var errText = await resp.text().catch(function() {
+      return "";
+    });
+    var err = new Error(`Ollama error ${resp.status}: ${errText}`);
+    err.status = resp.status;
+    throw err;
+  }
+  var events = [];
+  var toolCalls = [];
+  var textParts = [];
+  var stopReason = "end_turn";
+  var usage = { inputTokens: 0, outputTokens: 0 };
+  var toolCallCounter = 0;
+  var reader = resp.body.getReader();
+  var decoder = new TextDecoder();
+  var buffer = "";
+  while (true) {
+    var { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    var lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (var line of lines) {
+      var trimmed = line.trim();
+      if (!trimmed) continue;
+      var chunk;
+      try {
+        chunk = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (chunk.message?.content) {
+        textParts.push(chunk.message.content);
+        var textEvent = { type: "text_delta", text: chunk.message.content };
+        events.push(textEvent);
+        onEvent?.(textEvent);
+      }
+      if (chunk.message?.tool_calls) {
+        for (var tc of chunk.message.tool_calls) {
+          var tcId = "ollama_tc_" + ++toolCallCounter;
+          var tcStartEvent = {
+            type: "tool_call_start",
+            toolName: tc.function?.name || "",
+            toolCallId: tcId
+          };
+          events.push(tcStartEvent);
+          onEvent?.(tcStartEvent);
+          toolCalls.push({
+            id: tcId,
+            name: tc.function?.name || "",
+            input: tc.function?.arguments || {}
+          });
+        }
+      }
+      if (chunk.done) {
+        if (chunk.prompt_eval_count) usage.inputTokens = chunk.prompt_eval_count;
+        if (chunk.eval_count) usage.outputTokens = chunk.eval_count;
+      }
+    }
+  }
+  if (toolCalls.length > 0) {
+    stopReason = "tool_use";
+  }
+  return {
+    events,
+    toolCalls,
+    textContent: textParts.join(""),
+    thinkingContent: "",
+    stopReason,
+    usage
+  };
+}
+var DEFAULT_MAX_RETRY_DURATION_MS = 36e5;
+var DEFAULT_MAX_RETRIES = 200;
+var DEFAULT_BASE_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 6e4;
+function isRetryableError(err) {
+  var status = err.status || err.statusCode || err?.response?.status;
+  if (status === 400 || status === 401 || status === 403) {
+    return false;
+  }
+  if (status === 429 || status === 500 || status === 502 || status === 503) {
+    return true;
+  }
+  var message = String(err.message || err || "").toLowerCase();
+  if (message.includes("econnreset") || message.includes("etimedout") || message.includes("fetch failed") || message.includes("network") || message.includes("socket hang up") || message.includes("econnrefused")) {
+    return true;
+  }
+  return false;
+}
+function parseRetryAfterMs(err) {
+  var retryAfter = err.headers?.get?.("retry-after") || err.headers?.["retry-after"] || err.response?.headers?.get?.("retry-after") || err.response?.headers?.["retry-after"];
+  if (!retryAfter) return 0;
+  var seconds = Number(retryAfter);
+  if (!isNaN(seconds) && seconds > 0) {
+    return Math.ceil(seconds * 1e3);
+  }
+  var date = Date.parse(retryAfter);
+  if (!isNaN(date)) {
+    var delayMs = date - Date.now();
+    return delayMs > 0 ? delayMs : 0;
+  }
+  return 0;
+}
+async function callWithRetry(fn, retryConfig, onEvent) {
+  var maxDuration = retryConfig?.maxRetryDurationMs ?? DEFAULT_MAX_RETRY_DURATION_MS;
+  var maxRetries = retryConfig?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  var baseDelay = retryConfig?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  var maxDelay = retryConfig?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  var attempt = 0;
+  var startTime = Date.now();
+  while (true) {
+    try {
+      return await fn();
+    } catch (err) {
+      var elapsed = Date.now() - startTime;
+      if (!isRetryableError(err) || elapsed >= maxDuration || attempt >= maxRetries) {
+        throw err;
+      }
+      attempt++;
+      var retryAfterMs = parseRetryAfterMs(err);
+      var exponentialDelay = Math.min(
+        baseDelay * Math.pow(2, attempt - 1) + Math.random() * baseDelay,
+        maxDelay
+      );
+      var delayMs = retryAfterMs > 0 ? Math.max(retryAfterMs, exponentialDelay) : exponentialDelay;
+      var remainingMs = maxDuration - elapsed;
+      if (delayMs > remainingMs) {
+        delayMs = remainingMs;
+      }
+      var reason = err.message || String(err);
+      onEvent?.({
+        type: "retry",
+        attempt,
+        maxRetries,
+        delayMs: Math.round(delayMs),
+        reason
+      });
+      await new Promise(function(resolve) {
+        setTimeout(resolve, delayMs);
+      });
+    }
+  }
+}
+async function callLLM(config, messages, tools, options, onEvent, retryConfig) {
+  var invokeLLM = function() {
+    var providerDef = resolveProvider(config.provider);
+    var apiType = providerDef ? providerDef.apiType : "openai-compatible";
+    var baseURL = config.baseUrl || (providerDef ? providerDef.baseUrl : void 0);
+    switch (apiType) {
+      case "anthropic":
+        return callAnthropic(
+          { modelId: config.modelId, apiKey: config.apiKey, thinkingLevel: config.thinkingLevel, authMode: config.authMode, baseUrl: baseURL },
+          messages,
+          tools,
+          options,
+          onEvent
+        );
+      case "openai-compatible":
+        return callOpenAICompatible(
+          { modelId: config.modelId, apiKey: config.apiKey, baseURL, headers: config.headers },
+          messages,
+          tools,
+          options,
+          onEvent
+        );
+      case "google":
+        return callGoogle(
+          { modelId: config.modelId, apiKey: config.apiKey },
+          messages,
+          tools,
+          options,
+          onEvent
+        );
+      case "ollama":
+        return callOllama(
+          { modelId: config.modelId, baseURL },
+          messages,
+          tools,
+          options,
+          onEvent
+        );
+      default:
+        throw new Error(`Unsupported API type "${apiType}" for provider "${config.provider}"`);
+    }
+  };
+  return callWithRetry(invokeLLM, retryConfig, onEvent);
+}
+function toolsToDefinitions(tools) {
+  return tools.map(function(t) {
+    return {
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters || t.input_schema || { type: "object", properties: {} }
+    };
+  });
+}
+
+// src/runtime/tool-executor.ts
+var DEFAULT_TOOL_TIMEOUT_MS = 3e4;
+var MAX_RESULT_CHARS = 2e5;
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tools) {
+    for (var tool of tools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  clear() {
+    this.tools.clear();
+  }
+};
+async function executeTool(tool, toolCall, options) {
+  var timeoutMs = options?.timeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS;
+  var started = Date.now();
+  try {
+    var validationError = validateToolInput(tool, toolCall.input);
+    if (validationError) {
+      return {
+        result: { success: false, error: validationError, durationMs: Date.now() - started },
+        content: `Error: ${validationError}`
+      };
+    }
+    var toolResult = await executeWithTimeout(
+      tool.execute(toolCall.id, toolCall.input),
+      timeoutMs,
+      options?.signal
+    );
+    var content = formatToolResult(toolResult);
+    var durationMs = Date.now() - started;
+    return {
+      result: { success: true, output: content, durationMs },
+      content: truncateResult(content)
+    };
+  } catch (err) {
+    var durationMs = Date.now() - started;
+    var errorMessage = err?.message || String(err);
+    if (err?.name === "AbortError" || err?.name === "TimeoutError") {
+      errorMessage = `Tool "${tool.name}" timed out after ${timeoutMs}ms`;
+    }
+    return {
+      result: { success: false, error: errorMessage, durationMs },
+      content: `Error executing ${tool.name}: ${errorMessage}`
+    };
+  }
+}
+function validateToolInput(tool, input) {
+  var schema = tool.parameters;
+  if (!schema || !schema.required) return null;
+  for (var field of schema.required) {
+    if (input[field] === void 0 || input[field] === null) {
+      return `Missing required parameter: "${field}" for tool "${tool.name}"`;
+    }
+  }
+  if (schema.properties) {
+    for (var [key, prop] of Object.entries(schema.properties)) {
+      if (input[key] === void 0) continue;
+      var expectedType = prop.type;
+      var actualValue = input[key];
+      var actualType = typeof actualValue;
+      if (expectedType === "string" && actualType !== "string") {
+        return `Parameter "${key}" must be a string, got ${actualType}`;
+      }
+      if (expectedType === "number" && actualType !== "number") {
+        return `Parameter "${key}" must be a number, got ${actualType}`;
+      }
+      if (expectedType === "boolean" && actualType !== "boolean") {
+        return `Parameter "${key}" must be a boolean, got ${actualType}`;
+      }
+      if (expectedType === "array" && !Array.isArray(actualValue)) {
+        return `Parameter "${key}" must be an array`;
+      }
+    }
+  }
+  return null;
+}
+async function executeWithTimeout(promise, timeoutMs, signal) {
+  if (signal?.aborted) {
+    throw new Error("Aborted");
+  }
+  return new Promise(function(resolve, reject) {
+    var timer = setTimeout(function() {
+      var err = new Error("Tool execution timed out");
+      err.name = "TimeoutError";
+      reject(err);
+    }, timeoutMs);
+    var onAbort = function() {
+      clearTimeout(timer);
+      var err = new Error("Tool execution aborted");
+      err.name = "AbortError";
+      reject(err);
+    };
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    promise.then(
+      function(value) {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      function(err) {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+function formatToolResult(result) {
+  var anyResult = result;
+  if ((!result.content || result.content.length === 0) && anyResult.output) {
+    return String(anyResult.output);
+  }
+  if (!result.content || result.content.length === 0) {
+    return "(no output)";
+  }
+  var parts = [];
+  for (var block of result.content) {
+    if (block.type === "text") {
+      parts.push(block.text);
+    } else if (block.type === "image") {
+      parts.push(`[Image: ${block.mimeType}]`);
+    }
+  }
+  return parts.join("\n");
+}
+function truncateResult(content) {
+  if (content.length <= MAX_RESULT_CHARS) return content;
+  var truncated = content.slice(0, MAX_RESULT_CHARS);
+  return truncated + `
+
+... [truncated, ${content.length - MAX_RESULT_CHARS} chars omitted]`;
+}
+
+// src/runtime/compaction.ts
+var COMPACTION_THRESHOLD = 0.8;
+var TARGET_USAGE = 0.45;
+var MIN_KEEP_RECENT = 10;
+var MAX_KEEP_RECENT = 30;
+var SUMMARY_MAX_TOKENS = 4096;
+var CHUNK_MAX_CHARS = 8e4;
+var MAX_PARALLEL_CHUNKS = 3;
+var TOOL_RESULT_TRIM_THRESHOLD = 2e3;
+var TOOL_RESULT_TRIM_TO = 400;
+var HIGH_IMPORTANCE_PATTERNS = [
+  /error|fail|exception|crash|bug/i,
+  /decision|decided|chose|choosing/i,
+  /important|critical|must|required/i,
+  /password|secret|key|token|credential/i,
+  /\b[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}\b/,
+  // UUIDs
+  /https?:\/\/\S{20,}/,
+  // Long URLs
+  /\/[a-zA-Z][\w/.-]{10,}/
+  // File paths
+];
+async function compactContext(messages, config, hooks, options) {
+  const startMs = Date.now();
+  const contextWindowSize = config.contextWindowSize ?? 2e5;
+  const tokensBefore = estimateMessageTokens(messages);
+  const targetTokens = Math.floor(contextWindowSize * TARGET_USAGE);
+  if (tokensBefore <= contextWindowSize * COMPACTION_THRESHOLD) {
+    return messages;
+  }
+  const tokensToFree = tokensBefore - targetTokens;
+  console.log(`[compaction] Need to free ~${tokensToFree} tokens (${tokensBefore} \u2192 target ${targetTokens})`);
+  const systemMessages = messages.filter((m) => m.role === "system");
+  const nonSystem = messages.filter((m) => m.role !== "system");
+  if (nonSystem.length <= MIN_KEEP_RECENT) {
+    return messages;
+  }
+  const tier1Messages = trimToolResults(nonSystem);
+  const tier1Tokens = estimateMessageTokens([...systemMessages, ...tier1Messages]);
+  if (tier1Tokens <= contextWindowSize * COMPACTION_THRESHOLD) {
+    const stats = {
+      strategy: "tier1_trim",
+      messagesBefore: messages.length,
+      messagesAfter: systemMessages.length + tier1Messages.length,
+      tokensBefore,
+      tokensAfter: tier1Tokens,
+      msElapsed: Date.now() - startMs
+    };
+    console.log(`[compaction] Tier 1 (trim tool results) sufficient: ${tokensBefore} \u2192 ${tier1Tokens} tokens in ${stats.msElapsed}ms`);
+    return [...systemMessages, ...tier1Messages];
+  }
+  const keepCount = calculateKeepRecent(tier1Messages, targetTokens, estimateMessageTokens(systemMessages));
+  const { toSummarize, keepRecent } = splitAtSafeBoundary(tier1Messages, keepCount);
+  if (toSummarize.length === 0) {
+    return messages;
+  }
+  const groups = groupMessages(toSummarize);
+  const sortedGroups = groups.sort((a, b) => b.importance - a.importance);
+  const previousSummaries = sortedGroups.filter((g) => g.isPreviousSummary);
+  const regularGroups = sortedGroups.filter((g) => !g.isPreviousSummary);
+  const keepTokenBudget = estimateMessageTokens(systemMessages) + estimateMessageTokens(keepRecent);
+  const summaryBudget = targetTokens - keepTokenBudget;
+  if (!options?.apiKey || summaryBudget < 1e3) {
+    const summary = buildExtractiveSummary(previousSummaries, regularGroups, summaryBudget);
+    const result = assembleFinal(systemMessages, summary, keepRecent);
+    const stats = {
+      strategy: "tier2_extractive",
+      messagesBefore: messages.length,
+      messagesAfter: result.length,
+      tokensBefore,
+      tokensAfter: estimateMessageTokens(result),
+      msElapsed: Date.now() - startMs,
+      previousSummariesChained: previousSummaries.length
+    };
+    console.log(`[compaction] Tier 2 (extractive): ${stats.tokensBefore} \u2192 ${stats.tokensAfter} tokens in ${stats.msElapsed}ms`);
+    await persistSummary(hooks, options?.sessionId, config.agentId, summary);
+    return result;
+  }
+  try {
+    const transcript = buildTranscript(previousSummaries, regularGroups);
+    const summary = await llmSummarize(transcript, config, options.apiKey, summaryBudget);
+    const result = assembleFinal(systemMessages, summary.text, keepRecent);
+    const tokensAfter = estimateMessageTokens(result);
+    const stats = {
+      strategy: "tier3_llm",
+      messagesBefore: messages.length,
+      messagesAfter: result.length,
+      tokensBefore,
+      tokensAfter,
+      msElapsed: Date.now() - startMs,
+      summaryTokens: estimateTokens(summary.text),
+      llmInputTokens: summary.inputTokens,
+      llmOutputTokens: summary.outputTokens,
+      chunksUsed: summary.chunks,
+      previousSummariesChained: previousSummaries.length
+    };
+    console.log(`[compaction] Tier 3 (LLM): ${stats.tokensBefore} \u2192 ${stats.tokensAfter} tokens in ${stats.msElapsed}ms (${summary.chunks} chunks, ${summary.inputTokens}in/${summary.outputTokens}out)`);
+    await persistSummary(hooks, options?.sessionId, config.agentId, summary.text);
+    return result;
+  } catch (err) {
+    console.warn(`[compaction] LLM summarization failed: ${err.message} \u2014 falling back to extractive`);
+    const summary = buildExtractiveSummary(previousSummaries, regularGroups, summaryBudget);
+    const result = assembleFinal(systemMessages, summary, keepRecent);
+    await persistSummary(hooks, options?.sessionId, config.agentId, summary);
+    console.log(`[compaction] Extractive fallback: ${tokensBefore} \u2192 ${estimateMessageTokens(result)} tokens in ${Date.now() - startMs}ms`);
+    return result;
+  }
+}
+function trimToolResults(messages) {
+  return messages.map((msg) => {
+    if (!Array.isArray(msg.content)) return msg;
+    let modified = false;
+    const newContent = msg.content.map((block) => {
+      if (block.type === "tool_result") {
+        const content = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+        if (content.length > TOOL_RESULT_TRIM_THRESHOLD) {
+          modified = true;
+          return {
+            ...block,
+            content: content.slice(0, TOOL_RESULT_TRIM_TO) + `
+... [trimmed ${content.length - TOOL_RESULT_TRIM_TO} chars]`
+          };
+        }
+      }
+      return block;
+    });
+    return modified ? { ...msg, content: newContent } : msg;
+  });
+}
+function calculateKeepRecent(messages, targetTokens, systemTokens) {
+  const keepBudget = Math.floor((targetTokens - systemTokens) * 0.6);
+  let tokens = 0;
+  let count = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msgTokens = estimateMessageTokens([messages[i]]);
+    if (tokens + msgTokens > keepBudget && count >= MIN_KEEP_RECENT) break;
+    tokens += msgTokens;
+    count++;
+    if (count >= MAX_KEEP_RECENT) break;
+  }
+  return Math.max(MIN_KEEP_RECENT, count);
+}
+function splitAtSafeBoundary(messages, keepCount) {
+  let cutIndex = messages.length - keepCount;
+  for (let i = cutIndex; i > 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      const hasToolResult = msg.content.some((b) => b.type === "tool_result");
+      if (hasToolResult) continue;
+    }
+    cutIndex = i;
+    break;
+  }
+  return {
+    toSummarize: messages.slice(0, cutIndex),
+    keepRecent: messages.slice(cutIndex)
+  };
+}
+function groupMessages(messages) {
+  const groups = [];
+  let i = 0;
+  while (i < messages.length) {
+    const msg = messages[i];
+    if (msg.role === "user" && typeof msg.content === "string" && msg.content.includes("[CONTEXT COMPACTION")) {
+      groups.push({
+        messages: [msg],
+        tokens: estimateMessageTokens([msg]),
+        importance: 10,
+        // Highest — contains all prior context
+        isPreviousSummary: true,
+        isToolPair: false
+      });
+      i++;
+      continue;
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_use") && i + 1 < messages.length) {
+      const next = messages[i + 1];
+      if (next.role === "user" && Array.isArray(next.content) && next.content.some((b) => b.type === "tool_result")) {
+        const pair = [msg, next];
+        groups.push({
+          messages: pair,
+          tokens: estimateMessageTokens(pair),
+          importance: scoreImportance(pair),
+          isToolPair: true,
+          isPreviousSummary: false
+        });
+        i += 2;
+        continue;
+      }
+    }
+    groups.push({
+      messages: [msg],
+      tokens: estimateMessageTokens([msg]),
+      importance: scoreImportance([msg]),
+      isToolPair: false,
+      isPreviousSummary: false
+    });
+    i++;
+  }
+  return groups;
+}
+function scoreImportance(messages) {
+  let score = 1;
+  for (const msg of messages) {
+    const text = extractText(msg);
+    if (msg.role === "user") score += 1;
+    for (const pattern of HIGH_IMPORTANCE_PATTERNS) {
+      if (pattern.test(text)) {
+        score += 2;
+        break;
+      }
+    }
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result" && block.is_error) score += 3;
+      }
+    }
+    if (text.length < 20) score -= 1;
+    if (text.length > 5e3) score -= 1;
+  }
+  return Math.max(0, score);
+}
+function extractText(msg) {
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.map((b) => {
+      if (b.type === "text") return b.text || "";
+      if (b.type === "tool_use") return `${b.name}(${JSON.stringify(b.input || {}).slice(0, 200)})`;
+      if (b.type === "tool_result") return String(b.content || "").slice(0, 500);
+      return "";
+    }).join(" ");
+  }
+  return "";
+}
+function buildExtractiveSummary(previousSummaries, groups, tokenBudget) {
+  const parts = [];
+  let usedTokens = 0;
+  for (const sg of previousSummaries) {
+    const text = extractText(sg.messages[0]);
+    const content = text.replace(/^\[CONTEXT COMPACTION[^\]]*\]\s*/s, "");
+    const tokens = estimateTokens(content);
+    if (usedTokens + tokens < tokenBudget * 0.4) {
+      parts.push("## Prior Context (from earlier compaction)\n" + content);
+      usedTokens += tokens;
+    }
+  }
+  parts.push("\n## Recent Activity Summary");
+  for (const group of groups) {
+    if (usedTokens >= tokenBudget) break;
+    for (const msg of group.messages) {
+      const text = extractText(msg);
+      if (!text) continue;
+      const maxLen = group.importance >= 5 ? 800 : group.importance >= 3 ? 400 : 200;
+      const truncated = text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
+      const line = `[${msg.role}]: ${truncated}`;
+      const lineTokens = estimateTokens(line);
+      if (usedTokens + lineTokens > tokenBudget) break;
+      parts.push(line);
+      usedTokens += lineTokens;
+    }
+  }
+  return parts.join("\n");
+}
+function buildTranscript(previousSummaries, groups) {
+  const parts = [];
+  for (const sg of previousSummaries) {
+    const text = extractText(sg.messages[0]);
+    const content = text.replace(/^\[CONTEXT COMPACTION[^\]]*\]\s*/s, "");
+    parts.push("=== PRIOR COMPACTION SUMMARY ===\n" + content.slice(0, 2e4) + "\n=== END PRIOR SUMMARY ===");
+  }
+  const _chronoGroups = [...groups];
+  for (const group of groups) {
+    for (const msg of group.messages) {
+      const text = extractText(msg);
+      if (text.length > 0) {
+        parts.push(`[${msg.role}]: ${text.slice(0, 1500)}`);
+      }
+    }
+  }
+  return parts.join("\n\n");
+}
+var SUMMARY_SYSTEM_PROMPT = `You are a context compaction engine for an AI agent mid-task. Create a dense, lossless summary that the agent MUST be able to continue working from without any other context.
+
+RULES:
+- PRESERVE ALL: IDs, paths, URLs, emails, phone numbers, credentials (names only), version numbers, dates, amounts \u2014 use EXACT values
+- PRESERVE: Task goals, constraints, decisions made, errors encountered, workarounds found
+- PRESERVE: Current state \u2014 what was just done, what's next, any pending operations
+- COMPRESS: Routine tool calls (just note what tool was called and the outcome)
+- COMPRESS: Repeated similar operations (batch into counts: "read 12 files from /src/...")
+- OMIT: Pleasantries, acknowledgments, thinking-out-loud that didn't lead to decisions
+- FORMAT: Use ## headers for sections. Use bullet lists. Be dense but readable.
+- LENGTH: Use ALL available tokens. More detail = better continuation.
+
+Required sections:
+## Task & Goal
+## Completed Work (chronological)
+## Key Data (IDs, paths, URLs, names \u2014 EXACT values)
+## Decisions & Rationale
+## Current State
+## Next Steps
+## Errors & Lessons (if any)`;
+async function llmSummarize(transcript, config, apiKey, _tokenBudget) {
+  if (transcript.length <= CHUNK_MAX_CHARS) {
+    return singleChunkSummarize(transcript, config, apiKey);
+  }
+  const chunks = splitIntoChunks(transcript, CHUNK_MAX_CHARS);
+  const limitedChunks = chunks.slice(0, MAX_PARALLEL_CHUNKS);
+  console.log(`[compaction] Splitting transcript into ${limitedChunks.length} chunks for parallel summarization`);
+  const chunkResults = await Promise.all(
+    limitedChunks.map(
+      (chunk, idx) => singleChunkSummarize(
+        `[Chunk ${idx + 1}/${limitedChunks.length}]
+${chunk}`,
+        config,
+        apiKey
+      ).catch((err) => {
+        console.warn(`[compaction] Chunk ${idx + 1} failed: ${err.message}`);
+        return null;
+      })
+    )
+  );
+  const validResults = chunkResults.filter((r) => r !== null);
+  if (validResults.length === 0) {
+    throw new Error("All chunks failed");
+  }
+  if (validResults.length === 1) {
+    return { ...validResults[0], chunks: limitedChunks.length };
+  }
+  const mergedTranscript = validResults.map((r, i) => `=== Part ${i + 1} ===
+${r.text}`).join("\n\n");
+  const merged = await singleChunkSummarize(
+    `Merge these partial summaries into one cohesive summary:
+
+${mergedTranscript}`,
+    config,
+    apiKey
+  );
+  return {
+    text: merged.text,
+    inputTokens: validResults.reduce((s, r) => s + r.inputTokens, 0) + merged.inputTokens,
+    outputTokens: validResults.reduce((s, r) => s + r.outputTokens, 0) + merged.outputTokens,
+    chunks: limitedChunks.length
+  };
+}
+async function singleChunkSummarize(transcript, config, apiKey) {
+  const response = await callLLM(
+    {
+      provider: config.model.provider,
+      modelId: config.model.modelId,
+      apiKey
+    },
+    [
+      { role: "system", content: SUMMARY_SYSTEM_PROMPT },
+      { role: "user", content: `Summarize this conversation:
+
+${transcript}` }
+    ],
+    [],
+    { maxTokens: SUMMARY_MAX_TOKENS, temperature: 0.2 }
+  );
+  const text = response.textContent || "";
+  if (text.length < 50) throw new Error("Summary too short");
+  return {
+    text,
+    inputTokens: response.usage?.inputTokens || 0,
+    outputTokens: response.usage?.outputTokens || 0,
+    chunks: 1
+  };
+}
+function splitIntoChunks(text, maxChars) {
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = Math.min(start + maxChars, text.length);
+    if (end < text.length) {
+      const lastParagraph = text.lastIndexOf("\n\n", end);
+      if (lastParagraph > start + maxChars * 0.5) {
+        end = lastParagraph + 2;
+      }
+    }
+    chunks.push(text.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+function assembleFinal(systemMessages, summaryText, keepRecent) {
+  const summaryMessage = {
+    role: "user",
+    content: `[CONTEXT COMPACTION \u2014 Your earlier conversation was compressed to fit the context window. The summary below is authoritative \u2014 treat it as ground truth. Continue from where you left off.]
+
+${summaryText}`
+  };
+  return [...systemMessages, summaryMessage, ...keepRecent];
+}
+async function persistSummary(hooks, sessionId, agentId, summaryText) {
+  try {
+    await hooks.onContextCompaction(sessionId || "", agentId, summaryText);
+    console.log(`[compaction] Summary persisted to agent memory`);
+  } catch (err) {
+    console.warn(`[compaction] Memory save failed: ${err?.message}`);
+  }
+}
+
+// src/runtime/agent-loop.ts
+var DEFAULT_MAX_TURNS = 0;
+var DEFAULT_MAX_TOKENS = 8192;
+var DEFAULT_TEMPERATURE = 0.7;
+var DEFAULT_CONTEXT_WINDOW = 2e6;
+function fixOrphanedToolBlocks(messages) {
+  let fixed = false;
+  const allToolUseIds = /* @__PURE__ */ new Set();
+  const allToolResultIds = /* @__PURE__ */ new Set();
+  for (const m of messages) {
+    if (!Array.isArray(m.content)) continue;
+    for (const block of m.content) {
+      if (block.type === "tool_use" && block.id) allToolUseIds.add(block.id);
+      if (block.type === "tool_result" && block.tool_use_id) allToolResultIds.add(block.tool_use_id);
+    }
+  }
+  let result = messages.map((m) => {
+    if (!Array.isArray(m.content)) return m;
+    if (m.role === "user") {
+      const filtered = m.content.filter((block) => {
+        if (block.type === "tool_result" && block.tool_use_id && !allToolUseIds.has(block.tool_use_id)) {
+          fixed = true;
+          return false;
+        }
+        return true;
+      });
+      if (filtered.length === 0) return null;
+      if (filtered.length !== m.content.length) return { ...m, content: filtered };
+      return m;
+    }
+    if (m.role === "assistant") {
+      const filtered = m.content.filter((block) => {
+        if (block.type === "tool_use" && block.id && !allToolResultIds.has(block.id)) {
+          fixed = true;
+          return false;
+        }
+        return true;
+      });
+      if (filtered.length === 0) return null;
+      if (filtered.length !== m.content.length) return { ...m, content: filtered };
+      return m;
+    }
+    return m;
+  }).filter(Boolean);
+  for (let i = 0; i < result.length; i++) {
+    const m = result[i];
+    if (m.role !== "assistant" || !Array.isArray(m.content)) continue;
+    const toolUseIds = m.content.filter((b) => b.type === "tool_use" && b.id).map((b) => b.id);
+    if (toolUseIds.length === 0) continue;
+    const next = result[i + 1];
+    if (next && next.role === "user" && Array.isArray(next.content)) {
+      const hasResults = next.content.some((b) => b.type === "tool_result" && toolUseIds.includes(b.tool_use_id));
+      if (hasResults) continue;
+    }
+    for (let j = i + 2; j < result.length; j++) {
+      const candidate = result[j];
+      if (candidate.role !== "user" || !Array.isArray(candidate.content)) continue;
+      const matchingResults = candidate.content.filter((b) => b.type === "tool_result" && toolUseIds.includes(b.tool_use_id));
+      if (matchingResults.length === 0) continue;
+      const remaining = candidate.content.filter((b) => !(b.type === "tool_result" && toolUseIds.includes(b.tool_use_id)));
+      const toolResultMsg = { role: "user", content: matchingResults };
+      if (remaining.length === 0) {
+        result.splice(j, 1);
+      } else {
+        result[j] = { ...candidate, content: remaining };
+      }
+      result.splice(i + 1, 0, toolResultMsg);
+      fixed = true;
+      console.log(`[agent-loop] Reordered tool_result to fix adjacency (moved from index ${j} to ${i + 1})`);
+      break;
+    }
+    const nextAfterFix = result[i + 1];
+    const adjacencyOk = nextAfterFix && nextAfterFix.role === "user" && Array.isArray(nextAfterFix.content) && nextAfterFix.content.some((b) => b.type === "tool_result" && toolUseIds.includes(b.tool_use_id));
+    if (!adjacencyOk) {
+      const filtered = m.content.filter((b) => !(b.type === "tool_use" && toolUseIds.includes(b.id)));
+      if (filtered.length === 0) {
+        result.splice(i, 1);
+        i--;
+      } else {
+        result[i] = { ...m, content: filtered };
+      }
+      fixed = true;
+    }
+  }
+  if (fixed) console.log(`[agent-loop] Fixed orphaned/non-adjacent tool_use/tool_result blocks`);
+  return result;
+}
+async function runAgentLoop(config, initialMessages, hooks, options) {
+  var maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+  var maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
+  var temperature = config.temperature ?? DEFAULT_TEMPERATURE;
+  var contextWindowSize = config.contextWindowSize ?? DEFAULT_CONTEXT_WINDOW;
+  var toolTimeout = options.toolTimeoutMs ?? 12e4;
+  var registry = new ToolRegistry();
+  registry.register(config.tools);
+  var toolDefs = toolsToDefinitions(config.tools);
+  globalThis.__currentSessionTools = config.tools;
+  var messages = [];
+  if (config.systemPrompt) {
+    messages.push({ role: "system", content: config.systemPrompt });
+  }
+  messages.push(...initialMessages);
+  var turnCount = 0;
+  var totalTextContent = "";
+  var lastStopReason = "end_turn";
+  var sessionId = options.sessionId || "";
+  var cumulativeUsage = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+  var sessionStartEvent = { type: "session_start", sessionId: config.agentId };
+  options.onEvent?.(sessionStartEvent);
+  while (maxTurns === 0 || turnCount < maxTurns) {
+    if (options.signal?.aborted) {
+      return buildResult(messages, "paused", turnCount, totalTextContent, "aborted", cumulativeUsage);
+    }
+    turnCount++;
+    if (options.onHeartbeat) {
+      try {
+        await options.onHeartbeat({ turnCount, tokenCount: estimateMessageTokens(messages), timestamp: Date.now() });
+      } catch {
+      }
+    }
+    var turnStartEvent = { type: "turn_start", turnNumber: turnCount };
+    options.onEvent?.(turnStartEvent);
+    try {
+      messages = await hooks.beforeLLMCall(messages, config.agentId, sessionId);
+    } catch (err) {
+      console.warn(`[runtime] beforeLLMCall hook error: ${err.message}`);
+    }
+    var estimatedTokens = estimateMessageTokens(messages);
+    if (estimatedTokens > contextWindowSize * COMPACTION_THRESHOLD) {
+      messages = await compactContext(messages, config, hooks, { apiKey: options.apiKey, sessionId: options.sessionId });
+    }
+    messages = fixOrphanedToolBlocks(messages);
+    if (hooks.checkBudget) {
+      try {
+        var budgetResult = await hooks.checkBudget(config.agentId, config.orgId, estimateMessageTokens(messages));
+        if (!budgetResult.allowed) {
+          console.log(`[agent-loop] BUDGET EXCEEDED for agent ${config.agentId}: ${budgetResult.reason}`);
+          var budgetEvent = { type: "budget_exceeded", reason: budgetResult.reason || "Budget limit reached" };
+          options.onEvent?.(budgetEvent);
+          return buildResult(messages, "completed", turnCount, totalTextContent, "budget_exceeded", cumulativeUsage);
+        }
+        if (budgetResult.remainingUsd !== void 0 && budgetResult.remainingUsd < 1) {
+          var warnEvent = { type: "budget_warning", remainingUsd: budgetResult.remainingUsd, usedUsd: 0 };
+          options.onEvent?.(warnEvent);
+        }
+      } catch {
+      }
+    }
+    var llmCallStart = Date.now();
+    var llmResponse = void 0;
+    var llmRetryMax = 3;
+    var llmRetryMaxRateLimit = 5;
+    var llmRetryDelay = 2e3;
+    for (var llmAttempt = 0; llmAttempt <= llmRetryMax; llmAttempt++) {
+      try {
+        llmResponse = await callLLM(
+          {
+            provider: config.model.provider,
+            modelId: config.model.modelId,
+            apiKey: options.apiKey,
+            thinkingLevel: config.model.thinkingLevel,
+            baseUrl: config.model.baseUrl,
+            headers: config.model.headers,
+            authMode: config.model.authMode
+          },
+          messages,
+          toolDefs,
+          { maxTokens, temperature, signal: options.signal },
+          options.onEvent,
+          options.retryConfig
+        );
+        console.log(`[agent-loop] LLM responded in ${Date.now() - llmCallStart}ms (${estimateMessageTokens(messages)} input tokens)`);
+        break;
+      } catch (err) {
+        var isOrphanError = /tool_use_id.*tool_result|tool_use.*without.*tool_result|tool_result.*without.*tool_use/i.test(err.message);
+        if (isOrphanError && llmAttempt < llmRetryMax) {
+          var idMatch = err.message.match(/toolu_[A-Za-z0-9_]+/g);
+          var orphanIds = idMatch ? new Set(idMatch) : null;
+          console.warn(`[agent-loop] Orphaned tool blocks detected (ids: ${idMatch?.join(", ") || "unknown"}) \u2014 force-removing and retrying`);
+          messages = fixOrphanedToolBlocks(messages);
+          if (orphanIds) {
+            messages = messages.map((m) => {
+              if (!Array.isArray(m.content)) return m;
+              var filtered = m.content.filter((block) => {
+                if (block.type === "tool_use" && block.id && orphanIds.has(block.id)) return false;
+                if (block.type === "tool_result" && block.tool_use_id && orphanIds.has(block.tool_use_id)) return false;
+                return true;
+              });
+              if (filtered.length === 0) return null;
+              if (filtered.length !== m.content.length) return { ...m, content: filtered };
+              return m;
+            }).filter(Boolean);
+          }
+          continue;
+        }
+        var isRateLimit = /429|rate.limit|rate_limit/i.test(err.message);
+        var isTransient = isRateLimit || /premature close|ECONNRESET|ETIMEDOUT|socket hang up|fetch failed|network|502|503|529|overloaded/i.test(err.message);
+        var effectiveMax = isRateLimit ? llmRetryMaxRateLimit : llmRetryMax;
+        if (isTransient && llmAttempt < effectiveMax) {
+          var delay = isRateLimit ? Math.min(3e4 * Math.pow(2, llmAttempt), 12e4) : llmRetryDelay * Math.pow(2, llmAttempt);
+          console.warn(`[agent-loop] LLM call failed (attempt ${llmAttempt + 1}/${llmRetryMax + 1}): ${err.message} \u2014 retrying in ${delay}ms`);
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        var fallbackModels = options.fallbackModels;
+        if (fallbackModels && fallbackModels.length > 0) {
+          var primaryModel = config.model.provider + "/" + config.model.modelId;
+          var remainingFallbacks = fallbackModels.filter(function(m) {
+            return m !== primaryModel;
+          });
+          for (var fi = 0; fi < remainingFallbacks.length; fi++) {
+            var fbModel = remainingFallbacks[fi];
+            var fbParts = fbModel.split("/");
+            var fbProvider = fbParts[0];
+            var fbModelId = fbParts.slice(1).join("/");
+            console.log(`[agent-loop] Primary model failed \u2014 trying fallback ${fi + 1}/${remainingFallbacks.length}: ${fbModel}`);
+            try {
+              var fbApiKey = options.apiKey;
+              if (fbProvider !== config.model.provider && options.resolveApiKey) {
+                var resolved = await options.resolveApiKey(fbProvider);
+                if (resolved) fbApiKey = resolved;
+              }
+              llmResponse = await callLLM(
+                { provider: fbProvider, modelId: fbModelId, apiKey: fbApiKey, thinkingLevel: config.model.thinkingLevel },
+                messages,
+                toolDefs,
+                { maxTokens, temperature, signal: options.signal },
+                options.onEvent,
+                options.retryConfig
+              );
+              console.log(`[agent-loop] Fallback model ${fbModel} succeeded in ${Date.now() - llmCallStart}ms`);
+              break;
+            } catch (fbErr) {
+              console.warn(`[agent-loop] Fallback model ${fbModel} also failed: ${fbErr.message}`);
+              if (fi === remainingFallbacks.length - 1) {
+                console.error(`[agent-loop] All models failed (primary + ${remainingFallbacks.length} fallbacks): ${err.message}`);
+                var errorEvent = { type: "error", message: `All models failed. Primary: ${err.message}`, retryable: false };
+                options.onEvent?.(errorEvent);
+                return buildResult(messages, "failed", turnCount, totalTextContent, "error", cumulativeUsage);
+              }
+            }
+          }
+          if (llmResponse) break;
+        }
+        if (!llmResponse) {
+          console.error(`[agent-loop] LLM call failed after ${llmAttempt + 1} attempts: ${err.message}`);
+          var errorEvent2 = { type: "error", message: err.message, retryable: isTransient };
+          options.onEvent?.(errorEvent2);
+          return buildResult(messages, "failed", turnCount, totalTextContent, "error", cumulativeUsage);
+        }
+      }
+    }
+    if (hooks.recordLLMUsage) {
+      try {
+        var usageInput = llmResponse.usage?.inputTokens || 0;
+        var usageOutput = llmResponse.usage?.outputTokens || 0;
+        if (usageInput === 0 && usageOutput === 0) {
+          usageInput = Math.ceil(estimateMessageTokens(messages) * 0.9);
+          usageOutput = Math.ceil((llmResponse.textContent?.length || 100) / 4);
+        }
+        var costUsd = await estimateCostAsync(hooks, config.model, usageInput, usageOutput);
+        await hooks.recordLLMUsage(config.agentId, config.orgId, {
+          inputTokens: usageInput,
+          outputTokens: usageOutput,
+          costUsd
+        });
+        cumulativeUsage.inputTokens += usageInput;
+        cumulativeUsage.outputTokens += usageOutput;
+        cumulativeUsage.costUsd += costUsd;
+      } catch {
+      }
+    }
+    var assistantMessage = buildAssistantMessage(llmResponse);
+    messages.push(assistantMessage);
+    totalTextContent += llmResponse.textContent;
+    if (llmResponse.stopReason === "end_turn") {
+      lastStopReason = "end_turn";
+      var turnEndEvent = { type: "turn_end", stopReason: "end_turn" };
+      options.onEvent?.(turnEndEvent);
+      if (options.onCheckpoint) {
+        try {
+          var currentTokens = estimateMessageTokens(messages);
+          await options.onCheckpoint({ messages, turnCount, tokenCount: currentTokens });
+        } catch (err) {
+          console.warn("[runtime] Checkpoint save error:", err.message);
+        }
+      }
+      break;
+    }
+    if (llmResponse.stopReason === "tool_use" && llmResponse.toolCalls.length > 0) {
+      lastStopReason = "tool_use";
+      var toolResults = [];
+      for (var toolCall of llmResponse.toolCalls) {
+        var hookResult = await hooks.beforeToolCall({
+          toolCallId: toolCall.id,
+          toolName: toolCall.name,
+          parameters: toolCall.input,
+          agentId: config.agentId,
+          orgId: config.orgId,
+          sessionId
+        });
+        if (!hookResult.allowed) {
+          console.log(`[agent-loop] \u{1F6AB} Tool ${toolCall.name} BLOCKED: ${hookResult.reason} (session: ${sessionId})`);
+          var blockedEvent = {
+            type: "tool_call_end",
+            toolName: toolCall.name,
+            result: hookResult.reason,
+            blocked: true
+          };
+          options.onEvent?.(blockedEvent);
+          toolResults.push({
+            tool_use_id: toolCall.id,
+            content: `Tool call blocked: ${hookResult.reason}`,
+            is_error: true
+          });
+          await hooks.afterToolCall(
+            { toolCallId: toolCall.id, toolName: toolCall.name, parameters: toolCall.input, agentId: config.agentId, orgId: config.orgId, sessionId },
+            { success: false, error: hookResult.reason }
+          );
+          continue;
+        }
+        var effectiveInput = hookResult.modifiedParameters || toolCall.input;
+        var effectiveToolCall = { ...toolCall, input: effectiveInput };
+        var tool = registry.get(toolCall.name);
+        if (!tool) {
+          toolResults.push({
+            tool_use_id: toolCall.id,
+            content: `Unknown tool: "${toolCall.name}"`,
+            is_error: true
+          });
+          var unknownEvent = {
+            type: "tool_call_end",
+            toolName: toolCall.name,
+            result: "unknown tool",
+            blocked: true
+          };
+          options.onEvent?.(unknownEvent);
+          continue;
+        }
+        console.log(`[agent-loop] \u{1F527} Executing tool: ${toolCall.name} (session: ${sessionId})`);
+        try {
+          const { describeToolActivity } = await import("./agent-status-VQORDJXV.js");
+          if (options.runtime?._reportStatus) {
+            options.runtime._reportStatus({
+              status: "online",
+              currentActivity: { type: "tool_call", detail: describeToolActivity(toolCall.name), tool: toolCall.name, startedAt: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          }
+        } catch {
+        }
+        var { result, content } = await executeTool(tool, effectiveToolCall, {
+          timeoutMs: toolTimeout,
+          signal: options.signal
+        });
+        if (!result.success) {
+          console.log(`[agent-loop] \u274C Tool ${toolCall.name} failed: ${result.error?.slice(0, 200)}`);
+        } else {
+          console.log(`[agent-loop] \u2705 Tool ${toolCall.name} succeeded (${content.length} chars): ${content.slice(0, 300)}`);
+        }
+        try {
+          const { activity } = await import("./routes-UIUIEZKQ.js");
+          activity.recordToolCallCompact({
+            agentId: config.agentId,
+            orgId: config.orgId,
+            sessionId,
+            tool: toolCall.name,
+            success: !!result.success,
+            durationMs: result.durationMs,
+            error: result.error?.slice(0, 200)
+          });
+        } catch {
+        }
+        try {
+          if (options.runtime?._reportStatus) {
+            options.runtime._reportStatus({ currentActivity: null });
+          }
+        } catch {
+        }
+        if (result._dynamicTools?.length) {
+          var newTools = result._dynamicTools;
+          var existingNames = new Set(config.tools.map((t) => t.name));
+          var added = 0;
+          for (var nt of newTools) {
+            if (!existingNames.has(nt.name)) {
+              config.tools.push(nt);
+              toolDefs.push({ name: nt.name, description: nt.description, input_schema: nt.parameters });
+              existingNames.add(nt.name);
+              added++;
+            }
+          }
+          if (added) {
+            console.log(`[agent-loop] Dynamically loaded ${added} new tools`);
+            globalThis.__currentSessionTools = config.tools;
+          }
+        }
+        toolResults.push({
+          tool_use_id: toolCall.id,
+          content,
+          is_error: !result.success
+        });
+        var tcEndEvent = {
+          type: "tool_call_end",
+          toolName: toolCall.name,
+          result: result.success ? "success" : result.error
+        };
+        options.onEvent?.(tcEndEvent);
+        await hooks.afterToolCall(
+          { toolCallId: toolCall.id, toolName: toolCall.name, parameters: effectiveInput, agentId: config.agentId, orgId: config.orgId, sessionId },
+          result
+        );
+      }
+      messages.push({
+        role: "user",
+        content: toolResults.map(function(tr) {
+          return { type: "tool_result", tool_use_id: tr.tool_use_id, content: tr.content, is_error: tr.is_error };
+        }),
+        tool_results: toolResults.map(function(tr) {
+          return { tool_use_id: tr.tool_use_id, content: tr.content, is_error: tr.is_error };
+        })
+      });
+      if (options.onCheckpoint) {
+        try {
+          var currentTokens = estimateMessageTokens(messages);
+          await options.onCheckpoint({ messages, turnCount, tokenCount: currentTokens });
+        } catch (err) {
+          console.warn("[runtime] Checkpoint save error:", err.message);
+        }
+      }
+      var TERMINAL_TOOLS = /* @__PURE__ */ new Set([
+        "google_chat_send_message",
+        "google_chat_send_card",
+        "google_chat_send_dm",
+        "google_chat_reply_message"
+      ]);
+      var allTerminal = llmResponse.toolCalls.length > 0 && llmResponse.toolCalls.every(function(tc) {
+        return TERMINAL_TOOLS.has(tc.name);
+      }) && toolResults.every(function(tr) {
+        return !tr.is_error;
+      });
+      if (allTerminal) {
+        console.log(`[agent-loop] \u26A1 Auto-end: all tools were terminal send tools, skipping confirmation LLM call`);
+        lastStopReason = "end_turn";
+        var autoEndEvent = { type: "turn_end", stopReason: "end_turn" };
+        options.onEvent?.(autoEndEvent);
+        break;
+      }
+      continue;
+    }
+    if (llmResponse.stopReason === "max_tokens") {
+      lastStopReason = "max_tokens";
+      messages = await compactContext(messages, config, hooks, { apiKey: options.apiKey, sessionId: options.sessionId });
+      messages = fixOrphanedToolBlocks(messages);
+      if (options.onCheckpoint) {
+        try {
+          var currentTokens = estimateMessageTokens(messages);
+          await options.onCheckpoint({ messages, turnCount, tokenCount: currentTokens });
+        } catch (err) {
+          console.warn("[runtime] Checkpoint save error:", err.message);
+        }
+      }
+      continue;
+    }
+    lastStopReason = llmResponse.stopReason;
+    break;
+  }
+  if (maxTurns > 0 && turnCount >= maxTurns) {
+    lastStopReason = "max_turns";
+  }
+  var sessionEndEvent = {
+    type: "session_end",
+    summary: totalTextContent.slice(0, 200)
+  };
+  options.onEvent?.(sessionEndEvent);
+  return buildResult(
+    messages,
+    lastStopReason === "end_turn" ? "completed" : lastStopReason === "max_turns" ? "completed" : "completed",
+    turnCount,
+    totalTextContent,
+    lastStopReason,
+    cumulativeUsage
+  );
+}
+var FALLBACK_PRICES = {
+  // Anthropic (Feb 2026 — 1M context window)
+  "claude-opus-4-6": { input: 5, output: 25 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4.1": { input: 2, output: 8 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4 },
+  "o3": { input: 10, output: 40 },
+  "o4-mini": { input: 1.1, output: 4.4 },
+  // Google Gemini (up to 2M context)
+  "gemini-2.5-pro": { input: 2.5, output: 15 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-3-pro": { input: 2.5, output: 15 },
+  // DeepSeek (128K context)
+  "deepseek-chat": { input: 0.14, output: 0.28 },
+  "deepseek-chat-v3": { input: 0.14, output: 0.28 },
+  "deepseek-reasoner": { input: 0.55, output: 2.19 },
+  // xAI Grok (2M context window)
+  "grok-4": { input: 3, output: 15 },
+  "grok-4-fast": { input: 0.2, output: 0.5 },
+  "grok-3": { input: 3, output: 15 },
+  "grok-3-mini": { input: 0.3, output: 0.5 },
+  // Mistral
+  "mistral-large-latest": { input: 2, output: 6 },
+  "mistral-small-latest": { input: 0.1, output: 0.3 },
+  "codestral-latest": { input: 0.3, output: 0.9 },
+  // Meta Llama (via Groq, Together, etc.)
+  "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
+  "llama-3.1-8b-instant": { input: 0.05, output: 0.08 },
+  "meta-llama/Llama-3.3-70B-Instruct-Turbo": { input: 0.88, output: 0.88 }
+};
+var _PRICING_CACHE_TTL = 5 * 6e4;
+async function estimateCostAsync(hooks, model, inputTokens, outputTokens) {
+  if (hooks.getModelPricing) {
+    try {
+      var dbPricing = await hooks.getModelPricing(model.provider, model.modelId);
+      if (dbPricing) {
+        return (inputTokens * dbPricing.inputCostPerMillion + outputTokens * dbPricing.outputCostPerMillion) / 1e6;
+      }
+    } catch {
+    }
+  }
+  var p = FALLBACK_PRICES[model.modelId] || { input: 3, output: 15 };
+  return (inputTokens * p.input + outputTokens * p.output) / 1e6;
+}
+function buildAssistantMessage(response) {
+  var content = [];
+  if (response.thinkingContent) {
+    content.push({ type: "thinking", thinking: response.thinkingContent });
+  }
+  if (response.textContent) {
+    content.push({ type: "text", text: response.textContent });
+  }
+  for (var tc of response.toolCalls) {
+    content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+  }
+  return {
+    role: "assistant",
+    content: content.length === 1 && content[0].type === "text" ? content[0].text : content,
+    tool_calls: response.toolCalls.length > 0 ? response.toolCalls : void 0
+  };
+}
+function buildResult(messages, status, turnCount, textContent, stopReason, usage) {
+  return {
+    messages,
+    status,
+    tokenCount: estimateMessageTokens(messages),
+    turnCount,
+    textContent,
+    stopReason,
+    usage
+  };
+}
+
+// src/agent-tools/tool-resolver.ts
+var TIER_MAP = {
+  // Tier 1 — Agent can't function without these
+  core: 1,
+  // read/write/search/bash — fundamental
+  memory: 1,
+  // agent memory is always needed
+  // Tier 2 — Common workflows, loaded by context
+  gws_chat: 2,
+  // only when source is Google Chat
+  browser: 2,
+  system: 2,
+  visual_memory: 2,
+  meeting_voice: 2,
+  meeting_lifecycle: 2,
+  gws_gmail: 2,
+  gws_calendar: 2,
+  gws_drive: 2,
+  gws_docs: 2,
+  gws_tasks: 2,
+  gws_contacts: 2,
+  agenticmail: 2,
+  ent_http: 2,
+  // Tier 3 — Specialist, on-demand only
+  gws_sheets: 3,
+  gws_slides: 3,
+  gws_forms: 3,
+  gws_maps: 3,
+  ent_database: 3,
+  ent_spreadsheet: 3,
+  ent_documents: 3,
+  ent_security: 3,
+  ent_code: 3,
+  ent_diff: 3,
+  remotion_video: 3,
+  ent_knowledge: 2,
+  local_filesystem: 2,
+  local_shell: 2,
+  management: 1,
+  // always loaded — agent must know its position
+  msg_whatsapp: 2,
+  msg_telegram: 2,
+  mcp_bridge: 3,
+  filesystem: 2,
+  web: 2,
+  smtp_email: 2
+};
+var TOOL_REGISTRY = {
+  // ── Core (8) ──
+  read: "core",
+  write: "core",
+  edit: "core",
+  bash: "core",
+  glob: "core",
+  grep: "core",
+  web_fetch: "core",
+  web_search: "core",
+  // ── Browser (1) ──
+  browser: "browser",
+  // ── System (1) ──
+  system_capabilities: "system",
+  // ── Memory (4) ──
+  memory: "memory",
+  memory_context: "memory",
+  memory_reflect: "memory",
+  memory_stats: "memory",
+  // ── Visual Memory (10) ──
+  vision_capture: "visual_memory",
+  vision_compare: "visual_memory",
+  vision_diff: "visual_memory",
+  vision_health: "visual_memory",
+  vision_ocr: "visual_memory",
+  vision_query: "visual_memory",
+  vision_session_end: "visual_memory",
+  vision_session_start: "visual_memory",
+  vision_similar: "visual_memory",
+  vision_track: "visual_memory",
+  // ── Meeting Voice (4) ──
+  meeting_speak: "meeting_voice",
+  meeting_action: "meeting_voice",
+  meeting_audio_setup: "meeting_voice",
+  meeting_voices: "meeting_voice",
+  // ── Meeting Lifecycle (8) ──
+  meeting_join: "meeting_lifecycle",
+  meeting_rsvp: "meeting_lifecycle",
+  meeting_can_join: "meeting_lifecycle",
+  meeting_prepare: "meeting_lifecycle",
+  meeting_record: "meeting_lifecycle",
+  meeting_save: "meeting_lifecycle",
+  meetings_scan_inbox: "meeting_lifecycle",
+  meetings_upcoming: "meeting_lifecycle",
+  // ── Google Chat (14) ──
+  google_chat_send_message: "gws_chat",
+  google_chat_list_messages: "gws_chat",
+  google_chat_list_spaces: "gws_chat",
+  google_chat_get_space: "gws_chat",
+  google_chat_find_dm: "gws_chat",
+  google_chat_add_member: "gws_chat",
+  google_chat_list_members: "gws_chat",
+  google_chat_delete_message: "gws_chat",
+  google_chat_update_message: "gws_chat",
+  google_chat_react: "gws_chat",
+  google_chat_send_image: "gws_chat",
+  google_chat_upload_attachment: "gws_chat",
+  google_chat_download_attachment: "gws_chat",
+  google_chat_setup_space: "gws_chat",
+  // ── SMTP/IMAP Email (10) ──
+  email_send: "smtp_email",
+  email_reply: "smtp_email",
+  email_forward: "smtp_email",
+  email_search: "smtp_email",
+  email_read: "smtp_email",
+  email_list: "smtp_email",
+  email_folders: "smtp_email",
+  email_move: "smtp_email",
+  email_delete: "smtp_email",
+  email_mark_read: "smtp_email",
+  // ── Gmail (15) ──
+  gmail_search: "gws_gmail",
+  gmail_read: "gws_gmail",
+  gmail_send: "gws_gmail",
+  gmail_reply: "gws_gmail",
+  gmail_forward: "gws_gmail",
+  gmail_trash: "gws_gmail",
+  gmail_modify: "gws_gmail",
+  gmail_labels: "gws_gmail",
+  gmail_drafts: "gws_gmail",
+  gmail_thread: "gws_gmail",
+  gmail_attachment: "gws_gmail",
+  gmail_profile: "gws_gmail",
+  gmail_get_signature: "gws_gmail",
+  gmail_set_signature: "gws_gmail",
+  gmail_vacation: "gws_gmail",
+  // ── Google Calendar (6) ──
+  google_calendar_list: "gws_calendar",
+  google_calendar_events: "gws_calendar",
+  google_calendar_create_event: "gws_calendar",
+  google_calendar_update_event: "gws_calendar",
+  google_calendar_delete_event: "gws_calendar",
+  google_calendar_freebusy: "gws_calendar",
+  // ── Google Drive (7) ──
+  google_drive_list: "gws_drive",
+  google_drive_get: "gws_drive",
+  google_drive_create: "gws_drive",
+  google_drive_delete: "gws_drive",
+  google_drive_move: "gws_drive",
+  google_drive_share: "gws_drive",
+  google_drive_request_access: "gws_drive",
+  // ── Google Docs (3) ──
+  google_docs_create: "gws_docs",
+  google_docs_read: "gws_docs",
+  google_docs_write: "gws_docs",
+  // ── Google Sheets (7) ──
+  google_sheets_read: "gws_sheets",
+  google_sheets_write: "gws_sheets",
+  google_sheets_append: "gws_sheets",
+  google_sheets_create: "gws_sheets",
+  google_sheets_get: "gws_sheets",
+  google_sheets_add_sheet: "gws_sheets",
+  google_sheets_clear: "gws_sheets",
+  // ── Google Contacts (5) ──
+  google_contacts_list: "gws_contacts",
+  google_contacts_search: "gws_contacts",
+  google_contacts_create: "gws_contacts",
+  google_contacts_update: "gws_contacts",
+  google_contacts_search_directory: "gws_contacts",
+  // ── Google Slides (12) ──
+  google_slides_create: "gws_slides",
+  google_slides_get: "gws_slides",
+  google_slides_get_page: "gws_slides",
+  google_slides_add_slide: "gws_slides",
+  google_slides_delete_slide: "gws_slides",
+  google_slides_duplicate_slide: "gws_slides",
+  google_slides_insert_text: "gws_slides",
+  google_slides_replace_text: "gws_slides",
+  google_slides_create_textbox: "gws_slides",
+  google_slides_add_image: "gws_slides",
+  google_slides_batch_update: "gws_slides",
+  google_slides_thumbnail: "gws_slides",
+  // ── Google Forms (8) ──
+  google_forms_create: "gws_forms",
+  google_forms_get: "gws_forms",
+  google_forms_add_question: "gws_forms",
+  google_forms_delete_item: "gws_forms",
+  google_forms_update_info: "gws_forms",
+  google_forms_publish_settings: "gws_forms",
+  google_forms_get_response: "gws_forms",
+  google_forms_list_responses: "gws_forms",
+  // ── Google Tasks (7) ──
+  google_tasks_list: "gws_tasks",
+  google_tasks_list_tasklists: "gws_tasks",
+  google_tasks_create: "gws_tasks",
+  google_tasks_create_list: "gws_tasks",
+  google_tasks_update: "gws_tasks",
+  google_tasks_complete: "gws_tasks",
+  google_tasks_delete: "gws_tasks",
+  // ── Google Maps (10) ──
+  google_maps_search: "gws_maps",
+  google_maps_place_details: "gws_maps",
+  google_maps_nearby: "gws_maps",
+  google_maps_geocode: "gws_maps",
+  google_maps_directions: "gws_maps",
+  google_maps_distance: "gws_maps",
+  google_maps_elevation: "gws_maps",
+  google_maps_timezone: "gws_maps",
+  google_maps_autocomplete: "gws_maps",
+  google_maps_static: "gws_maps",
+  // ── Enterprise: Database (6) ──
+  ent_db_query: "ent_database",
+  ent_db_schema: "ent_database",
+  ent_db_tables: "ent_database",
+  ent_db_sample: "ent_database",
+  ent_db_explain: "ent_database",
+  ent_db_connections: "ent_database",
+  // ── Enterprise: Spreadsheet (8) ──
+  ent_sheet_read: "ent_spreadsheet",
+  ent_sheet_write: "ent_spreadsheet",
+  ent_sheet_filter: "ent_spreadsheet",
+  ent_sheet_aggregate: "ent_spreadsheet",
+  ent_sheet_transform: "ent_spreadsheet",
+  ent_sheet_merge: "ent_spreadsheet",
+  ent_sheet_pivot: "ent_spreadsheet",
+  ent_sheet_convert: "ent_spreadsheet",
+  // ── Enterprise: Documents (8) ──
+  ent_doc_generate_pdf: "ent_documents",
+  ent_doc_generate_docx: "ent_documents",
+  ent_doc_ocr: "ent_documents",
+  ent_doc_parse_invoice: "ent_documents",
+  ent_doc_convert: "ent_documents",
+  ent_doc_extract_tables: "ent_documents",
+  ent_doc_fill_form: "ent_documents",
+  ent_doc_merge_pdfs: "ent_documents",
+  // ── Enterprise: HTTP (4) ──
+  ent_http_request: "ent_http",
+  ent_http_graphql: "ent_http",
+  ent_http_batch: "ent_http",
+  ent_http_download: "ent_http",
+  // ── Enterprise: Security (6) ──
+  ent_sec_scan_secrets: "ent_security",
+  ent_sec_scan_pii: "ent_security",
+  ent_sec_redact_pii: "ent_security",
+  ent_sec_scan_deps: "ent_security",
+  ent_sec_compliance_check: "ent_security",
+  ent_sec_hash: "ent_security",
+  // ── Enterprise: Code Sandbox (5) ──
+  ent_code_run_js: "ent_code",
+  ent_code_run_python: "ent_code",
+  ent_code_run_shell: "ent_code",
+  ent_code_transform_json: "ent_code",
+  ent_code_regex: "ent_code",
+  // ── Enterprise: Diff (4) ──
+  ent_diff_text: "ent_diff",
+  ent_diff_json: "ent_diff",
+  ent_diff_spreadsheet: "ent_diff",
+  ent_diff_summary: "ent_diff",
+  // ── Remotion Video (8) ──
+  remotion_create_project: "remotion_video",
+  remotion_create_composition: "remotion_video",
+  remotion_render: "remotion_video",
+  remotion_render_still: "remotion_video",
+  remotion_list_compositions: "remotion_video",
+  remotion_preview_url: "remotion_video",
+  remotion_add_asset: "remotion_video",
+  remotion_install_package: "remotion_video",
+  remotion_share_file: "remotion_video",
+  // ── Knowledge Search (3) ──
+  knowledge_base_search: "ent_knowledge",
+  knowledge_hub_search: "ent_knowledge",
+  knowledge_search_stats: "ent_knowledge",
+  // ── AgenticMail (40) ──
+  agenticmail_inbox: "agenticmail",
+  agenticmail_read: "agenticmail",
+  agenticmail_send: "agenticmail",
+  agenticmail_reply: "agenticmail",
+  agenticmail_forward: "agenticmail",
+  agenticmail_delete: "agenticmail",
+  agenticmail_search: "agenticmail",
+  agenticmail_move: "agenticmail",
+  agenticmail_mark_read: "agenticmail",
+  agenticmail_mark_unread: "agenticmail",
+  agenticmail_folders: "agenticmail",
+  agenticmail_create_folder: "agenticmail",
+  agenticmail_list_folder: "agenticmail",
+  agenticmail_digest: "agenticmail",
+  agenticmail_contacts: "agenticmail",
+  agenticmail_drafts: "agenticmail",
+  agenticmail_signatures: "agenticmail",
+  agenticmail_templates: "agenticmail",
+  agenticmail_template_send: "agenticmail",
+  agenticmail_tags: "agenticmail",
+  agenticmail_rules: "agenticmail",
+  agenticmail_schedule: "agenticmail",
+  agenticmail_spam: "agenticmail",
+  agenticmail_batch_read: "agenticmail",
+  agenticmail_batch_delete: "agenticmail",
+  agenticmail_batch_mark_read: "agenticmail",
+  agenticmail_batch_mark_unread: "agenticmail",
+  agenticmail_batch_move: "agenticmail",
+  agenticmail_whoami: "agenticmail",
+  agenticmail_update_metadata: "agenticmail",
+  agenticmail_storage: "agenticmail",
+  agenticmail_list_agents: "agenticmail",
+  agenticmail_message_agent: "agenticmail",
+  agenticmail_call_agent: "agenticmail",
+  agenticmail_check_messages: "agenticmail",
+  agenticmail_check_tasks: "agenticmail",
+  agenticmail_claim_task: "agenticmail",
+  agenticmail_complete_task: "agenticmail",
+  agenticmail_submit_result: "agenticmail",
+  agenticmail_wait_for_email: "agenticmail",
+  // ── Local: Filesystem (7) ──
+  file_read: "local_filesystem",
+  file_write: "local_filesystem",
+  file_edit: "local_filesystem",
+  file_list: "local_filesystem",
+  file_search: "local_filesystem",
+  file_move: "local_filesystem",
+  file_delete: "local_filesystem",
+  // ── Local: Shell & System (7) ──
+  shell_exec: "local_shell",
+  shell_interactive: "local_shell",
+  shell_sudo: "local_shell",
+  shell_install: "local_shell",
+  shell_session_list: "local_shell",
+  shell_session_kill: "local_shell",
+  system_info: "local_shell",
+  check_dependency: "local_shell",
+  install_dependency: "local_shell",
+  check_environment: "local_shell",
+  cleanup_installed: "local_shell",
+  // ── Messaging: WhatsApp (16) ──
+  whatsapp_connect: "msg_whatsapp",
+  whatsapp_status: "msg_whatsapp",
+  whatsapp_send: "msg_whatsapp",
+  whatsapp_send_media: "msg_whatsapp",
+  whatsapp_get_groups: "msg_whatsapp",
+  whatsapp_send_voice: "msg_whatsapp",
+  whatsapp_send_location: "msg_whatsapp",
+  whatsapp_send_contact: "msg_whatsapp",
+  whatsapp_react: "msg_whatsapp",
+  whatsapp_typing: "msg_whatsapp",
+  whatsapp_read_receipts: "msg_whatsapp",
+  whatsapp_profile: "msg_whatsapp",
+  whatsapp_group_manage: "msg_whatsapp",
+  whatsapp_delete_message: "msg_whatsapp",
+  whatsapp_forward: "msg_whatsapp",
+  whatsapp_disconnect: "msg_whatsapp",
+  // ── Messaging: Telegram (4) ──
+  telegram_send: "msg_telegram",
+  telegram_send_media: "msg_telegram",
+  telegram_download_file: "msg_telegram",
+  telegram_get_me: "msg_telegram",
+  telegram_get_chat: "msg_telegram",
+  // ── Management (11) ──
+  team_status: "management",
+  team_delegate_task: "management",
+  team_tasks: "management",
+  team_reassign_task: "management",
+  team_feedback: "management",
+  team_resolve_escalation: "management",
+  team_forward_escalation: "management",
+  team_org_chart: "management",
+  task_update: "management",
+  my_tasks: "management",
+  escalate: "management"
+};
+var sessionToolStates = /* @__PURE__ */ new Map();
+function clearSessionToolState(sessionId) {
+  sessionToolStates.delete(sessionId);
+}
+var _ALL_SETS = Object.keys(TIER_MAP);
+var _COMMON_T2 = ["local_filesystem", "local_shell", "browser", "system", "ent_knowledge"];
+var CONTEXT_PROMOTIONS = {
+  // Meeting: voice + lifecycle essential, plus common tools
+  meeting: ["meeting_voice", "meeting_lifecycle", ..._COMMON_T2],
+  // Chat (webchat/generic): common tools only — rest loaded on demand via signals or request_tools
+  chat: _COMMON_T2,
+  // Messaging channels: load the relevant channel's tools + common tools
+  // The agent's OWN channel tools are essential (Tier 1-like for that session)
+  // Other channel tools and specialist tools load on demand
+  whatsapp: ["msg_whatsapp", "smtp_email", ..._COMMON_T2],
+  telegram: ["msg_telegram", "smtp_email", ..._COMMON_T2],
+  email: ["agenticmail", "gws_gmail", "smtp_email", ..._COMMON_T2],
+  // Task/full: broader set for agent-to-agent work
+  task: ["agenticmail", ..._COMMON_T2],
+  full: _ALL_SETS
+};
+var SIGNAL_RULES = [
+  // Email mentions
+  {
+    patterns: [/\bemail\b/i, /\bgmail\b/i, /\binbox\b/i, /\bsend.*mail\b/i],
+    sets: ["gws_gmail", "smtp_email"]
+  },
+  // Calendar mentions
+  {
+    patterns: [/\bcalendar\b/i, /\bschedule\b/i, /\bmeeting.*upcoming\b/i, /\bevent\b/i, /\bfree.*busy\b/i],
+    sets: ["gws_calendar"]
+  },
+  // Drive/docs
+  {
+    patterns: [/\bdrive\b/i, /\bdocument\b/i, /\bgoogle doc\b/i],
+    sets: ["gws_drive", "gws_docs"]
+  },
+  // Sheets
+  {
+    patterns: [/\bspreadsheet\b/i, /\bsheet\b/i, /\bcsv\b/i, /\bexcel\b/i],
+    sets: ["gws_sheets"]
+  },
+  // Slides
+  {
+    patterns: [/\bslide\b/i, /\bpresentation\b/i, /\bpowerpoint\b/i],
+    sets: ["gws_slides"]
+  },
+  // Forms
+  {
+    patterns: [/\bform\b/i, /\bsurvey\b/i, /\bquestionnaire\b/i],
+    sets: ["gws_forms"]
+  },
+  // Maps
+  {
+    patterns: [/\bmap\b/i, /\bdirection\b/i, /\bplace\b/i, /\brestaurant\b/i, /\bnearby\b/i, /\bgeocode\b/i, /\bdistance\b/i],
+    sets: ["gws_maps"]
+  },
+  // Meeting join — broad patterns to catch casual phrasing
+  {
+    patterns: [/\bjoin.*meeting\b/i, /\bmeeting.*join\b/i, /\bgoogle meet\b/i, /meet\.google\.com/i, /\bjoin.*call\b/i, /\bvideo.*call\b/i, /\bjoin.*meet\b/i, /\bjoin.*again\b/i, /\brejoin\b/i, /\bjoin back\b/i, /\bjoin the\b/i, /\bget.*in.*meeting\b/i],
+    sets: ["meeting_lifecycle", "meeting_voice"]
+  },
+  // Database
+  {
+    patterns: [/\bdatabase\b/i, /\bsql\b/i, /\bquery\b/i, /\bpostgres\b/i],
+    sets: ["ent_database"]
+  },
+  // Security
+  {
+    patterns: [/\bsecurity\b/i, /\bscan.*secret\b/i, /\bpii\b/i, /\bcompliance\b/i],
+    sets: ["ent_security"]
+  },
+  // PDF/docs
+  {
+    patterns: [/\bpdf\b/i, /\binvoice\b/i, /\bocr\b/i, /\bdocx\b/i],
+    sets: ["ent_documents"]
+  },
+  // Code
+  {
+    patterns: [/\brun.*python\b/i, /\brun.*javascript\b/i, /\bcode.*sandbox\b/i, /\bregex\b/i],
+    sets: ["ent_code"]
+  },
+  // Contacts
+  {
+    patterns: [/\bcontact\b/i, /\bphone.*number\b/i, /\bdirectory\b/i],
+    sets: ["gws_contacts"]
+  },
+  // AgenticMail
+  {
+    patterns: [/\bagenticmail\b/i, /\bagent.*email\b/i],
+    sets: ["agenticmail"]
+  },
+  // Knowledge base / hub
+  {
+    patterns: [/\bknowledge\s*base\b/i, /\bknowledge\s*hub\b/i, /\bfaq\b/i, /\bdocumentation\b/i, /\bwiki\b/i, /\bhow\s+do\s+(we|i)\b/i, /\bwhat.*(policy|process|procedure)\b/i, /\bcompany.*(guide|handbook)\b/i],
+    sets: ["ent_knowledge"]
+  },
+  // WhatsApp (cross-channel)
+  {
+    patterns: [/\bwhatsapp\b/i, /\bsend.*whatsapp\b/i, /\bwa\s+message\b/i],
+    sets: ["msg_whatsapp"]
+  },
+  // Telegram (cross-channel)
+  {
+    patterns: [/\btelegram\b/i, /\bsend.*telegram\b/i, /\btg\s+message\b/i],
+    sets: ["msg_telegram"]
+  },
+  // Spreadsheet / CSV
+  {
+    patterns: [/\bcsv\b/i, /\bspreadsheet\b/i, /\btransform.*data\b/i, /\bpivot\b/i],
+    sets: ["ent_spreadsheet"]
+  },
+  // Diff
+  {
+    patterns: [/\bdiff\b/i, /\bcompare.*files?\b/i, /\bwhat.*changed\b/i],
+    sets: ["ent_diff"]
+  },
+  // Tasks (Google)
+  {
+    patterns: [/\bgoogle\s*tasks?\b/i, /\btask\s*list\b/i, /\btodo\b/i],
+    sets: ["gws_tasks"]
+  },
+  // Visual memory
+  {
+    patterns: [/\bscreenshot\b/i, /\bcapture\b/i, /\bvision\b/i, /\bwhat.*see\b/i, /\blook\s*at\b/i],
+    sets: ["visual_memory"]
+  },
+  // AgenticMail (broader)
+  {
+    patterns: [/\bsend.*email\b/i, /\bwrite.*email\b/i, /\bdraft\b/i, /\binbox\b/i, /\bcheck.*mail\b/i],
+    sets: ["agenticmail"]
+  },
+  // Remotion Video
+  {
+    patterns: [/\bremotion\b/i, /\bcreate.*video\b/i, /\brender.*video\b/i, /\bvideo\s*project\b/i, /\bmarketing\s*video\b/i, /\bsocial\s*reel\b/i, /\banimation\b/i, /\bmotion\s*graphics?\b/i],
+    sets: ["remotion_video"]
+  }
+];
+function detectSignals(text) {
+  const needed = /* @__PURE__ */ new Set();
+  for (const rule of SIGNAL_RULES) {
+    if (rule.patterns.some((p) => p.test(text))) {
+      for (const s of rule.sets) needed.add(s);
+    }
+  }
+  return [...needed];
+}
+function detectSessionContext(opts) {
+  if (opts.explicitContext && opts.explicitContext in CONTEXT_PROMOTIONS) return opts.explicitContext;
+  if (opts.sessionKind === "meeting") return "meeting";
+  if (opts.sessionKind === "email") return "email";
+  if (opts.sessionKind === "task") return "task";
+  const sp = opts.systemPrompt || "";
+  if (opts.isKeepAlive && (sp.includes("MeetingMonitor") || sp.includes("meeting_speak"))) {
+    return "meeting";
+  }
+  if (sp.includes("[Email Handler]") || sp.includes("email triage")) return "email";
+  return "chat";
+}
+function resolveSetsForContext(context, additionalSets) {
+  const sets = /* @__PURE__ */ new Set();
+  for (const [setName, tier] of Object.entries(TIER_MAP)) {
+    if (tier === 1) sets.add(setName);
+  }
+  for (const s of CONTEXT_PROMOTIONS[context]) sets.add(s);
+  if (additionalSets) {
+    for (const s of additionalSets) sets.add(s);
+  }
+  return sets;
+}
+function filterToolsForContext(allTools, context, options) {
+  const activeSets = resolveSetsForContext(context, options?.additionalSets);
+  if (options?.userMessage) {
+    const signaled = detectSignals(options.userMessage);
+    for (const s of signaled) activeSets.add(s);
+  }
+  const sessionId = options?.sessionId;
+  if (sessionId) {
+    const state = sessionToolStates.get(sessionId);
+    if (state) {
+      for (const s of state.loadedSets) activeSets.add(s);
+    }
+  }
+  const filtered = allTools.filter((tool) => {
+    const set = TOOL_REGISTRY[tool.name];
+    if (!set) return true;
+    return activeSets.has(set);
+  });
+  filtered.push(createRequestToolsTool(allTools, activeSets, context));
+  if (sessionId) {
+    const existing = sessionToolStates.get(sessionId);
+    if (existing) {
+      existing.loadedSets = activeSets;
+      existing.cachedTools = filtered;
+      existing.allToolsRef = allTools;
+      existing.context = context;
+    } else {
+      sessionToolStates.set(sessionId, {
+        context,
+        loadedSets: activeSets,
+        cachedTools: filtered,
+        allToolsRef: allTools,
+        lastContextChange: Date.now(),
+        loadHistory: [{ sets: [...activeSets], reason: `initial:${context}`, time: Date.now() }]
+      });
+    }
+  }
+  return filtered;
+}
+function transitionSessionContext(sessionId, newContext, allTools) {
+  const state = sessionToolStates.get(sessionId);
+  if (!state) return null;
+  const oldContext = state.context;
+  if (oldContext === newContext) return null;
+  console.log(`[tool-resolver] Session ${sessionId} transitioning: ${oldContext} \u2192 ${newContext}`);
+  const dynamicSets = /* @__PURE__ */ new Set();
+  const baseSetsOld = resolveSetsForContext(oldContext);
+  for (const s of state.loadedSets) {
+    if (!baseSetsOld.has(s)) dynamicSets.add(s);
+  }
+  const newSets = resolveSetsForContext(newContext);
+  for (const s of dynamicSets) newSets.add(s);
+  const filtered = allTools.filter((tool) => {
+    const set = TOOL_REGISTRY[tool.name];
+    if (!set) return true;
+    return newSets.has(set);
+  });
+  filtered.push(createRequestToolsTool(allTools, newSets, newContext));
+  state.context = newContext;
+  state.loadedSets = newSets;
+  state.cachedTools = filtered;
+  state.lastContextChange = Date.now();
+  state.loadHistory.push({ sets: [...newSets], reason: `transition:${oldContext}\u2192${newContext}`, time: Date.now() });
+  console.log(`[tool-resolver] Transitioned ${sessionId}: ${filtered.length} tools (was ${state.cachedTools?.length || "?"})`);
+  return filtered;
+}
+var SET_DESCRIPTIONS = {
+  core: "File I/O, search, bash (8 tools)",
+  browser: "Web browser automation (1 tool)",
+  system: "System capabilities check (1 tool)",
+  memory: "Agent memory \u2014 store/search/reflect (4 tools)",
+  visual_memory: "Vision capture, OCR, visual comparison (10 tools)",
+  meeting_voice: "In-meeting voice + chat (4 tools)",
+  meeting_lifecycle: "Join/schedule/manage meetings (8 tools)",
+  gws_chat: "Google Chat messaging (14 tools)",
+  smtp_email: "Email via SMTP/IMAP \u2014 send, read, search, manage (10 tools)",
+  gws_gmail: "Gmail read/send/search (15 tools)",
+  gws_calendar: "Google Calendar events (6 tools)",
+  gws_drive: "Google Drive files (7 tools)",
+  gws_docs: "Google Docs read/write (3 tools)",
+  gws_sheets: "Google Sheets read/write (7 tools)",
+  gws_contacts: "Google Contacts (5 tools)",
+  gws_slides: "Google Slides presentations (12 tools)",
+  gws_forms: "Google Forms surveys (8 tools)",
+  gws_tasks: "Google Tasks (7 tools)",
+  gws_maps: "Google Maps + Places (10 tools)",
+  ent_database: "SQL database tools (6 tools)",
+  ent_spreadsheet: "CSV/spreadsheet processing (8 tools)",
+  ent_documents: "PDF/DOCX generation, OCR, invoices (8 tools)",
+  ent_http: "HTTP requests, GraphQL (4 tools)",
+  ent_security: "Security scanning \u2014 secrets, PII, deps (6 tools)",
+  ent_code: "Code sandbox \u2014 JS, Python, shell (5 tools)",
+  ent_diff: "Text/JSON/spreadsheet diffs (4 tools)",
+  remotion_video: "Create videos programmatically \u2014 Remotion React framework (9 tools)",
+  ent_knowledge: "Knowledge base + hub search (3 tools)",
+  agenticmail: "Full email management (40 tools)",
+  local_filesystem: "File read/write/edit/move/delete/search (7 tools)",
+  local_shell: "Shell exec, PTY sessions, sudo, package install, dependency management (11 tools)",
+  msg_whatsapp: "WhatsApp messaging, media, groups (16 tools)",
+  msg_telegram: "Telegram messaging, media, and file download (5 tools)",
+  management: "Team management \u2014 delegate tasks, escalate, org chart (10 tools)",
+  mcp_bridge: "MCP integration adapters",
+  filesystem: "File system tools (alias)",
+  web: "Web tools (alias)"
+};
+function createRequestToolsTool(allTools, activeSets, _context) {
+  const loadedSets = new Set(activeSets);
+  const availableSetsInAllTools = /* @__PURE__ */ new Set();
+  for (const tool of allTools) {
+    const set = TOOL_REGISTRY[tool.name];
+    if (set) availableSetsInAllTools.add(set);
+  }
+  const allSets = Object.keys(SET_DESCRIPTIONS).filter((s) => availableSetsInAllTools.has(s));
+  const notLoaded = allSets.filter((s) => !loadedSets.has(s));
+  const description = notLoaded.length > 0 ? `Load more tools into this session. Available: ${notLoaded.map((s) => `${s} (${SET_DESCRIPTIONS[s]})`).join("; ")}.` : "All tool sets are loaded.";
+  return {
+    name: "request_tools",
+    label: "Request Tools",
+    description,
+    category: "utility",
+    parameters: {
+      type: "object",
+      properties: {
+        sets: {
+          type: "array",
+          items: { type: "string", enum: allSets },
+          description: "Tool sets to load"
+        }
+      },
+      required: ["sets"]
+    },
+    async execute(_id, params) {
+      const requested = params.sets || [];
+      const newSets = requested.filter((s) => !loadedSets.has(s) && SET_DESCRIPTIONS[s]);
+      if (newSets.length === 0) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            status: "no_change",
+            loaded: [...loadedSets],
+            message: requested.length === 0 ? "No sets specified. Available: " + notLoaded.join(", ") : "All requested sets already loaded."
+          }) }]
+        };
+      }
+      const newToolNames = /* @__PURE__ */ new Set();
+      for (const [name, set] of Object.entries(TOOL_REGISTRY)) {
+        if (newSets.includes(set)) newToolNames.add(name);
+      }
+      const newTools = allTools.filter((t) => newToolNames.has(t.name));
+      for (const s of newSets) loadedSets.add(s);
+      return {
+        content: [{ type: "text", text: JSON.stringify({
+          status: "loaded",
+          newSets,
+          newToolCount: newTools.length,
+          newTools: newTools.map((t) => t.name),
+          allLoaded: [...loadedSets],
+          message: `Loaded ${newTools.length} tools from: ${newSets.join(", ")}. They are now available.`
+        }) }],
+        _dynamicTools: newTools
+      };
+    }
+  };
+}
+async function createToolsForContext(options, context, opts) {
+  const { createAllTools } = await import("./agent-tools-3BMHAUUM.js");
+  if (context === "full") {
+    return createAllTools(options);
+  }
+  const allTools = await createAllTools(options);
+  return filterToolsForContext(allTools, context, {
+    additionalSets: opts?.additionalSets,
+    sessionId: opts?.sessionId,
+    userMessage: opts?.userMessage
+  });
+}
+async function getToolsForSession(sessionId, options, opts) {
+  const state = sessionToolStates.get(sessionId);
+  if (state?.cachedTools && state.allToolsRef) {
+    if (opts?.userMessage) {
+      const signaled = detectSignals(opts.userMessage);
+      const newSignals = signaled.filter((s) => !state.loadedSets.has(s));
+      if (newSignals.length > 0) {
+        for (const s of newSignals) state.loadedSets.add(s);
+        state.loadHistory.push({ sets: newSignals, reason: `signal:${newSignals.join(",")}`, time: Date.now() });
+        console.log(`[tool-resolver] Auto-promoted sets for ${sessionId}: ${newSignals.join(", ")}`);
+        const filtered = state.allToolsRef.filter((tool) => {
+          const set = TOOL_REGISTRY[tool.name];
+          if (!set) return true;
+          return state.loadedSets.has(set);
+        });
+        filtered.push(createRequestToolsTool(state.allToolsRef, state.loadedSets, state.context));
+        state.cachedTools = filtered;
+        return filtered;
+      }
+    }
+    if (opts?.context && opts.context !== state.context) {
+      const transitioned = transitionSessionContext(sessionId, opts.context, state.allToolsRef);
+      if (transitioned) return transitioned;
+    }
+    return state.cachedTools;
+  }
+  const context = opts?.context || state?.context || "chat";
+  return createToolsForContext(options, context, {
+    sessionId,
+    userMessage: opts?.userMessage
+  });
+}
+function getToolSetStats(tools) {
+  const bySet = {};
+  const unregistered = [];
+  for (const tool of tools) {
+    const set = TOOL_REGISTRY[tool.name];
+    if (!set) {
+      if (tool.name !== "request_tools") unregistered.push(tool.name);
+      continue;
+    }
+    bySet[set] = (bySet[set] || 0) + 1;
+  }
+  return { total: tools.length, bySet, unregistered };
+}
+
+// src/runtime/model-router.ts
+function parseModelString(modelStr) {
+  if (!modelStr) return null;
+  const parts = modelStr.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+  return { provider: parts[0], modelId: parts[1] };
+}
+function resolveModelForContext(agentConfig, context) {
+  if (!agentConfig) return null;
+  const routing = agentConfig.modelRouting;
+  if (routing) {
+    const contextModel = routing[context];
+    if (contextModel) {
+      const parsed = parseModelString(contextModel);
+      if (parsed) return parsed;
+    }
+  }
+  const voiceConfig = agentConfig.voiceConfig;
+  if (voiceConfig) {
+    if (context === "chat" && voiceConfig.chatModel) {
+      return parseModelString(voiceConfig.chatModel);
+    }
+    if (context === "meeting" && voiceConfig.meetingModel) {
+      return parseModelString(voiceConfig.meetingModel);
+    }
+  }
+  return null;
+}
+
+// src/runtime/gateway.ts
+import { Hono } from "hono";
+var activeStreams = /* @__PURE__ */ new Map();
+function emitSessionEvent(sessionId, event) {
+  var listeners = activeStreams.get(sessionId);
+  if (listeners) {
+    for (var listener of listeners) {
+      listener(event);
+    }
+  }
+}
+function createRuntimeGateway(config) {
+  var app = new Hono();
+  var runtime = config.runtime;
+  app.get("/health", function(c) {
+    return c.json({
+      status: "ok",
+      runtime: "active",
+      sessions: runtime.getActiveSessionCount()
+    });
+  });
+  app.post("/sessions", async function(c) {
+    try {
+      var body = await c.req.json();
+      var agentId = body.agentId;
+      var message = body.message;
+      var orgId = body.orgId || "default";
+      var modelOverride = body.model;
+      var systemPrompt = body.systemPrompt;
+      if (!agentId) {
+        return c.json({ error: "agentId is required" }, 400);
+      }
+      if (!message) {
+        return c.json({ error: "message is required" }, 400);
+      }
+      var session = await runtime.spawnSession({
+        agentId,
+        orgId,
+        message,
+        model: modelOverride,
+        systemPrompt
+      });
+      return c.json({
+        sessionId: session.id,
+        agentId: session.agentId,
+        status: session.status,
+        createdAt: session.createdAt
+      }, 201);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/sessions", async function(c) {
+    try {
+      var agentId = c.req.query("agentId");
+      var status = c.req.query("status");
+      var limit = parseInt(c.req.query("limit") || "50", 10);
+      if (!agentId) {
+        return c.json({ error: "agentId query parameter required" }, 400);
+      }
+      var sessions = await runtime.listSessions(agentId, { status, limit });
+      return c.json({ sessions });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/sessions/:id", async function(c) {
+    try {
+      var sessionId = c.req.param("id");
+      var session = await runtime.getSession(sessionId);
+      if (!session) {
+        return c.json({ error: "Session not found" }, 404);
+      }
+      return c.json(session);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.delete("/sessions/:id", async function(c) {
+    try {
+      var sessionId = c.req.param("id");
+      await runtime.terminateSession(sessionId);
+      return c.json({ status: "terminated" });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/sessions/:id/message", async function(c) {
+    try {
+      var sessionId = c.req.param("id");
+      var body = await c.req.json();
+      var message = body.message;
+      if (!message) {
+        return c.json({ error: "message is required" }, 400);
+      }
+      await runtime.sendMessage(sessionId, message);
+      return c.json({ status: "sent" });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/sessions/:id/stream", function(c) {
+    var sessionId = c.req.param("id");
+    return new Response(
+      new ReadableStream({
+        start(controller) {
+          var encoder = new TextEncoder();
+          function sendEvent(event) {
+            try {
+              var data = JSON.stringify(event);
+              controller.enqueue(encoder.encode(`data: ${data}
+
+`));
+              if (event.type === "session_end" || event.type === "error") {
+                cleanup();
+                controller.close();
+              }
+            } catch {
+            }
+          }
+          function cleanup() {
+            var listeners = activeStreams.get(sessionId);
+            if (listeners) {
+              listeners.delete(sendEvent);
+              if (listeners.size === 0) activeStreams.delete(sessionId);
+            }
+          }
+          if (!activeStreams.has(sessionId)) {
+            activeStreams.set(sessionId, /* @__PURE__ */ new Set());
+          }
+          activeStreams.get(sessionId).add(sendEvent);
+          controller.enqueue(encoder.encode(": connected\n\n"));
+        }
+      }),
+      {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive"
+        }
+      }
+    );
+  });
+  app.post("/spawn", async function(c) {
+    try {
+      var body = await c.req.json();
+      var parentSessionId = body.parentSessionId;
+      var task = body.task;
+      var agentId = body.agentId;
+      var model = body.model;
+      if (!parentSessionId || !task) {
+        return c.json({ error: "parentSessionId and task are required" }, 400);
+      }
+      var result = await runtime.spawnSubAgent({
+        parentSessionId,
+        task,
+        agentId,
+        model
+      });
+      return c.json(result, 201);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/hooks/inbound", async function(c) {
+    try {
+      var body = await c.req.json();
+      var result = await runtime.handleInboundEmail(body);
+      return c.json(result);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  return app;
+}
+
+// src/runtime/subagent.ts
+var SubAgentManager = class {
+  /** Active sub-agent records keyed by parent session ID */
+  subAgents = /* @__PURE__ */ new Map();
+  /** Max children per parent session */
+  maxChildrenPerParent;
+  /** Max spawn depth */
+  maxSpawnDepth;
+  constructor(opts) {
+    this.maxChildrenPerParent = opts?.maxChildrenPerParent ?? 5;
+    this.maxSpawnDepth = opts?.maxSpawnDepth ?? 2;
+  }
+  /**
+   * Register a new sub-agent spawn.
+   */
+  register(info) {
+    var existing = this.subAgents.get(info.parentSessionId) || [];
+    existing.push(info);
+    this.subAgents.set(info.parentSessionId, existing);
+  }
+  /**
+   * Check if spawning is allowed for this parent session.
+   */
+  canSpawn(parentSessionId) {
+    var children = this.subAgents.get(parentSessionId) || [];
+    var activeCount = children.filter(function(c) {
+      return c.status === "active";
+    }).length;
+    if (activeCount >= this.maxChildrenPerParent) {
+      return {
+        allowed: false,
+        reason: `Max active sub-agents reached (${activeCount}/${this.maxChildrenPerParent})`
+      };
+    }
+    return { allowed: true };
+  }
+  /**
+   * Get depth of a session in the sub-agent tree.
+   */
+  getDepth(sessionId) {
+    var depth = 0;
+    for (var [parentId, children] of this.subAgents) {
+      for (var child of children) {
+        if (child.childSessionId === sessionId) {
+          return 1 + this.getDepth(parentId);
+        }
+      }
+    }
+    return depth;
+  }
+  /**
+   * Mark a sub-agent as completed.
+   */
+  complete(childSessionId, status) {
+    for (var [, children] of this.subAgents) {
+      for (var child of children) {
+        if (child.childSessionId === childSessionId) {
+          child.status = status;
+          child.completedAt = Date.now();
+          return;
+        }
+      }
+    }
+  }
+  /**
+   * List sub-agents for a parent session.
+   */
+  listForParent(parentSessionId) {
+    return this.subAgents.get(parentSessionId) || [];
+  }
+  /**
+   * Cancel all active sub-agents for a parent.
+   */
+  cancelAll(parentSessionId) {
+    var children = this.subAgents.get(parentSessionId) || [];
+    var cancelled = [];
+    for (var child of children) {
+      if (child.status === "active") {
+        child.status = "cancelled";
+        child.completedAt = Date.now();
+        cancelled.push(child.childSessionId);
+      }
+    }
+    return cancelled;
+  }
+  /**
+   * Clean up all records for a parent session.
+   */
+  cleanup(parentSessionId) {
+    this.subAgents.delete(parentSessionId);
+  }
+  /**
+   * Get total active sub-agent count across all parents.
+   */
+  getActiveCount() {
+    var count = 0;
+    for (var [, children] of this.subAgents) {
+      count += children.filter(function(c) {
+        return c.status === "active";
+      }).length;
+    }
+    return count;
+  }
+};
+
+// src/runtime/email-channel.ts
+var EmailChannel = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Handle an inbound email and trigger an agent session.
+   */
+  async handleInbound(email) {
+    var agent = await this.config.resolveAgent(email.to);
+    if (!agent) {
+      throw new Error(`No agent found for email address: ${email.to}`);
+    }
+    var isNewSession = false;
+    var session = await this.config.findActiveSession(agent.agentId, email.from);
+    if (!session) {
+      session = await this.config.createSession(agent.agentId, agent.orgId);
+      isNewSession = true;
+    }
+    var messageContent = formatEmailAsMessage(email);
+    await this.config.sendMessage(session.id, messageContent);
+    return {
+      sessionId: session.id,
+      agentId: agent.agentId,
+      isNewSession
+    };
+  }
+};
+function formatEmailAsMessage(email) {
+  var parts = [];
+  parts.push(`[Inbound Email]`);
+  parts.push(`From: ${email.from}`);
+  parts.push(`Subject: ${email.subject}`);
+  if (email.inReplyTo) {
+    parts.push(`In-Reply-To: ${email.inReplyTo}`);
+  }
+  parts.push("");
+  parts.push(email.body);
+  if (email.attachments && email.attachments.length > 0) {
+    parts.push("");
+    parts.push(`Attachments (${email.attachments.length}):`);
+    for (var att of email.attachments) {
+      parts.push(`  - ${att.filename} (${att.contentType}, ${formatBytes(att.size)})`);
+    }
+  }
+  return parts.join("\n");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+// src/runtime/followup.ts
+import { nanoid as nanoid2 } from "nanoid";
+var FollowUpScheduler = class {
+  followUps = /* @__PURE__ */ new Map();
+  timer = null;
+  checkIntervalMs;
+  onDue;
+  db;
+  constructor(opts) {
+    this.onDue = opts.onDue;
+    this.db = opts.engineDb || null;
+    this.checkIntervalMs = opts.checkIntervalMs ?? 3e4;
+  }
+  /**
+   * Schedule a new follow-up.
+   */
+  async schedule(opts) {
+    var id = nanoid2(12);
+    var now = Date.now();
+    var followUp = {
+      id,
+      agentId: opts.agentId,
+      sessionId: opts.sessionId,
+      message: opts.message,
+      executeAt: opts.executeAt.getTime(),
+      status: "pending",
+      createdAt: now
+    };
+    this.followUps.set(id, followUp);
+    if (this.db) {
+      try {
+        await this.db.run(
+          `INSERT INTO agent_followups (id, agent_id, session_id, message, execute_at, status, created_at)
+           VALUES (?, ?, ?, ?, ?, 'pending', ?)`,
+          [id, opts.agentId, opts.sessionId || null, opts.message, followUp.executeAt, now]
+        );
+      } catch (err) {
+        console.warn("[followup] Failed to persist follow-up:", err.message);
+      }
+    }
+    return id;
+  }
+  /**
+   * Cancel a pending follow-up.
+   */
+  async cancel(followUpId) {
+    var followUp = this.followUps.get(followUpId);
+    if (!followUp || followUp.status !== "pending") return false;
+    followUp.status = "cancelled";
+    this.followUps.delete(followUpId);
+    if (this.db) {
+      try {
+        await this.db.run(
+          `UPDATE agent_followups SET status = 'cancelled' WHERE id = ?`,
+          [followUpId]
+        );
+      } catch {
+      }
+    }
+    return true;
+  }
+  /**
+   * List pending follow-ups for an agent.
+   */
+  listPending(agentId) {
+    var results = [];
+    for (var [, fu] of this.followUps) {
+      if (fu.agentId === agentId && fu.status === "pending") {
+        results.push(fu);
+      }
+    }
+    return results.sort(function(a, b) {
+      return a.executeAt - b.executeAt;
+    });
+  }
+  /**
+   * Start the scheduler. Loads pending follow-ups from DB if available.
+   */
+  async start() {
+    if (this.timer) return;
+    if (this.db) {
+      try {
+        var rows = await this.db.query(
+          `SELECT * FROM agent_followups WHERE status = 'pending' ORDER BY execute_at ASC`,
+          []
+        );
+        for (var row of rows || []) {
+          var r = row;
+          var followUp = {
+            id: r.id,
+            agentId: r.agent_id,
+            sessionId: r.session_id || void 0,
+            message: r.message,
+            executeAt: r.execute_at,
+            status: "pending",
+            createdAt: r.created_at
+          };
+          this.followUps.set(followUp.id, followUp);
+        }
+        if (this.followUps.size > 0) {
+          console.log(`[followup] Loaded ${this.followUps.size} pending follow-ups from DB`);
+        }
+      } catch (err) {
+        console.warn("[followup] Failed to load follow-ups from DB:", err.message);
+      }
+    }
+    var self = this;
+    this.timer = setInterval(async function() {
+      await self.checkDueFollowUps();
+    }, this.checkIntervalMs);
+    this.timer.unref();
+  }
+  /**
+   * Stop the scheduler.
+   */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Check for and execute due follow-ups.
+   */
+  async checkDueFollowUps() {
+    var now = Date.now();
+    var due = [];
+    for (var [_id, fu] of this.followUps) {
+      if (fu.status === "pending" && fu.executeAt <= now) {
+        due.push(fu);
+      }
+    }
+    for (var followUp of due) {
+      try {
+        followUp.status = "executed";
+        await this.onDue(followUp);
+        this.followUps.delete(followUp.id);
+        if (this.db) {
+          try {
+            await this.db.run(
+              `UPDATE agent_followups SET status = 'executed' WHERE id = ?`,
+              [followUp.id]
+            );
+          } catch {
+          }
+        }
+      } catch (err) {
+        console.warn(`[followup] Failed to execute follow-up ${followUp.id}: ${err}`);
+        followUp.status = "pending";
+      }
+    }
+  }
+  /**
+   * Get count of pending follow-ups.
+   */
+  getPendingCount() {
+    var count = 0;
+    for (var [, fu] of this.followUps) {
+      if (fu.status === "pending") count++;
+    }
+    return count;
+  }
+};
+
+// src/runtime/index.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync } from "fs";
+var _remotionPrompt = buildRemotonPrompt();
+var DEFAULT_MODEL = {
+  provider: "anthropic",
+  modelId: "claude-sonnet-4-5-20250929"
+};
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 3e4;
+var DEFAULT_STALE_SESSION_TIMEOUT_MS = 15 * 6e4;
+var DEFAULT_SSE_KEEPALIVE_MS = 15e3;
+var AgentRuntime = class {
+  config;
+  sessionManager = null;
+  subAgentManager;
+  followUpScheduler;
+  emailChannel = null;
+  gatewayApp = null;
+  activeSessions = /* @__PURE__ */ new Map();
+  sessionCompleteCallbacks = /* @__PURE__ */ new Map();
+  /** Sessions that should NOT complete even when the LLM returns end_turn (e.g., meeting monitor active) */
+  keepAliveSessions = /* @__PURE__ */ new Set();
+  /** Sessions with an agent loop currently executing (LLM call in flight) */
+  loopRunning = /* @__PURE__ */ new Set();
+  /** Queued messages for sessions whose loop is currently running — prevents concurrent loops */
+  pendingMessages = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  staleCheckTimer = null;
+  sseKeepaliveTimer = null;
+  started = false;
+  constructor(config) {
+    this.config = config;
+    this.subAgentManager = new SubAgentManager();
+    this.followUpScheduler = new FollowUpScheduler({
+      engineDb: config.engineDb,
+      onDue: async (followUp) => {
+        if (followUp.sessionId) {
+          await this.sendMessage(followUp.sessionId, `[Scheduled Reminder] ${followUp.message}`);
+        }
+      }
+    });
+  }
+  /** Build tool options for a given agent, including OAuth email config if available */
+  buildToolOptions(agentId, sessionId) {
+    const self = this;
+    const agentWorkspace = join(homedir(), ".agenticmail", "workspaces", agentId);
+    try {
+      mkdirSync(agentWorkspace, { recursive: true });
+    } catch {
+    }
+    const base = {
+      agentId,
+      workspaceDir: agentWorkspace,
+      agenticmailManager: this.config.agenticmailManager,
+      agentMemoryManager: this.config.agentMemoryManager,
+      engineDb: this.config.engineDb,
+      knowledgeEngine: this.config.knowledgeEngine,
+      orgId: this.config.orgId || process.env.ORG_ID || "default",
+      runtimeRef: {
+        sendMessage: (sid, message) => self.sendMessage(sid, message),
+        getCurrentSessionId: () => sessionId,
+        setKeepAlive: (sid, keepAlive) => self.setKeepAlive(sid, keepAlive),
+        terminateSession: (sid) => self.terminateSession(sid)
+      }
+    };
+    if (this.config.getEmailConfig) {
+      const ec = this.config.getEmailConfig(agentId);
+      if (ec?.oauthAccessToken || ec?.smtpHost) {
+        base.emailConfig = ec;
+        if (this.config.onTokenRefresh) {
+          const onRefresh = this.config.onTokenRefresh;
+          base.onTokenRefresh = (tokens) => onRefresh(agentId, tokens);
+        }
+      }
+    }
+    if (this.config.getAgentConfig) {
+      const agentConfig = this.config.getAgentConfig(agentId);
+      if (agentConfig?.enabledGoogleServices?.length) {
+        base.enabledGoogleServices = agentConfig.enabledGoogleServices;
+      } else if (agentConfig?.skills?.length) {
+        const skillToService = {
+          "gws-gmail": "gmail",
+          "gws-calendar": "calendar",
+          "gws-drive": "drive",
+          "gws-tasks": "tasks",
+          "gws-docs": "docs",
+          "gws-sheets": "sheets",
+          "gws-contacts": "contacts",
+          "gws-chat": "chat",
+          "gws-slides": "slides",
+          "gws-forms": "forms",
+          "gws-meet": "meetings"
+        };
+        const derived = agentConfig.skills.filter((s) => s.startsWith("gws-")).map((s) => skillToService[s]).filter(Boolean);
+        if (derived.length) base.enabledGoogleServices = derived;
+      }
+      if (agentConfig?.voiceConfig) {
+        base.voiceConfig = agentConfig.voiceConfig;
+        console.log(`[runtime] Voice config loaded: ${JSON.stringify(agentConfig.voiceConfig)}`);
+      } else {
+        console.log(`[runtime] No voiceConfig in agent config (keys: ${Object.keys(agentConfig || {}).join(", ")})`);
+      }
+      if (agentConfig?.messagingChannels) {
+        base.agentConfig = { messagingChannels: agentConfig.messagingChannels };
+      }
+      if (agentConfig?.toolSecurity?.security) {
+        base.security = agentConfig.toolSecurity.security;
+      } else if (self.orgToolSecurity) {
+        base.security = self.orgToolSecurity;
+      }
+    }
+    if (this.config.vault) {
+      base.vault = this.config.vault;
+    }
+    if (this.config.permissionEngine) {
+      base.permissionEngine = this.config.permissionEngine;
+    }
+    if (this.config.getIntegrationKey) {
+      const getKey = this.config.getIntegrationKey;
+      base.mapsApiKeyResolver = () => getKey("google-maps");
+      base.elevenLabsKeyResolver = () => getKey("elevenlabs");
+    }
+    if (this.config.hierarchyManager) {
+      base.hierarchyManager = this.config.hierarchyManager;
+    }
+    if (this.config.mcpProcessManager) {
+      base.mcpProcessManager = this.config.mcpProcessManager;
+    }
+    if (this.config.databaseManager) {
+      base.databaseManager = this.config.databaseManager;
+    }
+    return base;
+  }
+  /**
+   * Start the runtime — initializes session manager, gateway, schedulers,
+   * heartbeat, stale detection, and resumes active sessions.
+   */
+  async start() {
+    if (this.started) return;
+    try {
+      if (this.config.adminDb) {
+        var settings = await this.config.adminDb.getSettings();
+        var pricingConfig = settings?.modelPricingConfig;
+        if (pricingConfig && pricingConfig.customProviders) {
+          this.customProviders = pricingConfig.customProviders;
+        }
+        var toolSecConfig = settings?.toolSecurityConfig;
+        if (toolSecConfig?.security) {
+          this.orgToolSecurity = toolSecConfig.security;
+        }
+      }
+    } catch {
+    }
+    this.sessionManager = new SessionManager({ engineDb: this.config.engineDb });
+    var self = this;
+    this.emailChannel = new EmailChannel({
+      async resolveAgent(email) {
+        try {
+          var rows = await self.config.engineDb.query(
+            `SELECT id, org_id FROM managed_agents WHERE config LIKE ? AND state = 'running'`,
+            [`%${email}%`]
+          );
+          if (rows && rows.length > 0) {
+            var row = rows[0];
+            return { agentId: row.id, orgId: row.org_id };
+          }
+        } catch {
+        }
+        return null;
+      },
+      async findActiveSession(agentId, _senderEmail) {
+        var sessions = await self.sessionManager.listSessions(agentId, { status: "active", limit: 1 });
+        return sessions.length > 0 ? await self.sessionManager.getSession(sessions[0].id) : null;
+      },
+      async createSession(agentId, orgId) {
+        return self.sessionManager.createSession(agentId, orgId);
+      },
+      async sendMessage(sessionId, message) {
+        await self.sendMessage(sessionId, message);
+      }
+    });
+    if (this.config.gatewayEnabled !== false) {
+      this.gatewayApp = createRuntimeGateway({ runtime: this });
+    }
+    await this.followUpScheduler.start();
+    var heartbeatMs = this.config.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this.heartbeatTimer = setInterval(function() {
+      self.emitHeartbeats().catch(function() {
+      });
+    }, heartbeatMs);
+    this.heartbeatTimer.unref();
+    var staleTimeoutMs = this.config.staleSessionTimeoutMs ?? DEFAULT_STALE_SESSION_TIMEOUT_MS;
+    this.staleCheckTimer = setInterval(function() {
+      self.cleanupStaleSessions(staleTimeoutMs).catch(function() {
+      });
+    }, staleTimeoutMs);
+    this.staleCheckTimer.unref();
+    this.sseKeepaliveTimer = setInterval(function() {
+      for (var [sessionId] of self.activeSessions) {
+        emitSessionEvent(sessionId, {
+          type: "heartbeat",
+          timestamp: Date.now(),
+          activeTurns: self.activeSessions.size
+        });
+      }
+    }, DEFAULT_SSE_KEEPALIVE_MS);
+    this.sseKeepaliveTimer.unref();
+    this.started = true;
+    console.log("[runtime] Agent runtime started");
+    if (this.config.resumeOnStartup !== false) {
+      await this.resumeActiveSessions();
+    }
+  }
+  /**
+   * Spawn a new agent session and begin processing.
+   */
+  async spawnSession(opts) {
+    this.ensureStarted();
+    var agentId = opts.agentId;
+    var orgId = opts.orgId || "default";
+    var model = opts.model || this.config.defaultModel || DEFAULT_MODEL;
+    var session = await this.sessionManager.createSession(agentId, orgId, opts.parentSessionId);
+    var memoryContext = "";
+    if (this.config.agentMemoryManager) {
+      try {
+        memoryContext = await this.config.agentMemoryManager.generateMemoryContext(agentId);
+      } catch {
+      }
+    }
+    var hierarchyContext = "";
+    if (this.config.hierarchyManager) {
+      try {
+        hierarchyContext = await this.config.hierarchyManager.buildManagerPrompt(agentId) || "";
+      } catch {
+      }
+    }
+    var _agentCfg = this.config.getAgentConfig ? this.config.getAgentConfig(agentId) : null;
+    var _agentIdentity = _agentCfg?.identity || null;
+    var _dbConnections = [];
+    try {
+      if (this.config.databaseManager) _dbConnections = this.config.databaseManager.getAgentConnectionSummary(agentId);
+    } catch {
+    }
+    var systemPrompt = opts.systemPrompt || buildDefaultSystemPrompt(agentId, memoryContext, hierarchyContext, _agentIdentity, _dbConnections);
+    var sessionContext = detectSessionContext({
+      systemPrompt,
+      sessionKind: opts.kind,
+      explicitContext: opts.sessionContext
+    });
+    var toolOpts = this.buildToolOptions(agentId, session.id);
+    var tools = opts.tools || await createToolsForContext(toolOpts, sessionContext, {
+      additionalSets: opts.additionalSets,
+      sessionId: session.id,
+      userMessage: opts.message
+    });
+    var toolStats = getToolSetStats(tools);
+    console.log(`[runtime] Session ${session.id} tools: ${toolStats.total} (context: ${sessionContext})${toolStats.unregistered.length ? `, unregistered: ${toolStats.unregistered.join(",")}` : ""}`);
+    if (this._reportStatus) {
+      this._reportStatus({
+        status: "online",
+        activeSessions: this.activeSessions.size,
+        currentActivity: { type: sessionContext, detail: opts.message?.slice(0, 100), sessionId: session.id, startedAt: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+    }
+    var _contextModel = this.resolveModelForContext(agentId, sessionContext);
+    if (_contextModel) {
+      model = _contextModel;
+      console.log(`[runtime] ${sessionContext} session \u2014 using model: ${_contextModel.provider}/${_contextModel.modelId}`);
+    }
+    var agentConfig = {
+      agentId,
+      orgId,
+      model,
+      systemPrompt,
+      tools
+    };
+    var apiKey = await this.resolveApiKeyAsync(model.provider, agentId);
+    if (!apiKey) {
+      await this.sessionManager.updateSession(session.id, { status: "failed" });
+      throw new Error(`No API key configured for provider: ${model.provider}`);
+    }
+    for (let ci = 0; ci < apiKey.length; ci++) {
+      if (apiKey.charCodeAt(ci) > 127) {
+        console.error(`[runtime] WARNING: API key for ${model.provider} contains non-ASCII at index ${ci}: charCode=${apiKey.charCodeAt(ci)}`);
+        break;
+      }
+    }
+    const initialContent = opts.messageContent || opts.message;
+    this.runSessionLoop(session.id, agentConfig, [{ role: "user", content: initialContent }], apiKey);
+    return session;
+  }
+  /**
+   * Send a message to an active session.
+   */
+  async sendMessage(sessionId, message) {
+    this.ensureStarted();
+    var session = await this.sessionManager.getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    if (session.status !== "active") throw new Error(`Session is not active: ${session.status}`);
+    await this.sessionManager.appendMessage(sessionId, { role: "user", content: message });
+    if (this.loopRunning.has(sessionId)) {
+      var queue = this.pendingMessages.get(sessionId);
+      if (!queue) {
+        queue = [];
+        this.pendingMessages.set(sessionId, queue);
+      }
+      queue.push(message);
+      console.log(`[runtime] Session ${sessionId} loop active \u2014 queued message (${queue.length} pending)`);
+      return;
+    }
+    var updatedSession = await this.sessionManager.getSession(sessionId);
+    var messages = updatedSession?.messages || [...session.messages, { role: "user", content: message }];
+    var model = this.config.defaultModel || DEFAULT_MODEL;
+    var _smCtx = this.keepAliveSessions.has(sessionId) ? "meeting" : "chat";
+    var _smModel = this.resolveModelForContext(session.agentId, _smCtx);
+    if (_smModel) {
+      model = _smModel;
+    }
+    var apiKey = await this.resolveApiKeyAsync(model.provider, session.agentId);
+    if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+    var memoryContext = "";
+    if (this.config.agentMemoryManager) {
+      try {
+        memoryContext = await this.config.agentMemoryManager.generateMemoryContext(session.agentId);
+      } catch {
+      }
+    }
+    var _hierarchyCtx = "";
+    if (this.config.hierarchyManager) {
+      try {
+        _hierarchyCtx = await this.config.hierarchyManager.buildManagerPrompt(session.agentId) || "";
+      } catch {
+      }
+    }
+    var _aCfg2 = this.config.getAgentConfig ? this.config.getAgentConfig(session.agentId) : null;
+    var _dbConns2 = [];
+    try {
+      if (this.config.databaseManager) _dbConns2 = this.config.databaseManager.getAgentConnectionSummary(session.agentId);
+    } catch {
+    }
+    var _systemPrompt = buildDefaultSystemPrompt(session.agentId, memoryContext, _hierarchyCtx, _aCfg2?.identity, _dbConns2);
+    var _sessionContext;
+    if (!this.keepAliveSessions.has(sessionId)) {
+      _sessionContext = detectSessionContext({
+        systemPrompt: _systemPrompt,
+        isKeepAlive: false
+      });
+    }
+    var tools = await getToolsForSession(sessionId, this.buildToolOptions(session.agentId, sessionId), {
+      context: _sessionContext,
+      userMessage: message
+    });
+    var agentConfig = {
+      agentId: session.agentId,
+      orgId: session.orgId,
+      model,
+      systemPrompt: _systemPrompt,
+      tools
+    };
+    this.runSessionLoop(sessionId, agentConfig, messages, apiKey);
+  }
+  /**
+   * Register a callback for when a session completes (or fails).
+   */
+  onSessionComplete(sessionId, callback) {
+    var existing = this.sessionCompleteCallbacks.get(sessionId);
+    if (!existing) {
+      existing = [];
+      this.sessionCompleteCallbacks.set(sessionId, existing);
+    }
+    existing.push(callback);
+  }
+  /**
+   * Terminate an active session.
+   */
+  async terminateSession(sessionId) {
+    var controller = this.activeSessions.get(sessionId);
+    if (controller) {
+      controller.abort();
+      this.activeSessions.delete(sessionId);
+    }
+    if (this.sessionManager) {
+      await this.sessionManager.updateSession(sessionId, { status: "completed" });
+    }
+    if (this._reportStatus) {
+      this._reportStatus({
+        status: this.activeSessions.size > 0 ? "online" : "idle",
+        activeSessions: this.activeSessions.size,
+        currentActivity: null
+      });
+    }
+  }
+  /**
+   * Get a session by ID.
+   */
+  async getSession(sessionId) {
+    this.ensureStarted();
+    return this.sessionManager.getSession(sessionId);
+  }
+  /**
+   * List sessions for an agent.
+   */
+  async listSessions(agentId, opts) {
+    this.ensureStarted();
+    return this.sessionManager.listSessions(agentId, opts);
+  }
+  /**
+   * Spawn a sub-agent.
+   */
+  async spawnSubAgent(opts) {
+    this.ensureStarted();
+    var check = this.subAgentManager.canSpawn(opts.parentSessionId);
+    if (!check.allowed) {
+      return { id: "", childSessionId: "", agentId: "", status: "error", error: check.reason };
+    }
+    var parentSession = await this.sessionManager.getSession(opts.parentSessionId);
+    if (!parentSession) {
+      return { id: "", childSessionId: "", agentId: "", status: "error", error: "Parent session not found" };
+    }
+    var agentId = opts.agentId || parentSession.agentId;
+    var childSession = await this.spawnSession({
+      agentId,
+      orgId: parentSession.orgId,
+      message: `[Sub-Agent Task] ${opts.task}`,
+      model: opts.model,
+      parentSessionId: opts.parentSessionId
+    });
+    var id = nanoid3(12);
+    this.subAgentManager.register({
+      id,
+      parentSessionId: opts.parentSessionId,
+      childSessionId: childSession.id,
+      agentId,
+      task: opts.task,
+      status: "active",
+      createdAt: Date.now()
+    });
+    return {
+      id,
+      childSessionId: childSession.id,
+      agentId,
+      status: "accepted"
+    };
+  }
+  /**
+   * Handle inbound email.
+   */
+  async handleInboundEmail(email) {
+    this.ensureStarted();
+    if (!this.emailChannel) throw new Error("Email channel not initialized");
+    return this.emailChannel.handleInbound(email);
+  }
+  /**
+   * Schedule a follow-up.
+   */
+  async scheduleFollowUp(opts) {
+    return this.followUpScheduler.schedule(opts);
+  }
+  /**
+   * Cancel a follow-up.
+   */
+  async cancelFollowUp(followUpId) {
+    return this.followUpScheduler.cancel(followUpId);
+  }
+  /**
+   * Get the Hono sub-app for mounting.
+   */
+  getApp() {
+    return this.gatewayApp;
+  }
+  /**
+   * Get the number of active sessions.
+   */
+  getActiveSessionCount() {
+    return this.activeSessions.size;
+  }
+  /**
+   * Mark a session as "keep alive" — prevents it from completing when the LLM returns end_turn.
+   * Used by MeetingMonitor to keep meeting sessions alive for incoming caption/chat updates.
+   * The session stays in 'active' status and waits for the next sendMessage() call.
+   */
+  setKeepAlive(sessionId, keepAlive) {
+    if (keepAlive) {
+      this.keepAliveSessions.add(sessionId);
+      console.log(`[runtime] Session ${sessionId} marked as keep-alive`);
+    } else {
+      this.keepAliveSessions.delete(sessionId);
+      console.log(`[runtime] Session ${sessionId} keep-alive removed`);
+    }
+  }
+  isKeepAlive(sessionId) {
+    return this.keepAliveSessions.has(sessionId);
+  }
+  /**
+   * Stop the runtime.
+   */
+  async stop() {
+    if (!this.started) return;
+    for (var [_sessionId, controller] of this.activeSessions) {
+      controller.abort();
+    }
+    this.activeSessions.clear();
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.staleCheckTimer) {
+      clearInterval(this.staleCheckTimer);
+      this.staleCheckTimer = null;
+    }
+    if (this.sseKeepaliveTimer) {
+      clearInterval(this.sseKeepaliveTimer);
+      this.sseKeepaliveTimer = null;
+    }
+    this.followUpScheduler.stop();
+    this.started = false;
+    console.log("[runtime] Agent runtime stopped");
+  }
+  // ─── Private: Session Loop ─────────────────────────
+  /**
+   * Run the agent loop for a session with all long-running features wired in:
+   * incremental persistence, heartbeat, retry, budget checks.
+   */
+  runSessionLoop(sessionId, agentConfig, initialMessages, apiKey, isResume) {
+    var self = this;
+    this.loopRunning.add(sessionId);
+    var _loopCtx = this.keepAliveSessions.has(sessionId) ? "meeting" : "chat";
+    var _loopModel = this.resolveModelForContext(agentConfig.agentId, _loopCtx);
+    var hooks = createRuntimeHooks({
+      engineDb: this.config.engineDb,
+      agentId: agentConfig.agentId,
+      orgId: agentConfig.orgId
+    });
+    var abortController = new AbortController();
+    this.activeSessions.set(sessionId, abortController);
+    if (isResume) {
+      emitSessionEvent(sessionId, { type: "session_resumed", sessionId, turnCount: 0 });
+    }
+    hooks.onSessionStart(sessionId, agentConfig.agentId, agentConfig.orgId).catch(function() {
+    });
+    (async function() {
+      try {
+        if (_loopModel && agentConfig.model.modelId !== _loopModel.modelId) {
+          agentConfig = { ...agentConfig, model: _loopModel };
+          apiKey = await self.resolveApiKeyAsync(_loopModel.provider, agentConfig.agentId) || apiKey;
+        }
+        var _fallbackModels = [];
+        if (self.config.getAgentConfig) {
+          var _ac = self.config.getAgentConfig(agentConfig.agentId);
+          if (_ac?.fallbackModels) _fallbackModels = _ac.fallbackModels;
+          else if (_ac?.modelFallback?.fallbacks) _fallbackModels = _ac.modelFallback.fallbacks;
+        }
+        var result = await runAgentLoop(agentConfig, initialMessages, hooks, {
+          apiKey,
+          signal: abortController.signal,
+          sessionId,
+          retryConfig: self.config.retry,
+          runtime: self,
+          fallbackModels: _fallbackModels,
+          resolveApiKey: async function(provider) {
+            return self.resolveApiKeyAsync(provider, agentConfig.agentId);
+          },
+          // Incremental persistence — save messages after every turn
+          onCheckpoint: async function(data) {
+            try {
+              await self.sessionManager.replaceMessages(sessionId, data.messages);
+              await self.sessionManager.touchSession(sessionId, {
+                tokenCount: data.tokenCount,
+                turnCount: data.turnCount
+              });
+              emitSessionEvent(sessionId, {
+                type: "checkpoint",
+                turnNumber: data.turnCount,
+                tokenCount: data.tokenCount,
+                messageCount: data.messages.length
+              });
+            } catch (err) {
+              console.warn(`[runtime] Checkpoint save error for ${sessionId}: ${err.message}`);
+            }
+          },
+          // Heartbeat — keep session alive during long operations
+          onHeartbeat: async function(data) {
+            try {
+              await self.sessionManager.touchSession(sessionId, {
+                tokenCount: data.tokenCount,
+                turnCount: data.turnCount
+              });
+            } catch {
+            }
+          },
+          onEvent: function(event) {
+            emitSessionEvent(sessionId, event);
+          }
+        });
+        await self.sessionManager.replaceMessages(sessionId, result.messages);
+        if (self.keepAliveSessions.has(sessionId)) {
+          await self.sessionManager.touchSession(sessionId, {
+            tokenCount: result.tokenCount,
+            turnCount: result.turnCount
+          });
+          self.loopRunning.delete(sessionId);
+          var queued = self.pendingMessages.get(sessionId);
+          if (queued && queued.length > 0) {
+            self.pendingMessages.delete(sessionId);
+            console.log(`[runtime] Session ${sessionId} keep-alive loop done \u2014 draining ${queued.length} queued message(s)`);
+            for (var qm of queued) {
+              await self.sessionManager.appendMessage(sessionId, { role: "user", content: qm });
+            }
+            var freshSession = await self.sessionManager.getSession(sessionId);
+            var freshMessages = freshSession?.messages || [...result.messages, ...queued.map(function(q) {
+              return { role: "user", content: q };
+            })];
+            var lastMsg = freshMessages[freshMessages.length - 1];
+            if (lastMsg && lastMsg.role !== "user") {
+              var nudge = { role: "user", content: "[System] You have new messages above. Please respond." };
+              freshMessages.push(nudge);
+              await self.sessionManager.appendMessage(sessionId, nudge);
+            }
+            self.runSessionLoop(sessionId, agentConfig, freshMessages, apiKey);
+          } else {
+            console.log(`[runtime] Session ${sessionId} finished LLM turn but is keep-alive \u2014 staying active for incoming messages`);
+          }
+          return;
+        }
+        await self.sessionManager.updateSession(sessionId, {
+          status: result.status,
+          tokenCount: result.tokenCount,
+          turnCount: result.turnCount
+        });
+        var cancelledChildren = self.subAgentManager.cancelAll(sessionId);
+        for (var childId of cancelledChildren) {
+          await self.terminateSession(childId).catch(function() {
+          });
+        }
+        await hooks.onSessionEnd(sessionId, agentConfig.agentId, agentConfig.orgId);
+        var cbs = self.sessionCompleteCallbacks.get(sessionId);
+        if (cbs) {
+          for (var cb of cbs) {
+            try {
+              cb(result);
+            } catch {
+            }
+          }
+          self.sessionCompleteCallbacks.delete(sessionId);
+        }
+      } catch (err) {
+        console.error(`[runtime] Session ${sessionId} error: ${err.message}`);
+        self.loopRunning.delete(sessionId);
+        self.pendingMessages.delete(sessionId);
+        await self.sessionManager.updateSession(sessionId, { status: "failed" }).catch(function() {
+        });
+        emitSessionEvent(sessionId, { type: "error", message: err.message });
+        var cbs2 = self.sessionCompleteCallbacks.get(sessionId);
+        if (cbs2) {
+          for (var cb2 of cbs2) {
+            try {
+              cb2({ status: "failed", error: err.message });
+            } catch {
+            }
+          }
+          self.sessionCompleteCallbacks.delete(sessionId);
+        }
+      } finally {
+        if (!self.keepAliveSessions.has(sessionId)) {
+          self.loopRunning.delete(sessionId);
+          self.pendingMessages.delete(sessionId);
+          self.activeSessions.delete(sessionId);
+          clearSessionToolState(sessionId);
+        }
+      }
+    })();
+  }
+  // ─── Private: Session Resume ───────────────────────
+  /**
+   * Resume active sessions from DB on startup.
+   * Sessions that were in-progress when the process died get picked up again.
+   */
+  async resumeActiveSessions() {
+    try {
+      var activeSessions = await this.sessionManager.findActiveSessions();
+      if (activeSessions.length === 0) return;
+      console.log(`[runtime] Found ${activeSessions.length} active session(s) to resume`);
+      for (var sessionMeta of activeSessions) {
+        try {
+          var session = await this.sessionManager.getSession(sessionMeta.id);
+          if (!session || session.messages.length === 0) {
+            await this.sessionManager.updateSession(sessionMeta.id, { status: "completed" });
+            continue;
+          }
+          if (sessionMeta.status === "failed") {
+            var lastUserIdx = -1;
+            var lastAssistantIdx = -1;
+            for (var mi = session.messages.length - 1; mi >= 0; mi--) {
+              if (session.messages[mi].role === "user" && lastUserIdx < 0) lastUserIdx = mi;
+              if (session.messages[mi].role === "assistant" && lastAssistantIdx < 0) lastAssistantIdx = mi;
+              if (lastUserIdx >= 0 && lastAssistantIdx >= 0) break;
+            }
+            if (lastUserIdx < lastAssistantIdx || lastUserIdx < 0) {
+              await this.sessionManager.updateSession(sessionMeta.id, { status: "completed" });
+              continue;
+            }
+            console.log(`[runtime] Recovering failed session ${session.id} \u2014 agent never replied to user message`);
+          }
+          await this.sessionManager.updateSession(session.id, { status: "active" });
+          var model = this.config.defaultModel || DEFAULT_MODEL;
+          var apiKey = await this.resolveApiKeyAsync(model.provider, session.agentId);
+          if (!apiKey) {
+            console.warn(`[runtime] Cannot resume session ${session.id}: no API key for ${model.provider}`);
+            await this.sessionManager.updateSession(session.id, { status: "failed" });
+            continue;
+          }
+          var mc = "";
+          if (this.config.agentMemoryManager) {
+            try {
+              mc = await this.config.agentMemoryManager.generateMemoryContext(session.agentId);
+            } catch {
+            }
+          }
+          var _hc = "";
+          if (this.config.hierarchyManager) {
+            try {
+              _hc = await this.config.hierarchyManager.buildManagerPrompt(session.agentId) || "";
+            } catch {
+            }
+          }
+          var _rCfg = this.config.getAgentConfig ? this.config.getAgentConfig(session.agentId) : null;
+          var _dbC3 = [];
+          try {
+            if (this.config.databaseManager) _dbC3 = this.config.databaseManager.getAgentConnectionSummary(session.agentId);
+          } catch {
+          }
+          var _resumePrompt = buildDefaultSystemPrompt(session.agentId, mc, _hc, _rCfg?.identity, _dbC3);
+          var _resumeCtx = detectSessionContext({
+            systemPrompt: _resumePrompt,
+            isKeepAlive: this.keepAliveSessions.has(session.id)
+          });
+          var tools = await createToolsForContext(this.buildToolOptions(session.agentId, session.id), _resumeCtx, {
+            sessionId: session.id
+          });
+          var agentConfig = {
+            agentId: session.agentId,
+            orgId: session.orgId,
+            model,
+            systemPrompt: _resumePrompt,
+            tools
+          };
+          var resumeMessages = [...session.messages];
+          resumeMessages.push({
+            role: "system",
+            content: `[Runtime Notice] Session resumed after process restart. Continue where you left off. Current time: ${(/* @__PURE__ */ new Date()).toISOString()}`
+          });
+          this.runSessionLoop(session.id, agentConfig, resumeMessages, apiKey, true);
+          console.log(`[runtime] Resumed session ${session.id} (agent: ${session.agentId}, turns: ${session.turnCount})`);
+        } catch (err) {
+          console.error(`[runtime] Failed to resume session ${sessionMeta.id}: ${err.message}`);
+          await this.sessionManager.updateSession(sessionMeta.id, { status: "failed" }).catch(function() {
+          });
+        }
+      }
+    } catch (err) {
+      console.warn(`[runtime] Session resume scan failed: ${err.message}`);
+    }
+  }
+  // ─── Private: Heartbeat + Stale Detection ──────────
+  /**
+   * Emit heartbeats for all active sessions (touch DB updated_at).
+   */
+  async emitHeartbeats() {
+    for (var [sessionId] of this.activeSessions) {
+      try {
+        await this.sessionManager.touchSession(sessionId);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Find and mark sessions that have gone stale (no heartbeat within timeout).
+   */
+  async cleanupStaleSessions(timeoutMs) {
+    try {
+      var staleIds = await this.sessionManager.markStaleSessions(timeoutMs);
+      for (var id of staleIds) {
+        var controller = this.activeSessions.get(id);
+        if (controller) {
+          controller.abort();
+          this.activeSessions.delete(id);
+        }
+        console.warn(`[runtime] Marked stale session: ${id}`);
+      }
+    } catch {
+    }
+  }
+  // ─── Private: Helpers ──────────────────────────────
+  ensureStarted() {
+    if (!this.started) {
+      throw new Error("Runtime not started. Call runtime.start() first.");
+    }
+  }
+  customProviders = [];
+  orgToolSecurity = null;
+  _resolveApiKey(provider, agentId) {
+    return resolveApiKeyForProvider(provider, this.config.apiKeys, this.customProviders);
+  }
+  /** Resolve API key with org-scoped fallback (async — checks org integrations first) */
+  async resolveApiKeyAsync(provider, agentId) {
+    if (agentId && this.config.resolveOrgApiKey) {
+      try {
+        const orgKey = await this.config.resolveOrgApiKey(agentId, provider);
+        if (orgKey) return orgKey;
+      } catch {
+      }
+    }
+    return resolveApiKeyForProvider(provider, this.config.apiKeys, this.customProviders);
+  }
+  /** Resolve per-context model from agent's modelRouting config */
+  resolveModelForContext(agentId, context) {
+    const agentCfg = this.config.getAgentConfig?.(agentId);
+    return resolveModelForContext(agentCfg, context);
+  }
+  /** Returns all available providers (built-in + custom). */
+  getProviderRegistry() {
+    return { builtIn: PROVIDER_REGISTRY, custom: this.customProviders };
+  }
+};
+function createAgentRuntime(config) {
+  return new AgentRuntime(config);
+}
+function buildDefaultSystemPrompt(agentId, memoryContext, hierarchyContext, agentIdentity, dbConnections) {
+  const wsDir = join(homedir(), ".agenticmail", "workspaces", agentId);
+  var base = `You are an AI agent managed by AgenticMail Enterprise (agent: ${agentId}).
+
+You have access to a comprehensive set of tools for completing tasks. Use them effectively.
+
+Guidelines:
+- Be helpful, accurate, and professional
+- Use tools when they help accomplish the task
+- Explain your reasoning when making decisions
+- If you encounter an error, try an alternative approach
+- Respect organization policies and permissions
+- Keep responses concise unless detail is requested
+- For long tasks, work systematically and report progress
+
+## Your Workspace
+Your dedicated workspace directory is: ${wsDir}
+ALWAYS save files, deliverables, rendered videos, images, and outputs here \u2014 NEVER in /tmp.
+/tmp files are cleaned up by the OS and will be lost. Your workspace persists across sessions.
+Create subdirectories as needed (e.g. videos/, images/, projects/, exports/).
+- ACTIVELY USE YOUR MEMORY: After corrections, lessons, or insights, call memory_reflect to record them
+- Before complex tasks, call memory_context to recall relevant knowledge
+- Your memory persists across conversations \u2014 it's how you grow as an expert
+
+Database Tools:
+- ent_db_* tools: For LOCAL databases \u2014 SQLite files in the workspace. Read-only inspection.
+- db_* tools (db_query, db_list_connections, db_list_tables, db_describe_table): For EXTERNAL databases granted to you by your admin.
+  IMPORTANT: When asked about any database by name, ALWAYS use db_* tools first. Start with db_list_connections.
+${dbConnections && dbConnections.length > 0 ? `
+Your External Database Access:
+${dbConnections.map((c) => "  - " + c).join("\n")}
+Use db_query with the connection name to query these databases.` : ""}
+
+Current time: ${(/* @__PURE__ */ new Date()).toISOString()}`;
+  if (memoryContext) {
+    base += "\n\n" + memoryContext;
+  }
+  if (hierarchyContext) {
+    base += "\n\n" + hierarchyContext;
+  }
+  base += "\n" + _remotionPrompt;
+  if (agentIdentity?.language && agentIdentity.language !== "en-us") {
+    var langMap = {
+      "en-us": "English (American)",
+      "en-gb": "English (British)",
+      "en-au": "English (Australian)",
+      "en-ca": "English (Canadian)",
+      "en-in": "English (Indian)",
+      "en-za": "English (South African)",
+      "en-ie": "English (Irish)",
+      "en-ng": "English (Nigerian)",
+      "es": "Spanish",
+      "es-mx": "Mexican Spanish",
+      "es-ar": "Argentine Spanish",
+      "es-co": "Colombian Spanish",
+      "es-latam": "Latin American Spanish",
+      "pt": "Portuguese",
+      "pt-br": "Brazilian Portuguese",
+      "fr": "French",
+      "fr-ca": "Canadian French",
+      "fr-be": "Belgian French",
+      "fr-ch": "Swiss French",
+      "fr-af": "African French",
+      "zh": "Simplified Chinese (Mandarin)",
+      "zh-tw": "Traditional Chinese (Mandarin)",
+      "zh-yue": "Cantonese",
+      "ar": "Modern Standard Arabic",
+      "ar-eg": "Egyptian Arabic",
+      "ar-sa": "Saudi Arabic",
+      "ar-ma": "Moroccan Arabic",
+      "de": "German",
+      "de-at": "Austrian German",
+      "de-ch": "Swiss German",
+      "it": "Italian",
+      "nl": "Dutch",
+      "ru": "Russian",
+      "pl": "Polish",
+      "uk": "Ukrainian",
+      "ja": "Japanese",
+      "ko": "Korean",
+      "hi": "Hindi",
+      "bn": "Bengali",
+      "ur": "Urdu",
+      "ta": "Tamil",
+      "te": "Telugu",
+      "mr": "Marathi",
+      "th": "Thai",
+      "vi": "Vietnamese",
+      "id": "Indonesian",
+      "ms": "Malay",
+      "tl": "Filipino (Tagalog)",
+      "yo": "Yoruba",
+      "ig": "Igbo",
+      "ha": "Hausa",
+      "sw": "Swahili",
+      "am": "Amharic",
+      "tr": "Turkish",
+      "sv": "Swedish",
+      "no": "Norwegian",
+      "da": "Danish",
+      "fi": "Finnish",
+      "el": "Greek",
+      "he": "Hebrew",
+      "fa": "Persian (Farsi)",
+      "ro": "Romanian",
+      "hu": "Hungarian",
+      "cs": "Czech",
+      "sk": "Slovak",
+      "bg": "Bulgarian",
+      "hr": "Croatian",
+      "sr": "Serbian",
+      "ca": "Catalan",
+      "gl": "Galician",
+      "eu": "Basque",
+      "af": "Afrikaans"
+    };
+    var langName = langMap[agentIdentity.language] || agentIdentity.language;
+    base += `
+
+## Language Requirement
+**CRITICAL: You MUST respond in ${langName} at all times.**
+- ALL your responses, messages, emails, and communications must be written in ${langName}.
+- When users write to you in any language, understand their message but ALWAYS reply in ${langName}.
+- Tool calls, code, and technical identifiers remain in their original language (English/code), but all human-facing text must be in ${langName}.
+- This is a hard requirement set by your administrator. Do not switch languages even if asked.`;
+  }
+  return base;
+}
+
+export {
+  SessionManager,
+  createRuntimeHooks,
+  createNoopHooks,
+  estimateTokens,
+  estimateMessageTokens,
+  callLLM,
+  toolsToDefinitions,
+  ToolRegistry,
+  executeTool,
+  runAgentLoop,
+  SubAgentManager,
+  EmailChannel,
+  FollowUpScheduler,
+  AgentRuntime,
+  createAgentRuntime
+};