diff --git a/browser_tests/fixtures/agentTurnLockFixture.ts b/browser_tests/fixtures/agentTurnLockFixture.ts index c8df97034f7..8a275fd0424 100644 --- a/browser_tests/fixtures/agentTurnLockFixture.ts +++ b/browser_tests/fixtures/agentTurnLockFixture.ts @@ -112,6 +112,14 @@ const FOREIGN_TURN_DONE_EVENT: AgentWsEvent = { const RUN_APPROVAL_ASK_ID = `${TURN_ID}:call-run-workflow` +/** + * The workflow this ask names. Not exported: it is the same workflow the + * panel's picker and tab already name, so a spec that matched it as text + * would resolve to three elements. `approvalWorkflowLink` below is the + * locator a spec should assert on instead. + */ +const APPROVAL_WORKFLOW_NAME = 'Unsaved Workflow' + /** * The option ids this ask offers. Declared separately because `AgentWsEvent` * types `data` loosely, so reading them back off the event would be an @@ -119,6 +127,9 @@ const RUN_APPROVAL_ASK_ID = `${TURN_ID}:call-run-workflow` */ const RUN_APPROVAL_OPTION_IDS = ['run', 'cancel'] as const +/** The option id the panel's Run button answers with. */ +export const APPROVAL_RUN_OPTION_ID = RUN_APPROVAL_OPTION_IDS[0] + /** * The frame the server sends when a turn parks waiting for the user to approve * a run. Shaped after `pendingRunApproval`'s reader and cloud's `asks` writer: @@ -132,8 +143,11 @@ export const RUN_APPROVAL_EVENT: AgentWsEvent = { thread_id: THREAD_ID, ask_id: RUN_APPROVAL_ASK_ID, kind: 'run_approval', - prompt: 'Run workflow “Unsaved Workflow”?', - context: { workflow_id: WORKFLOW_ID, workflow_name: 'Unsaved Workflow' }, + prompt: `Run workflow “${APPROVAL_WORKFLOW_NAME}”?`, + context: { + workflow_id: WORKFLOW_ID, + workflow_name: APPROVAL_WORKFLOW_NAME + }, options: [ { id: RUN_APPROVAL_OPTION_IDS[0], @@ -521,6 +535,8 @@ export class AgentTurnLockHarness { public readonly sendButton: Locator public readonly stopButton: Locator public readonly runApprovalButton: Locator + public readonly approvalCard: Locator + public readonly approvalWorkflowLink: Locator public readonly workSummary: Locator public readonly workingRow: Locator public readonly liveProgressRow: Locator @@ -553,6 +569,14 @@ export class AgentTurnLockHarness { name: enMessages.agent.runApproval.run, exact: true }) + this.approvalCard = this.panel.getByText( + enMessages.agent.runApproval.question, + { exact: true } + ) + this.approvalWorkflowLink = this.panel.getByRole('button', { + name: APPROVAL_WORKFLOW_NAME, + exact: true + }) this.workSummary = this.panel.getByRole('button', { name: new RegExp( `^(${[ @@ -676,6 +700,21 @@ export class AgentTurnLockHarness { this.server.recordAsk(event) } + /** + * Parks the live turn on a run-approval ask the way the service does while + * it waits for the user: the assistant row stays `streaming` (so posts keep + * returning 409) and starts carrying `pending_ask`. No frame is pushed -- + * that models the `agent_ask` a dropped socket never delivered. + */ + parkOnApproval(): void { + this.primePendingAsk(RUN_APPROVAL_EVENT) + } + + /** The frame the server pushes once it accepts an answer to the approval. */ + resolveApproval(ws: WebSocketRoute): void { + this.push(ws, RUN_APPROVAL_RESOLVED_EVENT) + } + /** True only when a test explicitly primed transcript-based recovery. */ pendingAskIsPrimed(): boolean { return this.server.askIsPending diff --git a/browser_tests/fixtures/networkIsolationFixture.ts b/browser_tests/fixtures/networkIsolationFixture.ts index e52d92a0365..799d3a8b9ec 100644 --- a/browser_tests/fixtures/networkIsolationFixture.ts +++ b/browser_tests/fixtures/networkIsolationFixture.ts @@ -137,7 +137,7 @@ export const networkIsolationFixture = base.extend<{ await context.route('**/*', async (route) => { const url = new URL(route.request().url()) if (origins.has(url.origin)) { - await route.continue() + await route.fallback() return } unexpected.add(getBlockedRequestViolation(url, route.request().method())) diff --git a/browser_tests/tests/agent/agentApprovalSurvivesSocketDrop.spec.ts b/browser_tests/tests/agent/agentApprovalSurvivesSocketDrop.spec.ts new file mode 100644 index 00000000000..59c1318384e --- /dev/null +++ b/browser_tests/tests/agent/agentApprovalSurvivesSocketDrop.spec.ts @@ -0,0 +1,136 @@ +import { expect } from '@playwright/test' + +import { + APPROVAL_RUN_OPTION_ID, + RUN_APPROVAL_EVENT, + TURN_IN_PROGRESS_MESSAGE, + agentTurnLockTest as test +} from '@e2e/fixtures/agentTurnLockFixture' + +// PM-1738, filed under PM-1199. Reported from the agent panel while building an +// img2img and then img2video workflow: "after generate workflow, agent stopped, +// I couldn't run but need to restart agent tab. Session was remained so that I +// could run again with existing session." +// +// The service side was never hung. Its logs show the turn accepted, then +// twenty-three minutes of silence, then two posts answered 409, then a GET of +// the transcript (the tab restart) and an `asks/.../answer` four seconds later +// — the user approving a tool call the moment a reload finally drew it. A turn +// parked on a run approval stays `streaming` for as long as the user takes to +// answer, so the socket drop that swallowed the `agent_ask` frame left the +// server waiting on a card the panel never drew: no way forward, and every +// follow-up message rejected by the single-active-turn guard. +// +// Distinct from agentTurnSurvivesSocketDrop.spec.ts, which drops the socket +// around a turn the server finishes on its own. Here the server cannot finish +// without an answer, so keeping the turn live is not enough — the ask itself +// has to come back. +test.describe.configure({ timeout: 120_000 }) +test.use({ connectWebSocketToServer: false }) + +test.describe( + 'Agent approval ask across a transient websocket reconnect', + { tag: ['@cloud', '@ui'] }, + () => { + const PROMPT = 'build an img2img workflow and then turn it into img2video' + + test.beforeEach(async ({ turnLock }) => { + await turnLock.openOnBlankWorkflow() + await turnLock.startTurn(PROMPT) + }) + + test('surfaces an approval whose frame the drop swallowed, and resumes on it', async ({ + turnLock + }) => { + const nextPrompt = 'now raise the video length to 48 frames' + + const reconnected = + await test.step('the turn parks on an approval whose frame never arrives', async () => { + turnLock.parkOnApproval() + await expect(turnLock.approvalCard).toHaveCount(0) + return turnLock.dropSocket() + }) + + await test.step('the approval surfaces without a reload', async () => { + await expect(turnLock.approvalCard).toBeVisible({ timeout: 30_000 }) + await expect(turnLock.approvalWorkflowLink).toBeVisible() + await expect(turnLock.stopButton).toBeVisible() + }) + + await test.step('answering it reaches the server', async () => { + await turnLock.runApprovalButton.click() + + // The fake's answer route 404s any ask id but the parked one, so a + // recorded answer proves the panel answered the ask it restored -- + // and this reads the server, not the DOM, so it proves the answer + // actually left the client. + await expect + .poll(() => turnLock.answeredAsks()) + .toEqual([APPROVAL_RUN_OPTION_ID]) + + turnLock.resolveApproval(reconnected) + await expect(turnLock.approvalCard).toHaveCount(0) + }) + + await test.step('the thread is usable again', async () => { + turnLock.finishTurn(reconnected) + await expect(turnLock.sendButton).toBeVisible() + + await turnLock.composer.fill(nextPrompt) + await turnLock.sendButton.click() + + // The post has to have actually reached the server before the absence + // of a turn-in-progress notice means anything. + await expect + .poll(() => turnLock.postAttempts()) + .toBeGreaterThanOrEqual(2) + await expect(turnLock.userBubbles).toHaveCount(2) + await expect(turnLock.userBubbles.last()).toHaveText(nextPrompt) + await expect( + turnLock.panel + .getByRole('alert') + .filter({ hasText: TURN_IN_PROGRESS_MESSAGE }) + ).toHaveCount(0) + expect(turnLock.rejectedPosts()).toBe(0) + }) + }) + + // Recovery re-reads the persisted row on every poll, so an ask the socket + // did deliver has to be recognised as already on screen rather than + // restored again. + test('does not redraw an approval the socket already delivered', async ({ + turnLock, + page + }) => { + turnLock.parkOnApproval() + turnLock.push(await turnLock.liveSocket(), RUN_APPROVAL_EVENT) + await expect(turnLock.approvalCard).toBeVisible() + let recoveryResponses = 0 + const secondRecoveryResponse = page.waitForResponse((response) => { + const request = response.request() + if ( + request.method() !== 'GET' || + !new URL(response.url()).pathname.endsWith('/messages') + ) + return false + return ++recoveryResponses === 2 + }) + + await turnLock.dropSocket() + + // toHaveCount returns as soon as it passes, so the count alone would + // assert nothing before recovery has even polled. Wait until the browser + // receives two recovery responses, then let the app apply the second + // one before holding the panel to one card. + await secondRecoveryResponse + await page.evaluate( + () => + new Promise((resolve) => + requestAnimationFrame(() => requestAnimationFrame(() => resolve())) + ) + ) + await expect(turnLock.approvalCard).toHaveCount(1) + await expect(turnLock.runApprovalButton).toHaveCount(1) + }) + } +) diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 60ce972edd1..2cecc66ccdb 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -5991,6 +5991,7 @@ "run": "Run", "answerFailed": "Could not send your answer. Reload the page and try again.", "answerUncertain": "Could not confirm your answer reached the agent. It may still have been applied — reload the page to see where things stand.", + "answerAcceptedUnconfirmed": "Your answer reached the agent, but we could not confirm whether it was the answer applied. Reload the page to see where things stand.", "answerSuperseded": "This was already answered somewhere else, so that answer was used instead of yours." }, "askUnavailable": "The agent is waiting on a step this panel can't show.", diff --git a/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts b/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts index 1abf8d438dd..b56db2fd22c 100644 --- a/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts +++ b/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts @@ -2325,7 +2325,7 @@ describe('useAgentSession (v1 composition root)', () => { receipt: AgentAnswerReceipt = { status: 'answered' } ) => { const answerAsk = vi.fn(async () => receipt) - const { source, emit } = fakeEvents() + const { source, emit, status } = fakeEvents() const session = useAgentSession({ rest: fakeRest({ answerAsk }), events: source @@ -2333,7 +2333,7 @@ describe('useAgentSession (v1 composition root)', () => { session.start() await session.sendMessage('pick for me') emit(askUser('msg-1')) - return { session, answerAsk, emit } + return { session, answerAsk, emit, status } } const card = () => useAgentConversationStore().messages[0].parts.find( @@ -2517,7 +2517,8 @@ describe('useAgentSession (v1 composition root)', () => { ] as const)( 'does not report a 409 with %s as another answer winning', async ([, body]) => { - const { session, answerAsk } = await parkedOnQuestion() + const { session, answerAsk, status } = await parkedOnQuestion() + status(true) answerAsk.mockRejectedValue( new AgentApiError('already answered', 409, body) ) @@ -2729,6 +2730,24 @@ describe('useAgentSession (v1 composition root)', () => { ]) }) + it('accepts an explicitly empty answer committed by the server', async () => { + const { session } = await parkedOnQuestion({ + status: 'answered', + selected: [] + }) + + const committed = await session.answerAsk('turn-1:call-1', { + selected: [] + }) + await vi.advanceTimersByTimeAsync(15_000) + + expect(committed).toBe(true) + expect(card()).toMatchObject({ + resolution: { status: 'answered', selected: [] } + }) + expect(session.notices.value).toEqual([]) + }) + it('leaves a status-only 202 to the frame to report', async () => { const { session, emit } = await parkedOnQuestion() await session.answerAsk('turn-1:call-1', { selected: ['sdxl'] }) @@ -2745,6 +2764,21 @@ describe('useAgentSession (v1 composition root)', () => { ]) }) + it('keeps a pre-open accepted answer tracked until a later socket drop', async () => { + const { session, status } = await parkedOnQuestion() + await session.answerAsk('turn-1:call-1', { selected: ['sdxl'] }) + + status(true) + status(false) + + expect(session.notices.value).toEqual([ + { + level: 'error', + text: enMessages.agent.runApproval.answerAcceptedUnconfirmed + } + ]) + }) + it.for([400, 500])( 'marks the outcome unconfirmed when the answer may have landed (%i)', async (status) => { @@ -2870,16 +2904,17 @@ describe('useAgentSession (v1 composition root)', () => { ) }) - it('collapses a stale approval on 409 without surfacing an error', async () => { + it('retires a live-socket 409 without a false uncertainty notice', async () => { const answerAsk = vi .fn() .mockRejectedValue(new AgentApiError('already answered', 409, undefined)) - const { source, emit } = fakeEvents() + const { source, emit, status } = fakeEvents() const session = useAgentSession({ rest: fakeRest({ answerAsk }), events: source }) session.start() + status(true) await session.sendMessage('build it') emit(runApproval('msg-1')) @@ -3014,7 +3049,7 @@ describe('useAgentSession (v1 composition root)', () => { expect(session.notices.value).toEqual([]) }) - it('dismisses itself when the server reports the ask already resolved', async () => { + it('retires itself as unconfirmed when a 409 omits the committed answer', async () => { const answerAsk = vi .fn() .mockRejectedValue( @@ -3030,13 +3065,22 @@ describe('useAgentSession (v1 composition root)', () => { await session.sendMessage('build it and run it') emit(runApproval('msg-1')) emit(done('msg-1')) + status(false) await session.answerAsk('turn-1:call-1', { selected: ['run'] }) expect(cardOnScreen()).toBe(false) expect(session.answeringAskIds.value.size).toBe(0) - expect(session.notices.value).toEqual([]) - expect(reportError).not.toHaveBeenCalled() + expect(session.notices.value).toEqual([ + { + level: 'error', + text: 'Could not confirm your answer reached the agent. It may still have been applied — reload the page to see where things stand.' + } + ]) + expect(reportError).toHaveBeenCalledWith(expect.any(AgentApiError), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) }) it.for([403, 404] as const)( @@ -3191,6 +3235,68 @@ describe('useAgentSession (v1 composition root)', () => { expect(cardOnScreen()).toBe(false) }) + it('warns from the canonical answer receipt when another selection won', async () => { + const answerAsk = vi + .fn() + .mockResolvedValue({ status: 'answered', selected: ['run'] }) + const events = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ answerAsk }), + events: events.source + }) + session.start() + events.status(true) + await session.sendMessage('build it and run it') + events.emit(runApproval('msg-1')) + + const answered = await session.answerAsk('turn-1:call-1', 'cancel') + + expect(answered).toBe(false) + expect(reportError).toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_superseded', + tags: { + ask_kind: 'run_approval', + committed_selected_count: 1, + other_text_changed: false, + selection_changed: true, + selection_known: true, + submitted_selected_count: 1 + } + }) + expect(reportError).not.toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + expect(session.notices.value).toHaveLength(1) + }) + + it('treats an empty approval receipt as status-only for object answers', async () => { + const answerAsk = vi + .fn() + .mockResolvedValue({ status: 'answered', selected: [] }) + const events = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ answerAsk }), + events: events.source + }) + session.start() + events.status(true) + await session.sendMessage('build it and run it') + events.emit(runApproval('msg-1')) + + const answered = await session.answerAsk('turn-1:call-1', { + selected: ['run'] + }) + + expect(answered).toBe(true) + expect(reportError).not.toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_superseded' + }) + expect(session.notices.value).toEqual([]) + }) + // The resolution frame retires the card on its way through, so by the time // a slow request rejects there is nothing left to warn about — and telling // the user their answer might not have arrived, after the server has said @@ -4365,6 +4471,23 @@ describe('useAgentSession (v1 composition root)', () => { expect(rest.getMessages).toHaveBeenCalledWith('th-1', expect.anything()) }) + it('(g2b) a later false after the initial snapshot marks the channel dropped', async () => { + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + status(false) + + await session.sendMessage('go') + emit(runApproval('msg-1')) + status(false) + await session.answerAsk('turn-1:call-1', 'run') + + expect(reportError).toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_winner_unconfirmed' + }) + }) + // Backend invariant (cloud `newAssistantMessage` + the complete/fail writes): // an assistant row carries content only once it goes terminal, so a live turn // has nothing to re-hydrate from. Keep this row contentless — giving it text @@ -4764,6 +4887,22 @@ describe('useAgentSession (v1 composition root)', () => { expect(session.editableTurnId.value).toBe('msg-1') }) + it('(g6b) an approval does not make a still-streaming stopped turn editable', async () => { + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + status(true) + + await session.sendMessage('go') + emit(delta('msg-1', 'partial')) + await session.stopTurn() + emit(runApproval('msg-1')) + + expect(approvalParts(session)).toHaveLength(1) + expect(session.isStreaming.value).toBe(true) + expect(session.editableTurnId.value).toBeNull() + }) + it('(g7) a flapping socket starts one recovery job per turn, not one per reconnect', async () => { const rest = streamingTurnRest() const { source, emit, status } = fakeEvents() @@ -4903,7 +5042,7 @@ describe('useAgentSession (v1 composition root)', () => { ) }) - it('(g10) a failing recovery fetch stays silent and leaves the turn live for the socket', async () => { + it('(g10) a failing recovery fetch does not amplify backend failure and leaves the turn live', async () => { const rest = fakeRest({ getMessages: vi.fn(async (): Promise => { throw new TypeError('Failed to fetch') @@ -5051,7 +5190,7 @@ describe('useAgentSession (v1 composition root)', () => { ) }) - it('(g18) a history fetch that never answers is abandoned at the recovery deadline', async () => { + it('(g18) a history fetch that never answers stops at its deadline', async () => { const getMessages = vi.fn(hangingGetMessages) const rest = fakeRest({ getMessages }) const { source, emit, status } = fakeEvents() @@ -5064,21 +5203,17 @@ describe('useAgentSession (v1 composition root)', () => { status(false) status(true) - await vi.advanceTimersByTimeAsync(59_999) + await vi.advanceTimersByTimeAsync(59_000) expect(getMessages).toHaveBeenCalledTimes(1) const signal = getMessages.mock.calls[0]?.[1]?.signal assert.exists(signal) expect(signal.aborted).toBe(false) - await vi.advanceTimersByTimeAsync(1) + await vi.advanceTimersByTimeAsync(1_000) expect(signal.aborted).toBe(true) expect(session.isStreaming.value).toBe(true) expect(reportError).not.toHaveBeenCalled() - - status(false) - status(true) - await vi.advanceTimersByTimeAsync(0) - expect(getMessages).toHaveBeenCalledTimes(2) + await vi.waitFor(() => expect(getMessages).toHaveBeenCalledOnce()) }) it('(g19) stopping the session cancels its in-flight history fetch', async () => { @@ -5247,6 +5382,863 @@ describe('useAgentSession (v1 composition root)', () => { expect(conversationStore.liveTurns()).toHaveLength(1) }) + it('(g47) each reconnect gets one bounded recovery pass', async () => { + vi.useFakeTimers() + try { + const getMessages = vi.fn(async (): Promise => { + throw new AgentApiError('temporary failure', 500, undefined) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ getMessages }), + events: source + }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(delta('msg-1', 'partial')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(64_000) + expect(getMessages).toHaveBeenCalledTimes(6) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(64_000) + expect(getMessages).toHaveBeenCalledTimes(12) + } finally { + vi.useRealTimers() + } + }) + + // PM-1738. A turn parked on a run approval stays `streaming` for as long as + // the user takes to answer, so the drop that swallowed its `agent_ask` frame + // leaves the server waiting on a card the panel never drew. Recovery already + // polls the row, and the row carries the unanswered ask. + const PARKED_ASK: NonNullable = { + message_id: 'msg-1', + ask_id: 'turn-1:call-1', + kind: 'run_approval', + context: { + workflow_id: 'workflow-1', + workflow_name: 'Portrait workflow' + }, + prompt: 'Run it?', + options: [ + { id: 'run', label: 'Run' }, + { id: 'cancel', label: 'Cancel' } + ], + min_selections: 1, + max_selections: 1, + allow_other: false + } + + const parkedRow = (): AgentMessages[number] => ({ + ...historyRow(2, 'assistant', 'msg-1', '', 'msg-1'), + content: {}, + status: 'streaming', + pending_ask: PARKED_ASK + }) + + const unparkedRow = (): AgentMessages[number] => ({ + ...historyRow(2, 'assistant', 'msg-1', '', 'msg-1'), + content: {}, + status: 'streaming' + }) + + const parkedOnApprovalRest = () => + fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + parkedRow() + ] + ) + }) + + const approvalParts = (session: ReturnType) => { + const assistant = session.entries.value.at(-1) + assert(assistant !== undefined && 'parts' in assistant) + return assistant.parts.filter((part) => part.type === 'runApproval') + } + + it('(g27) an approval the drop swallowed is restored from the row and reported once', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + await session.sendMessage('go') + emit(delta('msg-1', 'partial')) + expect(approvalParts(session)).toHaveLength(0) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(0) + + expect(approvalParts(session)).toEqual([ + { + type: 'runApproval', + askId: 'turn-1:call-1', + workflowId: 'workflow-1', + workflowName: 'Portrait workflow' + } + ]) + expect(session.isStreaming.value).toBe(true) + + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(1) + expect(reportError).toHaveBeenCalledExactlyOnceWith(expect.any(Error), { + surface: 'agent', + errorType: 'failure_delivering_agent_approval_ask', + level: 'error', + tags: { + feature_area: 'agent', + operation: 'recovery', + recovery_cause: 'reconnect' + }, + context: { + threadId: 'th-1', + messageId: 'msg-1', + askId: 'turn-1:call-1' + } + }) + } finally { + vi.useRealTimers() + } + }) + + it('(g28) an approval the socket did deliver is neither redrawn nor reported', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + await session.sendMessage('go') + emit(runApproval('msg-1')) + expect(approvalParts(session)).toHaveLength(1) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(1) + expect(reportError).not.toHaveBeenCalled() + } finally { + vi.useRealTimers() + } + }) + + it('(g29) a poll whose snapshot predates the answer does not resurrect the card', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + await session.sendMessage('go') + emit(runApproval('msg-1')) + status(false) + status(true) + await vi.advanceTimersByTimeAsync(0) + expect(approvalParts(session)).toHaveLength(1) + + emit(askResolved('msg-1')) + expect(approvalParts(session)).toHaveLength(0) + + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(0) + expect(reportError).not.toHaveBeenCalled() + } finally { + vi.useRealTimers() + } + }) + + it('(g30) a broadcast that merely lagged the poll renders one card and is not reported', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + await session.sendMessage('go') + status(false) + status(true) + await vi.advanceTimersByTimeAsync(0) + expect(approvalParts(session)).toHaveLength(1) + + emit(runApproval('msg-1')) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(1) + expect(reportError).not.toHaveBeenCalled() + } finally { + vi.useRealTimers() + } + }) + + it('(g32) an ask answered elsewhere is not resurrected by a stale poll', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + vi.mocked(rest.answerAsk).mockRejectedValue( + new AgentApiError('already answered', 409, undefined) + ) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + await session.sendMessage('go') + emit(runApproval('msg-1')) + status(false) + await session.answerAsk('turn-1:call-1', 'run') + expect(approvalParts(session)).toHaveLength(0) + + status(true) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(0) + expect(reportError).toHaveBeenCalledWith(expect.any(AgentApiError), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + } finally { + vi.useRealTimers() + } + }) + + // The 409 branch resolves the ask straight on the store, so the ledger only + // learns of a hydrated card's ask from `answerAsk` itself. Without that the + // next poll, whose row still carries the ask the server has not cleared yet, + // would draw the card back over a reply the user had already released. + it('(g33) answering a hydrated ask keeps a stale poll from drawing it again', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + parkedRow() + ] + ) + }) + vi.mocked(rest.answerAsk).mockRejectedValue( + new AgentApiError('already answered', 409, undefined) + ) + const { source, status } = fakeEvents() + localStorage.setItem(StorageKeys.agentThread('personal'), 'th-1') + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + await vi.advanceTimersByTimeAsync(0) + expect(approvalParts(session)).toHaveLength(1) + + status(false) + await session.answerAsk('turn-1:call-1', 'run') + expect(approvalParts(session)).toHaveLength(0) + + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(0) + expect(reportError).toHaveBeenCalledWith(expect.any(AgentApiError), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + } finally { + vi.useRealTimers() + } + }) + + it('(g37) an uncertain hydrated answer keeps a stale poll from restoring its card', async () => { + vi.useFakeTimers() + try { + let resolveStalePoll: ((history: AgentMessages) => void) | undefined + const rest = fakeRest({ + getMessages: vi + .fn() + .mockResolvedValueOnce([ + historyRow(1, 'user', 'msg-1', 'go'), + parkedRow() + ]) + .mockImplementationOnce( + () => + new Promise((resolve) => { + resolveStalePoll = resolve + }) + ), + answerAsk: vi + .fn() + .mockRejectedValue(new AgentApiError('backend blip', 500, undefined)) + }) + const { source, status } = fakeEvents() + localStorage.setItem(StorageKeys.agentThread('personal'), 'th-1') + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + await vi.advanceTimersByTimeAsync(0) + expect(approvalParts(session)).toHaveLength(1) + await vi.waitFor(() => expect(rest.getMessages).toHaveBeenCalledTimes(2)) + + const answered = session.answerAsk('turn-1:call-1', 'run') + await vi.advanceTimersByTimeAsync(5_000) + await answered + expect(approvalParts(session)).toHaveLength(0) + + resolveStalePoll?.([historyRow(1, 'user', 'msg-1', 'go'), parkedRow()]) + await vi.advanceTimersByTimeAsync(0) + + expect(approvalParts(session)).toHaveLength(0) + } finally { + vi.useRealTimers() + } + }) + + it('(g39) a 202 cannot silently confirm which answer won for a recovered card', async () => { + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + status(false) + + await session.answerAsk('turn-1:call-1', 'run') + + expect(reportError).toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_winner_unconfirmed' + }) + expect(session.notices.value).toHaveLength(1) + }) + + it('(g39b) a drop and reconnect during the POST cannot silently confirm which answer won', async () => { + let accept: (receipt: AgentAnswerAccepted) => void = () => {} + const rest = fakeRest({ + answerAsk: vi.fn( + () => + new Promise((resolve) => { + accept = resolve + }) + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + const answered = session.answerAsk('turn-1:call-1', { selected: ['run'] }) + status(false) + status(true) + accept({ status: 'answered', selected: [] }) + await answered + + expect(reportError).toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_winner_unconfirmed' + }) + expect(session.notices.value).toEqual([ + { + level: 'error', + text: enMessages.agent.runApproval.answerAcceptedUnconfirmed + } + ]) + }) + + it('(g39c) a first open during the POST tracks the accepted answer instead of reporting it', async () => { + let accept: (receipt: AgentAnswerAccepted) => void = () => {} + const rest = fakeRest({ + answerAsk: vi.fn( + () => + new Promise((resolve) => { + accept = resolve + }) + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + await session.sendMessage('go') + emit(runApproval('msg-1')) + + const answered = session.answerAsk('turn-1:call-1', { selected: ['run'] }) + status(true) + accept({ status: 'answered', selected: [] }) + await answered + + expect(session.notices.value).toEqual([]) + + status(false) + + expect(session.notices.value).toEqual([ + { + level: 'error', + text: enMessages.agent.runApproval.answerAcceptedUnconfirmed + } + ]) + }) + + it('(g38) a remount does not restore an ask the prior session retired', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + vi.mocked(rest.answerAsk).mockRejectedValue( + new AgentApiError('already answered', 409, undefined) + ) + const firstEvents = fakeEvents() + localStorage.setItem(StorageKeys.agentThread('personal'), 'th-1') + const first = useAgentSession({ rest, events: firstEvents.source }) + first.start() + firstEvents.status(true) + await vi.advanceTimersByTimeAsync(0) + expect(approvalParts(first)).toHaveLength(1) + + await first.answerAsk('turn-1:call-1', 'run') + first.stop() + + const secondEvents = fakeEvents() + const second = useAgentSession({ rest, events: secondEvents.source }) + second.start() + secondEvents.status(true) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(second)).toHaveLength(0) + } finally { + vi.useRealTimers() + } + }) + + // The same lag `(g33)` describes, read from the other side: the server + // clears `pending_ask` behind the answer, so a row it has already closed can + // still be carrying a spent one. A later row keeps the turn open, so + // recovery still polls -- and must take the ask only from the open row, or + // the turn's own closed row resurrects a card nobody can answer. The + // hydrate path is already gated this way (`applyAssistantRow`). + it('(g36) a closed row still carrying a spent ask does not restore a card', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + { + ...parkedRow(), + status: 'interrupted' + }, + { + ...historyRow(3, 'assistant', 'msg-1', '', 'row-3'), + content: {}, + status: 'streaming' + } + ] + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + await session.sendMessage('go') + emit(delta('msg-1', 'partial')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(0) + expect(reportError).not.toHaveBeenCalled() + } finally { + vi.useRealTimers() + } + }) + + // A frame published while the first history fetch is still in flight has no + // turn in memory to reach: `ingest` drops it. Recovery is the only thing + // left that can draw the card, so the drop must not be recorded as a + // delivery. + it('(g34) a frame the store could not route yet is still restored by recovery', async () => { + vi.useFakeTimers() + try { + let releaseHistory = (): void => {} + const history = new Promise((resolve) => { + releaseHistory = resolve + }) + let served = 0 + const rest = fakeRest({ + getMessages: vi.fn(async (): Promise => { + // The first response is the one that predates the ask row, so + // hydration has nothing to draw the card from. + if (served++ === 0) { + await history + return [historyRow(1, 'user', 'msg-1', 'go'), unparkedRow()] + } + return [historyRow(1, 'user', 'msg-1', 'go'), parkedRow()] + }), + answerAsk: vi + .fn() + .mockRejectedValue( + new AgentApiError('already answered', 409, undefined) + ) + }) + const { source, status } = fakeEvents() + localStorage.setItem(StorageKeys.agentThread('personal'), 'th-1') + const session = useAgentSession({ rest, events: source }) + useAgentConversationStore().ingest( + zAgentWsEvent.parse(runApproval('msg-1')) + ) + session.start() + status(true) + + expect(session.entries.value).toHaveLength(0) + + releaseHistory() + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(1) + status(false) + await session.answerAsk('turn-1:call-1', 'run') + expect(session.notices.value).toEqual([ + { + level: 'error', + text: 'Could not confirm your answer reached the agent. It may still have been applied — reload the page to see where things stand.' + } + ]) + } finally { + vi.useRealTimers() + } + }) + + it('(g35) a drop while a hydrate job is polling files the ask as a lost frame', async () => { + vi.useFakeTimers() + try { + // The row parks only once the socket is down, so the hydrate job's own + // polls see nothing and the restore can only come from the reconnect + // job that takes it over. Keyed on the drop rather than on a call count + // because hydrate and its first poll share the 0ms head of the schedule. + let parked = false + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + parked ? parkedRow() : unparkedRow() + ] + ) + }) + const { source, status } = fakeEvents() + localStorage.setItem(StorageKeys.agentThread('personal'), 'th-1') + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + await vi.advanceTimersByTimeAsync(0) + expect(approvalParts(session)).toHaveLength(0) + + parked = true + status(false) + status(true) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(1) + expect(reportError).toHaveBeenCalledExactlyOnceWith( + expect.any(Error), + expect.objectContaining({ + level: 'error', + tags: expect.objectContaining({ recovery_cause: 'reconnect' }) + }) + ) + } finally { + vi.useRealTimers() + } + }) + + it('(g40) recovery replaces a stale approval with the row current ask', async () => { + vi.useFakeTimers() + try { + const currentAskId = 'turn-1:call-2' + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + { + ...parkedRow(), + pending_ask: { ...PARKED_ASK, ask_id: currentAskId } + } + ] + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(1_000) + + expect(approvalParts(session).map((part) => part.askId)).toEqual([ + currentAskId + ]) + } finally { + vi.useRealTimers() + } + }) + + it('(g46) a confirmed row with no pending ask retires a stale approval', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + unparkedRow() + ] + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(1_000) + + expect(approvalParts(session)).toHaveLength(0) + } finally { + vi.useRealTimers() + } + }) + + it('(g47) a delayed duplicate frame cannot redraw a confirmed-stale approval', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + unparkedRow() + ] + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(1_000) + expect(approvalParts(session)).toHaveLength(0) + + emit(runApproval('msg-1')) + expect(approvalParts(session)).toHaveLength(0) + } finally { + vi.useRealTimers() + } + }) + + it('(g41) a missing turn row cannot retire a live approval', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go') + ] + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(31_000) + + expect(approvalParts(session)).toHaveLength(1) + } finally { + vi.useRealTimers() + } + }) + + it('(g42) a newer terminal row retires an older pending approval', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + parkedRow(), + { + ...historyRow(3, 'assistant', 'msg-1', 'done', 'row-3'), + status: 'complete' + } + ] + ) + }) + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(0) + + expect(session.isStreaming.value).toBe(false) + expect(approvalParts(session)).toHaveLength(0) + } finally { + vi.useRealTimers() + } + }) + + it('(g43) a confirmed current ask clears reconnect-only answer warnings', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + const { source, emit, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + emit(runApproval('msg-1')) + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(0) + emit(runApproval('msg-1')) + await session.answerAsk('turn-1:call-1', 'run') + + expect(session.notices.value).toHaveLength(0) + expect(reportError).not.toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + } finally { + vi.useRealTimers() + } + }) + + it('(g44) a restored approval answered on a live socket is not uncertain', async () => { + vi.useFakeTimers() + try { + const rest = parkedOnApprovalRest() + const { source, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(3_000) + await session.answerAsk('turn-1:call-1', 'run') + + expect(reportError).not.toHaveBeenCalledWith(expect.any(Error), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + } finally { + vi.useRealTimers() + } + }) + + it('(g45) recovery reads the newest ask-bearing open row', async () => { + vi.useFakeTimers() + try { + const rest = fakeRest({ + getMessages: vi.fn( + async (): Promise => [ + historyRow(1, 'user', 'msg-1', 'go'), + parkedRow(), + { + ...historyRow(3, 'assistant', 'msg-1', '', 'row-3'), + content: {}, + status: 'streaming' + } + ] + ) + }) + const { source, status } = fakeEvents() + const session = useAgentSession({ rest, events: source }) + session.start({ restore: false }) + status(true) + await session.sendMessage('go') + + status(false) + status(true) + await vi.advanceTimersByTimeAsync(0) + + expect(approvalParts(session).map((part) => part.askId)).toEqual([ + 'turn-1:call-1' + ]) + } finally { + vi.useRealTimers() + } + }) + + it('(g31) an ask the server parks during a hydrate fetch is restored as a warning', async () => { + vi.useFakeTimers() + try { + const getMessages = vi + .fn<() => Promise>() + .mockResolvedValueOnce([ + historyRow(1, 'user', 'msg-1', 'go'), + unparkedRow() + ]) + .mockResolvedValue([historyRow(1, 'user', 'msg-1', 'go'), parkedRow()]) + const rest = fakeRest({ getMessages }) + const { source, status } = fakeEvents() + localStorage.setItem(StorageKeys.agentThread('personal'), 'th-1') + const session = useAgentSession({ rest, events: source }) + session.start() + status(true) + + // Hydrate and its first recovery poll share the 0ms head of the + // schedule, so the restore lands in the same tick as the hydrate that + // missed the ask -- and it is filed as the benign publish race, not as + // a lost frame, because no socket ever dropped here. + await vi.advanceTimersByTimeAsync(0) + + expect(approvalParts(session)).toHaveLength(1) + expect(reportError).toHaveBeenCalledExactlyOnceWith( + expect.any(Error), + expect.objectContaining({ + errorType: 'failure_delivering_agent_approval_ask', + level: 'warning', + tags: expect.objectContaining({ recovery_cause: 'hydrate' }) + }) + ) + } finally { + vi.useRealTimers() + } + }) + it('(h) attachments pass through to the postMessage wire body', async () => { const rest = fakeRest() const { source } = fakeEvents() diff --git a/src/workbench/extensions/agent/composables/agent/useAgentSession.ts b/src/workbench/extensions/agent/composables/agent/useAgentSession.ts index bdc51ada833..272148313b3 100644 --- a/src/workbench/extensions/agent/composables/agent/useAgentSession.ts +++ b/src/workbench/extensions/agent/composables/agent/useAgentSession.ts @@ -201,6 +201,18 @@ const MAX_HYDRATION_MAILBOXES = 32 const TURN_RECOVERY_DELAYS_MS = [0, 1000, 2000, 4000, 8000, 16000] /** Upper bound on one recovery job, including any history fetch still in flight. */ const TURN_RECOVERY_DEADLINE_MS = 60_000 +const THREAD_MISSING_CONFIRMATION_INTERVAL_MS = 1000 +/** How long a restored ask waits for its own broadcast before it counts as lost. */ +const LATE_ASK_FRAME_GRACE_MS = 2000 + +/** + * Why a recovery job is running, which is what separates an ask the socket + * genuinely dropped from one that merely had not been published when a + * hydrate's history fetch went out. Only the former is a defect. + */ +type RecoveryCause = 'reconnect' | 'hydrate' + +type PendingAsk = NonNullable type TurnOutcome = | { @@ -209,9 +221,20 @@ type TurnOutcome = ending: 'completed' | 'failed' } | { kind: 'thread-missing' } - | { kind: 'streaming' } + | { kind: 'streaming'; pendingAsk: PendingAsk | undefined } | { kind: 'error'; message: string } +function streamingPendingAskId(outcome: TurnOutcome): string | undefined { + return outcome.kind === 'streaming' ? outcome.pendingAsk?.ask_id : undefined +} + +function isTransientMissingTurn( + outcome: TurnOutcome, + consecutiveThreadMissing: number +): boolean { + return outcome.kind === 'thread-missing' && consecutiveThreadMissing < 2 +} + function isTerminalTurnStatus( status: AgentMessages[number]['status'] ): boolean { @@ -352,6 +375,7 @@ function classifyAnswerFailure(error: unknown): AnswerFailure { * the shared 60s request deadline it replaces. */ const ANSWER_RETRY_BACKOFF_MS = [300] +const MAX_DELIVERED_ASKS = 128 /** * A rejected fetch never reached the server, and 5xx is the status the server @@ -388,6 +412,15 @@ function diffAnswers( } } +function isSupersededAnswer( + submitted: AgentAnswerRequest, + committed: Extract, + selectionKnown: boolean +): boolean { + const changes = diffAnswers(submitted, committed, selectionKnown) + return changes.selection_changed || changes.other_text_changed +} + let sessionGeneration = 0 /** @@ -604,7 +637,135 @@ export function useAgentSession(deps: AgentSessionDeps) { let unsubscribeStatus: (() => void) | null = null let ownedGeneration = 0 let connection: SocketConnection = 'initial' - const recoveringTurns = new Map() + let receivedStatusSnapshot = false + let resolutionChannelEpoch = 0 + interface RunningRecovery { + controller: AbortController + cause: RecoveryCause + rerun: boolean + rerunCause: RecoveryCause + automaticRerun: boolean + } + interface MissingThreadObservation { + count: number + observedAt: number + } + const recoveringTurns = new Map() + interface PendingAskObservation { + pendingAskId: string | undefined + deliveredAskIds: Set + observedAt: number + } + const recoveryPendingAskObservations = new Map< + string, + PendingAskObservation + >() + const recoveryThreadMissingCounts = new Map< + string, + MissingThreadObservation + >() + /** + * Asks recovery must not re-deliver: one it already restored, one a frame + * has delivered, and any the user has answered or the server has resolved. + * Without the latter, a poll whose snapshot predates the answer would + * resurrect a card the user is done with, splitting the reply that has + * since resumed streaming. Deliberately outlives `newChat`/`loadThread`: + * an `ask_id` carries its `message_id`, so it is never reused. + */ + const deliveredAsks = new Set() + const observedDeliveredAsks = new Set() + const supersededAnswerReports = new Set() + const acceptedUnconfirmedReports = new Set() + const conflictUnconfirmedReports = new Set() + const lateAskReports = new Map< + string, + { + threadId: string + messageId: string + timer: ReturnType + } + >() + + function recordDeliveredAsk(askId: string): void { + observedDeliveredAsks.delete(askId) + observedDeliveredAsks.add(askId) + deliveredAsks.delete(askId) + deliveredAsks.add(askId) + for (const ledger of [deliveredAsks, observedDeliveredAsks]) { + if (ledger.size <= MAX_DELIVERED_ASKS) continue + const oldest = ledger.values().next().value + if (oldest !== undefined) ledger.delete(oldest) + } + } + + function recordAnswerReport(reports: Set, askId: string): boolean { + if (reports.has(askId)) return false + reports.add(askId) + if (reports.size > MAX_DELIVERED_ASKS) { + const oldest = reports.values().next().value + if (oldest !== undefined) reports.delete(oldest) + } + return true + } + + function recordPendingAskObservation( + key: string, + pendingAskId: string | undefined, + deliveredAskIds: Set + ): PendingAskObservation { + const observation = { + pendingAskId, + deliveredAskIds, + observedAt: Date.now() + } + recoveryPendingAskObservations.delete(key) + recoveryPendingAskObservations.set(key, observation) + if (recoveryPendingAskObservations.size > MAX_DELIVERED_ASKS) { + const oldest = recoveryPendingAskObservations.keys().next().value + if (oldest !== undefined) recoveryPendingAskObservations.delete(oldest) + } + return observation + } + + function recordThreadAvailability(key: string, outcome: TurnOutcome): number { + const previous = recoveryThreadMissingCounts.get(key) + if (outcome.kind === 'thread-missing') { + const observedAt = Date.now() + const consecutive = + previous === undefined || + observedAt - previous.observedAt > TURN_RECOVERY_DEADLINE_MS + ? 1 + : observedAt - previous.observedAt >= + THREAD_MISSING_CONFIRMATION_INTERVAL_MS + ? previous.count + 1 + : previous.count + recoveryThreadMissingCounts.delete(key) + recoveryThreadMissingCounts.set(key, { count: consecutive, observedAt }) + return consecutive + } + recoveryThreadMissingCounts.delete(key) + return previous?.count ?? 0 + } + + function pruneRecoveryLedgers(): void { + while (recoveryThreadMissingCounts.size > MAX_DELIVERED_ASKS) { + const oldest = recoveryThreadMissingCounts.keys().next().value + if (oldest === undefined) break + recoveryThreadMissingCounts.delete(oldest) + } + } + + function lateAskReportKey(threadId: string, askId: string): string { + return `${threadId}\u0000${askId}` + } + + function clearLateAskReports(threadId?: string): void { + for (const [key, scheduled] of lateAskReports) { + if (threadId !== undefined && scheduled.threadId !== threadId) continue + clearTimeout(scheduled.timer) + lateAskReports.delete(key) + } + } function pushError(text: string): void { notices.value.push({ level: 'error', text }) @@ -654,6 +815,7 @@ export function useAgentSession(deps: AgentSessionDeps) { readyThreadId.value = null ownedGeneration = ++sessionGeneration connection = 'initial' + receivedStatusSnapshot = false const surviving = conversationStore.threadId const stored = conversationStore.messages.length === 0 @@ -894,7 +1056,7 @@ export function useAgentSession(deps: AgentSessionDeps) { if (conversationStore.threadId !== threadId || !isCurrent()) return false conversationStore.hydrate(history) rememberSnapshotTurn(conversationStore.activeTurnId) - reconcileLiveTurns() + reconcileLiveTurns('hydrate') readyThreadId.value = threadId drainHydration(buffer) const workflowReady = await workflow?.restored?.( @@ -981,8 +1143,11 @@ export function useAgentSession(deps: AgentSessionDeps) { unsubscribeStatus?.() unsubscribe = null unsubscribeStatus = null - for (const recovery of recoveringTurns.values()) recovery.abort() + for (const running of recoveringTurns.values()) running.controller.abort() recoveringTurns.clear() + recoveryPendingAskObservations.clear() + recoveryThreadMissingCounts.clear() + clearLateAskReports() const stoppedGeneration = ownedGeneration queueMicrotask(() => { if (stoppedGeneration !== sessionGeneration) return @@ -1601,44 +1766,178 @@ export function useAgentSession(deps: AgentSessionDeps) { async function answerAsk( askId: string, - answer: AgentAnswerRequest + answer: AgentAnswerRequest | 'run' | 'cancel' ): Promise { const currentThreadId = conversationStore.threadId if (currentThreadId === null) { - reportError(new Error('agent ask answered with no thread to send on'), { - surface: 'agent', - errorType: 'agent_ask_answer_unroutable' - }) - pushError(i18n.global.t('agent.runApproval.answerFailed')) - conversationStore.retireAsk(askId, { status: 'retired' }) + failUnroutableAsk(askId) return false } if (answeringAskIds.value.has(askId)) return false - conversationStore.recordAskAnswer(askId, answer) + const legacyRunApprovalAnswer = typeof answer === 'string' + const runApprovalAnswer = + legacyRunApprovalAnswer || + conversationStore.askKind(askId) === 'runApproval' + const normalizedAnswer = legacyRunApprovalAnswer + ? { selected: [answer] } + : answer + conversationStore.recordAskAnswer(askId, normalizedAnswer, currentThreadId) conversationStore.setAskAnswering(askId, true) + const answerChannelEpoch = resolutionChannelEpoch + const answerStartedBeforeFirstOpen = connection === 'initial' + const answerStartedDropped = connection === 'dropped' + const resolutionChannelDropped = () => + answerStartedDropped || resolutionChannelEpoch !== answerChannelEpoch + const resolutionChannelWasLost = () => + answerStartedBeforeFirstOpen || resolutionChannelDropped() try { - const receipt = await sendAnswer(currentThreadId, askId, answer) - const committed = toAskResolution(receipt) - reportSupersededAnswer(askId, receipt) - conversationStore.commitAsk(askId, currentThreadId, committed) - return true + const receipt = await sendAnswer(currentThreadId, askId, normalizedAnswer) + return commitAskReceipt({ + askId, + answer: normalizedAnswer, + currentThreadId, + receipt, + runApprovalAnswer, + resolutionChannelDropped + }) } catch (error) { if (answeringAskIds.value.has(askId)) - handleAnswerFailure(error, askId, currentThreadId) + return handleAnswerFailure( + error, + askId, + currentThreadId, + runApprovalAnswer, + resolutionChannelWasLost() + ) + return false + } + } + + function commitAskReceipt({ + askId, + answer, + currentThreadId, + receipt, + runApprovalAnswer, + resolutionChannelDropped + }: { + askId: string + answer: AgentAnswerRequest + currentThreadId: string + receipt: AgentAnswerReceipt + runApprovalAnswer: boolean + resolutionChannelDropped: () => boolean + }): boolean { + if (!receiptNamesCommittedAnswer(receipt, runApprovalAnswer)) + return commitStatusOnlyAskReceipt({ + askId, + answer, + currentThreadId, + resolutionChannelDropped + }) + const committed = toAskResolution(receipt) + conversationStore.clearAskAwaitingResolution(askId) + const superseded = + committed.status === 'answered' && + isSupersededAnswer(answer, committed, Array.isArray(receipt.selected)) + reportSupersededAnswer(askId, receipt) + recordDeliveredAsk(askId) + conversationStore.commitAsk(askId, currentThreadId, committed) + return !superseded + } + + function receiptNamesCommittedAnswer( + receipt: { + status?: string + selected?: string[] | null + other_text?: string + }, + runApprovalAnswer = false + ): boolean { + if (receipt.status !== undefined && receipt.status !== 'answered') + return false + if (receipt.other_text !== undefined) return true + if (receipt.selected === undefined || receipt.selected === null) return false + return !runApprovalAnswer || receipt.selected.length > 0 + } + + function commitStatusOnlyAskReceipt({ + askId, + answer, + currentThreadId, + resolutionChannelDropped + }: { + askId: string + answer: AgentAnswerRequest + currentThreadId: string + resolutionChannelDropped: () => boolean + }): boolean { + const channelDropped = resolutionChannelDropped() + const resolutionStillPending = + conversationStore.submittedAskAnswer(askId) !== undefined + if (resolutionStillPending) + reportAcceptedRecoveredAnswer(askId, channelDropped) + recordDeliveredAsk(askId) + conversationStore.commitAsk(askId, currentThreadId, { status: 'retired' }) + if (resolutionStillPending && !channelDropped) { + conversationStore.recordAskAnswer(askId, answer, currentThreadId) + conversationStore.markAskAwaitingResolution(askId, 'accepted') } + return !supersededAnswerReports.has(askId) + } + + function failUnroutableAsk(askId: string): void { + reportError(new Error('agent ask answered with no thread to send on'), { + surface: 'agent', + errorType: 'agent_ask_answer_unroutable' + }) + pushError(i18n.global.t('agent.runApproval.answerFailed')) + recordDeliveredAsk(askId) + conversationStore.retireAsk(askId, { status: 'retired' }) + } + + function reportAcceptedRecoveredAnswer( + askId: string, + resolutionChannelWasLost: boolean + ): void { + if ( + !resolutionChannelWasLost || + !recordAnswerReport(acceptedUnconfirmedReports, askId) + ) + return + reportError(new Error('accepted restored approval cannot be verified'), { + surface: 'agent', + errorType: 'agent_ask_answer_winner_unconfirmed' + }) + pushError(i18n.global.t('agent.runApproval.answerAcceptedUnconfirmed')) + } + + function reportUnconfirmedConflict(askId: string): void { + if (!recordAnswerReport(conflictUnconfirmedReports, askId)) return + reportError(new Error('restored approval conflict cannot be verified'), { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + pushError(i18n.global.t('agent.runApproval.answerUncertain')) } function handleAnswerFailure( error: unknown, askId: string, - threadId: string - ): void { + threadId: string, + runApprovalAnswer: boolean, + resolutionChannelWasLost = connection === 'dropped' + ): boolean { + conversationStore.clearAskAwaitingResolution(askId) if (error instanceof AgentApiError && error.status === 409) { - const conflict = zAgentAskConflict.safeParse(error.body).data ?? {} - reportSupersededAnswer(askId, conflict) - conversationStore.retireAsk(askId, toAskResolution(conflict), threadId) - return + return handleConflictAnswerFailure( + error, + askId, + threadId, + runApprovalAnswer, + resolutionChannelWasLost + ) } const failure = classifyAnswerFailure(error) reportError(error, { @@ -1650,6 +1949,7 @@ export function useAgentSession(deps: AgentSessionDeps) { }) const settle: Record void> = { rejected: () => { + deliveredAsks.delete(askId) conversationStore.takeSubmittedAskAnswer(askId) conversationStore.setAskAnswering(askId, false) pushError(i18n.global.t('agent.askUser.answerRejected')) @@ -1659,11 +1959,88 @@ export function useAgentSession(deps: AgentSessionDeps) { conversationStore.retireAsk(askId, { status: 'retired' }, threadId) }, unconfirmed: () => { + recordDeliveredAsk(askId) conversationStore.retireAsk(askId, { status: 'unconfirmed' }, threadId) pushError(i18n.global.t('agent.runApproval.answerUncertain')) } } settle[failure]() + return false + } + + function handleConflictAnswerFailure( + error: AgentApiError, + askId: string, + threadId: string, + runApprovalAnswer: boolean, + resolutionChannelWasLost: boolean + ): boolean { + const conflict = zAgentAskConflict.safeParse(error.body) + if ( + conflict.success && + conflict.data.status !== undefined && + conflict.data.status !== 'answered' + ) { + conversationStore.retireAsk( + askId, + toAskResolution(conflict.data), + threadId + ) + return false + } + const submitted = conversationStore.submittedAskAnswer(askId) + if ( + conflict.success && + receiptNamesCommittedAnswer(conflict.data, runApprovalAnswer) + ) { + const committed = toAskResolution(conflict.data) + const superseded = + submitted !== undefined && + committed.status === 'answered' && + isSupersededAnswer( + submitted, + committed, + Array.isArray(conflict.data.selected) + ) + reportSupersededAnswer(askId, conflict.data) + conversationStore.retireAsk(askId, committed, threadId) + return !superseded + } + retireUnknownConflict( + error, + askId, + threadId, + submitted, + resolutionChannelWasLost + ) + return false + } + + function retireUnknownConflict( + error: AgentApiError, + askId: string, + threadId: string, + submitted: AgentAnswerRequest | undefined, + resolutionChannelWasLost: boolean + ): void { + recordDeliveredAsk(askId) + conversationStore.retireAsk( + askId, + { status: resolutionChannelWasLost ? 'unconfirmed' : 'retired' }, + threadId + ) + if (!resolutionChannelWasLost) { + if (submitted) { + conversationStore.recordAskAnswer(askId, submitted, threadId) + conversationStore.markAskAwaitingResolution(askId, 'conflict') + } + return + } + reportError(error, { + surface: 'agent', + errorType: 'agent_ask_answer_unconfirmed' + }) + pushError(i18n.global.t('agent.runApproval.answerUncertain')) } function reportSupersededAnswer( @@ -1677,7 +2054,11 @@ export function useAgentSession(deps: AgentSessionDeps) { if (submitted === undefined) return const selectionKnown = Array.isArray(source.selected) const changes = diffAnswers(submitted.answer, committed, selectionKnown) - if (!changes.selection_changed && !changes.other_text_changed) return + if ( + (!changes.selection_changed && !changes.other_text_changed) || + !recordAnswerReport(supersededAnswerReports, askId) + ) + return reportError(new Error('agent ask resolved with a different answer'), { surface: 'agent', errorType: 'agent_ask_answer_superseded', @@ -1913,25 +2294,41 @@ export function useAgentSession(deps: AgentSessionDeps) { if (messageId !== undefined) snapshotTurns.delete(toTurnId(messageId)) } + function handleResolvedAsk( + event: Extract + ): void { + conversationStore.clearAskAwaitingResolution(event.data.ask_id) + const resolution = toAskResolution(event.data) + reportSupersededAnswer(event.data.ask_id, event.data) + // The owning transport may already be gone, so retire the ask explicitly + // before ingest can otherwise leave its card enabled. + conversationStore.retireAsk( + event.data.ask_id, + resolution, + event.data.thread_id + ) + recordDeliveredAsk(event.data.ask_id) + onAskResolved?.(event.data.ask_id) + } + + function observeSkillEvent(event: AgentWsEvent): void { + for (const turn of conversationStore.liveTurns()) observeSkillTurn(turn) + if (event.type !== 'agent_message_done') return + finishSkillTurn({ + threadId: event.data.thread_id, + messageId: toTurnId(event.data.message_id) + }) + } + function handleAgentEvent(event: AgentWsEvent): void { if (heldForHydration(event)) return observeLiveDelivery(event) - if (event.type === 'agent_ask_resolved') { - const resolution = toAskResolution(event.data) - reportSupersededAnswer(event.data.ask_id, event.data) - conversationStore.retireAsk( - event.data.ask_id, - resolution, - event.data.thread_id - ) - onAskResolved?.(event.data.ask_id) - } - for (const turn of conversationStore.liveTurns()) observeSkillTurn(turn) - if (event.type === 'agent_message_done') { - finishSkillTurn({ - threadId: event.data.thread_id, - messageId: toTurnId(event.data.message_id) - }) + if (event.type === 'agent_ask_resolved') handleResolvedAsk(event) + observeSkillEvent(event) + if (event.type === 'agent_ask') { + deliverAsk(event) + for (const turn of conversationStore.liveTurns()) observeSkillTurn(turn) + return } conversationStore.ingest(event) for (const turn of conversationStore.liveTurns()) observeSkillTurn(turn) @@ -1954,33 +2351,69 @@ export function useAgentSession(deps: AgentSessionDeps) { function onStatus(live: boolean): void { if (!live) { + if (connection === 'initial' && !receivedStatusSnapshot) { + receivedStatusSnapshot = true + return + } + receivedStatusSnapshot = true + if (connection === 'dropped') return connection = 'dropped' + resolutionChannelEpoch += 1 + for (const awaiting of conversationStore.asksAwaitingResolution()) + if (awaiting.kind === 'accepted') + reportAcceptedRecoveredAnswer(awaiting.askId, true) + else reportUnconfirmedConflict(awaiting.askId) return } + receivedStatusSnapshot = true const reconnected = connection === 'dropped' + const firstLive = connection === 'initial' connection = 'live' - if (!reconnected) return - reconcileLiveTurns() + if (reconnected) reconcileLiveTurns('reconnect') + else if (firstLive) reconcileLiveTurns('hydrate') } - function reconcileLiveTurns(): void { - const turns = conversationStore - .liveTurns() - .filter((turn) => !recoveringTurns.has(recoveryKey(turn))) - for (const turn of turns) void reconcileTurn(turn) + function reconcileLiveTurns(cause: RecoveryCause): void { + for (const turn of conversationStore.liveTurns()) + void reconcileTurn(turn, cause) } - async function reconcileTurn(turn: LiveTurn): Promise { + async function reconcileTurn( + turn: LiveTurn, + cause: RecoveryCause, + isAutomaticRerun = false + ): Promise { observeSkillTurn(turn) const key = recoveryKey(turn) + if (deferToRunningRecovery(key, cause)) return const recovery = new AbortController() - recoveringTurns.set(key, recovery) - const deadline = setTimeout( - () => recovery.abort(), - TURN_RECOVERY_DEADLINE_MS - ) + const state = { + controller: recovery, + cause, + rerun: false, + rerunCause: cause, + automaticRerun: false + } + recoveringTurns.set(key, state) + const deadline = setTimeout(() => { + if (recoveringTurns.get(key)?.controller !== recovery) return + recoveringTurns.delete(key) + recovery.abort() + if (!isTurnLive(turn, ownedGeneration)) return + if (state.rerun) + void reconcileTurn(turn, state.rerunCause, state.automaticRerun) + }, TURN_RECOVERY_DEADLINE_MS) try { - await recoverTurn(turn, ownedGeneration, recovery.signal) + const needsRerun = await recoverTurn( + turn, + cause, + ownedGeneration, + recovery.signal + ) + if (needsRerun && !isAutomaticRerun && !state.rerun) { + state.rerun = true + state.automaticRerun = true + } } catch (error) { // `onStatus` floats this job (`void reconcileTurn(turn)`), so a rethrow // would land as an `unhandledrejection` the session never sees. Abort is @@ -1993,27 +2426,285 @@ export function useAgentSession(deps: AgentSessionDeps) { }) } finally { clearTimeout(deadline) - if (recoveringTurns.get(key) === recovery) recoveringTurns.delete(key) + finishRecovery(key, recovery, state, turn) } } + function deferToRunningRecovery(key: string, cause: RecoveryCause): boolean { + const running = recoveringTurns.get(key) + if (running === undefined) return false + if (cause !== 'reconnect') { + running.rerun = true + return true + } + if (running.cause === 'reconnect') { + running.rerun = true + running.rerunCause = 'reconnect' + return true + } + running.controller.abort() + return false + } + + function finishRecovery( + key: string, + recovery: AbortController, + state: RunningRecovery, + turn: LiveTurn + ): void { + if (recoveringTurns.get(key)?.controller !== recovery) return + recoveringTurns.delete(key) + if (state.rerun && isTurnLive(turn, ownedGeneration)) + void reconcileTurn(turn, state.rerunCause, state.automaticRerun) + } + async function recoverTurn( turn: LiveTurn, + cause: RecoveryCause, generation: number, signal: AbortSignal - ): Promise { - let consecutiveThreadMissing = 0 + ): Promise { + const key = recoveryKey(turn) + let previousObservation = recentPendingAskObservation(key) + let hasUnconfirmedObservation = false + let sawStreamingObservation = false for (const ms of TURN_RECOVERY_DELAYS_MS) { await delay(ms, { signal }) - if (!isTurnLive(turn, generation)) return + if (!isTurnLive(turn, generation)) return false + const deliveredBeforeFetch = new Set(deliveredAsks) const outcome = await fetchTurnOutcome(turn, signal) - if (!isTurnLive(turn, generation)) return - consecutiveThreadMissing = - outcome.kind === 'thread-missing' ? consecutiveThreadMissing + 1 : 0 - if (outcome.kind === 'thread-missing' && consecutiveThreadMissing < 2) + signal.throwIfAborted() + if (!isTurnLive(turn, generation)) return false + const consecutiveThreadMissing = recordThreadAvailability(key, outcome) + pruneRecoveryLedgers() + if (isTransientMissingTurn(outcome, consecutiveThreadMissing)) { + hasUnconfirmedObservation = true continue - if (settleFinishedTurn(turn, outcome)) return + } + if (settleFinishedTurn(turn, outcome)) { + recoveryPendingAskObservations.delete(key) + recoveryThreadMissingCounts.delete(key) + return false + } + if (outcome.kind !== 'streaming') { + hasUnconfirmedObservation = true + continue + } + sawStreamingObservation = true + const pendingAskId = streamingPendingAskId(outcome) + const pendingAskConfirmed = + previousObservation !== undefined && + previousObservation.pendingAskId === pendingAskId + hasUnconfirmedObservation = !pendingAskConfirmed + const deliveredSincePreviousObservation = new Set( + [...deliveredAsks].filter( + (askId) => !previousObservation?.deliveredAskIds.has(askId) + ) + ) + reconcileStreamingApproval( + turn, + outcome, + cause, + pendingAskConfirmed, + deliveredSincePreviousObservation + ) + previousObservation = recordPendingAskObservation( + key, + pendingAskId, + deliveredBeforeFetch + ) } + return hasUnconfirmedObservation && sawStreamingObservation + } + + function recentPendingAskObservation( + key: string + ): PendingAskObservation | undefined { + const observation = recoveryPendingAskObservations.get(key) + if ( + observation === undefined || + Date.now() - observation.observedAt <= TURN_RECOVERY_DEADLINE_MS + ) + return observation + recoveryPendingAskObservations.delete(key) + return undefined + } + + function reconcileStreamingApproval( + turn: LiveTurn, + outcome: TurnOutcome, + cause: RecoveryCause, + pendingAskConfirmed: boolean, + deliveredDuringPoll: ReadonlySet + ): void { + if (outcome.kind !== 'streaming') return + if (pendingAskConfirmed) + reconcileConfirmedApproval(turn, outcome, deliveredDuringPoll) + if ( + !pendingAskConfirmed && + outcome.pendingAsk !== undefined && + !conversationStore.isAskShown(turn, outcome.pendingAsk.ask_id) && + conversationStore.hasApprovalShown(turn) + ) + return + restoreMissingApproval(turn, outcome.pendingAsk, cause) + } + + function reconcileConfirmedApproval( + turn: LiveTurn, + outcome: Extract, + deliveredDuringPoll: ReadonlySet + ): void { + if (outcome.pendingAsk) + conversationStore.confirmAskPending( + outcome.pendingAsk.ask_id, + turn.threadId + ) + const hiddenAskIds = conversationStore.reconcileApprovalParts( + turn, + outcome.pendingAsk?.ask_id, + deliveredDuringPoll + ) + for (const askId of hiddenAskIds) deliveredAsks.delete(askId) + } + + /** + * PM-1738: a turn parked on a tool-call approval stays `streaming` until the + * user answers, so a socket drop that swallowed the `agent_ask` frame leaves + * the server waiting on a card the panel never drew -- the turn reads as + * hung and every follow-up post comes back 409. The polled row still carries + * the unanswered ask, so re-deliver it through the store, which routes it to + * the same transport the lost frame would have reached, and mirror the one + * other thing the socket branch does with an ask. + * + * Reported at `error` only after a reconnect, where the frame really is + * gone. A hydrate's poll can instead be racing a broadcast the server had + * not published when its history fetch went out, so that reads as a warning. + */ + function restoreMissingApproval( + turn: LiveTurn, + pendingAsk: PendingAsk | undefined, + cause: RecoveryCause + ): void { + if (!pendingAsk) return + if (deliveredAsks.has(pendingAsk.ask_id)) return + if ( + conversationStore.submittedAskAnswer(pendingAsk.ask_id) !== undefined || + answeringAskIds.value.has(pendingAsk.ask_id) + ) + return + if (conversationStore.isAskRetired(pendingAsk.ask_id, turn.threadId)) return + if (conversationStore.isAskShown(turn, pendingAsk.ask_id)) return + const wasDeliveredBefore = observedDeliveredAsks.has(pendingAsk.ask_id) + conversationStore.ingest({ + type: 'agent_ask', + data: { + ...pendingAsk, + thread_id: turn.threadId, + message_id: turn.messageId + } + }) + if (!conversationStore.isAskShown(turn, pendingAsk.ask_id)) return + recordDeliveredAsk(pendingAsk.ask_id) + if (!wasDeliveredBefore) + reportRestoredApproval(turn, pendingAsk.ask_id, cause) + } + + /** + * The server writes the ask row before it publishes the frame, so a poll + * can restore an ask whose broadcast is merely in flight. Only a reconnect + * claims a frame was lost, and only once its own broadcast has had a grace + * window to turn up -- `withdrawLateAskReport` cancels this when it does. + * A hydrate races the same way but never had a dropped socket to blame, so + * it files as a warning immediately. + */ + function reportRestoredApproval( + turn: LiveTurn, + askId: string, + cause: RecoveryCause + ): void { + const lostFrame = cause === 'reconnect' || connection === 'dropped' + if (!lostFrame) { + sendRestoredApprovalReport(turn, askId, cause, 'warning') + return + } + const key = lateAskReportKey(turn.threadId, askId) + withdrawLateAskReport(turn.threadId, askId) + lateAskReports.set(key, { + threadId: turn.threadId, + messageId: turn.messageId, + timer: setTimeout(() => { + lateAskReports.delete(key) + sendRestoredApprovalReport(turn, askId, cause, 'error') + }, LATE_ASK_FRAME_GRACE_MS) + }) + } + + /** + * Routes an inbound `agent_ask`. One already in the ledger is an ask + * recovery has supplied, or one the user has finished with; dropping it on + * the id rather than on the rendered parts is what stops a frame delayed + * past its own resolution from drawing a card over a resumed reply. + * + * A frame is only ledgered once its card is actually on screen. `ingest` + * has nowhere to route one that arrives before its turn is in memory -- the + * window between subscribing and the first history fetch landing -- and + * ledgering a frame the store dropped would convince recovery the ask had + * been delivered, leaving the panel with no card at all. + */ + function deliverAsk( + event: Extract + ): void { + const askId = event.data.ask_id + if (conversationStore.isAskRetired(askId, event.data.thread_id)) { + withdrawLateAskReport(event.data.thread_id, askId) + return + } + const turn = { + threadId: event.data.thread_id, + messageId: toTurnId(event.data.message_id) + } + if ( + deliveredAsks.has(askId) && + (conversationStore.isAskShown(turn, askId) || + conversationStore.submittedAskAnswer(askId) !== undefined) + ) { + withdrawLateAskReport(event.data.thread_id, askId) + return + } + conversationStore.ingest(event) + withdrawLateAskReport(event.data.thread_id, askId) + if (conversationStore.isAskShown(turn, askId)) recordDeliveredAsk(askId) + } + + function withdrawLateAskReport(threadId: string, askId: string): void { + const key = lateAskReportKey(threadId, askId) + const scheduled = lateAskReports.get(key) + if (scheduled === undefined) return + clearTimeout(scheduled.timer) + lateAskReports.delete(key) + } + + function sendRestoredApprovalReport( + turn: LiveTurn, + askId: string, + cause: RecoveryCause, + level: 'error' | 'warning' + ): void { + reportError( + new Error('Agent approval ask was missing from the panel when polled'), + { + surface: 'agent', + errorType: 'failure_delivering_agent_approval_ask', + level, + tags: { + feature_area: 'agent', + operation: 'recovery', + recovery_cause: cause + }, + context: { threadId: turn.threadId, messageId: turn.messageId, askId } + } + ) } function isTurnLive(turn: LiveTurn, generation: number): boolean { @@ -2028,21 +2719,34 @@ export function useAgentSession(deps: AgentSessionDeps) { ) } + function markRecoveredSkillUse( + turn: LiveTurn, + parts: Extract['parts'] + ): void { + if ( + !parts?.some((part) => part.type === 'tool' && part.name === 'load_skill') + ) + return + observeSkillTurn(turn) + const usage = skillTurnUsage.get(recoveryKey(turn)) + if (usage) usage.used = true + } + + function settleTerminalTurn( + turn: LiveTurn, + parts: Extract['parts'], + ending: Extract['ending'] + ): void { + markRecoveredSkillUse(turn, parts) + finishSkillTurn(turn) + conversationStore.settleTurn(turn, parts, ending) + markStoppedTurnReady(turn) + } + function settleFinishedTurn(turn: LiveTurn, outcome: TurnOutcome): boolean { switch (outcome.kind) { case 'terminal': - if ( - outcome.parts?.some( - (part) => part.type === 'tool' && part.name === 'load_skill' - ) - ) { - observeSkillTurn(turn) - const usage = skillTurnUsage.get(recoveryKey(turn)) - if (usage) usage.used = true - } - finishSkillTurn(turn) - conversationStore.settleTurn(turn, outcome.parts, outcome.ending) - markStoppedTurnReady(turn) + settleTerminalTurn(turn, outcome.parts, outcome.ending) return true case 'thread-missing': forgetDeletedThread(turn) @@ -2079,15 +2783,22 @@ export function useAgentSession(deps: AgentSessionDeps) { const anchor = history.find( (entry) => entry.role === 'assistant' && entry.id === turn.messageId ) - if (!anchor) return { kind: 'streaming' } + if (!anchor) return { kind: 'error', message: 'turn row is not visible' } const rows = history .filter( (entry) => entry.role === 'assistant' && entry.turn_id === anchor.turn_id ) .sort((a, b) => a.seq - b.seq) - if (rows.some((row) => !isTerminalTurnStatus(row.status))) - return { kind: 'streaming' } + const latest = rows.at(-1) + if (latest && !isTerminalTurnStatus(latest.status)) + return { + kind: 'streaming', + pendingAsk: rows.findLast( + (row) => + !isTerminalTurnStatus(row.status) && row.pending_ask !== undefined + )?.pending_ask + } return { kind: 'terminal', parts: terminalRecoveryParts(rows), @@ -2101,6 +2812,9 @@ export function useAgentSession(deps: AgentSessionDeps) { function forgetDeletedThread(turn: LiveTurn): void { skillTurnUsage.delete(recoveryKey(turn)) + recoveryPendingAskObservations.delete(recoveryKey(turn)) + recoveryThreadMissingCounts.delete(recoveryKey(turn)) + clearLateAskReports(turn.threadId) if (conversationStore.threadId !== turn.threadId) { conversationStore.settleTurn(turn, undefined, 'failed') return diff --git a/src/workbench/extensions/agent/services/agent/agentEventTransport.test.ts b/src/workbench/extensions/agent/services/agent/agentEventTransport.test.ts index d0648a69da1..76b01d914e0 100644 --- a/src/workbench/extensions/agent/services/agent/agentEventTransport.test.ts +++ b/src/workbench/extensions/agent/services/agent/agentEventTransport.test.ts @@ -662,6 +662,24 @@ describe('agentEventTransport run approval', () => { ]) }) + it('leaves open transcript parts unchanged for a duplicate approval frame', () => { + const message = drive([ + runApproval(), + delta('before the delayed frame'), + runApproval() + ]) + + expect(message.parts).toEqual([ + { + type: 'runApproval', + askId: 'turn-1:call-1', + workflowId: 'workflow-1', + workflowName: 'Portrait workflow' + }, + { type: 'text', text: 'before the delayed frame', state: 'streaming' } + ]) + }) + it('removes only the matching approval when the ask resolves', () => { const message = drive([ runApproval('ask-1'), diff --git a/src/workbench/extensions/agent/services/agent/agentTranscript.test.ts b/src/workbench/extensions/agent/services/agent/agentTranscript.test.ts index 6a20ab95f93..dfb81d6b93d 100644 --- a/src/workbench/extensions/agent/services/agent/agentTranscript.test.ts +++ b/src/workbench/extensions/agent/services/agent/agentTranscript.test.ts @@ -834,6 +834,41 @@ describe('normalizeAgentTranscript', () => { ]) }) + it('keeps an older available approval when the newest streaming row has none', () => { + const first = row(1, 'assistant', 'turn-a', '', 'row-1') + first.status = 'streaming' + first.pending_ask = { + message_id: 'row-1', + ask_id: 'ask-available', + kind: 'run_approval', + prompt: 'Run it?', + options: [], + min_selections: 1, + max_selections: 1, + allow_other: false + } + const second = row(2, 'assistant', 'turn-a', '', 'row-2') + second.status = 'streaming' + second.pending_ask = { + ...first.pending_ask, + message_id: 'row-2', + ask_id: 'ask-retired' + } + const latest = row(3, 'assistant', 'turn-a', '', 'row-3') + latest.status = 'streaming' + + const transcript = normalizeAgentTranscript( + [first, second, latest], + (askId) => askId === 'ask-retired', + (askId) => askId === 'ask-retired' + ) + + expect(transcript.pending?.message.streaming).toBe(true) + expect(transcript.messages[0].parts).toContainEqual( + expect.objectContaining({ askId: 'ask-available' }) + ) + }) + // Only a transport can resolve an ask, and a demoted row is not getting one. // Kept, the card renders enabled and answering it posts against a turn that // is no longer active -- a button that silently does nothing. diff --git a/src/workbench/extensions/agent/services/agent/agentTranscript.ts b/src/workbench/extensions/agent/services/agent/agentTranscript.ts index ea6d0af15c1..2fb58ff1f43 100644 --- a/src/workbench/extensions/agent/services/agent/agentTranscript.ts +++ b/src/workbench/extensions/agent/services/agent/agentTranscript.ts @@ -17,6 +17,7 @@ import type { ToolPart } from './agentMessageParts' import { + askIdOf, createAssistantMessage, isOpenAskPart, toAskOrNoticePart @@ -540,6 +541,46 @@ function recordAssistantRow( return rowPending } +function keepAuthoritativeAsk( + message: AssistantMessage, + row: AgentMessages[number], + isAskUnavailable: (askId: string) => boolean, + isAskRetired: (askId: string) => boolean +): void { + const rowAsk = row.status === 'streaming' ? row.pending_ask : undefined + const priorAvailableAskId = message.parts.findLast((part) => { + const askId = askIdOf(part) + return ( + isOpenAskPart(part) && + askId !== undefined && + askId !== rowAsk?.ask_id && + !isAskUnavailable(askId) + ) + }) + // The snapshot's newest ask stays authoritative even while its answer is + // in flight. Falling back then would resurrect an older card. + const authoritativeAskId = + rowAsk !== undefined && !isAskRetired(rowAsk.ask_id) + ? rowAsk.ask_id + : ((priorAvailableAskId === undefined + ? undefined + : askIdOf(priorAvailableAskId)) ?? rowAsk?.ask_id) + message.parts = message.parts.filter((part) => { + if (!isOpenAskPart(part)) return true + const askId = askIdOf(part) + return askId !== undefined && askId === authoritativeAskId + }) +} + +/** + * Strips the liveness a row's `streaming` status granted a message that turns + * out not to be getting a transport. The parts matter as much as the flag, + * and both kinds this row could have been granted are settled here because a + * transport is the only thing that could have settled either: a still-running + * tool call is clamped, and a `runApproval` ask is dropped the way + * `agent_ask_resolved` drops it -- left in place it renders an enabled card + * whose answer would be posted against a turn that is no longer active. + */ export function settleLiveMessage(message: AssistantMessage): void { message.streaming = false message.parts = message.parts.filter((part) => !isOpenAskPart(part)) @@ -566,7 +607,9 @@ function liveTranscriptTurn( } export function normalizeAgentTranscript( - history: AgentMessages + history: AgentMessages, + isAskUnavailable: (askId: string) => boolean = () => false, + isAskRetired: (askId: string) => boolean = () => false ): NormalizedAgentTranscript { const userTexts = new Map() const userAttachments = new Map() @@ -597,10 +640,11 @@ export function normalizeAgentTranscript( if (workflowId) latestWorkflowId = workflowId } if (row.role === 'assistant') { - pendingByTurn.set( - turnId, - recordAssistantRow(row, turnId, text, assistants) - ) + const pending = recordAssistantRow(row, turnId, text, assistants) + const message = assistants.get(turnId) + if (message) + keepAuthoritativeAsk(message, row, isAskUnavailable, isAskRetired) + pendingByTurn.set(turnId, pending) } } diff --git a/src/workbench/extensions/agent/stores/agent/agentConversationStore.test.ts b/src/workbench/extensions/agent/stores/agent/agentConversationStore.test.ts index 06423dbe5ee..c0a63232131 100644 --- a/src/workbench/extensions/agent/stores/agent/agentConversationStore.test.ts +++ b/src/workbench/extensions/agent/stores/agent/agentConversationStore.test.ts @@ -1079,6 +1079,15 @@ describe('useAgentConversationStore', () => { ])[0] ] store.hydrate(deleteTranscript()) + store.retireAsk('turn-1:call-1', { status: 'retired' }, 'th', false) + store.confirmAskPending('turn-1:call-1', 'th') + expect( + store.messages.flatMap((message) => + message.parts.filter((part) => part.type === 'deleteApproval') + ) + ).toEqual([ + expect.not.objectContaining({ resolution: expect.anything() }) + ]) store.retireAsk( 'turn-1:call-1', { status: 'answered', selected: ['keep'] }, @@ -1221,6 +1230,7 @@ describe('useAgentConversationStore', () => { store.hydrate(parkedTranscript) store.retireAsk('turn-1:call-1', { status: 'retired' }) + store.hydrate(parkedTranscript) store.hydrate(parkedTranscript) expect( @@ -1377,6 +1387,59 @@ describe('useAgentConversationStore', () => { expect(store.isStreaming).toBe(false) }) + it('reset discards foreground ask recovery state', () => { + const store = useAgentConversationStore() + store.setThreadId('foreground') + store.recordAskAnswer('ask-1', { selected: ['run'] }) + store.retireAsk('ask-2', { status: 'retired' }) + + store.reset() + + expect(store.submittedAskAnswer('ask-1')).toBeUndefined() + expect(store.isAskRetired('ask-2', 'foreground')).toBe(false) + }) + + it('reset preserves ask recovery state owned by a background turn', () => { + const store = useAgentConversationStore() + store.setThreadId('background') + store.startTurn(T1) + store.recordAskAnswer('ask-1', { selected: ['run'] }) + store.retireAsk('ask-2', { status: 'retired' }) + store.stashActiveTurn() + + store.reset() + + expect(store.submittedAskAnswer('ask-1')).toEqual({ selected: ['run'] }) + expect(store.isAskRetired('ask-2', 'background')).toBe(true) + }) + + it('does not clear live ask state when a stale turn settlement arrives', () => { + const store = useAgentConversationStore() + store.setThreadId('th') + store.startTurn(T1) + store.recordAskAnswer('ask-1', { selected: ['run'] }, 'th') + store.retireAsk('ask-2', { status: 'retired' }, 'th', false) + + store.settleTurn( + { threadId: 'th', messageId: 'stale' as TurnId }, + undefined + ) + + expect(store.submittedAskAnswer('ask-1')).toEqual({ selected: ['run'] }) + expect(store.isAskRetired('ask-2', 'th')).toBe(true) + }) + + it('clears provisional tombstones when the matching turn settles', () => { + const store = useAgentConversationStore() + store.setThreadId('th') + store.startTurn(T1) + store.retireAsk('ask-2', { status: 'retired' }, 'th', false) + + store.settleTurn({ threadId: 'th', messageId: T1 }, undefined) + + expect(store.isAskRetired('ask-2', 'th')).toBe(false) + }) + it('holds the thread id and clears it on reset', () => { const store = useAgentConversationStore() store.setThreadId('th-7') @@ -1965,6 +2028,56 @@ describe('useAgentConversationStore', () => { expect(store.liveTurns()).toEqual([]) }) + it.for([ + { + name: 'the displayed turn', + turn: { threadId: 'th-front', messageId: T1 }, + askId: 'front-ask', + otherAskId: 'back-ask' + }, + { + name: 'a stashed background turn', + turn: { threadId: 'th-back', messageId: T2 }, + askId: 'back-ask', + otherAskId: 'front-ask' + } + ])( + 'reads back the approval showing on $name, and only that one', + ({ turn, askId, otherAskId }) => { + const store = useAgentConversationStore() + store.setThreadId('th-back') + store.startTurn(T2) + store.recordUser(T2, 'background prompt') + store.ingest(runApproval('t2', 'back-ask')) + store.stashActiveTurn() + store.setThreadId('th-front') + store.hydrate([]) + store.startTurn(T1) + store.recordUser(T1, 'front prompt') + store.ingest(runApproval('t1', 'front-ask')) + + expect(store.isApprovalShown(turn, askId)).toBe(true) + expect(store.isApprovalShown(turn, otherAskId)).toBe(false) + expect(store.isApprovalShown(turn, 'never-delivered')).toBe(false) + } + ) + + it('stops reporting an approval once its turn has settled', () => { + const store = useAgentConversationStore() + const turn = { threadId: 'th', messageId: T1 } + store.setThreadId('th') + store.startTurn(T1) + store.recordUser(T1, 'go') + store.ingest(runApproval('t1', 'ask-1')) + expect(store.isApprovalShown(turn, 'ask-1')).toBe(true) + + store.settleTurn(turn, [ + { type: 'text', text: 'persisted final', state: 'done' } + ]) + + expect(store.isApprovalShown(turn, 'ask-1')).toBe(false) + }) + it.for([ { name: 'the displayed turn', diff --git a/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts b/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts index 7dd353cd3d2..57f759df1ee 100644 --- a/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts +++ b/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts @@ -264,6 +264,8 @@ const MAX_DEPARTED_TURNS = 32 interface SubmittedAskAnswer { answer: AgentAnswerRequest kind: RenderedAskKind | 'unknown' + owner: string + awaitingResolution?: 'accepted' | 'conflict' } export const useAgentConversationStore = defineStore( @@ -515,7 +517,8 @@ export const useAgentConversationStore = defineStore( function retireAsk( askId: string, resolution: AskUserResolution, - owner?: string + owner?: string, + permanent = true ): void { const key = threadKey(owner) if (key === threadKey()) { @@ -530,14 +533,18 @@ export const useAgentConversationStore = defineStore( for (const entry of backgroundTurns.values()) if (entry.threadId === key) entry.transport.retireAskPart(askId, resolution) - const retired = retiredAsksFor(key) - retired.set(askId, settleResolution(retired.get(askId), resolution)) + if (permanent) { + const retired = retiredAsksFor(key) + retired.set(askId, settleResolution(retired.get(askId), resolution)) + provisionalRetiredAsksFor(key).delete(askId) + } else provisionalRetiredAsksFor(key).add(askId) clearAskResolutionWatchdog(askId) submittedAskAnswers.delete(askId) setAskAnswering(askId, false) } const retiredAsks = new Map>() + const provisionalRetiredAsks = new Map>() const threadKey = (owner?: string) => owner ?? threadId.value ?? '' @@ -549,14 +556,60 @@ export const useAgentConversationStore = defineStore( return retired } + function provisionalRetiredAsksFor(owner?: string): Set { + const key = threadKey(owner) + const retired = provisionalRetiredAsks.get(key) ?? new Set() + provisionalRetiredAsks.set(key, retired) + return retired + } + function isAskRetired(askId: string, owner?: string): boolean { + const key = threadKey(owner) + return ( + retiredAsks.get(key)?.has(askId) === true || + provisionalRetiredAsks.get(key)?.has(askId) === true + ) + } + + function confirmAskPending(askId: string, owner?: string): void { + const key = threadKey(owner) + const provisional = provisionalRetiredAsks.get(key) + if (provisional?.delete(askId) !== true) return + if (provisional.size === 0) provisionalRetiredAsks.delete(key) + if (retiredAsks.get(key)?.has(askId) === true) return + const reopen = (message: AssistantMessage): void => { + message.parts = message.parts.map((part) => + (part.type === 'askUser' || part.type === 'deleteApproval') && + askIdOf(part) === askId + ? { ...part, resolution: undefined } + : part + ) + } + if (activeSlot.value?.threadId === key) reopen(activeSlot.value.message) + for (const entry of backgroundTurns.values()) + if (entry.threadId === key) reopen(entry.message) + if (key === threadKey()) messages.value.forEach(reopen) + } + const submittedAskAnswers = new Map() - function recordAskAnswer(askId: string, answer: AgentAnswerRequest): void { + function recordAskAnswer( + askId: string, + answer: AgentAnswerRequest, + owner?: string + ): void { const kind = messages.value .map((message) => askKindOf(message.parts, askId)) .find((found) => found !== undefined) ?? 'unknown' - submittedAskAnswers.set(askId, { answer, kind }) + submittedAskAnswers.set(askId, { + answer, + kind, + owner: threadKey(owner) + }) + } + + function submittedAskAnswer(askId: string): AgentAnswerRequest | undefined { + return submittedAskAnswers.get(askId)?.answer } function takeSubmittedAskAnswer( @@ -567,6 +620,50 @@ export const useAgentConversationStore = defineStore( return answer } + function markAskAwaitingResolution( + askId: string, + kind: 'accepted' | 'conflict' + ): void { + const submitted = submittedAskAnswers.get(askId) + if (submitted) submitted.awaitingResolution = kind + } + + function asksAwaitingResolution(): Array<{ + askId: string + kind: 'accepted' | 'conflict' + }> { + return [...submittedAskAnswers] + .filter(([, submitted]) => submitted.awaitingResolution !== undefined) + .map(([askId, submitted]) => ({ + askId, + kind: submitted.awaitingResolution! + })) + } + + function clearAskAwaitingResolution(askId: string): void { + const submitted = submittedAskAnswers.get(askId) + if (submitted) submitted.awaitingResolution = undefined + } + + function clearSettledAskState(owner: string): void { + provisionalRetiredAsks.delete(owner) + for (const [askId, submitted] of submittedAskAnswers) + if (submitted.owner === owner) submittedAskAnswers.delete(askId) + } + + function discardDetachedAskState(): void { + const retainedThreads = new Set( + [...backgroundTurns.values()].map((turn) => turn.threadId) + ) + for (const owner of retiredAsks.keys()) + if (!retainedThreads.has(owner)) retiredAsks.delete(owner) + for (const owner of provisionalRetiredAsks.keys()) + if (!retainedThreads.has(owner)) provisionalRetiredAsks.delete(owner) + for (const [askId, submitted] of submittedAskAnswers) + if (!retainedThreads.has(submitted.owner)) + submittedAskAnswers.delete(askId) + } + const askResolutionWatchdogs = new Map< string, ReturnType @@ -1092,6 +1189,7 @@ export const useAgentConversationStore = defineStore( turn.threadId === slot.threadId && turn.messageId === slot.turnId if (isActive) { + clearSettledAskState(turn.threadId) finishWithPersistedParts(slot.message, persistedParts) rememberDepartedActiveTurn('settled-turn') slot.transport.settle() @@ -1102,6 +1200,7 @@ export const useAgentConversationStore = defineStore( } const entry = backgroundTurns.get(turn.messageId) if (!entry || entry.messageId !== turn.messageId || entry.settled) return + clearSettledAskState(turn.threadId) finishWithPersistedParts(entry.message, persistedParts) entry.transport.settle() updateBackgroundTurn(entry.messageId, { settled: true }) @@ -1133,6 +1232,84 @@ export const useAgentConversationStore = defineStore( rememberDepartedTurn(slot.threadId, slot.turnId, reason) } + /** + * The mutable message a live turn is written into, not the snapshot copy + * in `messages`: transports emit snapshots, so only this object carries + * parts applied since the last emit. + */ + function liveTurnMessage(turn: LiveTurn): AssistantMessage | null { + const slot = activeSlot.value + if ( + slot !== null && + turn.threadId === slot.threadId && + turn.messageId === slot.turnId + ) + return slot.message + const entry = backgroundTurns.get(turn.messageId) + if ( + !entry || + entry.threadId !== turn.threadId || + entry.messageId !== turn.messageId || + entry.settled + ) + return null + return entry.message + } + + function reconcileApprovalParts( + turn: LiveTurn, + pendingAskId?: string, + protectedAskIds: ReadonlySet = new Set() + ): string[] { + const message = liveTurnMessage(turn) + if (message === null) return [] + const stale = message.parts.flatMap((part) => { + if (!isOpenAskPart(part)) return [] + const askId = askIdOf(part) + return askId !== undefined && + (pendingAskId === undefined || askId !== pendingAskId) && + !protectedAskIds.has(askId) && + submittedAskAnswer(askId) === undefined && + !answeringAskIds.value.has(askId) + ? [askId] + : [] + }) + for (const askId of stale) + retireAsk(askId, { status: 'retired' }, turn.threadId, false) + return stale + } + + /** + * Whether this turn is already showing `askId`. Turn recovery asks before + * re-delivering an ask off a persisted row: the card a hydrate drew is on + * screen without the session's ask ledger ever having seen a frame for + * it, and only this catches that one. Reads the mutable message, so it + * answers for the current moment and takes no reactive dependency. + */ + function isApprovalShown(turn: LiveTurn, askId: string): boolean { + const message = liveTurnMessage(turn) + return ( + message?.parts.some( + (part) => part.type === 'runApproval' && part.askId === askId + ) ?? false + ) + } + + function isAskShown(turn: LiveTurn, askId: string): boolean { + return ( + liveTurnMessage(turn)?.parts.some( + (part) => isOpenAskPart(part) && askIdOf(part) === askId + ) ?? false + ) + } + + function hasApprovalShown(turn: LiveTurn): boolean { + return ( + liveTurnMessage(turn)?.parts.some((part) => isOpenAskPart(part)) ?? + false + ) + } + function clearActive(): void { activeSlot.value = null } @@ -1161,6 +1338,7 @@ export const useAgentConversationStore = defineStore( function reset(): void { disposeActiveAndSettledTransports() + discardDetachedAskState() messages.value = [] userTexts.value = new Map() userTags.value = new Map() @@ -1188,17 +1366,15 @@ export const useAgentConversationStore = defineStore( transcript: ReturnType ): void { const retired = retiredAsksFor() - if (retired.size === 0) return - const named = new Set( - transcript.messages.flatMap((message) => - message.parts.flatMap((part) => askIdOf(part) ?? []) - ) - ) - for (const askId of retired.keys()) - if (!named.has(askId)) retired.delete(askId) + const provisional = provisionalRetiredAsksFor() for (const message of transcript.messages) for (const [askId, resolution] of retired) message.parts = retireAskParts(message.parts, askId, resolution) + for (const message of transcript.messages) + for (const askId of provisional) + message.parts = retireAskParts(message.parts, askId, { + status: 'retired' + }) } function hydrate(history: AgentMessages): void { @@ -1206,7 +1382,14 @@ export const useAgentConversationStore = defineStore( if (replacedSlot) rememberDepartedActiveTurn('no-live-turn') disposeActiveAndSettledTransports() clearActive() - const transcript = normalizeAgentTranscript(history) + const transcript = normalizeAgentTranscript( + history, + (askId) => + isAskRetired(askId) || + submittedAskAnswer(askId) !== undefined || + answeringAskIds.value.has(askId), + (askId) => isAskRetired(askId) + ) reapplyRetiredAsks(transcript) messages.value = transcript.messages resolvedPaywallIds.value = new Set() @@ -1355,6 +1538,23 @@ export const useAgentConversationStore = defineStore( ) } + function askKind( + askId: string + ): 'runApproval' | 'askUser' | 'deleteApproval' | undefined { + for (const message of messages.value) { + const part = message.parts.find( + (candidate) => + isPendingAskPart(candidate) && candidate.askId === askId + ) + if ( + part?.type === 'runApproval' || + part?.type === 'askUser' || + part?.type === 'deleteApproval' + ) + return part.type + } + } + const activeMessageId = computed(() => activeMessage.value?.id ?? null) const isStreaming = computed(() => activeMessage.value?.streaming ?? false) @@ -1434,9 +1634,17 @@ export const useAgentConversationStore = defineStore( answeringAskIds, setAskAnswering, recordAskAnswer, + submittedAskAnswer, takeSubmittedAskAnswer, + markAskAwaitingResolution, + asksAwaitingResolution, + clearAskAwaitingResolution, + askKind, commitAsk, retireAsk, + isAskRetired, + confirmAskPending, + reconcileApprovalParts, startTurn, ingest, setCanvasSyncGate, @@ -1450,6 +1658,9 @@ export const useAgentConversationStore = defineStore( turnUsesSkill, historySkillNames, settleTurn, + isApprovalShown, + isAskShown, + hasApprovalShown, reset, hydrate }