@junctionpanel/server 0.1.53 → 0.1.55

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

@@ -8,7 +8,16 @@ import { AGENT_PROVIDER_IDS } from "./provider-manifest.js";
 import { buildPermissionRecoveryFingerprint } from "./agent-permission-fingerprint.js";
 import { isCodexPlanModeEnabled, normalizeCodexModeId, setCodexPlanModeEnabled, } from "./codex-config.js";
 import { getPendingPlanReviewFingerprint, hasPendingPlanReview, } from "./pending-plan-review.js";
+import { extractPermissionQuestionAnswersFromResponse, formatPermissionQuestionAnswers, isInteractiveQuestionPermission, } from "../../shared/permission-questions.js";
 export { AGENT_LIFECYCLE_STATUSES };
+function toPersistedPermissionResolution(resolution) {
+    return resolution.behavior === "deny"
+        ? {
+            behavior: "deny",
+            message: resolution.message,
+        }
+        : { behavior: "allow" };
+}
 function attachPersistenceCwd(handle, cwd) {
     if (!handle) {
         return null;
@@ -157,6 +166,8 @@ export class AgentManager {
         this.pendingUserInterruptAgents = new Set();
         this.userInterruptedAgents = new Set();
         this.backgroundTasks = new Set();
+        this.backgroundPersistQueuedAgents = new Set();
+        this.backgroundPersistDirtyAgents = new Set();
         this.liveEventPumps = new Map();
         this.liveEventBacklog = new Map();
         this.liveEventBacklogFlushTimers = new Map();
@@ -511,6 +522,9 @@ export class AgentManager {
         const session = handle
             ? await client.resumeSession(handle, normalizedConfig)
             : await client.createSession(normalizedConfig);
+        if (this.backgroundPersistQueuedAgents.has(agentId)) {
+            this.backgroundPersistDirtyAgents.add(agentId);
+        }
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
         this.liveEventPumps.delete(agentId);
@@ -552,6 +566,8 @@ export class AgentManager {
         this.suppressedPermissionAttentionKeys.delete(agentId);
         this.pendingUserInterruptAgents.delete(agentId);
         this.userInterruptedAgents.delete(agentId);
+        this.backgroundPersistQueuedAgents.delete(agentId);
+        this.backgroundPersistDirtyAgents.delete(agentId);
         const session = agent.session;
         const closedAgent = {
             ...agent,
@@ -927,9 +943,18 @@ export class AgentManager {
     async respondToPermission(agentId, requestId, response) {
         const agent = this.requireAgent(agentId);
         const pendingRequest = agent.pendingPermissions.get(requestId) ?? null;
-        await agent.session.respondToPermission(requestId, response);
-        agent.pendingPermissions.delete(requestId);
-        this.clearAttentionForUserEngagement(agent);
+        if (pendingRequest &&
+            response.behavior === "allow" &&
+            isInteractiveQuestionPermission(pendingRequest)) {
+            const answers = extractPermissionQuestionAnswersFromResponse(pendingRequest, response);
+            const summary = formatPermissionQuestionAnswers(pendingRequest, answers).trim();
+            if (summary.length > 0) {
+                this.recordUserMessage(agentId, summary, {
+                    emitState: false,
+                    messageId: `permission-answer:${requestId}`,
+                });
+            }
+        }
         if (pendingRequest?.kind === "plan" &&
             response.behavior === "deny" &&
             typeof response.message === "string") {
@@ -941,6 +966,14 @@ export class AgentManager {
                 });
             }
         }
+        await agent.session.respondToPermission(requestId, response);
+        agent.pendingPermissions.delete(requestId);
+        this.clearAttentionForUserEngagement(agent);
+        this.recordPermissionResolutionTimelineItem(agent, requestId, response, {
+            provider: agent.provider,
+            pendingRequest,
+            dispatchTimeline: true,
+        });
         // Update currentModeId - the session may have changed mode internally
         // (e.g., plan approval changes mode from "plan" to "acceptEdits")
         try {
@@ -1008,15 +1041,14 @@ export class AgentManager {
         // block before it consumes the turn_canceled event, skipping our cleanup code.
         if (agent.pendingPermissions.size > 0) {
             for (const [requestId] of agent.pendingPermissions) {
-                this.dispatchStream(agent.id, {
-                    type: "permission_resolved",
+                this.resolvePendingPermission(agent, requestId, { behavior: "deny", message: "Interrupted" }, {
                     provider: agent.provider,
-                    requestId,
-                    resolution: { behavior: "deny", message: "Interrupted" },
+                    dispatchEvent: true,
+                    dispatchTimeline: true,
                 });
             }
-            agent.pendingPermissions.clear();
             this.emitState(agent);
+            await this.persistSnapshot(agent);
         }
         return true;
     }
@@ -1249,7 +1281,9 @@ export class AgentManager {
         this.userInterruptedAgents.delete(resolvedAgentId);
         const initialPersistedTitle = await this.resolveInitialPersistedTitle(resolvedAgentId, config);
         const now = new Date();
-        const initialTimeline = options?.timeline ? [...options.timeline] : [];
+        const initialTimeline = options?.timeline
+            ? [...options.timeline]
+            : options?.timelineRows?.map((row) => row.item) ?? [];
         const initialTimelineRows = options?.timelineRows?.length
             ? options.timelineRows.map((row) => ({ ...row }))
             : this.buildTimelineRowsFromItems(initialTimeline, options?.timelineNextSeq ?? 1, (options?.updatedAt ?? options?.createdAt ?? now).toISOString());
@@ -1416,6 +1450,7 @@ export class AgentManager {
             }
             return [[messageId, row.item.text]];
         }));
+        const initialTimelineRowCount = agent.timelineRows.length;
         try {
             for await (const event of agent.session.streamHistory()) {
                 if (event.type === "timeline") {
@@ -1438,6 +1473,9 @@ export class AgentManager {
         catch {
             // ignore history failures
         }
+        if (agent.timelineRows.length > initialTimelineRowCount) {
+            await this.persistSnapshot(agent);
+        }
     }
     handleStreamEvent(agent, event, options) {
         // Only update timestamp for live events, not history replay
@@ -1445,6 +1483,7 @@ export class AgentManager {
             this.touchUpdatedAt(agent);
         }
         let timelineRow = null;
+        let shouldPersistSnapshot = false;
         switch (event.type) {
             case "thread_started":
                 // Update persistence with the new session ID from the provider.
@@ -1458,6 +1497,7 @@ export class AgentManager {
                             this.emitState(agent);
                         }
                     }
+                    shouldPersistSnapshot = true;
                 }
                 break;
             case "timeline":
@@ -1479,6 +1519,7 @@ export class AgentManager {
                     break;
                 }
                 timelineRow = this.recordTimeline(agent, event.item);
+                shouldPersistSnapshot = true;
                 if (!options?.fromHistory &&
                     event.item.type === "user_message") {
                     agent.lastUserMessageAt = new Date();
@@ -1501,6 +1542,7 @@ export class AgentManager {
                                 seq: timelineRow.seq,
                                 epoch: this.ensureTimelineState(agent).epoch,
                             });
+                            shouldPersistSnapshot = true;
                         }
                     }
                     agent.activeTurnStartedAt = null;
@@ -1512,6 +1554,7 @@ export class AgentManager {
                         this.emitState(agent);
                     }
                     void this.refreshRuntimeInfo(agent);
+                    shouldPersistSnapshot = true;
                 }
                 break;
             case "turn_failed":
@@ -1523,17 +1566,14 @@ export class AgentManager {
                 agent.activeTurnStartedAt = null;
                 agent.lastError = event.error;
                 for (const [requestId] of agent.pendingPermissions) {
-                    agent.pendingPermissions.delete(requestId);
-                    if (!options?.fromHistory) {
-                        this.dispatchStream(agent.id, {
-                            type: "permission_resolved",
-                            provider: event.provider,
-                            requestId,
-                            resolution: { behavior: "deny", message: "Turn failed" },
-                        });
-                    }
+                    this.resolvePendingPermission(agent, requestId, { behavior: "deny", message: "Turn failed" }, {
+                        provider: event.provider,
+                        dispatchEvent: !options?.fromHistory,
+                        dispatchTimeline: !options?.fromHistory,
+                    });
                 }
                 this.emitState(agent);
+                shouldPersistSnapshot = true;
                 break;
             case "turn_canceled":
                 {
@@ -1549,17 +1589,15 @@ export class AgentManager {
                     agent.lastError = undefined;
                     if (!pendingRefresh.hasPendingPermissions) {
                         for (const requestId of pendingRequestIds) {
-                            if (!options?.fromHistory) {
-                                this.dispatchStream(agent.id, {
-                                    type: "permission_resolved",
-                                    provider: event.provider,
-                                    requestId,
-                                    resolution: { behavior: "deny", message: "Interrupted" },
-                                });
-                            }
+                            this.resolvePendingPermission(agent, requestId, { behavior: "deny", message: "Interrupted" }, {
+                                provider: event.provider,
+                                dispatchEvent: !options?.fromHistory,
+                                dispatchTimeline: !options?.fromHistory,
+                            });
                         }
                     }
                     this.emitState(agent);
+                    shouldPersistSnapshot = true;
                 }
                 break;
             case "turn_started":
@@ -1579,10 +1617,15 @@ export class AgentManager {
                     agent.lifecycle = "running";
                 }
                 this.emitState(agent);
+                shouldPersistSnapshot = true;
                 break;
             case "permission_requested":
                 {
                     agent.pendingPermissions.set(event.request.id, event.request);
+                    this.recordPermissionRequestTimelineItem(agent, event.request, {
+                        provider: event.provider,
+                        dispatchTimeline: !options?.fromHistory,
+                    });
                     const planText = extractPlanTextFromPermissionRequest(event.request);
                     if (planText && !options?.fromHistory) {
                         const planMessage = formatProposedPlanTimelineMessage(planText);
@@ -1603,10 +1646,16 @@ export class AgentManager {
                     }
                 }
                 this.emitState(agent);
+                shouldPersistSnapshot = true;
                 break;
             case "permission_resolved":
-                agent.pendingPermissions.delete(event.requestId);
+                this.resolvePendingPermission(agent, event.requestId, event.resolution, {
+                    provider: event.provider,
+                    dispatchEvent: false,
+                    dispatchTimeline: !options?.fromHistory,
+                });
                 this.emitState(agent);
+                shouldPersistSnapshot = true;
                 break;
             default:
                 break;
@@ -1620,6 +1669,9 @@ export class AgentManager {
                 }
                 : undefined);
         }
+        if (!options?.fromHistory && shouldPersistSnapshot) {
+            this.enqueueBackgroundPersist(agent);
+        }
     }
     shouldSuppressLiveUserMessageEcho(agent, event, options) {
         if (options?.fromHistory || event.type !== "timeline") {
@@ -1661,6 +1713,81 @@ export class AgentManager {
             ...(durationMs != null ? { durationMs } : {}),
         };
     }
+    findRecordedPermissionRequest(agent, requestId) {
+        for (let index = agent.timelineRows.length - 1; index >= 0; index -= 1) {
+            const row = agent.timelineRows[index];
+            if (row?.item.type === "permission_request" &&
+                row.item.request.id === requestId) {
+                return structuredClone(row.item.request);
+            }
+        }
+        return null;
+    }
+    hasPermissionResolutionTimelineItem(agent, requestId) {
+        return agent.timelineRows.some((row) => row.item.type === "permission_resolution" &&
+            row.item.requestId === requestId);
+    }
+    recordPermissionRequestTimelineItem(agent, request, options) {
+        if (request.kind === "plan") {
+            return null;
+        }
+        if (this.findRecordedPermissionRequest(agent, request.id)) {
+            return null;
+        }
+        const item = {
+            type: "permission_request",
+            request: structuredClone(request),
+        };
+        const row = this.recordTimeline(agent, item);
+        if (options.dispatchTimeline) {
+            this.dispatchStream(agent.id, { type: "timeline", provider: options.provider, item }, {
+                seq: row.seq,
+                epoch: this.ensureTimelineState(agent).epoch,
+            });
+        }
+        return row;
+    }
+    recordPermissionResolutionTimelineItem(agent, requestId, resolution, options) {
+        const request = options.pendingRequest ??
+            agent.pendingPermissions.get(requestId) ??
+            this.findRecordedPermissionRequest(agent, requestId);
+        if (!request || request.kind === "plan") {
+            return null;
+        }
+        if (this.hasPermissionResolutionTimelineItem(agent, requestId)) {
+            return null;
+        }
+        const item = {
+            type: "permission_resolution",
+            requestId,
+            resolution: toPersistedPermissionResolution(resolution),
+        };
+        const row = this.recordTimeline(agent, item);
+        if (options.dispatchTimeline) {
+            this.dispatchStream(agent.id, { type: "timeline", provider: options.provider, item }, {
+                seq: row.seq,
+                epoch: this.ensureTimelineState(agent).epoch,
+            });
+        }
+        return row;
+    }
+    resolvePendingPermission(agent, requestId, resolution, options) {
+        const pendingRequest = agent.pendingPermissions.get(requestId) ?? null;
+        agent.pendingPermissions.delete(requestId);
+        this.recordPermissionResolutionTimelineItem(agent, requestId, resolution, {
+            provider: options.provider,
+            pendingRequest,
+            dispatchTimeline: options.dispatchTimeline,
+        });
+        if (options.dispatchEvent) {
+            this.dispatchStream(agent.id, {
+                type: "permission_resolved",
+                provider: options.provider,
+                requestId,
+                resolution,
+            });
+        }
+    }
     recordTimeline(agent, item) {
         const timelineState = this.ensureTimelineState(agent);
         const row = {
@@ -1805,8 +1932,27 @@ export class AgentManager {
         this.suppressedPermissionAttentionKeys.delete(agent.id);
     }
     enqueueBackgroundPersist(agent) {
-        const task = this.persistSnapshot(agent).catch((err) => {
-            this.logger.error({ err, agentId: agent.id }, "Failed to persist agent snapshot");
+        this.enqueueBackgroundPersistById(agent.id);
+    }
+    enqueueBackgroundPersistById(agentId) {
+        if (this.backgroundPersistQueuedAgents.has(agentId)) {
+            this.backgroundPersistDirtyAgents.add(agentId);
+            return;
+        }
+        const currentAgent = this.agents.get(agentId);
+        if (!currentAgent) {
+            return;
+        }
+        this.backgroundPersistQueuedAgents.add(agentId);
+        const task = this.persistSnapshot(currentAgent)
+            .catch((err) => {
+            this.logger.error({ err, agentId }, "Failed to persist agent snapshot");
+        })
+            .finally(() => {
+            this.backgroundPersistQueuedAgents.delete(agentId);
+            if (this.backgroundPersistDirtyAgents.delete(agentId)) {
+                this.enqueueBackgroundPersistById(agentId);
+            }
         });
         this.trackBackgroundTask(task);
     }