@getpaseo/server 0.1.69 → 0.1.71

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

@@ -2,16 +2,55 @@ import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
 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 { 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";
+import { IMPORTABLE_PROVIDERS } from "./provider-registry.js";
 const RELOAD_SESSION_CLOSE_TIMEOUT_MS = 3000;
 const INTERRUPT_SESSION_TIMEOUT_MS = 2000;
+const STORED_AGENT_CAPABILITIES = {
+    supportsStreaming: false,
+    supportsSessionPersistence: true,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: true,
+};
 function formatProviderList(providers) {
     return providers.length > 0 ? providers.join(", ") : "none";
 }
+function buildStoredAgentConfig(record) {
+    const config = {
+        provider: record.provider,
+        cwd: record.cwd,
+    };
+    if (!record.config) {
+        return config;
+    }
+    if (record.config.title != null)
+        config.title = record.config.title;
+    if (record.config.modeId != null)
+        config.modeId = record.config.modeId;
+    if (record.config.model != null)
+        config.model = record.config.model;
+    if (record.config.thinkingOptionId != null) {
+        config.thinkingOptionId = record.config.thinkingOptionId;
+    }
+    if (record.config.featureValues != null) {
+        config.featureValues = record.config.featureValues;
+    }
+    if (record.config.extra != null)
+        config.extra = record.config.extra;
+    if (record.config.systemPrompt != null) {
+        config.systemPrompt = record.config.systemPrompt;
+    }
+    if (record.config.mcpServers != null)
+        config.mcpServers = record.config.mcpServers;
+    return config;
+}
 export { AGENT_LIFECYCLE_STATUSES };
 function resolveInitialAttention(input) {
     if (input == null || !input.requiresAttention) {
@@ -99,6 +138,7 @@ export class AgentManager {
     constructor(options) {
         this.clients = new Map();
         this.providerEnabled = new Map();
+        this.providerDerivedFromId = new Map();
         this.agents = new Map();
         this.timelineStore = new InMemoryAgentTimelineStore();
         this.agentsAwaitingInitialSnapshotPersist = new Set();
@@ -137,6 +177,7 @@ export class AgentManager {
         for (const [provider, definition] of Object.entries(input.providerDefinitions)) {
             if (definition) {
                 this.providerEnabled.set(provider, definition.enabled);
+                this.providerDerivedFromId.set(provider, definition.derivedFromProviderId ?? null);
             }
         }
         for (const [provider, client] of Object.entries(input.clients)) {
@@ -239,18 +280,15 @@ export class AgentManager {
             .filter((agent) => !agent.internal)
             .map((agent) => Object.assign({}, agent));
     }
-    async listPersistedAgents(options) {
-        if (options?.provider) {
-            const client = this.requireClient(options.provider);
-            if (!client.listPersistedAgents) {
-                return [];
-            }
-            return client.listPersistedAgents({ limit: options.limit });
-        }
-        const providerEntries = Array.from(this.clients.entries()).filter(([, client]) => !!client.listPersistedAgents);
+    async listImportablePersistedAgents(options) {
+        const providerEntries = Array.from(this.clients.entries()).filter(([provider, client]) => !!client.listPersistedAgents &&
+            this.isProviderImportable(provider, options?.providerFilter));
         const descriptorLists = await Promise.all(providerEntries.map(async ([provider, client]) => {
             try {
-                return await client.listPersistedAgents({ limit: options?.limit });
+                return await client.listPersistedAgents({
+                    limit: options?.limit,
+                    cwd: options?.cwd,
+                });
             }
             catch (error) {
                 this.logger.warn({ err: error, provider }, "Failed to list persisted agents for provider");
@@ -263,6 +301,21 @@ export class AgentManager {
             .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
             .slice(0, limit);
     }
+    isProviderImportable(provider, providerFilter) {
+        if (!IMPORTABLE_PROVIDERS.includes(provider)) {
+            return false;
+        }
+        if (this.providerEnabled.get(provider) === false) {
+            return false;
+        }
+        if (this.providerDerivedFromId.get(provider) != null) {
+            return false;
+        }
+        if (providerFilter && !providerFilter.has(provider)) {
+            return false;
+        }
+        return true;
+    }
     async findPersistedAgent(provider, sessionId) {
         const client = this.requireClient(provider);
         if (!client.listPersistedAgents) {
@@ -408,26 +461,38 @@ export class AgentManager {
             provider: handle.provider,
         };
         const normalizedConfig = await this.normalizeConfig(mergedConfig);
-        const resumeOverrides = normalizedConfig.model !== mergedConfig.model
-            ? { ...overrides, model: normalizedConfig.model }
-            : overrides;
+        const resumeOverrides = { ...overrides };
+        let hasResumeOverrides = overrides !== undefined;
+        if (normalizedConfig.model !== mergedConfig.model) {
+            resumeOverrides.model = normalizedConfig.model;
+            hasResumeOverrides = true;
+        }
+        if (normalizedConfig.modeId !== mergedConfig.modeId) {
+            resumeOverrides.modeId = normalizedConfig.modeId;
+            hasResumeOverrides = true;
+        }
         const launchContext = this.buildLaunchContext(resolvedAgentId);
         const client = this.requireClient(handle.provider);
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${handle.provider}' is not available. Please ensure the CLI is installed.`);
         }
-        const session = await client.resumeSession(handle, resumeOverrides, launchContext);
+        const session = await client.resumeSession(handle, hasResumeOverrides ? resumeOverrides : undefined, launchContext);
         return this.registerSession(session, normalizedConfig, resolvedAgentId, options);
     }
-    // Hot-reload an active agent session with config overrides while preserving
-    // in-memory timeline state.
-    async reloadAgentSession(agentId, overrides) {
+    // Hot-reload an active agent session with config overrides. By default the
+    // in-memory timeline is preserved (used for voice-mode toggles and similar
+    // config swaps). When `rehydrateFromDisk` is set, the timeline is wiped so a
+    // new epoch is minted and provider history is re-streamed — this is what the
+    // user-facing "Reload agent" action wants when the on-disk session was
+    // mutated outside Paseo.
+    async reloadAgentSession(agentId, overrides, options) {
         let existing = this.requireSessionAgent(agentId);
         if (this.hasInFlightRun(agentId)) {
             await this.cancelAgentRun(agentId);
             existing = this.requireSessionAgent(agentId);
         }
+        const rehydrateFromDisk = options?.rehydrateFromDisk ?? false;
         const preservedHistoryPrimed = existing.historyPrimed;
         const preservedLastUsage = existing.lastUsage;
         const preservedLastError = existing.lastError;
@@ -454,13 +519,20 @@ export class AgentManager {
         }
         this.foregroundRuns.clearAgent(agentId, existing);
         await this.closeReloadedSession(existing.session, agentId);
+        if (rehydrateFromDisk) {
+            // Wipe both durable and in-memory timeline so registerSession mints a
+            // new epoch and hydrateTimelineFromProvider re-streams the freshly read
+            // provider history into an empty timeline.
+            await this.deleteCommittedTimeline(agentId);
+            this.timelineStore.delete(agentId);
+        }
         // Preserve existing labels and timeline during reload.
         return this.registerSession(session, normalizedConfig, agentId, {
             labels: existing.labels,
             createdAt: existing.createdAt,
             updatedAt: existing.updatedAt,
             lastUserMessageAt: existing.lastUserMessageAt,
-            historyPrimed: preservedHistoryPrimed,
+            historyPrimed: rehydrateFromDisk ? false : preservedHistoryPrimed,
             lastUsage: preservedLastUsage,
             lastError: preservedLastError,
             attention: preservedAttention,
@@ -539,22 +611,99 @@ export class AgentManager {
         if (!stored) {
             throw new Error(`Agent ${agentId} not found in storage after snapshot`);
         }
+        const { archivedAt } = await this.markRecordArchived(stored);
+        await this.closeAgent(agentId);
+        await this.cascadeArchiveChildren(agentId);
+        return { archivedAt };
+    }
+    // Children created via the MCP `create_agent` tool carry the parent-agent-id
+    // label pointing back at the caller. Archiving the parent cascades to those
+    // children so subagent fleets don't outlive their orchestrator. Handoff agents
+    // launched the same way are caught by this cascade — see docs/agent-lifecycle.md
+    // for the accepted limitation.
+    async cascadeArchiveChildren(parentAgentId) {
+        const registry = this.registry;
+        if (!registry) {
+            return;
+        }
+        const records = await registry.list();
+        for (const record of records) {
+            if (record.archivedAt) {
+                continue;
+            }
+            if (record.labels?.[PARENT_AGENT_ID_LABEL] !== parentAgentId) {
+                continue;
+            }
+            if (this.agents.has(record.id)) {
+                await this.archiveAgent(record.id);
+            }
+            else {
+                await this.markRecordArchived(record);
+                await this.cascadeArchiveChildren(record.id);
+            }
+        }
+    }
+    async markRecordArchived(record) {
+        const registry = this.requireRegistry();
         const archivedAt = new Date().toISOString();
-        const normalizedStatus = stored.lastStatus === "running" || stored.lastStatus === "initializing"
+        const normalizedStatus = record.lastStatus === "running" || record.lastStatus === "initializing"
             ? "idle"
-            : stored.lastStatus;
-        await this.registry.upsert({
-            ...stored,
+            : record.lastStatus;
+        const archivedRecord = {
+            ...record,
             archivedAt,
             updatedAt: archivedAt,
             lastStatus: normalizedStatus,
             requiresAttention: false,
             attentionReason: null,
             attentionTimestamp: null,
+        };
+        await registry.upsert(archivedRecord);
+        await this.archiveNativeSessionBestEffort(record.provider, record.persistence);
+        if (this.agents.has(record.id)) {
+            this.notifyAgentState(record.id);
+        }
+        else if (!archivedRecord.internal) {
+            this.dispatchArchivedStoredAgent(archivedRecord);
+        }
+        return archivedRecord;
+    }
+    dispatchArchivedStoredAgent(record) {
+        const updatedAt = new Date(record.updatedAt);
+        this.dispatch({
+            type: "agent_state",
+            agent: {
+                id: record.id,
+                provider: record.provider,
+                cwd: record.cwd,
+                session: null,
+                capabilities: STORED_AGENT_CAPABILITIES,
+                config: buildStoredAgentConfig(record),
+                runtimeInfo: undefined,
+                lifecycle: "closed",
+                createdAt: new Date(record.createdAt),
+                updatedAt,
+                availableModes: [],
+                features: record.features,
+                currentModeId: record.lastModeId ?? null,
+                pendingPermissions: new Map(),
+                bufferedPermissionResolutions: new Map(),
+                inFlightPermissionResponses: new Set(),
+                pendingReplacement: false,
+                activeForegroundTurnId: null,
+                foregroundTurnWaiters: new Set(),
+                finalizedForegroundTurnIds: new Set(),
+                unsubscribeSession: null,
+                persistence: record.persistence ?? null,
+                historyPrimed: true,
+                lastUserMessageAt: record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null,
+                lastUsage: undefined,
+                lastError: record.lastError ?? undefined,
+                attention: { requiresAttention: false },
+                internal: record.internal,
+                labels: record.labels,
+            },
         });
-        this.notifyAgentState(agentId);
-        await this.closeAgent(agentId);
-        return { archivedAt };
     }
     async setAgentMode(agentId, modeId) {
         const agent = this.requireSessionAgent(agentId);
@@ -671,6 +820,7 @@ export class AgentManager {
             attentionTimestamp: null,
         };
         await registry.upsert(nextRecord);
+        await this.archiveNativeSessionBestEffort(record.provider, record.persistence);
         return nextRecord;
     }
     async unarchiveSnapshot(agentId) {
@@ -754,6 +904,48 @@ export class AgentManager {
             canceled,
         };
     }
+    /**
+     * Try to run a prompt out-of-band — i.e. without allocating a foreground turn
+     * and without canceling any active turn. Returns true when the session
+     * accepted the prompt as a side-effect command (e.g. /goal pause). Events
+     * emitted by the handler flow through dispatchStream so they persist and
+     * broadcast like normal timeline events.
+     */
+    tryRunOutOfBand(agentId, prompt) {
+        const agent = this.requireSessionAgent(agentId);
+        const handler = agent.session.tryHandleOutOfBand?.(prompt);
+        if (!handler) {
+            return false;
+        }
+        const dispatch = (event) => {
+            // Persist timeline items so they show up in fetchAgentTimeline; broadcast
+            // for live subscribers. Other event types are broadcast only.
+            if (event.type === "timeline") {
+                this.touchUpdatedAt(agent);
+                const row = this.recordTimeline(agent.id, event.item);
+                this.dispatchStream(agent.id, event, {
+                    seq: row.seq,
+                    epoch: this.timelineStore.getEpoch(agent.id),
+                });
+                return;
+            }
+            this.dispatchStream(agent.id, event);
+        };
+        void (async () => {
+            try {
+                await handler.run({ emit: dispatch });
+            }
+            catch (error) {
+                const text = error instanceof Error ? error.message : "Out-of-band command failed";
+                dispatch({
+                    type: "timeline",
+                    provider: agent.provider,
+                    item: { type: "assistant_message", text: `[Error] ${text}` },
+                });
+            }
+        })();
+        return true;
+    }
     recordUserMessage(agentId, text, options) {
         const agent = this.requireAgent(agentId);
         const normalizedMessageId = normalizeMessageId(options?.messageId);
@@ -1104,7 +1296,7 @@ export class AgentManager {
         // activeForegroundTurnId, settles waiters, and unblocks the streamForwarder.
         if (foregroundTurnId && agent.activeForegroundTurnId === foregroundTurnId) {
             this.logger.warn({ agentId, foregroundTurnId }, "cancelAgentRun: foreground turn still active after timeout, force-canceling");
-            this.dispatchSessionEvent(agent, {
+            void this.dispatchSessionEvent(agent, {
                 type: "turn_canceled",
                 provider: agent.provider,
                 reason: "interrupted",
@@ -2198,6 +2390,19 @@ export class AgentManager {
         }
         return client;
     }
+    async archiveNativeSessionBestEffort(provider, persistence) {
+        if (!persistence)
+            return;
+        const client = this.clients.get(provider);
+        if (!client?.archiveNativeSession)
+            return;
+        try {
+            await client.archiveNativeSession(persistence);
+        }
+        catch (error) {
+            this.logger.warn({ error, provider, sessionId: persistence.sessionId }, "Failed to archive native session (best-effort)");
+        }
+    }
     requireAgent(id) {
         const normalizedId = validateAgentId(id, "requireAgent");
         const agent = this.agents.get(normalizedId);