diff --git a/packages/server/src/server/agent/agent-manager.test.ts b/packages/server/src/server/agent/agent-manager.test.ts index 8045127e33..c13a3184c4 100644 --- a/packages/server/src/server/agent/agent-manager.test.ts +++ b/packages/server/src/server/agent/agent-manager.test.ts @@ -9768,6 +9768,69 @@ test.each([ }, ); +test("turns an agent starts on its own keep its finish unread until it is read", async () => { + const workdir = mkdtempSync(join(tmpdir(), "agent-manager-autonomous-finish-unread-")); + const storage = new AgentStorage(join(workdir, "agents"), logger); + class AutonomousClient extends TestAgentClient { + readonly session = new TestAgentSession({ provider: "codex", cwd: workdir }); + + override async createSession(): Promise { + return this.session; + } + } + + const client = new AutonomousClient(); + const attention: Array<{ reason: string; attentionTimestamp: Date | null }> = []; + const manager = new AgentManager({ + clients: { codex: client }, + registry: storage, + logger, + onAgentAttention: ({ reason, attentionTimestamp }) => + attention.push({ reason, attentionTimestamp }), + }); + onTestFinished(async () => { + await manager.closeAgent(agent.id); + await manager.flush(); + rmSync(workdir, { recursive: true, force: true }); + }); + const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, { + workspaceId: undefined, + }); + + async function runAutonomousTurn(turnId: string): Promise { + const running = waitForAgentLifecycle(manager, agent.id, "running"); + client.session.pushEvent({ type: "turn_started", provider: "codex", turnId }); + await running; + const idle = waitForAgentLifecycle(manager, agent.id, "idle"); + client.session.pushEvent({ type: "turn_completed", provider: "codex", turnId }); + await idle; + } + + // A background task's output wakes the agent three times while nobody reads it. + await runAutonomousTurn("wake-1"); + await runAutonomousTurn("wake-2"); + await runAutonomousTurn("wake-3"); + // Each finish is reported, and all three belong to the same unread finish. + const unreadFinish = attention[0]?.attentionTimestamp; + expect(unreadFinish).toBeInstanceOf(Date); + expect(attention).toEqual([ + { reason: "finished", attentionTimestamp: unreadFinish }, + { reason: "finished", attentionTimestamp: unreadFinish }, + { reason: "finished", attentionTimestamp: unreadFinish }, + ]); + expect(toAgentPayload(manager.getAgent(agent.id)!)).toMatchObject({ + requiresAttention: true, + attentionReason: "finished", + }); + + // After the user reads the agent, its next finish is a new unread finish. + await manager.clearAgentAttention(agent.id); + await runAutonomousTurn("wake-4"); + expect(attention).toHaveLength(4); + expect(attention[3]?.reason).toBe("finished"); + expect(attention[3]?.attentionTimestamp).not.toBe(unreadFinish); +}); + test("streamAgent clears pending run when startTurn fails before a turn id exists", async () => { const workdir = mkdtempSync(join(tmpdir(), "agent-manager-start-turn-failure-")); const storagePath = join(workdir, "agents"); diff --git a/packages/server/src/server/agent/agent-manager.ts b/packages/server/src/server/agent/agent-manager.ts index a7e49d9319..ec08163ab3 100644 --- a/packages/server/src/server/agent/agent-manager.ts +++ b/packages/server/src/server/agent/agent-manager.ts @@ -334,6 +334,8 @@ export type AgentAttentionCallback = (params: { agentId: string; provider: AgentProvider; reason: "finished" | "error" | "permission"; + /** When the agent's current unread attention started; null when the agent is read. */ + attentionTimestamp: Date | null; }) => void; export type AgentArchivedCallback = (agentId: string) => Promise | void; @@ -5596,7 +5598,11 @@ export class AgentManager { this.openActiveTurn(agent, eventTurnId, new Date()); } agent.lastError = undefined; - agent.attention = { requiresAttention: false }; + // Nobody read the agent, so an unread finish stays unread. Clearing it would make every + // turn the agent starts on its own, such as a reaction to background output, notify again. + if (agent.attention.requiresAttention && agent.attention.attentionReason === "error") { + agent.attention = { requiresAttention: false }; + } agent.lifecycle = "running"; this.emitState(agent); } @@ -5872,11 +5878,16 @@ export class AgentManager { return; } + const finished = previousStatus === "running" && currentStatus === "idle"; if (agent.attention.requiresAttention) { + // The unread finish stays the same; the notifier knows whether the user was told about it. + if (finished && agent.attention.attentionReason === "finished") { + this.broadcastAgentAttention(agent, "finished"); + } return; } - if (previousStatus === "running" && currentStatus === "idle") { + if (finished) { agent.attention = { requiresAttention: true, attentionReason: "finished", @@ -6013,6 +6024,9 @@ export class AgentManager { agentId: agent.id, provider: agent.provider, reason, + attentionTimestamp: agent.attention.requiresAttention + ? agent.attention.attentionTimestamp + : null, }); } diff --git a/packages/server/src/server/websocket-server.notifications.test.ts b/packages/server/src/server/websocket-server.notifications.test.ts index c16a079628..2d0a36f654 100644 --- a/packages/server/src/server/websocket-server.notifications.test.ts +++ b/packages/server/src/server/websocket-server.notifications.test.ts @@ -246,6 +246,7 @@ describe("VoiceAssistantWebSocketServer notification payloads", () => { agentId: "agent-1", provider: "claude", reason: "finished", + attentionTimestamp: new Date(), }); expect(unsubscribed.send).not.toHaveBeenCalled(); @@ -270,6 +271,7 @@ describe("VoiceAssistantWebSocketServer notification payloads", () => { agentId: "agent-1", provider: "claude", reason: "finished", + attentionTimestamp: new Date(), }); expect(pushNotifications.sent).toEqual([ @@ -304,6 +306,7 @@ describe("VoiceAssistantWebSocketServer notification payloads", () => { agentId: "agent-2", provider: "claude", reason: "finished", + attentionTimestamp: new Date(), }); expect(pushNotifications.sent).toHaveLength(1); @@ -330,6 +333,7 @@ describe("VoiceAssistantWebSocketServer notification payloads", () => { agentId: "agent-X", provider: "claude", reason: "finished", + attentionTimestamp: new Date(), }); expect(readAttentionRequiredMessage(electronWs).shouldNotify).toBe(true); @@ -345,6 +349,7 @@ describe("VoiceAssistantWebSocketServer notification payloads", () => { agentId: "agent-no-heartbeat", provider: "claude", reason: "finished", + attentionTimestamp: new Date(), }); expect(readAttentionRequiredMessage(ws).shouldNotify).toBe(false); @@ -359,9 +364,60 @@ describe("VoiceAssistantWebSocketServer notification payloads", () => { agentId: "agent-no-heartbeat", provider: "claude", reason: "error", + attentionTimestamp: new Date(), }); expect(readAttentionRequiredMessage(ws).shouldNotify).toBe(false); expect(pushNotifications.sent).toEqual([]); }); + it("notifies once while an agent's finish stays unread", async () => { + const { server, pushNotifications } = createServer(); + const broadcast = (attentionTimestamp: Date) => + asInternals(server).broadcastAgentAttention({ + agentId: "agent-1", + provider: "claude", + reason: "finished", + attentionTimestamp, + }); + const firstUnreadFinish = new Date(1_000); + + await broadcast(firstUnreadFinish); + await broadcast(firstUnreadFinish); + await broadcast(firstUnreadFinish); + expect(pushNotifications.sent).toHaveLength(1); + + // After the user reads the agent (or marks it unread), its next unread finish is new. + await broadcast(new Date(2_000)); + expect(pushNotifications.sent).toHaveLength(2); + }); + + it("notifies a repeated finish when the user had the agent on screen for the first one", async () => { + const { server, pushNotifications } = createServer(); + const activity = { + deviceType: "web" as const, + appVisible: true, + focusedAgentId: "agent-1" as string | null, + lastActivityAt: new Date(), + }; + connectClient(server, activity); + const unreadFinish = new Date(1_000); + const broadcast = () => + asInternals(server).broadcastAgentAttention({ + agentId: "agent-1", + provider: "claude", + reason: "finished", + attentionTimestamp: unreadFinish, + }); + + await broadcast(); + expect(pushNotifications.sent).toEqual([]); + + // The user leaves; the agent keeps finishing turns it starts on its own. + activity.appVisible = false; + activity.focusedAgentId = null; + activity.lastActivityAt = new Date(Date.now() - 600_000); + await broadcast(); + await broadcast(); + expect(pushNotifications.sent).toHaveLength(1); + }); }); diff --git a/packages/server/src/server/websocket-server.ts b/packages/server/src/server/websocket-server.ts index 2fab6c73a4..37e82203e8 100644 --- a/packages/server/src/server/websocket-server.ts +++ b/packages/server/src/server/websocket-server.ts @@ -98,6 +98,7 @@ import { computeNotificationPlan, isPushEligibleAttentionReason, type ClientPresenceState, + type NotificationPlan, } from "./agent-attention-policy.js"; import { buildAgentAttentionNotificationPayload, @@ -599,6 +600,8 @@ export class VoiceAssistantWebSocketServer { private readonly daemonConfigStore: DaemonConfigStore; private readonly pushNotifications: PushNotifications; private readonly pushNotificationSender: PushNotificationSender; + // Per agent, the unread finish (by its attention timestamp) that a notification was delivered for. + private readonly notifiedUnreadFinishAt = new Map(); private readonly mcpBaseUrl: string | null; private speech!: SpeechService | null; private terminalManager!: TerminalManager | null; @@ -2922,6 +2925,7 @@ export class VoiceAssistantWebSocketServer { agentId: string; provider: AgentProvider; reason: "finished" | "error" | "permission"; + attentionTimestamp: Date | null; }): Promise { const agent = this.agentManager.getAgent(params.agentId); if (!agent?.workspaceId) { @@ -2960,12 +2964,15 @@ export class VoiceAssistantWebSocketServer { permissionRequest: findLatestPermissionRequest(agent.pendingPermissions), }); - const plan = computeNotificationPlan({ - allStates, - focusTarget: { kind: "agent", id: params.agentId }, - pushEligible: isPushEligibleAttentionReason(params.reason), - nowMs, - }); + const plan = this.planOncePerUnreadFinish( + params, + computeNotificationPlan({ + allStates, + focusTarget: { kind: "agent", id: params.agentId }, + pushEligible: isPushEligibleAttentionReason(params.reason), + nowMs, + }), + ); if (plan.shouldPush) { void this.pushNotificationSender.send(notification).catch((err) => { @@ -3016,6 +3023,26 @@ export class VoiceAssistantWebSocketServer { } } + // An agent can finish many times while its first finish is unread, for example when it + // reacts to each event of a background task. The user hears about an unread finish once. + // A finish that was not delivered, because the user had the agent on screen, does not count. + private planOncePerUnreadFinish( + params: { agentId: string; reason: string; attentionTimestamp: Date | null }, + plan: NotificationPlan, + ): NotificationPlan { + if (params.reason !== "finished" || params.attentionTimestamp === null) { + return plan; + } + const unreadFinishAt = params.attentionTimestamp.getTime(); + if (this.notifiedUnreadFinishAt.get(params.agentId) === unreadFinishAt) { + return { inAppRecipientIndex: null, shouldPush: false }; + } + if (plan.shouldPush || plan.inAppRecipientIndex !== null) { + this.notifiedUnreadFinishAt.set(params.agentId, unreadFinishAt); + } + return plan; + } + private async broadcastTerminalAttention(params: { terminalId: string; cwd: string;