@getpaseo/server 0.1.74 → 0.1.76

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

@@ -4,6 +4,7 @@ import { stat } from "node:fs/promises";
 import { AGENT_LIFECYCLE_STATUSES, } from "../../shared/agent-lifecycle.js";
 import { PARENT_AGENT_ID_LABEL } from "../../shared/agent-labels.js";
 import { z } from "zod";
+import { getAgentStreamEventTurnId, } from "./agent-sdk-types.js";
 import { buildArchivedAgentRecord } from "./agent-archive.js";
 import { InMemoryAgentTimelineStore, } from "./agent-timeline-store.js";
 import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS, AgentStreamCoalescer, } from "./agent-stream-coalescer.js";
@@ -589,16 +590,23 @@ export class AgentManager {
         const agent = this.requireAgent(agentId);
         this.logger.trace({
             agentId,
+            provider: agent.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId: agent.activeForegroundTurnId ?? undefined,
             lifecycle: agent.lifecycle,
             activeForegroundTurnId: agent.activeForegroundTurnId,
             pendingPermissions: agent.pendingPermissions.size,
-        }, "closeAgent: start");
+        }, "agent.manager.close.start");
         const closedAgent = this.prepareAgentForClosure(agent, "agent closed");
         await agent.session.close();
         this.timelineStore.delete(agentId);
         await this.persistSnapshot(closedAgent);
         this.emitClosedAgent(closedAgent, { persist: false });
-        this.logger.trace({ agentId }, "closeAgent: completed");
+        this.logger.trace({
+            agentId,
+            provider: closedAgent.provider,
+            sessionId: closedAgent.persistence?.sessionId ?? undefined,
+        }, "agent.manager.close.complete");
     }
     async archiveAgent(agentId) {
         const agent = this.requireAgent(agentId);
@@ -906,10 +914,11 @@ export class AgentManager {
                 this.dispatchStream(agent.id, event, {
                     seq: row.seq,
                     epoch: this.timelineStore.getEpoch(agent.id),
+                    timestamp: row.timestamp,
                 });
                 return;
             }
-            this.dispatchStream(agent.id, event);
+            this.dispatchStream(agent.id, event, { timestamp: new Date().toISOString() });
         };
         void (async () => {
             try {
@@ -944,6 +953,7 @@ export class AgentManager {
         }, {
             seq: row.seq,
             epoch: this.timelineStore.getEpoch(agentId),
+            timestamp: row.timestamp,
         });
         if (options?.emitState !== false) {
             this.emitState(agent);
@@ -960,6 +970,7 @@ export class AgentManager {
         }, {
             seq: row.seq,
             epoch: this.timelineStore.getEpoch(agentId),
+            timestamp: row.timestamp,
         });
         await this.persistSnapshot(agent);
     }
@@ -976,18 +987,24 @@ export class AgentManager {
         const existingAgent = this.requireSessionAgent(agentId);
         this.logger.trace({
             agentId,
+            provider: existingAgent.provider,
+            sessionId: existingAgent.persistence?.sessionId ?? undefined,
+            turnId: existingAgent.activeForegroundTurnId ?? undefined,
             lifecycle: existingAgent.lifecycle,
             activeForegroundTurnId: existingAgent.activeForegroundTurnId,
             hasPendingForegroundRun: this.foregroundRuns.hasPendingRun(agentId),
             promptType: typeof prompt === "string" ? "string" : "structured",
             hasRunOptions: Boolean(options),
-        }, "streamAgent: requested");
+        }, "agent.manager.stream.request");
         if (existingAgent.activeForegroundTurnId || this.foregroundRuns.hasPendingRun(agentId)) {
             this.logger.trace({
                 agentId,
+                provider: existingAgent.provider,
+                sessionId: existingAgent.persistence?.sessionId ?? undefined,
+                turnId: existingAgent.activeForegroundTurnId ?? undefined,
                 lifecycle: existingAgent.lifecycle,
                 hasPendingForegroundRun: this.foregroundRuns.hasPendingRun(agentId),
-            }, "streamAgent: rejected because a foreground run is already in flight");
+            }, "agent.manager.stream.reject");
             throw new Error(`Agent ${agentId} already has an active run`);
         }
         const agent = existingAgent;
@@ -1019,9 +1036,12 @@ export class AgentManager {
             this.emitState(agent);
             this.logger.trace({
                 agentId,
+                provider: agent.provider,
+                sessionId: agent.persistence?.sessionId ?? undefined,
+                turnId,
                 lifecycle: agent.lifecycle,
                 activeForegroundTurnId: agent.activeForegroundTurnId,
-            }, "streamAgent: started");
+            }, "agent.manager.stream.start");
             turnStream = this.foregroundRuns.createTurnStream(turnId);
             this.foregroundRuns.addWaiter(agent, turnStream.waiter);
             try {
@@ -1069,10 +1089,13 @@ export class AgentManager {
         }
         this.logger.trace({
             agentId: agent.id,
+            provider: agent.provider,
+            sessionId: mutableAgent.persistence?.sessionId ?? undefined,
+            turnId,
             lifecycle: mutableAgent.lifecycle,
             terminalError,
             pendingReplacement: mutableAgent.pendingReplacement,
-        }, "finalizeForegroundTurn: applying terminal state");
+        }, "agent.manager.finalize");
         if (!shouldHoldBusyForReplacement) {
             this.touchUpdatedAt(mutableAgent);
             this.emitState(mutableAgent);
@@ -1216,7 +1239,7 @@ export class AgentManager {
             const bufferedResolution = agent.bufferedPermissionResolutions.get(requestId);
             if (bufferedResolution) {
                 agent.bufferedPermissionResolutions.delete(requestId);
-                this.dispatchStream(agent.id, bufferedResolution);
+                this.dispatchStream(agent.id, bufferedResolution, { timestamp: new Date().toISOString() });
             }
             return result;
         }
@@ -1297,7 +1320,7 @@ export class AgentManager {
                     provider: agent.provider,
                     requestId,
                     resolution: { behavior: "deny", message: "Interrupted" },
-                });
+                }, { timestamp: new Date().toISOString() });
             }
             agent.pendingPermissions.clear();
             this.touchUpdatedAt(agent);
@@ -1690,6 +1713,13 @@ export class AgentManager {
         agent.unsubscribeSession = unsubscribe;
     }
     enqueueSessionEvent(agentId, event) {
+        this.logger.trace({
+            agentId,
+            provider: event.provider,
+            sessionId: this.agents.get(agentId)?.persistence?.sessionId ?? undefined,
+            turnId: getAgentStreamEventTurnId(event),
+            event,
+        }, "agent.manager.enqueue");
         const previous = this.sessionEventTails.get(agentId) ?? Promise.resolve();
         const next = previous
             .catch(() => undefined)
@@ -1701,6 +1731,13 @@ export class AgentManager {
             if (current.session == null) {
                 return;
             }
+            this.logger.trace({
+                agentId,
+                provider: event.provider,
+                sessionId: current.persistence?.sessionId ?? undefined,
+                turnId: getAgentStreamEventTurnId(event),
+                event,
+            }, "agent.manager.dequeue");
             await this.dispatchSessionEvent(current, event);
             return;
         })
@@ -1716,8 +1753,16 @@ export class AgentManager {
         });
     }
     async dispatchSessionEvent(agent, event) {
-        const turnId = event.turnId;
+        const turnId = getAgentStreamEventTurnId(event);
         const matchingWaiters = this.foregroundRuns.getMatchingWaiters(agent, turnId);
+        this.logger.trace({
+            agentId: agent.id,
+            provider: event.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId,
+            matchingWaiterCount: matchingWaiters.length,
+            event,
+        }, "agent.manager.dispatch_session_event");
         const shouldNotifyWaiters = await this.handleStreamEvent(agent, event);
         if (!shouldNotifyWaiters) {
             return;
@@ -1725,6 +1770,15 @@ export class AgentManager {
         this.foregroundRuns.notifyWaiters(matchingWaiters, event, {
             terminal: isTurnTerminalEvent(event),
         });
+        this.logger.trace({
+            agentId: agent.id,
+            provider: event.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId,
+            notifiedWaiterCount: matchingWaiters.length,
+            terminal: isTurnTerminalEvent(event),
+            event,
+        }, "agent.manager.notify_waiters");
     }
     async resolveInitialPersistedTitle(agentId, config) {
         const existing = await this.registry?.get(agentId);
@@ -1814,7 +1868,7 @@ export class AgentManager {
                 if (isDuplicateLegacyUserMessage(event.item, canonicalUserMessagesById)) {
                     continue;
                 }
-                this.recordTimeline(agent.id, event.item);
+                this.recordTimeline(agent.id, event.item, event.timestamp ? { timestamp: event.timestamp } : undefined);
             }
         }
         catch {
@@ -1822,7 +1876,7 @@ export class AgentManager {
         }
     }
     notifyForegroundTurnWaiters(agentId, event) {
-        const turnId = event.turnId;
+        const turnId = getAgentStreamEventTurnId(event);
         if (turnId == null) {
             return;
         }
@@ -1831,10 +1885,18 @@ export class AgentManager {
             return;
         }
         this.foregroundRuns.notifyAgentWaiters(agent, event);
+        this.logger.trace({
+            agentId,
+            provider: event.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId,
+            event,
+        }, "agent.manager.notify_waiters.coalesced");
     }
     async handleStreamEvent(agent, event, options) {
-        const eventTurnId = event.turnId;
+        const eventTurnId = getAgentStreamEventTurnId(event);
         const isForegroundEvent = Boolean(eventTurnId && agent.activeForegroundTurnId === eventTurnId);
+        this.traceHandleStreamEventStart(agent, event, eventTurnId, isForegroundEvent);
         if (eventTurnId &&
             isTurnTerminalEvent(event) &&
             this.foregroundRuns.hasFinalizedTurn(agent, eventTurnId)) {
@@ -1844,6 +1906,7 @@ export class AgentManager {
         if (!options?.fromHistory) {
             this.touchUpdatedAt(agent);
             if (this.agentStreamCoalescer.handle(agent.id, event)) {
+                this.traceCoalescerBuffered(agent, event, eventTurnId);
                 return false;
             }
             this.agentStreamCoalescer.flushFor(agent.id);
@@ -1864,10 +1927,45 @@ export class AgentManager {
             this.finalizeForegroundTurn(agent, eventTurnId);
         }
         if (!options?.fromHistory && flags.shouldDispatchEvent) {
-            this.dispatchStream(agent.id, event);
+            this.dispatchStream(agent.id, event, { timestamp: new Date().toISOString() });
         }
+        this.traceHandleStreamEventEnd(agent, event, eventTurnId, flags);
         return flags.shouldNotifyWaiters;
     }
+    traceHandleStreamEventStart(agent, event, turnId, isForegroundEvent) {
+        this.logger.trace({
+            agentId: agent.id,
+            provider: event.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId,
+            lifecycle: agent.lifecycle,
+            activeForegroundTurnId: agent.activeForegroundTurnId,
+            isForegroundEvent,
+            event,
+        }, "agent.manager.handle_stream_event.start");
+    }
+    traceCoalescerBuffered(agent, event, turnId) {
+        this.logger.trace({
+            agentId: agent.id,
+            provider: event.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId,
+            event,
+        }, "agent.manager.coalescer.buffer");
+    }
+    traceHandleStreamEventEnd(agent, event, turnId, flags) {
+        this.logger.trace({
+            agentId: agent.id,
+            provider: event.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId,
+            lifecycle: agent.lifecycle,
+            activeForegroundTurnId: agent.activeForegroundTurnId,
+            shouldDispatchEvent: flags.shouldDispatchEvent,
+            shouldNotifyWaiters: flags.shouldNotifyWaiters,
+            event,
+        }, "agent.manager.handle_stream_event.end");
+    }
     dispatchStreamEventByType(params) {
         const { agent, event, options, isForegroundEvent, eventTurnId, flags } = params;
         switch (event.type) {
@@ -1972,7 +2070,7 @@ export class AgentManager {
             }
         }
         if (options?.fromHistory) {
-            this.recordTimeline(agent.id, event.item);
+            this.recordTimeline(agent.id, event.item, event.timestamp ? { timestamp: event.timestamp } : undefined);
             flags.shouldDispatchEvent = false;
             flags.shouldNotifyWaiters = false;
             return;
@@ -1989,10 +2087,12 @@ export class AgentManager {
         const { agent, event, eventTurnId, isForegroundEvent } = params;
         this.logger.trace({
             agentId: agent.id,
+            provider: agent.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId: eventTurnId,
             lifecycle: agent.lifecycle,
             activeForegroundTurnId: agent.activeForegroundTurnId,
-            eventTurnId,
-        }, "handleStreamEvent: turn_completed");
+        }, "agent.manager.turn.completed");
         agent.lastUsage = event.usage;
         agent.lastError = undefined;
         if (!isForegroundEvent && agent.lifecycle !== "idle" && !agent.pendingReplacement) {
@@ -2005,6 +2105,9 @@ export class AgentManager {
         const { agent, event, eventTurnId, isForegroundEvent, options } = params;
         this.logger.warn({
             agentId: agent.id,
+            provider: agent.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId: eventTurnId,
             lifecycle: agent.lifecycle,
             activeForegroundTurnId: agent.activeForegroundTurnId,
             eventTurnId,
@@ -2026,10 +2129,13 @@ export class AgentManager {
         const { agent, event, eventTurnId, isForegroundEvent, options } = params;
         this.logger.trace({
             agentId: agent.id,
+            provider: agent.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId: eventTurnId,
             lifecycle: agent.lifecycle,
             activeForegroundTurnId: agent.activeForegroundTurnId,
             eventTurnId,
-        }, "handleStreamEvent: turn_canceled");
+        }, "agent.manager.turn.canceled");
         if (!isForegroundEvent && !agent.pendingReplacement) {
             agent.lifecycle = "idle";
         }
@@ -2043,10 +2149,12 @@ export class AgentManager {
         const { agent, eventTurnId, isForegroundEvent } = params;
         this.logger.trace({
             agentId: agent.id,
+            provider: agent.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId: eventTurnId,
             lifecycle: agent.lifecycle,
             activeForegroundTurnId: agent.activeForegroundTurnId,
-            eventTurnId,
-        }, "handleStreamEvent: turn_started");
+        }, "agent.manager.turn.started");
         if (!isForegroundEvent) {
             agent.lifecycle = "running";
             this.emitState(agent);
@@ -2094,6 +2202,7 @@ export class AgentManager {
         this.dispatchStream(agentId, event, {
             seq: row.seq,
             epoch: this.timelineStore.getEpoch(agentId),
+            timestamp: row.timestamp,
         });
         return event;
     }
@@ -2119,6 +2228,7 @@ export class AgentManager {
         }, {
             seq: row.seq,
             epoch: this.timelineStore.getEpoch(agent.id),
+            timestamp: row.timestamp,
         });
     }
     formatTurnFailedMessage(event) {
@@ -2134,8 +2244,8 @@ export class AgentManager {
         }
         return parts.join("\n\n");
     }
-    recordTimeline(agentId, item) {
-        const row = this.timelineStore.append(agentId, item);
+    recordTimeline(agentId, item, options) {
+        const row = this.timelineStore.append(agentId, item, options);
         this.enqueueDurableTimelineAppend(agentId, row);
         return row;
     }
@@ -2146,6 +2256,16 @@ export class AgentManager {
             this.enqueueBackgroundPersist(agent);
         }
         this.syncFeaturesFromSession(agent);
+        this.logger.trace({
+            agentId: agent.id,
+            provider: agent.provider,
+            sessionId: agent.persistence?.sessionId ?? undefined,
+            turnId: agent.activeForegroundTurnId ?? undefined,
+            lifecycle: agent.lifecycle,
+            activeForegroundTurnId: agent.activeForegroundTurnId,
+            pendingPermissions: agent.pendingPermissions.size,
+            persist: options?.persist !== false,
+        }, "agent.manager.emit_state");
         this.dispatch({
             type: "agent_state",
             agent: { ...agent },
@@ -2243,6 +2363,15 @@ export class AgentManager {
         });
     }
     dispatchStream(agentId, event, metadata) {
+        const agent = this.agents.get(agentId);
+        this.logger.trace({
+            agentId,
+            provider: event.provider,
+            sessionId: agent?.persistence?.sessionId ?? undefined,
+            turnId: getAgentStreamEventTurnId(event),
+            metadata,
+            event,
+        }, "agent.manager.dispatch_stream");
         this.dispatch({ type: "agent_stream", agentId, event, ...metadata });
     }
     dispatch(event) {
@@ -2327,6 +2456,7 @@ export class AgentManager {
     }
     buildLaunchContext(agentId) {
         return {
+            agentId,
             env: {
                 PASEO_AGENT_ID: agentId,
             },