@junctionpanel/server 0.1.96 → 0.1.98

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

@@ -960,6 +960,7 @@ export class AgentManager {
             mutableAgent.pendingRun = null;
             mutableAgent.lifecycle = error ? "error" : "idle";
             mutableAgent.lastError = error;
+            self.touchUpdatedAt(mutableAgent);
             const persistenceHandle = mutableAgent.session.describePersistence() ??
                 (mutableAgent.runtimeInfo?.sessionId
                     ? { provider: mutableAgent.provider, sessionId: mutableAgent.runtimeInfo.sessionId }
@@ -1407,12 +1408,13 @@ export class AgentManager {
             unsubscribe = this.subscribe((event) => {
                 if (event.type === "agent_state") {
                     currentStatus = event.agent.lifecycle;
+                    const hasPendingRunForEvent = "pendingRun" in event.agent && Boolean(event.agent.pendingRun);
                     const pending = this.peekPendingPermission(event.agent);
                     if (pending) {
                         finish(pending);
                         return;
                     }
-                    if (isAgentBusy(event.agent.lifecycle)) {
+                    if (isAgentBusy(event.agent.lifecycle) || hasPendingRunForEvent) {
                         hasStarted = true;
                         return;
                     }
@@ -1665,6 +1667,52 @@ export class AgentManager {
             await this.persistSnapshot(agent);
         }
     }
+    shouldNormalizeInterruptedProviderFailure(agent, event) {
+        const hadExplicitUserInterrupt = this.pendingUserInterruptAgents.has(agent.id) ||
+            this.userInterruptedAgents.has(agent.id);
+        return (hadExplicitUserInterrupt &&
+            event.provider === "claude" &&
+            event.error === "Claude stream ended before terminal result");
+    }
+    applyCanceledTurnEvent(agent, event, options) {
+        if (this.pendingUserInterruptAgents.delete(agent.id)) {
+            this.userInterruptedAgents.add(agent.id);
+        }
+        const pendingRequestIds = Array.from(agent.pendingPermissions.keys());
+        const pendingRefresh = this.refreshPendingPermissionsFromSession(agent);
+        if (agent.lifecycle !== "idle") {
+            agent.lifecycle = "idle";
+        }
+        agent.activeTurnStartedAt = null;
+        agent.lastError = undefined;
+        if (!options?.fromHistory) {
+            this.finalizeHarnessTurn(agent, "canceled");
+            const timestamp = new Date().toISOString();
+            const harnessExtra = getHarnessSessionExtra(agent.config);
+            setHarnessSessionExtra(agent.config, {
+                resumeState: touchHarnessResumeState(harnessExtra?.resumeState, {
+                    status: "live",
+                    source: harnessExtra?.resumeState?.source ?? "snapshot",
+                    timestamp,
+                    recoveryHint: "The run was interrupted before completion.",
+                }),
+            });
+        }
+        if (!pendingRefresh.hasPendingPermissions) {
+            for (const requestId of pendingRequestIds) {
+                this.resolvePendingPermission(agent, requestId, { behavior: "deny", message: "Interrupted" }, {
+                    provider: event.provider,
+                    dispatchEvent: !options?.fromHistory,
+                    dispatchTimeline: !options?.fromHistory,
+                    syncHarness: !options?.fromHistory,
+                    dispatchHarnessEvent: !options?.fromHistory,
+                    transitionRunToStreaming: false,
+                });
+            }
+        }
+        this.touchUpdatedAt(agent);
+        this.emitState(agent);
+    }
     handleStreamEvent(agent, event, options) {
         // Only update timestamp for live events, not history replay
         if (!options?.fromHistory) {
@@ -1763,11 +1811,12 @@ export class AgentManager {
                         }
                     }
                     agent.activeTurnStartedAt = null;
-                    if (!agent.pendingRun && agent.lifecycle !== "idle") {
+                    if (agent.lifecycle !== "idle") {
                         agent.lifecycle = "idle";
                         shouldEmitState = true;
                     }
                     if (shouldEmitState) {
+                        this.touchUpdatedAt(agent);
                         this.emitState(agent);
                     }
                     void this.refreshRuntimeInfo(agent);
@@ -1775,9 +1824,18 @@ export class AgentManager {
                 }
                 break;
             case "turn_failed":
+                if (this.shouldNormalizeInterruptedProviderFailure(agent, event)) {
+                    this.applyCanceledTurnEvent(agent, {
+                        type: "turn_canceled",
+                        provider: event.provider,
+                        reason: "Interrupted",
+                    }, options);
+                    shouldPersistSnapshot = true;
+                    break;
+                }
                 this.pendingUserInterruptAgents.delete(agent.id);
                 this.userInterruptedAgents.delete(agent.id);
-                if (!agent.pendingRun) {
+                if (agent.lifecycle !== "error") {
                     agent.lifecycle = "error";
                 }
                 agent.activeTurnStartedAt = null;
@@ -1802,49 +1860,13 @@ export class AgentManager {
                         transitionRunToStreaming: false,
                     });
                 }
+                this.touchUpdatedAt(agent);
                 this.emitState(agent);
                 shouldPersistSnapshot = true;
                 break;
             case "turn_canceled":
-                {
-                    if (this.pendingUserInterruptAgents.delete(agent.id)) {
-                        this.userInterruptedAgents.add(agent.id);
-                    }
-                    const pendingRequestIds = Array.from(agent.pendingPermissions.keys());
-                    const pendingRefresh = this.refreshPendingPermissionsFromSession(agent);
-                    if (!agent.pendingRun) {
-                        agent.lifecycle = "idle";
-                    }
-                    agent.activeTurnStartedAt = null;
-                    agent.lastError = undefined;
-                    if (!options?.fromHistory) {
-                        this.finalizeHarnessTurn(agent, "canceled");
-                        const timestamp = new Date().toISOString();
-                        const harnessExtra = getHarnessSessionExtra(agent.config);
-                        setHarnessSessionExtra(agent.config, {
-                            resumeState: touchHarnessResumeState(harnessExtra?.resumeState, {
-                                status: "live",
-                                source: harnessExtra?.resumeState?.source ?? "snapshot",
-                                timestamp,
-                                recoveryHint: "The run was interrupted before completion.",
-                            }),
-                        });
-                    }
-                    if (!pendingRefresh.hasPendingPermissions) {
-                        for (const requestId of pendingRequestIds) {
-                            this.resolvePendingPermission(agent, requestId, { behavior: "deny", message: "Interrupted" }, {
-                                provider: event.provider,
-                                dispatchEvent: !options?.fromHistory,
-                                dispatchTimeline: !options?.fromHistory,
-                                syncHarness: !options?.fromHistory,
-                                dispatchHarnessEvent: !options?.fromHistory,
-                                transitionRunToStreaming: false,
-                            });
-                        }
-                    }
-                    this.emitState(agent);
-                    shouldPersistSnapshot = true;
-                }
+                this.applyCanceledTurnEvent(agent, event, options);
+                shouldPersistSnapshot = true;
                 break;
             case "turn_started":
                 this.pendingUserInterruptAgents.delete(agent.id);