vellum 0.2.13 → 0.3.2

package/src/daemon/session-evictor.ts

@@ -1,196 +0,0 @@
-import { getLogger } from '../util/logger.js';
-
-const log = getLogger('session-evictor');
-
-/** Minimal interface a session must satisfy to be evictable. */
-export interface EvictableSession {
-  isProcessing(): boolean;
-  dispose(): void;
-}
-
-export interface EvictorOptions {
-  /** Max idle time before a session is eligible for eviction (ms). Default: 30 min. */
-  ttlMs?: number;
-  /** Max number of in-memory sessions before LRU eviction kicks in. Default: 100. */
-  maxSessions?: number;
-  /** RSS threshold (bytes) above which idle sessions are aggressively evicted. Default: 3 GB. */
-  memoryThresholdBytes?: number;
-  /** Interval between periodic sweeps (ms). Default: 60 s. */
-  sweepIntervalMs?: number;
-}
-
-export interface EvictionResult {
-  /** Sessions evicted because they exceeded TTL. */
-  ttlEvicted: number;
-  /** Sessions evicted because pool exceeded maxSessions (LRU order). */
-  lruEvicted: number;
-  /** Sessions evicted due to memory pressure. */
-  memoryEvicted: number;
-  /** Sessions skipped because they were actively processing. */
-  skipped: number;
-}
-
-const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
-const DEFAULT_MAX_SESSIONS = 100;
-const DEFAULT_MEMORY_THRESHOLD_BYTES = 3072 * 1024 * 1024; // 3 GB
-const DEFAULT_SWEEP_INTERVAL_MS = 60 * 1000; // 60 seconds
-
-export class SessionEvictor {
-  private readonly ttlMs: number;
-  private readonly maxSessions: number;
-  private readonly memoryThresholdBytes: number;
-  private readonly sweepIntervalMs: number;
-
-  /** Tracks last access time per session ID. */
-  private lastAccess = new Map<string, number>();
-
-  private sweepTimer: ReturnType<typeof setInterval> | null = null;
-  private sessions: Map<string, EvictableSession>;
-
-  /** Optional hook called for each evicted session (for cleanup in DaemonServer). */
-  onEvict?: (sessionId: string) => void;
-
-  /** Optional guard: if this returns true, the session is protected from eviction. */
-  shouldProtect?: (sessionId: string) => boolean;
-
-  constructor(
-    sessions: Map<string, EvictableSession>,
-    options?: EvictorOptions,
-  ) {
-    this.sessions = sessions;
-    this.ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
-    this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
-    this.memoryThresholdBytes = options?.memoryThresholdBytes ?? DEFAULT_MEMORY_THRESHOLD_BYTES;
-    this.sweepIntervalMs = options?.sweepIntervalMs ?? DEFAULT_SWEEP_INTERVAL_MS;
-  }
-
-  /** Record an access for the given session (resets its idle clock). */
-  touch(sessionId: string): void {
-    this.lastAccess.set(sessionId, Date.now());
-  }
-
-  /** Remove tracking state for a session that was externally removed. */
-  remove(sessionId: string): void {
-    this.lastAccess.delete(sessionId);
-  }
-
-  /** Start the periodic sweep timer. */
-  start(): void {
-    if (this.sweepTimer) return;
-    this.sweepTimer = setInterval(() => {
-      try {
-        const result = this.sweep();
-        const total = result.ttlEvicted + result.lruEvicted + result.memoryEvicted;
-        if (total > 0) {
-          log.info(result, 'Session eviction sweep completed');
-        }
-      } catch (err) {
-        log.error({ err }, 'Session eviction sweep failed');
-      }
-    }, this.sweepIntervalMs);
-  }
-
-  /** Stop the periodic sweep timer. */
-  stop(): void {
-    if (this.sweepTimer) {
-      clearInterval(this.sweepTimer);
-      this.sweepTimer = null;
-    }
-    this.lastAccess.clear();
-  }
-
-  /**
-   * Run a single eviction sweep. Safe to call manually (e.g. from tests)
-   * in addition to the periodic timer.
-   */
-  sweep(): EvictionResult {
-    const now = Date.now();
-    const result: EvictionResult = {
-      ttlEvicted: 0,
-      lruEvicted: 0,
-      memoryEvicted: 0,
-      skipped: 0,
-    };
-
-    // Phase 1: TTL eviction — remove sessions idle longer than ttlMs.
-    for (const [id, session] of this.sessions) {
-      const lastAccessTime = this.lastAccess.get(id) ?? 0;
-      if (now - lastAccessTime < this.ttlMs) continue;
-      if (session.isProcessing() || this.shouldProtect?.(id)) {
-        result.skipped++;
-        continue;
-      }
-      this.evict(id, session);
-      result.ttlEvicted++;
-    }
-
-    // Phase 2: LRU eviction — if still over capacity, evict least-recently-used.
-    if (this.sessions.size > this.maxSessions) {
-      const sorted = this.idleSessionsByLru();
-      for (const [id, session] of sorted) {
-        if (this.sessions.size <= this.maxSessions) break;
-        this.evict(id, session);
-        result.lruEvicted++;
-      }
-    }
-
-    // Phase 3: Memory pressure — if RSS exceeds threshold, evict idle sessions
-    // starting from least-recently-used until we're under the threshold or
-    // no more idle sessions remain.
-    const rss = process.memoryUsage.rss();
-    if (rss > this.memoryThresholdBytes) {
-      const sorted = this.idleSessionsByLru();
-      if (sorted.length > 0) {
-        log.warn(
-          { rssBytes: rss, thresholdBytes: this.memoryThresholdBytes, sessionCount: this.sessions.size },
-          'Memory pressure detected, evicting idle sessions',
-        );
-        for (const [id, session] of sorted) {
-          if (process.memoryUsage.rss() <= this.memoryThresholdBytes) break;
-          this.evict(id, session);
-          result.memoryEvicted++;
-        }
-      }
-    }
-
-    // Clean up stale lastAccess entries for sessions that no longer exist
-    // (e.g. removed by clearAllSessions or evictSessionsForReload).
-    for (const id of this.lastAccess.keys()) {
-      if (!this.sessions.has(id)) {
-        this.lastAccess.delete(id);
-      }
-    }
-
-    return result;
-  }
-
-  /** Current number of tracked sessions (for diagnostics). */
-  get trackedCount(): number {
-    return this.lastAccess.size;
-  }
-
-  // ── Internals ──────────────────────────────────────────────────────
-
-  private evict(id: string, session: EvictableSession): void {
-    session.dispose();
-    this.sessions.delete(id);
-    this.lastAccess.delete(id);
-    this.onEvict?.(id);
-    log.debug({ sessionId: id }, 'Evicted idle session');
-  }
-
-  /**
-   * Return idle (non-processing) sessions sorted by last access time
-   * ascending (least recently used first).
-   */
-  private idleSessionsByLru(): Array<[string, EvictableSession]> {
-    const idle: Array<[string, EvictableSession, number]> = [];
-    for (const [id, session] of this.sessions) {
-      if (session.isProcessing()) continue;
-      if (this.shouldProtect?.(id)) continue;
-      idle.push([id, session, this.lastAccess.get(id) ?? 0]);
-    }
-    idle.sort((a, b) => a[2] - b[2]);
-    return idle.map(([id, session]) => [id, session]);
-  }
-}

package/src/daemon/session-history.ts

@@ -1,437 +0,0 @@
-import { v4 as uuid } from 'uuid';
-import type { Message, ContentBlock } from '../providers/types.js';
-import type { ServerMessage } from './ipc-protocol.js';
-import { getQdrantClient } from '../memory/qdrant-client.js';
-import { enqueueMemoryJob } from '../memory/jobs-store.js';
-import * as conversationStore from '../memory/conversation-store.js';
-import { getSummaryFromContextMessage } from '../context/window-manager.js';
-import type { TraceEmitter } from './trace-emitter.js';
-import { getLogger } from '../util/logger.js';
-
-const log = getLogger('session-history');
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-function isUndoableUserMessage(message: Message): boolean {
-  if (message.role !== 'user') return false;
-  if (getSummaryFromContextMessage(message) !== null) return false;
-  // A user message is undoable if it contains user-authored content (non-tool_result
-  // blocks). Messages that contain ONLY tool_result blocks (e.g. automated tool
-  // responses) are not undoable. Messages that have both tool_result and text blocks
-  // (e.g. after repairHistory merges a tool_result turn with a user prompt) are still
-  // undoable because they contain real user content.
-  const hasNonToolResultContent = message.content.some(
-    (block) => block.type !== 'tool_result',
-  );
-  if (!hasNonToolResultContent) return false;
-  return true;
-}
-
-export function findLastUndoableUserMessageIndex(messages: Message[]): number {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (isUndoableUserMessage(messages[i])) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-// ── Qdrant Vector Cleanup ────────────────────────────────────────────
-
-/**
- * Delete Qdrant vector entries for the given segment and item IDs.
- * Individual deletion failures are logged and enqueued as retry jobs
- * to prevent silently orphaned vectors.
- */
-export async function cleanupQdrantVectors(
-  conversationId: string,
-  segmentIds: string[],
-  orphanedItemIds: string[],
-): Promise<void> {
-  let qdrant: ReturnType<typeof getQdrantClient>;
-  try {
-    qdrant = getQdrantClient();
-  } catch {
-    return; // Qdrant not initialized — nothing to clean up.
-  }
-
-  if (segmentIds.length === 0 && orphanedItemIds.length === 0) return;
-
-  const targets: Array<{ targetType: string; targetId: string }> = [];
-  for (const segId of segmentIds) {
-    targets.push({ targetType: 'segment', targetId: segId });
-  }
-  for (const itemId of orphanedItemIds) {
-    targets.push({ targetType: 'item', targetId: itemId });
-  }
-
-  const results = await Promise.allSettled(
-    targets.map((t) => qdrant.deleteByTarget(t.targetType, t.targetId)),
-  );
-
-  let succeeded = 0;
-  let failed = 0;
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i];
-    if (result.status === 'fulfilled') {
-      succeeded++;
-    } else {
-      failed++;
-      const { targetType, targetId } = targets[i];
-      log.warn(
-        { err: result.reason, targetType, targetId, conversationId },
-        'Qdrant vector deletion failed, enqueuing retry job',
-      );
-      enqueueMemoryJob('delete_qdrant_vectors', { targetType, targetId });
-    }
-  }
-
-  if (succeeded > 0) {
-    log.info(
-      { conversationId, succeeded, failed, segments: segmentIds.length, items: orphanedItemIds.length },
-      'Cleaned up Qdrant vectors after regenerate',
-    );
-  }
-}
-
-// ── Consolidation ────────────────────────────────────────────────────
-
-/**
- * Consolidate consecutive assistant messages created during an agent loop.
- * After the loop completes, merge all assistant messages that came after
- * the user message into a single message, and delete the internal tool_result
- * user messages. This ensures the database matches what the client sees
- * during streaming (one consolidated message per user request).
- */
-export function consolidateAssistantMessages(conversationId: string, userMessageId: string): void {
-  const allMessages = conversationStore.getMessages(conversationId);
-  const userMsgIndex = allMessages.findIndex((m) => m.id === userMessageId);
-  if (userMsgIndex === -1) return;
-
-  const messagesToConsolidate: typeof allMessages = [];
-  const internalToolResultMessages: typeof allMessages = [];
-  const messagesToDelete: string[] = [];
-
-  // Collect all assistant messages and internal tool_result user messages after this user message
-  for (let i = userMsgIndex + 1; i < allMessages.length; i++) {
-    const msg = allMessages[i];
-    if (msg.role === 'assistant') {
-      messagesToConsolidate.push(msg);
-    } else if (msg.role === 'user') {
-      // Check if this is an internal tool_result message (no text, only tool_result blocks)
-      try {
-        const content = JSON.parse(msg.content);
-        const isToolResultOnly = Array.isArray(content) &&
-          content.every((block) => block.type === 'tool_result') &&
-          content.length > 0;
-        if (isToolResultOnly) {
-          internalToolResultMessages.push(msg);
-          messagesToDelete.push(msg.id);
-        } else {
-          // Hit a real user message, stop consolidating
-          break;
-        }
-      } catch {
-        // Can't parse, assume it's a real user message
-        break;
-      }
-    }
-  }
-
-  // Only consolidate if there are multiple assistant messages
-  if (messagesToConsolidate.length <= 1) {
-    // Still delete internal tool_result messages even if only one assistant message,
-    // and collect IDs for vector cleanup
-    const allSegmentIds: string[] = [];
-    const allOrphanedItemIds: string[] = [];
-    for (const id of messagesToDelete) {
-      const deleted = conversationStore.deleteMessageById(id);
-      allSegmentIds.push(...deleted.segmentIds);
-      allOrphanedItemIds.push(...deleted.orphanedItemIds);
-    }
-
-    // Clean up Qdrant vectors (fire-and-forget)
-    if (allSegmentIds.length > 0 || allOrphanedItemIds.length > 0) {
-      cleanupQdrantVectors(conversationId, allSegmentIds, allOrphanedItemIds).catch((err) => {
-        log.warn({ err, conversationId }, 'Qdrant cleanup after consolidation failed (non-fatal)');
-      });
-    }
-    return;
-  }
-
-  log.info({
-    conversationId,
-    userMessageId,
-    assistantCount: messagesToConsolidate.length,
-    internalMessageCount: messagesToDelete.length,
-  }, 'Consolidating assistant messages');
-
-  // Merge all content blocks from all assistant messages AND tool_result blocks from internal user messages
-  const consolidatedContent: ContentBlock[] = [];
-  for (const msg of messagesToConsolidate) {
-    try {
-      const content = JSON.parse(msg.content);
-      if (Array.isArray(content)) {
-        const toolUseBlocks = content.filter((b: Record<string, unknown>) => b.type === 'tool_use');
-        log.info({ messageId: msg.id, blockCount: content.length, toolUseCount: toolUseBlocks.length }, 'Consolidating assistant message content');
-        consolidatedContent.push(...content);
-      }
-    } catch (err) {
-      log.warn({ err, messageId: msg.id }, 'Failed to parse message content during consolidation');
-    }
-  }
-
-  // Also merge tool_result blocks from internal user messages
-  for (const msg of internalToolResultMessages) {
-    try {
-      const content = JSON.parse(msg.content);
-      if (Array.isArray(content)) {
-        const toolResultBlocks = content.filter((b: Record<string, unknown>) => b.type === 'tool_result');
-        log.info({ messageId: msg.id, blockCount: content.length, toolResultCount: toolResultBlocks.length }, 'Merging tool_result blocks from internal user message');
-        consolidatedContent.push(...content);
-      }
-    } catch (err) {
-      log.warn({ err, messageId: msg.id }, 'Failed to parse internal tool_result message during consolidation');
-    }
-  }
-
-  const toolUseBlocksInConsolidated = consolidatedContent.filter((b) => b.type === 'tool_use').length;
-  const toolResultBlocksInConsolidated = consolidatedContent.filter((b) => b.type === 'tool_result').length;
-  log.info({ totalBlocks: consolidatedContent.length, toolUseBlocks: toolUseBlocksInConsolidated, toolResultBlocks: toolResultBlocksInConsolidated }, 'Final consolidated content');
-
-  // Update the first assistant message with all content
-  const firstAssistantMsg = messagesToConsolidate[0];
-  conversationStore.updateMessageContent(firstAssistantMsg.id, JSON.stringify(consolidatedContent));
-
-  // Re-link attachments from messages about to be deleted to the consolidated
-  // message. Without this, ON DELETE CASCADE on message_attachments destroys
-  // the attachment links, and deleteOrphanAttachments removes the data.
-  const messageIdsToDelete = [
-    ...messagesToConsolidate.slice(1).map((m) => m.id),
-    ...messagesToDelete,
-  ];
-  if (messageIdsToDelete.length > 0) {
-    const relinked = conversationStore.relinkAttachments(messageIdsToDelete, firstAssistantMsg.id);
-    if (relinked > 0) {
-      log.info({ relinked, targetMessageId: firstAssistantMsg.id }, 'Re-linked attachments to consolidated message');
-    }
-  }
-
-  // Delete the other assistant messages and internal tool_result messages,
-  // and collect IDs for vector cleanup
-  const allSegmentIds: string[] = [];
-  const allOrphanedItemIds: string[] = [];
-  for (let i = 1; i < messagesToConsolidate.length; i++) {
-    const deleted = conversationStore.deleteMessageById(messagesToConsolidate[i].id);
-    allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
-  }
-  for (const id of messagesToDelete) {
-    const deleted = conversationStore.deleteMessageById(id);
-    allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
-  }
-
-  // Clean up Qdrant vectors (fire-and-forget)
-  if (allSegmentIds.length > 0 || allOrphanedItemIds.length > 0) {
-    cleanupQdrantVectors(conversationId, allSegmentIds, allOrphanedItemIds).catch((err) => {
-      log.warn({ err, conversationId }, 'Qdrant cleanup after consolidation failed (non-fatal)');
-    });
-  }
-
-  log.info({
-    conversationId,
-    consolidatedMessageId: firstAssistantMsg.id,
-    deletedCount: messagesToConsolidate.length - 1 + messagesToDelete.length,
-  }, 'Assistant messages consolidated');
-}
-
-// ── Undo ─────────────────────────────────────────────────────────────
-
-/**
- * Subset of Session state that undo/regenerate need access to.
- */
-export interface HistorySessionContext {
-  readonly conversationId: string;
-  readonly traceEmitter: TraceEmitter;
-  messages: Message[];
-  processing: boolean;
-  abortController: AbortController | null;
-  currentRequestId?: string;
-  runAgentLoop(
-    content: string,
-    userMessageId: string,
-    onEvent: (msg: ServerMessage) => void,
-    options?: { skipPreMessageRollback?: boolean },
-  ): Promise<void>;
-}
-
-/**
- * Remove the last user+assistant exchange from memory and DB.
- * Returns the number of messages removed.
- */
-export function undo(session: HistorySessionContext): number {
-  if (session.processing) return 0;
-
-  const lastUserIdx = findLastUndoableUserMessageIndex(session.messages);
-  if (lastUserIdx === -1) return 0;
-
-  const removed = session.messages.length - lastUserIdx;
-  session.messages = session.messages.slice(0, lastUserIdx);
-
-  // Also remove from DB. We may need to call deleteLastExchange multiple
-  // times because the DB stores tool_result user messages as separate rows.
-  // The in-memory findLastUndoableUserMessageIndex skips these, but the DB's
-  // deleteLastExchange only finds the last role='user' row — which may be a
-  // tool_result message, leaving the real user message orphaned.
-  //
-  // Strategy: peel back any trailing tool_result exchanges first, then
-  // delete the real user message exchange only if tool_result rows were
-  // actually encountered. The do-while handles the case where the last DB
-  // exchange is a tool_result row; the flag ensures we only issue the extra
-  // deleteLastExchange when the loop peeled back tool_result messages.
-  let hadToolResult = false;
-  do {
-    conversationStore.deleteLastExchange(session.conversationId);
-    if (conversationStore.isLastUserMessageToolResult(session.conversationId)) {
-      hadToolResult = true;
-    } else {
-      break;
-    }
-  } while (true);
-  if (hadToolResult) {
-    conversationStore.deleteLastExchange(session.conversationId);
-  }
-
-  return removed;
-}
-
-// ── Regenerate ───────────────────────────────────────────────────────
-
-/**
- * Regenerate the last assistant response: remove the assistant's reply
- * (and any intermediate tool_result messages) from memory, DB, and
- * Qdrant, then re-run the agent loop with the same user message.
- */
-export async function regenerate(
-  session: HistorySessionContext,
-  onEvent: (msg: ServerMessage) => void,
-  requestId?: string,
-): Promise<void> {
-  if (session.processing) {
-    onEvent({ type: 'error', message: 'Cannot regenerate while processing' });
-    if (requestId) {
-      session.traceEmitter.emit('request_error', 'Cannot regenerate while processing', {
-        requestId,
-        status: 'error',
-        attributes: { reason: 'already_processing' },
-      });
-    }
-    return;
-  }
-
-  // Find the last undoable user message — everything after it is the
-  // assistant's exchange that we want to regenerate.
-  const lastUserIdx = findLastUndoableUserMessageIndex(session.messages);
-  if (lastUserIdx === -1) {
-    onEvent({ type: 'error', message: 'No messages to regenerate' });
-    if (requestId) {
-      session.traceEmitter.emit('request_error', 'No messages to regenerate', {
-        requestId,
-        status: 'error',
-        attributes: { reason: 'no_messages' },
-      });
-    }
-    return;
-  }
-
-  // There must be at least one message after the user message (the assistant reply).
-  if (lastUserIdx >= session.messages.length - 1) {
-    onEvent({ type: 'error', message: 'No assistant response to regenerate' });
-    if (requestId) {
-      session.traceEmitter.emit('request_error', 'No assistant response to regenerate', {
-        requestId,
-        status: 'error',
-        attributes: { reason: 'no_assistant_response' },
-      });
-    }
-    return;
-  }
-
-  // Remove the assistant's exchange from in-memory history (keep the user message).
-  session.messages = session.messages.slice(0, lastUserIdx + 1);
-
-  // Find DB message IDs to delete: get all messages from the DB, then
-  // identify the ones that come after the last user message.
-  const dbMessages = conversationStore.getMessages(session.conversationId);
-
-  // Walk backwards to find the last real (non-tool_result) user message in the DB.
-  let dbUserMsgIdx = -1;
-  for (let i = dbMessages.length - 1; i >= 0; i--) {
-    if (dbMessages[i].role !== 'user') continue;
-    try {
-      const parsed = JSON.parse(dbMessages[i].content);
-      if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((b: Record<string, unknown>) => b.type === 'tool_result')) {
-        continue; // Skip tool_result-only user messages
-      }
-    } catch { /* plain text = real user message */ }
-    dbUserMsgIdx = i;
-    break;
-  }
-
-  if (dbUserMsgIdx === -1) {
-    onEvent({ type: 'error', message: 'No user message found in DB' });
-    if (requestId) {
-      session.traceEmitter.emit('request_error', 'No user message found in DB', {
-        requestId,
-        status: 'error',
-        attributes: { reason: 'no_db_user_message' },
-      });
-    }
-    return;
-  }
-
-  // Capture the existing DB user message ID so we can pass it to
-  // runAgentLoop without re-persisting the user message.
-  const existingUserMessageId = dbMessages[dbUserMsgIdx].id;
-
-  // Everything after the user message needs to be deleted.
-  const messagesToDelete = dbMessages.slice(dbUserMsgIdx + 1);
-
-  // Delete each message via deleteMessageById and collect IDs for Qdrant cleanup.
-  const allSegmentIds: string[] = [];
-  const allOrphanedItemIds: string[] = [];
-  for (const msg of messagesToDelete) {
-    const deleted = conversationStore.deleteMessageById(msg.id);
-    allSegmentIds.push(...deleted.segmentIds);
-    allOrphanedItemIds.push(...deleted.orphanedItemIds);
-  }
-
-  // Clean up Qdrant vectors (fire-and-forget).
-  cleanupQdrantVectors(session.conversationId, allSegmentIds, allOrphanedItemIds).catch((err) => {
-    log.warn({ err, conversationId: session.conversationId }, 'Qdrant cleanup after regenerate failed (non-fatal)');
-  });
-
-  // Re-extract the user message content for the agent loop.
-  // Use all content blocks (text, image, file) so attachments are
-  // preserved — not just text blocks.
-  const userMessage = session.messages[lastUserIdx];
-  const textBlocks = userMessage.content.filter(
-    (b) => b.type === 'text',
-  );
-  const content = textBlocks
-    .map((b) => (b as { type: 'text'; text: string }).text)
-    .join('');
-
-  // Notify client that the old response has been removed.
-  onEvent({ type: 'undo_complete', removedCount: messagesToDelete.length, sessionId: session.conversationId });
-
-  // Set up processing state manually and call runAgentLoop directly,
-  // bypassing processMessage to avoid duplicating the user message
-  // in both this.messages and the DB.
-  session.processing = true;
-  session.abortController = new AbortController();
-  session.currentRequestId = requestId ?? uuid();
-
-  await session.runAgentLoop(content, existingUserMessageId, onEvent, { skipPreMessageRollback: true });
-}