@getpaseo/server 0.1.15 → 0.1.17

package/dist/server/server/agent/agent-manager.js

@@ -5,6 +5,7 @@ import { AGENT_LIFECYCLE_STATUSES, } from "../../shared/agent-lifecycle.js";
 import { z } from "zod";
 import { AGENT_PROVIDER_IDS } from "./provider-manifest.js";
 export { AGENT_LIFECYCLE_STATUSES };
+const SYSTEM_ERROR_PREFIX = "[System Error]";
 function attachPersistenceCwd(handle, cwd) {
     if (!handle) {
         return null;
@@ -17,8 +18,8 @@ function attachPersistenceCwd(handle, cwd) {
         },
     };
 }
-const DEFAULT_MAX_TIMELINE_ITEMS = 2000;
 const DEFAULT_TIMELINE_FETCH_LIMIT = 200;
+const LIVE_BACKLOG_TERMINAL_REPLAY_DELAY_MS = 300;
 const BUSY_STATUSES = [
     "initializing",
     "running",
@@ -27,6 +28,11 @@ const AgentIdSchema = z.string().uuid();
 function isAgentBusy(status) {
     return BUSY_STATUSES.includes(status);
 }
+function isTurnTerminalEvent(event) {
+    return (event.type === "turn_completed" ||
+        event.type === "turn_failed" ||
+        event.type === "turn_canceled");
+}
 function createAbortError(signal, fallbackMessage) {
     const reason = signal?.reason;
     const message = typeof reason === "string"
@@ -43,6 +49,18 @@ function validateAgentId(agentId, source) {
     }
     return result.data;
 }
+function supportsLiveEventStream(session) {
+    return ("streamLiveEvents" in session &&
+        typeof session.streamLiveEvents ===
+            "function");
+}
+function normalizeMessageId(messageId) {
+    if (typeof messageId !== "string") {
+        return undefined;
+    }
+    const trimmed = messageId.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
 export class AgentManager {
     constructor(options) {
         this.clients = new Map();
@@ -50,8 +68,16 @@ export class AgentManager {
         this.subscribers = new Set();
         this.previousStatuses = new Map();
         this.backgroundTasks = new Set();
+        this.liveEventPumps = new Map();
+        this.liveEventBacklog = new Map();
+        this.liveEventBacklogFlushTimers = new Map();
+        const maxTimelineItems = options?.maxTimelineItems;
         this.maxTimelineItems =
-            options?.maxTimelineItems ?? DEFAULT_MAX_TIMELINE_ITEMS;
+            typeof maxTimelineItems === "number" &&
+                Number.isFinite(maxTimelineItems) &&
+                maxTimelineItems >= 0
+                ? Math.floor(maxTimelineItems)
+                : null;
         this.idFactory = options?.idFactory ?? (() => randomUUID());
         this.registry = options?.registry;
         this.onAgentAttention = options?.onAgentAttention;
@@ -397,6 +423,9 @@ export class AgentManager {
             : await client.createSession(normalizedConfig);
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
+        this.liveEventPumps.delete(agentId);
+        this.liveEventBacklog.delete(agentId);
+        this.clearLiveEventBacklogFlushTimer(agentId);
         try {
             await existing.session.close();
         }
@@ -421,7 +450,16 @@ export class AgentManager {
     }
     async closeAgent(agentId) {
         const agent = this.requireAgent(agentId);
+        this.logger.trace({
+            agentId,
+            lifecycle: agent.lifecycle,
+            hasPendingRun: Boolean(agent.pendingRun),
+            pendingPermissions: agent.pendingPermissions.size,
+        }, "closeAgent: start");
         this.agents.delete(agentId);
+        this.liveEventPumps.delete(agentId);
+        this.liveEventBacklog.delete(agentId);
+        this.clearLiveEventBacklogFlushTimer(agentId);
         // Clean up previousStatus to prevent memory leak
         this.previousStatuses.delete(agentId);
         const session = agent.session;
@@ -433,6 +471,7 @@ export class AgentManager {
         };
         await session.close();
         this.emitState(closedAgent);
+        this.logger.trace({ agentId }, "closeAgent: completed");
     }
     async setAgentMode(agentId, modeId) {
         const agent = this.requireAgent(agentId);
@@ -469,7 +508,12 @@ export class AgentManager {
     }
     async setTitle(agentId, title) {
         const agent = this.requireAgent(agentId);
-        await this.registry?.setTitle(agentId, title);
+        const normalizedTitle = title.trim();
+        if (!normalizedTitle) {
+            return;
+        }
+        this.touchUpdatedAt(agent);
+        await this.persistSnapshot(agent, { title: normalizedTitle });
         this.emitState(agent);
     }
     async setLabels(agentId, labels) {
@@ -483,6 +527,7 @@ export class AgentManager {
         if (!agent || agent.internal) {
             return;
         }
+        this.touchUpdatedAt(agent);
         this.emitState(agent);
     }
     async clearAgentAttention(agentId) {
@@ -507,7 +552,7 @@ export class AgentManager {
                 usage = event.usage;
             }
             else if (event.type === "turn_failed") {
-                throw new Error(event.error);
+                throw new Error(this.formatTurnFailedMessage(event));
             }
             else if (event.type === "turn_canceled") {
                 canceled = true;
@@ -529,10 +574,11 @@ export class AgentManager {
     }
     recordUserMessage(agentId, text, options) {
         const agent = this.requireAgent(agentId);
+        const normalizedMessageId = normalizeMessageId(options?.messageId);
         const item = {
             type: "user_message",
             text,
-            messageId: options?.messageId,
+            messageId: normalizedMessageId,
         };
         const updatedAt = this.touchUpdatedAt(agent);
         agent.lastUserMessageAt = updatedAt;
@@ -574,7 +620,18 @@ export class AgentManager {
     }
     streamAgent(agentId, prompt, options) {
         const existingAgent = this.requireAgent(agentId);
+        this.logger.trace({
+            agentId,
+            lifecycle: existingAgent.lifecycle,
+            hasPendingRun: Boolean(existingAgent.pendingRun),
+            promptType: typeof prompt === "string" ? "string" : "structured",
+            hasRunOptions: Boolean(options),
+        }, "streamAgent: requested");
         if (existingAgent.pendingRun) {
+            this.logger.trace({
+                agentId,
+                lifecycle: existingAgent.lifecycle,
+            }, "streamAgent: rejected because pendingRun already exists");
             throw new Error(`Agent ${agentId} already has an active run`);
         }
         const agent = existingAgent;
@@ -582,11 +639,24 @@ export class AgentManager {
         agent.lastError = undefined;
         let finalized = false;
         const finalize = (error) => {
+            this.logger.trace({
+                agentId,
+                error,
+                alreadyFinalized: finalized,
+                lifecycle: agent.lifecycle,
+                hasPendingRun: Boolean(agent.pendingRun),
+            }, "streamAgent.finalize: invoked");
             if (finalized) {
                 return;
             }
             finalized = true;
             if (agent.pendingRun !== streamForwarder) {
+                this.logger.trace({
+                    agentId,
+                    error,
+                    lifecycle: agent.lifecycle,
+                    hasPendingRun: Boolean(agent.pendingRun),
+                }, "streamAgent.finalize: skipped because pendingRun no longer points to streamForwarder");
                 if (error) {
                     agent.lastError = error;
                 }
@@ -594,8 +664,9 @@ export class AgentManager {
             }
             const mutableAgent = agent;
             mutableAgent.pendingRun = null;
-            mutableAgent.lifecycle = error ? "error" : "idle";
-            mutableAgent.lastError = error;
+            const terminalError = error ?? mutableAgent.lastError;
+            mutableAgent.lifecycle = terminalError ? "error" : "idle";
+            mutableAgent.lastError = terminalError;
             const persistenceHandle = mutableAgent.session.describePersistence() ??
                 (mutableAgent.runtimeInfo?.sessionId
                     ? { provider: mutableAgent.provider, sessionId: mutableAgent.runtimeInfo.sessionId }
@@ -603,7 +674,14 @@ export class AgentManager {
             if (persistenceHandle) {
                 mutableAgent.persistence = attachPersistenceCwd(persistenceHandle, mutableAgent.cwd);
             }
+            this.logger.trace({
+                agentId,
+                lifecycle: mutableAgent.lifecycle,
+                hasPendingRun: Boolean(mutableAgent.pendingRun),
+                terminalError,
+            }, "streamAgent.finalize: applying terminal state");
             this.emitState(mutableAgent);
+            this.flushLiveEventBacklog(mutableAgent);
         };
         const self = this;
         const streamForwarder = (async function* streamForwarder() {
@@ -611,12 +689,28 @@ export class AgentManager {
             try {
                 for await (const event of iterator) {
                     self.handleStreamEvent(agent, event);
+                    if (event.type === "turn_started" ||
+                        event.type === "turn_completed" ||
+                        event.type === "turn_failed" ||
+                        event.type === "turn_canceled") {
+                        self.logger.trace({
+                            agentId,
+                            eventType: event.type,
+                            lifecycle: agent.lifecycle,
+                            hasPendingRun: Boolean(agent.pendingRun),
+                        }, "streamAgent: forwarded terminal/turn event");
+                    }
                     yield event;
                 }
             }
             catch (error) {
                 finalizeError =
                     error instanceof Error ? error.message : "Agent stream failed";
+                self.handleStreamEvent(agent, {
+                    type: "turn_failed",
+                    provider: agent.provider,
+                    error: finalizeError,
+                });
                 throw error;
             }
             finally {
@@ -632,6 +726,11 @@ export class AgentManager {
         // deterministically order idle->running transitions.
         this.touchUpdatedAt(agent);
         self.emitState(agent);
+        this.logger.trace({
+            agentId,
+            lifecycle: agent.lifecycle,
+            hasPendingRun: Boolean(agent.pendingRun),
+        }, "streamAgent: started");
         return streamForwarder;
     }
     async waitForAgentRunStart(agentId, options) {
@@ -726,7 +825,9 @@ export class AgentManager {
     async cancelAgentRun(agentId) {
         const agent = this.requireAgent(agentId);
         const pendingRun = agent.pendingRun;
-        if (!pendingRun || typeof pendingRun.return !== "function") {
+        const hasForegroundPendingRun = Boolean(pendingRun) && typeof pendingRun?.return === "function";
+        const isAutonomousRunning = agent.lifecycle === "running" && !hasForegroundPendingRun;
+        if (!hasForegroundPendingRun && !isAutonomousRunning) {
             return false;
         }
         try {
@@ -735,14 +836,16 @@ export class AgentManager {
         catch (error) {
             this.logger.error({ err: error, agentId }, "Failed to interrupt session");
         }
-        try {
-            // Await the generator's .return() to ensure the finally block runs
-            // and pendingRun is properly cleared before we return.
-            await pendingRun.return(undefined);
-        }
-        catch (error) {
-            this.logger.error({ err: error, agentId }, "Failed to cancel run");
-            throw error;
+        if (hasForegroundPendingRun && pendingRun) {
+            try {
+                // Await the generator's .return() to ensure the finally block runs
+                // and pendingRun is properly cleared before we return.
+                await pendingRun.return(undefined);
+            }
+            catch (error) {
+                this.logger.error({ err: error, agentId }, "Failed to cancel run");
+                throw error;
+            }
         }
         // Clear any pending permissions that weren't cleaned up by handleStreamEvent.
         // Due to microtask ordering, .return() may force the generator to its finally
@@ -841,6 +944,7 @@ export class AgentManager {
             }
             let currentStatus = initialStatus;
             let hasStarted = initialBusy || hasPendingRun;
+            let terminalStatusOverride = null;
             // Bug #3 Fix: Declare unsubscribe and abortHandler upfront so cleanup can reference them
             let unsubscribe = null;
             let abortHandler = null;
@@ -898,6 +1002,9 @@ export class AgentManager {
                         return;
                     }
                     if (!waitForActive || hasStarted) {
+                        if (terminalStatusOverride) {
+                            currentStatus = terminalStatusOverride;
+                        }
                         finish(null);
                     }
                     return;
@@ -908,20 +1015,15 @@ export class AgentManager {
                         return;
                     }
                     if (event.event.type === "turn_failed") {
-                        currentStatus = "error";
                         hasStarted = true;
-                        finish(null);
+                        terminalStatusOverride = "error";
                         return;
                     }
                     if (event.event.type === "turn_completed") {
-                        currentStatus = "idle";
                         hasStarted = true;
-                        finish(null);
                     }
                     if (event.event.type === "turn_canceled") {
-                        currentStatus = "idle";
                         hasStarted = true;
-                        finish(null);
                     }
                 }
             }, { agentId, replayState: true });
@@ -932,6 +1034,7 @@ export class AgentManager {
         if (this.agents.has(resolvedAgentId)) {
             throw new Error(`Agent with id ${resolvedAgentId} already exists`);
         }
+        const initialPersistedTitle = await this.resolveInitialPersistedTitle(resolvedAgentId, config);
         const now = new Date();
         const initialTimeline = options?.timeline ? [...options.timeline] : [];
         const initialTimelineRows = options?.timelineRows?.length
@@ -982,15 +1085,26 @@ export class AgentManager {
         this.previousStatuses.set(resolvedAgentId, managed.lifecycle);
         await this.refreshRuntimeInfo(managed);
         await this.persistSnapshot(managed, {
-            title: config.title ?? null,
+            title: initialPersistedTitle,
         });
         this.emitState(managed);
         await this.refreshSessionState(managed);
         managed.lifecycle = "idle";
         await this.persistSnapshot(managed);
         this.emitState(managed);
+        this.startLiveEventPump(managed);
         return { ...managed };
     }
+    async resolveInitialPersistedTitle(agentId, config) {
+        const existing = await this.registry?.get(agentId);
+        if (existing) {
+            return existing.title ?? null;
+        }
+        if (Object.prototype.hasOwnProperty.call(config, "title")) {
+            return config.title ?? null;
+        }
+        return null;
+    }
     buildTimelineRowsFromItems(items, startSeq, timestamp) {
         let nextSeq = startSeq;
         return items.map((item) => {
@@ -1053,6 +1167,7 @@ export class AgentManager {
         try {
             const newInfo = await agent.session.getRuntimeInfo();
             const changed = newInfo.model !== agent.runtimeInfo?.model ||
+                newInfo.thinkingOptionId !== agent.runtimeInfo?.thinkingOptionId ||
                 newInfo.sessionId !== agent.runtimeInfo?.sessionId ||
                 newInfo.modeId !== agent.runtimeInfo?.modeId;
             agent.runtimeInfo = newInfo;
@@ -1073,9 +1188,22 @@ export class AgentManager {
             return;
         }
         agent.historyPrimed = true;
+        const canonicalUserMessagesById = new Map(agent.timelineRows.flatMap((row) => {
+            if (row.item.type !== "user_message") {
+                return [];
+            }
+            const messageId = normalizeMessageId(row.item.messageId);
+            if (!messageId) {
+                return [];
+            }
+            return [[messageId, row.item.text]];
+        }));
         try {
             for await (const event of agent.session.streamHistory()) {
-                this.handleStreamEvent(agent, event, { fromHistory: true });
+                this.handleStreamEvent(agent, event, {
+                    fromHistory: true,
+                    canonicalUserMessagesById: canonicalUserMessagesById.size > 0 ? canonicalUserMessagesById : undefined,
+                });
             }
         }
         catch {
@@ -1104,6 +1232,23 @@ export class AgentManager {
                 }
                 break;
             case "timeline":
+                // Skip provider-replayed user_message items during history hydration.
+                // These are already canonically recorded by recordUserMessage() and replaying them would
+                // create duplicates. Match by messageId (not text) to avoid dropping legitimate
+                // provider-origin messages that happen to reuse the same text.
+                if (options?.fromHistory &&
+                    event.item.type === "user_message") {
+                    const eventMessageId = normalizeMessageId(event.item.messageId);
+                    if (eventMessageId) {
+                        const canonicalText = options?.canonicalUserMessagesById?.get(eventMessageId);
+                        if (canonicalText === event.item.text) {
+                            break;
+                        }
+                    }
+                }
+                if (this.shouldSuppressLiveUserMessageEcho(agent, event, options)) {
+                    break;
+                }
                 timelineRow = this.recordTimeline(agent, event.item);
                 if (!options?.fromHistory &&
                     event.item.type === "user_message") {
@@ -1112,12 +1257,23 @@ export class AgentManager {
                 }
                 break;
             case "turn_completed":
+                this.logger.trace({
+                    agentId: agent.id,
+                    lifecycle: agent.lifecycle,
+                    hasPendingRun: Boolean(agent.pendingRun),
+                }, "handleStreamEvent: turn_completed");
                 agent.lastUsage = event.usage;
                 agent.lastError = undefined;
+                if (!agent.pendingRun && agent.lifecycle !== "idle") {
+                    agent.lifecycle = "idle";
+                    this.emitState(agent);
+                }
                 void this.refreshRuntimeInfo(agent);
                 break;
             case "turn_failed":
+                agent.lifecycle = "error";
                 agent.lastError = event.error;
+                this.appendSystemErrorTimelineMessage(agent, event.provider, this.formatTurnFailedMessage(event), options);
                 for (const [requestId] of agent.pendingPermissions) {
                     agent.pendingPermissions.delete(requestId);
                     if (!options?.fromHistory) {
@@ -1132,6 +1288,14 @@ export class AgentManager {
                 this.emitState(agent);
                 break;
             case "turn_canceled":
+                this.logger.trace({
+                    agentId: agent.id,
+                    lifecycle: agent.lifecycle,
+                    hasPendingRun: Boolean(agent.pendingRun),
+                }, "handleStreamEvent: turn_canceled");
+                if (!agent.pendingRun) {
+                    agent.lifecycle = "idle";
+                }
                 agent.lastError = undefined;
                 for (const [requestId] of agent.pendingPermissions) {
                     agent.pendingPermissions.delete(requestId);
@@ -1146,8 +1310,25 @@ export class AgentManager {
                 }
                 this.emitState(agent);
                 break;
+            case "turn_started":
+                this.logger.trace({
+                    agentId: agent.id,
+                    lifecycle: agent.lifecycle,
+                    hasPendingRun: Boolean(agent.pendingRun),
+                }, "handleStreamEvent: turn_started");
+                if (!agent.pendingRun) {
+                    agent.lifecycle = "running";
+                    this.emitState(agent);
+                }
+                break;
             case "permission_requested":
-                agent.pendingPermissions.set(event.request.id, event.request);
+                {
+                    const hadPendingPermissions = agent.pendingPermissions.size > 0;
+                    agent.pendingPermissions.set(event.request.id, event.request);
+                    if (!hadPendingPermissions && !agent.internal) {
+                        this.broadcastAgentAttention(agent, "permission");
+                    }
+                }
                 this.emitState(agent);
                 break;
             case "permission_resolved":
@@ -1167,6 +1348,64 @@ export class AgentManager {
                 : undefined);
         }
     }
+    appendSystemErrorTimelineMessage(agent, provider, message, options) {
+        if (options?.fromHistory) {
+            return;
+        }
+        const normalized = message.trim();
+        if (!normalized) {
+            return;
+        }
+        const text = `${SYSTEM_ERROR_PREFIX} ${normalized}`;
+        const lastItem = agent.timelineRows[agent.timelineRows.length - 1]?.item;
+        if (lastItem?.type === "assistant_message" && lastItem.text === text) {
+            return;
+        }
+        const item = { type: "assistant_message", text };
+        const row = this.recordTimeline(agent, item);
+        this.dispatchStream(agent.id, {
+            type: "timeline",
+            item,
+            provider,
+        }, {
+            seq: row.seq,
+            epoch: this.ensureTimelineState(agent).epoch,
+        });
+    }
+    formatTurnFailedMessage(event) {
+        const base = event.error.trim();
+        const parts = [base.length > 0 ? base : "Provider run failed"];
+        const code = event.code?.trim();
+        if (code) {
+            parts.push(`code: ${code}`);
+        }
+        const diagnostic = event.diagnostic?.trim();
+        if (diagnostic && diagnostic !== base) {
+            parts.push(diagnostic);
+        }
+        return parts.join("\n\n");
+    }
+    shouldSuppressLiveUserMessageEcho(agent, event, options) {
+        if (options?.fromHistory || event.type !== "timeline") {
+            return false;
+        }
+        if (event.item.type !== "user_message" || !agent.pendingRun) {
+            return false;
+        }
+        const eventMessageId = normalizeMessageId(event.item.messageId);
+        const eventText = event.item.text;
+        if (!eventMessageId) {
+            return false;
+        }
+        return agent.timelineRows.some((row) => {
+            const rowItem = row.item;
+            if (rowItem.type !== "user_message") {
+                return false;
+            }
+            const rowMessageId = normalizeMessageId(rowItem.messageId);
+            return rowMessageId === eventMessageId && rowItem.text === eventText;
+        });
+    }
     recordTimeline(agent, item) {
         const timelineState = this.ensureTimelineState(agent);
         const row = {
@@ -1177,7 +1416,8 @@ export class AgentManager {
         agent.timelineNextSeq = timelineState.nextSeq + 1;
         agent.timeline.push(item);
         timelineState.rows.push(row);
-        if (agent.timeline.length > this.maxTimelineItems) {
+        if (typeof this.maxTimelineItems === "number" &&
+            agent.timeline.length > this.maxTimelineItems) {
             const removeCount = agent.timeline.length - this.maxTimelineItems;
             agent.timeline.splice(0, removeCount);
             timelineState.rows.splice(0, removeCount);
@@ -1185,7 +1425,7 @@ export class AgentManager {
         return row;
     }
     emitState(agent) {
-        // Check if attention should be set based on status change
+        // Keep attention as an edge-triggered unread signal, not a level signal.
         this.checkAndSetAttention(agent);
         this.dispatch({
             type: "agent_state",
@@ -1217,7 +1457,7 @@ export class AgentManager {
             return;
         }
         // Check if agent entered error state
-        if (currentStatus === "error") {
+        if (previousStatus !== "error" && currentStatus === "error") {
             agent.attention = {
                 requiresAttention: true,
                 attentionReason: "error",
@@ -1227,17 +1467,6 @@ export class AgentManager {
             this.enqueueBackgroundPersist(agent);
             return;
         }
-        // Check if agent has pending permissions
-        if (agent.pendingPermissions.size > 0) {
-            agent.attention = {
-                requiresAttention: true,
-                attentionReason: "permission",
-                attentionTimestamp: new Date(),
-            };
-            this.broadcastAgentAttention(agent, "permission");
-            this.enqueueBackgroundPersist(agent);
-            return;
-        }
     }
     enqueueBackgroundPersist(agent) {
         const task = this.persistSnapshot(agent).catch((err) => {
@@ -1343,5 +1572,141 @@ export class AgentManager {
         }
         return agent;
     }
+    startLiveEventPump(agent) {
+        if (!supportsLiveEventStream(agent.session)) {
+            return;
+        }
+        if (this.liveEventPumps.has(agent.id)) {
+            return;
+        }
+        const pump = (async () => {
+            while (true) {
+                const current = this.agents.get(agent.id);
+                if (!current) {
+                    return;
+                }
+                if (!supportsLiveEventStream(current.session)) {
+                    return;
+                }
+                try {
+                    for await (const event of current.session.streamLiveEvents()) {
+                        const latest = this.agents.get(agent.id);
+                        if (!latest) {
+                            return;
+                        }
+                        // Keep consuming provider events even during an active foreground run,
+                        // then replay them immediately once that run settles.
+                        if (latest.pendingRun) {
+                            this.logger.trace({
+                                agentId: latest.id,
+                                eventType: event.type,
+                                backlogSize: (this.liveEventBacklog.get(latest.id)?.length ?? 0) + 1,
+                            }, "Live event pump: queued event because pendingRun is active");
+                            this.enqueueLiveEvent(latest.id, event);
+                            continue;
+                        }
+                        this.flushLiveEventBacklog(latest);
+                        this.handleStreamEvent(latest, event);
+                    }
+                    this.logger.warn({ agentId: agent.id }, "Live event pump stream ended; restarting");
+                }
+                catch (error) {
+                    this.logger.warn({ err: error, agentId: agent.id }, "Live event pump failed");
+                }
+                // Keep pump alive unless the agent is gone.
+                await new Promise((resolve) => setTimeout(resolve, 250));
+                const latest = this.agents.get(agent.id);
+                if (!latest) {
+                    return;
+                }
+                if (!latest.pendingRun) {
+                    this.flushLiveEventBacklog(latest);
+                }
+            }
+        })();
+        this.liveEventPumps.set(agent.id, pump);
+        pump.finally(() => {
+            const current = this.liveEventPumps.get(agent.id);
+            if (current === pump) {
+                this.liveEventPumps.delete(agent.id);
+            }
+        });
+    }
+    enqueueLiveEvent(agentId, event) {
+        const existing = this.liveEventBacklog.get(agentId);
+        if (existing) {
+            existing.push(event);
+            return;
+        }
+        this.liveEventBacklog.set(agentId, [event]);
+    }
+    clearLiveEventBacklogFlushTimer(agentId) {
+        const timer = this.liveEventBacklogFlushTimers.get(agentId);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.liveEventBacklogFlushTimers.delete(agentId);
+    }
+    scheduleLiveEventBacklogFlush(agentId, delayMs) {
+        if (this.liveEventBacklogFlushTimers.has(agentId)) {
+            return;
+        }
+        const timer = setTimeout(() => {
+            this.liveEventBacklogFlushTimers.delete(agentId);
+            const latest = this.agents.get(agentId);
+            if (!latest) {
+                return;
+            }
+            if (latest.pendingRun) {
+                this.scheduleLiveEventBacklogFlush(agentId, LIVE_BACKLOG_TERMINAL_REPLAY_DELAY_MS);
+                return;
+            }
+            this.flushLiveEventBacklog(latest);
+        }, delayMs);
+        this.liveEventBacklogFlushTimers.set(agentId, timer);
+    }
+    flushLiveEventBacklog(agent) {
+        if (agent.pendingRun) {
+            return;
+        }
+        const pending = this.liveEventBacklog.get(agent.id);
+        if (!pending || pending.length === 0) {
+            return;
+        }
+        this.clearLiveEventBacklogFlushTimer(agent.id);
+        this.liveEventBacklog.delete(agent.id);
+        const immediate = [];
+        const deferred = [];
+        let sawTurnStarted = false;
+        let deferRemainder = false;
+        for (const event of pending) {
+            if (!deferRemainder && sawTurnStarted && isTurnTerminalEvent(event)) {
+                deferRemainder = true;
+            }
+            if (deferRemainder) {
+                deferred.push(event);
+                continue;
+            }
+            immediate.push(event);
+            if (event.type === "turn_started") {
+                sawTurnStarted = true;
+            }
+        }
+        for (const event of immediate) {
+            this.handleStreamEvent(agent, event);
+        }
+        if (deferred.length === 0) {
+            return;
+        }
+        const existing = this.liveEventBacklog.get(agent.id);
+        if (existing && existing.length > 0) {
+            this.liveEventBacklog.set(agent.id, [...deferred, ...existing]);
+        }
+        else {
+            this.liveEventBacklog.set(agent.id, deferred);
+        }
+        this.scheduleLiveEventBacklogFlush(agent.id, LIVE_BACKLOG_TERMINAL_REPLAY_DELAY_MS);
+    }
 }
 //# sourceMappingURL=agent-manager.js.map