@getpaseo/server 0.1.15 → 0.1.16

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

@@ -19,6 +19,7 @@ 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,6 +68,9 @@ 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();
         this.maxTimelineItems =
             options?.maxTimelineItems ?? DEFAULT_MAX_TIMELINE_ITEMS;
         this.idFactory = options?.idFactory ?? (() => randomUUID());
@@ -397,6 +418,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();
         }
@@ -422,6 +446,9 @@ export class AgentManager {
     async closeAgent(agentId) {
         const agent = this.requireAgent(agentId);
         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;
@@ -529,10 +556,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;
@@ -604,6 +632,7 @@ export class AgentManager {
                 mutableAgent.persistence = attachPersistenceCwd(persistenceHandle, mutableAgent.cwd);
             }
             this.emitState(mutableAgent);
+            this.flushLiveEventBacklog(mutableAgent);
         };
         const self = this;
         const streamForwarder = (async function* streamForwarder() {
@@ -726,7 +755,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 +766,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 +874,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 +932,9 @@ export class AgentManager {
                         return;
                     }
                     if (!waitForActive || hasStarted) {
+                        if (terminalStatusOverride) {
+                            currentStatus = terminalStatusOverride;
+                        }
                         finish(null);
                     }
                     return;
@@ -908,20 +945,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 +964,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 +1015,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 +1097,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 +1118,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 +1162,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") {
@@ -1114,9 +1189,16 @@ export class AgentManager {
             case "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":
+                if (!agent.pendingRun) {
+                    agent.lifecycle = "error";
+                }
                 agent.lastError = event.error;
                 for (const [requestId] of agent.pendingPermissions) {
                     agent.pendingPermissions.delete(requestId);
@@ -1132,6 +1214,9 @@ export class AgentManager {
                 this.emitState(agent);
                 break;
             case "turn_canceled":
+                if (!agent.pendingRun) {
+                    agent.lifecycle = "idle";
+                }
                 agent.lastError = undefined;
                 for (const [requestId] of agent.pendingPermissions) {
                     agent.pendingPermissions.delete(requestId);
@@ -1146,6 +1231,12 @@ export class AgentManager {
                 }
                 this.emitState(agent);
                 break;
+            case "turn_started":
+                if (!agent.pendingRun) {
+                    agent.lifecycle = "running";
+                    this.emitState(agent);
+                }
+                break;
             case "permission_requested":
                 agent.pendingPermissions.set(event.request.id, event.request);
                 this.emitState(agent);
@@ -1167,6 +1258,27 @@ export class AgentManager {
                 : undefined);
         }
     }
+    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 = {
@@ -1343,5 +1455,136 @@ 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.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