@getpaseo/server 0.1.63 → 0.1.65

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 { InMemoryAgentTimelineStore, } from "./agent-timeline-store.js";
 import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS, AgentStreamCoalescer, } from "./agent-stream-coalescer.js";
+import { ForegroundRunState } from "./foreground-run-state.js";
 import { getAgentProviderDefinition } from "./provider-manifest.js";
 const RELOAD_SESSION_CLOSE_TIMEOUT_MS = 3000;
 const INTERRUPT_SESSION_TIMEOUT_MS = 2000;
@@ -102,7 +103,7 @@ export class AgentManager {
         this.timelineStore = new InMemoryAgentTimelineStore();
         this.agentsAwaitingInitialSnapshotPersist = new Set();
         this.sessionEventTails = new Map();
-        this.pendingForegroundRuns = new Map();
+        this.foregroundRuns = new ForegroundRunState();
         this.subscribers = new Set();
         this.previousStatuses = new Map();
         this.backgroundTasks = new Set();
@@ -197,7 +198,7 @@ export class AgentManager {
         }
         return (agent.lifecycle === "running" ||
             Boolean(agent.activeForegroundTurnId) ||
-            this.hasPendingForegroundRun(agentId));
+            this.foregroundRuns.hasPendingRun(agentId));
     }
     subscribe(callback, options) {
         const targetAgentId = options?.agentId == null ? null : validateAgentId(options.agentId, "subscribe");
@@ -262,6 +263,16 @@ export class AgentManager {
             .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
             .slice(0, limit);
     }
+    async findPersistedAgent(provider, sessionId) {
+        const client = this.requireClient(provider);
+        if (!client.listPersistedAgents) {
+            return null;
+        }
+        const descriptors = await client.listPersistedAgents({ limit: 200 });
+        return (descriptors.find((descriptor) => {
+            return (descriptor.sessionId === sessionId || descriptor.persistence.nativeHandle === sessionId);
+        }) ?? null);
+    }
     async listProviderAvailability() {
         const checks = Array.from(this.clients.keys()).map(async (provider) => {
             const client = this.clients.get(provider);
@@ -435,11 +446,7 @@ export class AgentManager {
             existing.unsubscribeSession();
             existing.unsubscribeSession = null;
         }
-        for (const waiter of existing.foregroundTurnWaiters) {
-            this.settleForegroundTurnWaiter(waiter);
-        }
-        existing.foregroundTurnWaiters.clear();
-        this.settlePendingForegroundRun(agentId);
+        this.foregroundRuns.clearAgent(agentId, existing);
         await this.closeReloadedSession(existing.session, agentId);
         // Preserve existing labels and timeline during reload.
         return this.registerSession(session, normalizedConfig, agentId, {
@@ -793,38 +800,38 @@ export class AgentManager {
             agentId,
             lifecycle: existingAgent.lifecycle,
             activeForegroundTurnId: existingAgent.activeForegroundTurnId,
-            hasPendingForegroundRun: this.hasPendingForegroundRun(agentId),
+            hasPendingForegroundRun: this.foregroundRuns.hasPendingRun(agentId),
             promptType: typeof prompt === "string" ? "string" : "structured",
             hasRunOptions: Boolean(options),
         }, "streamAgent: requested");
-        if (existingAgent.activeForegroundTurnId || this.hasPendingForegroundRun(agentId)) {
+        if (existingAgent.activeForegroundTurnId || this.foregroundRuns.hasPendingRun(agentId)) {
             this.logger.trace({
                 agentId,
                 lifecycle: existingAgent.lifecycle,
-                hasPendingForegroundRun: this.hasPendingForegroundRun(agentId),
+                hasPendingForegroundRun: this.foregroundRuns.hasPendingRun(agentId),
             }, "streamAgent: rejected because a foreground run is already in flight");
             throw new Error(`Agent ${agentId} already has an active run`);
         }
         const agent = existingAgent;
         agent.pendingReplacement = false;
         agent.lastError = undefined;
-        const pendingRun = this.createPendingForegroundRun();
-        this.pendingForegroundRuns.set(agentId, pendingRun);
+        const pendingRun = this.foregroundRuns.createPendingRun(agentId);
         const streamForwarder = async function* streamForwarder() {
             let turnId;
-            let waiter = null;
+            let turnStream = null;
             try {
                 const result = await agent.session.startTurn(prompt, options);
                 turnId = result.turnId;
             }
             catch (error) {
                 const errorMsg = error instanceof Error ? error.message : "Failed to start turn";
-                this.handleStreamEvent(agent, {
+                await this.handleStreamEvent(agent, {
                     type: "turn_failed",
                     provider: agent.provider,
                     error: errorMsg,
                 });
                 this.finalizeForegroundTurn(agent);
+                this.foregroundRuns.settlePendingRun(agentId, pendingRun.token);
                 throw error;
             }
             pendingRun.started = true;
@@ -837,54 +844,18 @@ export class AgentManager {
                 lifecycle: agent.lifecycle,
                 activeForegroundTurnId: agent.activeForegroundTurnId,
             }, "streamAgent: started");
-            // Create a pushable queue for this foreground turn
-            const queue = [];
-            let queueResolve = null;
-            let done = false;
-            let resolveSettled;
-            const settledPromise = new Promise((resolvePromise) => {
-                resolveSettled = resolvePromise;
-            });
-            waiter = {
-                turnId,
-                settled: false,
-                settledPromise,
-                resolveSettled,
-                callback: (event) => {
-                    queue.push(event);
-                    if (queueResolve) {
-                        queueResolve();
-                        queueResolve = null;
-                    }
-                },
-            };
-            agent.foregroundTurnWaiters.add(waiter);
+            turnStream = this.foregroundRuns.createTurnStream(turnId);
+            this.foregroundRuns.addWaiter(agent, turnStream.waiter);
             try {
-                while (!done) {
-                    while (queue.length > 0) {
-                        const event = queue.shift();
-                        yield event;
-                        if (isTurnTerminalEvent(event)) {
-                            done = true;
-                            break;
-                        }
-                    }
-                    if (!done && queue.length === 0) {
-                        if (waiter.settled) {
-                            break;
-                        }
-                        await new Promise((resolvePromise) => {
-                            queueResolve = resolvePromise;
-                        });
-                    }
+                for await (const event of turnStream.events(isTurnTerminalEvent)) {
+                    yield event;
                 }
             }
             finally {
-                if (waiter) {
-                    agent.foregroundTurnWaiters.delete(waiter);
-                    this.settleForegroundTurnWaiter(waiter);
+                if (turnStream) {
+                    this.foregroundRuns.deleteWaiter(agent, turnStream.waiter);
                 }
-                this.settlePendingForegroundRun(agentId, pendingRun.token);
+                this.foregroundRuns.settlePendingRun(agentId, pendingRun.token);
                 if (!agent.activeForegroundTurnId) {
                     await this.refreshRuntimeInfo(agent);
                 }
@@ -895,7 +866,7 @@ export class AgentManager {
     finalizeForegroundTurn(agent, turnId) {
         const mutableAgent = agent;
         if (turnId) {
-            this.rememberFinalizedForegroundTurn(mutableAgent, turnId);
+            this.foregroundRuns.rememberFinalizedTurn(mutableAgent, turnId);
         }
         mutableAgent.activeForegroundTurnId = null;
         const terminalError = mutableAgent.lastError;
@@ -933,7 +904,7 @@ export class AgentManager {
         const snapshot = this.requireAgent(agentId);
         if (snapshot.lifecycle !== "running" &&
             !snapshot.activeForegroundTurnId &&
-            !this.hasPendingForegroundRun(agentId)) {
+            !this.foregroundRuns.hasPendingRun(agentId)) {
             return this.streamAgent(agentId, prompt, options);
         }
         const agent = this.requireSessionAgent(agentId);
@@ -969,7 +940,7 @@ export class AgentManager {
         if (!snapshot) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        const pendingRun = this.getPendingForegroundRun(agentId);
+        const pendingRun = this.foregroundRuns.getPendingRun(agentId);
         if ((snapshot.lifecycle === "running" || pendingRun?.started) && !snapshot.pendingReplacement) {
             return;
         }
@@ -1024,7 +995,7 @@ export class AgentManager {
                     finishErr(new Error(`Agent ${agentId} not found`));
                     return true;
                 }
-                const currentPendingRun = this.getPendingForegroundRun(agentId);
+                const currentPendingRun = this.foregroundRuns.getPendingRun(agentId);
                 if ((current.lifecycle === "running" || currentPendingRun?.started) &&
                     !current.pendingReplacement) {
                     finishOk();
@@ -1078,7 +1049,7 @@ export class AgentManager {
     }
     async cancelAgentRun(agentId) {
         const agent = this.requireSessionAgent(agentId);
-        const pendingRun = this.getPendingForegroundRun(agentId);
+        const pendingRun = this.foregroundRuns.getPendingRun(agentId);
         const foregroundTurnId = agent.activeForegroundTurnId;
         const hasForegroundTurn = Boolean(foregroundTurnId);
         const isAutonomousRunning = agent.lifecycle === "running" && !hasForegroundTurn && !pendingRun;
@@ -1135,7 +1106,7 @@ export class AgentManager {
             });
             // The synthetic event unblocks the streamForwarder generator, whose finally
             // block settles the pending foreground run asynchronously. Wait for it.
-            const staleRun = this.getPendingForegroundRun(agentId);
+            const staleRun = this.foregroundRuns.getPendingRun(agentId);
             if (staleRun && !staleRun.settled) {
                 await staleRun.settledPromise;
             }
@@ -1272,7 +1243,7 @@ export class AgentManager {
         if (!snapshot) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        const pendingForegroundRun = this.getPendingForegroundRun(agentId);
+        const pendingForegroundRun = this.foregroundRuns.getPendingRun(agentId);
         const hasForegroundTurn = Boolean(snapshot.activeForegroundTurnId) || Boolean(pendingForegroundRun);
         const immediatePermission = this.peekPendingPermission(snapshot);
         if (immediatePermission) {
@@ -1513,17 +1484,13 @@ export class AgentManager {
             agent.unsubscribeSession();
             agent.unsubscribeSession = null;
         }
-        for (const waiter of agent.foregroundTurnWaiters) {
-            waiter.callback({
-                type: "turn_canceled",
-                provider: agent.provider,
-                reason: cancelReason,
-                turnId: waiter.turnId,
-            });
-            this.settleForegroundTurnWaiter(waiter);
-        }
-        agent.foregroundTurnWaiters.clear();
-        this.settlePendingForegroundRun(agent.id);
+        this.foregroundRuns.cancelWaiters(agent, (turnId) => ({
+            type: "turn_canceled",
+            provider: agent.provider,
+            reason: cancelReason,
+            turnId,
+        }));
+        this.foregroundRuns.settlePendingRun(agent.id);
         return {
             ...agent,
             lifecycle: "closed",
@@ -1572,70 +1539,14 @@ export class AgentManager {
     }
     async dispatchSessionEvent(agent, event) {
         const turnId = event.turnId;
-        const matchingWaiters = turnId == null
-            ? []
-            : Array.from(agent.foregroundTurnWaiters).filter((waiter) => waiter.turnId === turnId && !waiter.settled);
+        const matchingWaiters = this.foregroundRuns.getMatchingWaiters(agent, turnId);
         const shouldNotifyWaiters = await this.handleStreamEvent(agent, event);
         if (!shouldNotifyWaiters) {
             return;
         }
-        for (const waiter of matchingWaiters) {
-            waiter.callback(event);
-            if (isTurnTerminalEvent(event)) {
-                this.settleForegroundTurnWaiter(waiter);
-            }
-        }
-    }
-    settleForegroundTurnWaiter(waiter) {
-        if (waiter.settled) {
-            return;
-        }
-        waiter.settled = true;
-        waiter.resolveSettled();
-    }
-    rememberFinalizedForegroundTurn(agent, turnId) {
-        agent.finalizedForegroundTurnIds.add(turnId);
-        if (agent.finalizedForegroundTurnIds.size <= 50) {
-            return;
-        }
-        const oldest = agent.finalizedForegroundTurnIds.values().next().value;
-        if (oldest) {
-            agent.finalizedForegroundTurnIds.delete(oldest);
-        }
-    }
-    createPendingForegroundRun() {
-        let resolveSettled;
-        const settledPromise = new Promise((resolvePromise) => {
-            resolveSettled = resolvePromise;
+        this.foregroundRuns.notifyWaiters(matchingWaiters, event, {
+            terminal: isTurnTerminalEvent(event),
         });
-        return {
-            token: randomUUID(),
-            started: false,
-            settled: false,
-            settledPromise,
-            resolveSettled,
-        };
-    }
-    getPendingForegroundRun(agentId) {
-        return this.pendingForegroundRuns.get(agentId) ?? null;
-    }
-    hasPendingForegroundRun(agentId) {
-        return this.pendingForegroundRuns.has(agentId);
-    }
-    settlePendingForegroundRun(agentId, token) {
-        const pendingRun = this.pendingForegroundRuns.get(agentId);
-        if (!pendingRun) {
-            return;
-        }
-        if (token && pendingRun.token !== token) {
-            return;
-        }
-        this.pendingForegroundRuns.delete(agentId);
-        if (pendingRun.settled) {
-            return;
-        }
-        pendingRun.settled = true;
-        pendingRun.resolveSettled();
     }
     async resolveInitialPersistedTitle(agentId, config) {
         const existing = await this.registry?.get(agentId);
@@ -1741,18 +1652,14 @@ export class AgentManager {
         if (!agent) {
             return;
         }
-        for (const waiter of agent.foregroundTurnWaiters) {
-            if (waiter.turnId === turnId && !waiter.settled) {
-                waiter.callback(event);
-            }
-        }
+        this.foregroundRuns.notifyAgentWaiters(agent, event);
     }
     async handleStreamEvent(agent, event, options) {
         const eventTurnId = event.turnId;
         const isForegroundEvent = Boolean(eventTurnId && agent.activeForegroundTurnId === eventTurnId);
         if (eventTurnId &&
             isTurnTerminalEvent(event) &&
-            agent.finalizedForegroundTurnIds.has(eventTurnId)) {
+            this.foregroundRuns.hasFinalizedTurn(agent, eventTurnId)) {
             return false;
         }
         // Only update timestamp for live events, not history replay
@@ -1793,6 +1700,34 @@ export class AgentManager {
                 agent.lastUsage = event.usage;
                 this.emitState(agent);
                 return undefined;
+            case "mode_changed":
+                agent.currentModeId = event.currentModeId;
+                agent.availableModes = event.availableModes;
+                if (agent.runtimeInfo) {
+                    agent.runtimeInfo = { ...agent.runtimeInfo, modeId: event.currentModeId };
+                }
+                flags.shouldDispatchEvent = false;
+                this.emitState(agent);
+                return undefined;
+            case "model_changed":
+                agent.runtimeInfo = event.runtimeInfo;
+                if (!agent.persistence && event.runtimeInfo.sessionId) {
+                    agent.persistence = attachPersistenceCwd({ provider: agent.provider, sessionId: event.runtimeInfo.sessionId }, agent.cwd);
+                }
+                agent.currentModeId = event.runtimeInfo.modeId ?? agent.currentModeId;
+                flags.shouldDispatchEvent = false;
+                this.emitState(agent);
+                return undefined;
+            case "thinking_option_changed":
+                if (agent.runtimeInfo) {
+                    agent.runtimeInfo = {
+                        ...agent.runtimeInfo,
+                        thinkingOptionId: event.thinkingOptionId,
+                    };
+                }
+                flags.shouldDispatchEvent = false;
+                this.emitState(agent);
+                return undefined;
             case "timeline":
                 return this.onStreamTimelineEvent({ agent, event, options, isForegroundEvent, flags });
             case "turn_completed":