diff --git a/browser_tests/tests/agent/agentPanel.spec.ts b/browser_tests/tests/agent/agentPanel.spec.ts index ee391aac436..c9787270d5f 100644 --- a/browser_tests/tests/agent/agentPanel.spec.ts +++ b/browser_tests/tests/agent/agentPanel.spec.ts @@ -214,6 +214,38 @@ test.describe('In-App Agent panel', { tag: '@cloud' }, () => { await expect(paywall).toContainText('Add credits to continue.') }) + test('keeps a failed prompt available to retry', async ({ + agentPanel, + comfyPage + }) => { + // Regression: https://github.com/Comfy-Org/ComfyUI_frontend/pull/16628 + await comfyPage.page.route( + '**/api/agent/threads/*/messages', + async (route) => { + if (route.request().method() !== 'POST') return route.fallback() + await route.fulfill({ + status: 500, + body: 'Agent temporarily unavailable' + }) + } + ) + await agentPanel.open() + await agentPanel.selectWorkflow() + + const prompt = 'Build a product photo workflow' + await agentPanel.composer.fill(prompt) + await agentPanel.sendButton.click() + + await expect(agentPanel.root.getByTestId('user-message-bubble')).toHaveText( + prompt + ) + await expect( + agentPanel.root.getByText(enMessages.agent.sendFailed) + ).toBeVisible() + await expect(agentPanel.composer).toHaveText(prompt) + await expect(agentPanel.sendButton).toBeEnabled() + }) + test.describe('composer sizing', () => { test.use({ viewport: { width: 1920, height: 1080 }, diff --git a/src/platform/telemetry/TelemetryRegistry.ts b/src/platform/telemetry/TelemetryRegistry.ts index ca0246850bf..8a6156a484d 100644 --- a/src/platform/telemetry/TelemetryRegistry.ts +++ b/src/platform/telemetry/TelemetryRegistry.ts @@ -8,6 +8,7 @@ import type { AgentPaywallCtaMetadata, AgentPaywallShownMetadata, AgentEntryButtonClickedMetadata, + AgentErrorMetadata, AgentMessageSentMetadata, AgentMessageFeedbackMetadata, AgentNodeTaggedMetadata, @@ -445,6 +446,10 @@ export class TelemetryRegistry implements TelemetryDispatcher { this.dispatch((provider) => provider.trackAgentWorkflowApplied?.(metadata)) } + trackAgentError(metadata: AgentErrorMetadata): void { + this.dispatch((provider) => provider.trackAgentError?.(metadata)) + } + trackAgentStopClicked(metadata: AgentStopClickedMetadata): void { this.dispatch((provider) => provider.trackAgentStopClicked?.(metadata)) } diff --git a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts index 0d30e28437d..d3668520fba 100644 --- a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts +++ b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts @@ -20,6 +20,7 @@ import type { AgentConsentResolvedMetadata, AgentConsentShownMetadata, AgentEntryButtonClickedMetadata, + AgentErrorMetadata, AgentPaywallCtaMetadata, AgentPaywallShownMetadata, AgentMessageSentMetadata, @@ -803,6 +804,10 @@ export class PostHogTelemetryProvider implements TelemetryProvider { this.trackEvent(TelemetryEvents.AGENT_WORKFLOW_APPLIED, metadata) } + trackAgentError(metadata: AgentErrorMetadata): void { + this.trackEvent(TelemetryEvents.AGENT_ERROR, metadata) + } + trackAgentStopClicked(metadata: AgentStopClickedMetadata): void { this.trackEvent(TelemetryEvents.AGENT_STOP_CLICKED, metadata) } diff --git a/src/platform/telemetry/types.ts b/src/platform/telemetry/types.ts index 50d2775901b..3b733f8f931 100644 --- a/src/platform/telemetry/types.ts +++ b/src/platform/telemetry/types.ts @@ -958,6 +958,23 @@ export interface AgentThreadStartedMetadata extends Record { source: AgentThreadStartSource } +export type AgentErrorClass = + | 'request_failed' + | 'malformed_stream_event' + | 'cancel_failed' + | 'history_load_failed' + | 'ask_answer_failed' + | 'thread_list_load_failed' + | 'workflow_open_failed' +export interface AgentErrorMetadata extends Record { + error_class: AgentErrorClass + failure_stage: 'pre_acceptance' | 'post_acceptance' + retryable: boolean + turn_accepted: boolean + /** `none` is a failure the user was never shown. */ + ui_treatment: 'inline_notice' | 'error_overlay' | 'toast' | 'none' +} + /** * Widget (input/parameter) favorite toggle tracking metadata. * Used to measure discoverability of the right side panel favoriting feature. @@ -1691,6 +1708,7 @@ export interface TelemetryProvider { metadata: AgentAttachButtonClickedMetadata ): void trackAgentWorkflowApplied?(metadata: AgentWorkflowAppliedMetadata): void + trackAgentError?(metadata: AgentErrorMetadata): void trackAgentStopClicked?(metadata: AgentStopClickedMetadata): void trackAgentWorkflowBound?(metadata: AgentWorkflowBoundMetadata): void trackAgentRunApprovalShown?(metadata: AgentRunApprovalShownMetadata): void @@ -1880,6 +1898,7 @@ export const TelemetryEvents = { AGENT_NODE_TAGGED: 'app:agent_node_tagged', AGENT_ATTACH_BUTTON_CLICKED: 'app:agent_attach_button_clicked', AGENT_WORKFLOW_APPLIED: 'app:agent_workflow_applied', + AGENT_ERROR: 'app:agent_error', AGENT_STOP_CLICKED: 'app:agent_stop_clicked', AGENT_WORKFLOW_BOUND: 'app:agent_workflow_bound', AGENT_RUN_APPROVAL_SHOWN: 'app:agent_run_approval_shown', diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index cb213ec0c7c..9f0453560f5 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -1540,7 +1540,8 @@ describe('useWorkflowService', () => { await vi.waitFor(() => expect(app.loadGraphData).toHaveBeenCalledTimes(2)) const staleOpen = service.openWorkflow(closing) resolveReplacement?.() - await Promise.all([secondClose, staleOpen]) + await expect(staleOpen).resolves.toBe(false) + await secondClose expect(app.loadGraphData).toHaveBeenCalledTimes(2) expect(workflowStore.openWorkflows).not.toContain(closing) diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index 2257a1d650f..c1d0503a275 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -359,9 +359,9 @@ export const useWorkflowService = () => { * Open a workflow in the current workspace * @param workflow The workflow to open * @param options The options for opening the workflow - * @returns false when the graph load reported failure (the error - * dialog was shown and the workflow never painted) or when the open - * was skipped because the workflow is mid-close; true otherwise + * @returns false when the graph load reported failure (the error dialog was + * shown and the workflow never painted) or when the open was skipped because + * the workflow is mid-close; true otherwise */ /** * A failed replacement load leaves the shared root graph cleaned or diff --git a/src/workbench/extensions/agent/AgentPanelRoot.test.ts b/src/workbench/extensions/agent/AgentPanelRoot.test.ts index a265c7206c7..d89b7df17fd 100644 --- a/src/workbench/extensions/agent/AgentPanelRoot.test.ts +++ b/src/workbench/extensions/agent/AgentPanelRoot.test.ts @@ -57,6 +57,7 @@ import { useToastStore } from '@/platform/updates/common/toastStore' import { useAssetsStore } from '@/stores/assetsStore' import { getFilenameDetails } from '@/utils/formatUtil' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' +import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' import type { LoadedComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore' // eslint-disable-next-line import-x/no-restricted-paths import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' @@ -1460,6 +1461,15 @@ describe('AgentPanelRoot session notices', () => { type: 'agent_api_failed', details: i18n.global.t('agent.malformedEvent') }) + expect(telemetry.trackAgentError).toHaveBeenCalledWith( + expect.objectContaining({ + error_class: 'malformed_stream_event', + failure_stage: 'pre_acceptance', + retryable: false, + turn_accepted: false, + ui_treatment: 'error_overlay' + }) + ) }) }) @@ -3157,6 +3167,7 @@ describe('AgentPanelRoot history', () => { it('surfaces a thread-list failure via the host error modal', async () => { executionErrors.showErrorOverlay.mockClear() + telemetry.trackAgentError.mockClear() vi.stubGlobal( 'fetch', vi.fn(async () => new Response('{}', { status: 500 })) @@ -3170,6 +3181,15 @@ describe('AgentPanelRoot history', () => { expect(executionErrors.lastPromptError).toMatchObject({ type: 'agent_api_failed' }) + expect(telemetry.trackAgentError).toHaveBeenCalledWith( + expect.objectContaining({ + error_class: 'thread_list_load_failed', + failure_stage: 'pre_acceptance', + retryable: true, + turn_accepted: false, + ui_treatment: 'error_overlay' + }) + ) expect(useAgentChatHistoryStore().sessions).toHaveLength(0) }) @@ -5587,6 +5607,27 @@ describe('AgentPanelRoot workflow binding', () => { ) }) + it('agent_active_tab reports when a bound tab cannot be opened', async () => { + makeTab('wf-42') + mockMessagesEndpoint('wf-42') + await renderAndSend('work here') + telemetry.trackAgentError.mockClear() + vi.mocked(useWorkflowService()).openWorkflow.mockResolvedValueOnce(false) + + ws.emit('agent_active_tab', { workflow_id: 'wf-42', thread_id: 'th-1' }) + + await vi.waitFor(() => + expect(telemetry.trackAgentError).toHaveBeenCalledWith( + expect.objectContaining({ + error_class: 'workflow_open_failed', + retryable: true, + ui_treatment: 'toast' + }) + ) + ) + expect(useTelemetry()!.trackAgentWorkflowApplied).not.toHaveBeenCalled() + }) + // A browser tab closed without the SPA's own unbind() left 'wf-abandoned' // bound to the default unsaved path in localStorage, and the thread pointer // survived beside it. On the next boot the thread hydrates and names that @@ -6024,12 +6065,14 @@ describe('AgentPanelRoot workflow binding', () => { ) }) - it('agent_active_tab closes the minted tab when opening it fails', async () => { + it('agent_active_tab reports when a minted tab cannot be opened', async () => { makeTab('wf-42') mockMessagesEndpoint('wf-42') await renderAndSend('work here') - workflowService.openWorkflow.mockRejectedValueOnce(new Error('disk full')) + telemetry.trackAgentError.mockClear() + vi.mocked(useWorkflowService()).openWorkflow.mockResolvedValueOnce(false) + vi.useFakeTimers() ws.emit('agent_active_tab', { workflow_id: 'wf-77', @@ -6047,14 +6090,25 @@ describe('AgentPanelRoot workflow binding', () => { workflowStore.getWorkflowByPath('workflows/Video test.json') ).toBeNull() ) + expect(telemetry.trackAgentError).toHaveBeenCalledWith( + expect.objectContaining({ + error_class: 'workflow_open_failed', + retryable: true, + ui_treatment: 'toast' + }) + ) }) - it('agent_active_tab closes the minted tab when opening it reports failure', async () => { + it('agent_active_tab closes the minted tab when opening it throws', async () => { makeTab('wf-42') mockMessagesEndpoint('wf-42') await renderAndSend('work here') - workflowService.openWorkflow.mockResolvedValueOnce(false) + telemetry.trackAgentError.mockClear() + vi.mocked(useWorkflowService()).openWorkflow.mockRejectedValueOnce( + new Error('open boom') + ) + vi.useFakeTimers() ws.emit('agent_active_tab', { workflow_id: 'wf-77', @@ -6075,7 +6129,16 @@ describe('AgentPanelRoot workflow binding', () => { expect( useAgentWorkflowTabBindingStore().tabPathFor('wf-77') ).toBeUndefined() - expect(telemetry.trackAgentWorkflowApplied).not.toHaveBeenCalled() + expect(useTelemetry()!.trackAgentWorkflowApplied).not.toHaveBeenCalled() + expect(telemetry.trackAgentError).toHaveBeenCalledWith( + expect.objectContaining({ + error_class: 'workflow_open_failed', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + ) }) it('agent_active_tab strips dotfile prefixes hidden behind whitespace', async () => { diff --git a/src/workbench/extensions/agent/AgentPanelRoot.vue b/src/workbench/extensions/agent/AgentPanelRoot.vue index a34edd7611f..5f918f275ad 100644 --- a/src/workbench/extensions/agent/AgentPanelRoot.vue +++ b/src/workbench/extensions/agent/AgentPanelRoot.vue @@ -18,7 +18,9 @@ import { useI18n } from 'vue-i18n' import { useCurrentUser } from '@/composables/auth/useCurrentUser' import { useTelemetry } from '@/platform/telemetry' +import { reportError } from '@/platform/telemetry/reportError' import type { + AgentErrorMetadata, AgentMessageSentMetadata, AgentRunApprovalDecision, AgentStopMethod @@ -103,7 +105,11 @@ import type { import type { CoachStep } from './composables/agent/useOnboarding' import { useAgentWorkflowResolver } from './composables/agent/useAgentWorkflowResolver' import { useAgentWorkflowSelection } from './composables/agent/useAgentWorkflowSelection' -import { useAgentSession } from './composables/agent/useAgentSession' +import { + isRetryableRequestFailure, + trackAgentError, + useAgentSession +} from './composables/agent/useAgentSession' import { useAgentDraftSubmission } from './composables/agent/useAgentDraftSubmission' import { useAgentWorkflowTabBindingStore } from './stores/agent/agentWorkflowTabBindingStore' import { createAgentRestClient } from './services/agent/agentRestClient' @@ -668,6 +674,15 @@ function warnWorkflowUnavailable(): void { }) } +function trackWorkflowOpenFailure( + uiTreatment: AgentErrorMetadata['ui_treatment'], + retryable = false +): void { + trackAgentError('workflow_open_failed', 'post_acceptance', uiTreatment, { + retryable + }) +} + /** * The sent message, held from the moment the user sends until the cloud ids * are refreshed, alongside the turn's origin. Scoped to one `sendMessage` @@ -1009,71 +1024,91 @@ async function onAgentActiveTab( if (stale()) return false try { const bound = boundOrOpenWorkflowFor(data.workflow_id) - if (bound) { - const opened = await workflowService.openWorkflow(bound) - if (stale()) return false - if (!opened) { - warnWorkflowUnavailable() - return false - } - // boundOrOpenWorkflowFor can resolve by cloud name, which leaves no binding behind - // for everything downstream that only reads tabPathFor. - bindingStore.bind(data.workflow_id, bound.path) - if (status.value !== 'idle') tabActivity.setEditing(bound.path) - bindWorkflow(data.workflow_id) - reportWorkflowBound(data.workflow_id, previousWorkflowId, 'active_tab') - useTelemetry()?.trackAgentWorkflowApplied({ - workflow_id: data.workflow_id, - target: 'active_tab_switch' - }) - return true - } - const creatingStartedAt = Date.now() - tabActivity.setCreating(true) - const remainingCreatingTime = - CREATING_TAB_MIN_DURATION_MS - (Date.now() - creatingStartedAt) - if (remainingCreatingTime > 0) - await new Promise((resolve) => setTimeout(resolve, remainingCreatingTime)) - if (stale()) return false - const tab = workflowStore.createNewTemporary( - agentTabFilename(data.name), - agentTabGraph - ) - tabActivity.setCreating(false) - let opened: boolean - try { - opened = await workflowService.openWorkflow(tab) - } catch (error) { - await workflowService.closeWorkflow(tab, { warnIfUnsaved: false }) - throw error - } - if (stale() || !opened) { - await workflowService.closeWorkflow(tab, { warnIfUnsaved: false }) - if (!stale()) warnWorkflowUnavailable() - return false - } - if (status.value !== 'idle') tabActivity.setEditing(tab.path) - bindingStore.bind(data.workflow_id, tab.path) - bindWorkflow(data.workflow_id) - reportWorkflowBound(data.workflow_id, previousWorkflowId, 'active_tab') - useTelemetry()?.trackAgentWorkflowApplied({ - workflow_id: data.workflow_id, - target: 'active_tab_open' - }) - return true + return bound + ? await activateExistingAgentTab(data, bound, previousWorkflowId, stale) + : await createAndActivateAgentTab(data, previousWorkflowId, stale) } catch (error) { if (stale()) return false bindWorkflow(data.workflow_id) + reportError(error, { errorType: 'agent_workflow_open_failed' }) surfaceAgentError( 'agent_api_failed', error instanceof Error ? error.message : String(error) ) + trackWorkflowOpenFailure('error_overlay') return false } finally { tabActivity.setCreating(false) } } +async function activateExistingAgentTab( + data: AgentActiveTabData, + bound: ComfyWorkflow, + previousWorkflowId: string | null, + stale: () => boolean +): Promise { + const opened = await workflowService.openWorkflow(bound) + if (stale()) return false + if (!opened) { + warnWorkflowUnavailable() + trackWorkflowOpenFailure('toast', true) + return false + } + bindingStore.bind(data.workflow_id, bound.path) + if (status.value !== 'idle') tabActivity.setEditing(bound.path) + bindWorkflow(data.workflow_id) + reportWorkflowBound(data.workflow_id, previousWorkflowId, 'active_tab') + useTelemetry()?.trackAgentWorkflowApplied({ + workflow_id: data.workflow_id, + target: 'active_tab_switch' + }) + return true +} + +async function createAndActivateAgentTab( + data: AgentActiveTabData, + previousWorkflowId: string | null, + stale: () => boolean +): Promise { + const creatingStartedAt = Date.now() + tabActivity.setCreating(true) + const remainingCreatingTime = + CREATING_TAB_MIN_DURATION_MS - (Date.now() - creatingStartedAt) + if (remainingCreatingTime > 0) + await new Promise((resolve) => setTimeout(resolve, remainingCreatingTime)) + if (stale()) return false + const tab = workflowStore.createNewTemporary( + agentTabFilename(data.name), + agentTabGraph + ) + tabActivity.setCreating(false) + let opened: boolean + try { + opened = await workflowService.openWorkflow(tab) + } catch (error) { + await workflowService.closeWorkflow(tab, { warnIfUnsaved: false }) + throw error + } + if (stale() || !opened) { + await workflowService.closeWorkflow(tab, { warnIfUnsaved: false }) + if (!stale()) { + warnWorkflowUnavailable() + trackWorkflowOpenFailure('toast', true) + } + return false + } + if (status.value !== 'idle') tabActivity.setEditing(tab.path) + bindingStore.bind(data.workflow_id, tab.path) + bindWorkflow(data.workflow_id) + reportWorkflowBound(data.workflow_id, previousWorkflowId, 'active_tab') + useTelemetry()?.trackAgentWorkflowApplied({ + workflow_id: data.workflow_id, + target: 'active_tab_open' + }) + return true +} + function onApprovalShown( askId: string, turnId: string, @@ -1172,10 +1207,17 @@ async function refreshHistory(): Promise { try { history.replaceAll((await listThreads()).map(toChatSession)) } catch (error) { + reportError(error, { errorType: 'agent_thread_list_load_failed' }) surfaceAgentError( 'agent_api_failed', error instanceof Error ? error.message : String(error) ) + trackAgentError( + 'thread_list_load_failed', + 'pre_acceptance', + 'error_overlay', + { retryable: isRetryableRequestFailure(error, false) } + ) } } diff --git a/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts b/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts index 349ebcaab3b..bd4ffa39ec9 100644 --- a/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts +++ b/src/workbench/extensions/agent/composables/agent/useAgentSession.test.ts @@ -21,9 +21,13 @@ import type { } from '../../schemas/agentApiSchema' import { zAgentAdmissionError, + zAgentTurnAccepted, zAgentWsEvent } from '../../schemas/agentApiSchema' -import { AgentApiError } from '../../services/agent/agentRestClient' +import { + AgentApiError, + AgentResponseUnreadableError +} from '../../services/agent/agentRestClient' import type { AgentRestClient, PostMessageInput @@ -2885,3 +2889,548 @@ describe('thread resume (B17)', () => { expect(threads[0]).toMatchObject({ id: 'th-9', title: 'build a duck' }) }) }) + +describe('app:agent_error telemetry (TEL-8)', () => { + beforeEach(() => { + localStorage.clear() + telemetry.trackAgentError.mockClear() + vi.mocked(reportError).mockClear() + }) + + it('reports unexpected agent failures to the unified error sinks', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ + getMessages: vi.fn(async () => { + throw new Error('history boom') + }), + cancelMessage: vi.fn(async () => { + throw new AgentApiError('cancel boom', 500, null) + }) + }), + events: source + }) + session.start() + await session.loadThread('th-9') + await session.sendMessage('go') + await session.stopTurn() + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + + const errorTypes = vi + .mocked(reportError) + .mock.calls.map(([, options]) => options.errorType) + expect(errorTypes).toEqual([ + 'agent_history_load_failed', + 'agent_cancel_turn_failed', + 'agent_malformed_stream_event' + ]) + }) + + it('dedupes interleaved malformed frames per turn in A-B-A order', async () => { + const postMessage = vi + .fn< + (threadId: string, req: PostMessageInput) => Promise + >() + .mockResolvedValueOnce({ thread_id: 'th-1', message_id: 'msg-1' }) + .mockResolvedValueOnce({ thread_id: 'th-2', message_id: 'msg-2' }) + const { source, emit } = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ postMessage }), + events: source + }) + session.start() + await session.sendMessage('first') + await session.loadThread('th-2') + await session.sendMessage('second') + telemetry.trackAgentError.mockClear() + + emit({ type: 'agent_message_delta', data: { message_id: 'msg-2' } }) + emit({ type: 'agent_message_delta', data: { message_id: 'msg-1' } }) + emit({ type: 'agent_message_delta', data: { message_id: 'msg-2' } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledTimes(2) + }) + + it('reports idle malformed frames again after switching threads', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + await session.loadThread('th-2') + emit({ type: 'agent_message_done', data: { thread_id: 'th-2' } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledTimes(2) + }) + + it('groups malformed frames under one Sentry issue, detail in context', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + + const [error, options] = vi.mocked(reportError).mock.calls[0] + expect((error as Error).message).toBe('Malformed agent stream event') + expect(options.tags?.event_type).toBe('agent_message_done') + expect(options.context?.issues).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + code: expect.any(String), + path: expect.any(Array), + message: expect.any(String) + }) + ]) + ) + for (const issue of (options.context?.issues ?? []) as object[]) + expect(Object.keys(issue).sort()).toEqual(['code', 'message', 'path']) + }) + + it('reports a rejected send to the unified error sinks', async () => { + const rest = fakeRest({ + postMessage: vi.fn(async () => { + throw new AgentApiError('boom', 500, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + await session.sendMessage('make me a cat') + + expect(reportError).toHaveBeenCalledWith(expect.any(AgentApiError), { + errorType: 'agent_send_message_failed' + }) + }) + + it('keeps the expected 404 history and 409 cancel races out of the sinks', async () => { + const session = useAgentSession({ + rest: fakeRest({ + getMessages: vi.fn(async () => { + throw new AgentApiError('gone', 404, null) + }), + cancelMessage: vi.fn(async () => { + throw new AgentApiError('already done', 409, null) + }) + }), + events: fakeEvents().source + }) + session.start() + await session.loadThread('th-gone') + await session.sendMessage('go') + await session.stopTurn() + + expect(reportError).not.toHaveBeenCalled() + }) + + it('tracks a pre-acceptance request failure from a rejected postMessage', async () => { + const rest = fakeRest({ + postMessage: vi.fn(async () => { + throw new AgentApiError('boom', 500, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + const ok = await session.sendMessage('make me a cat') + + expect(ok).toBe(false) + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'request_failed', + failure_stage: 'pre_acceptance', + retryable: true, + turn_accepted: false, + ui_treatment: 'inline_notice' + }) + }) + + it('marks a deterministic send rejection unretryable', async () => { + const rest = fakeRest({ + postMessage: vi.fn(async () => { + throw new AgentApiError('unprocessable', 422, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + await session.sendMessage('make me a cat') + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'request_failed', + failure_stage: 'pre_acceptance', + retryable: false, + turn_accepted: false, + ui_treatment: 'inline_notice' + }) + }) + + it('classifies a failure after the ack as post-acceptance and unretryable', async () => { + const rest = fakeRest() + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + const setItem = vi + .spyOn(globalThis.localStorage, 'setItem') + .mockImplementation(() => { + throw new DOMException('quota', 'QuotaExceededError') + }) + + try { + const ok = await session.sendMessage('make me a cat') + expect(ok).toBe(true) + } finally { + setItem.mockRestore() + } + + expect(rest.postMessage).toHaveBeenCalledTimes(1) + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'request_failed', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'inline_notice' + }) + }) + + it('treats an unreadable ack body as an accepted turn', async () => { + const rest = fakeRest({ + postMessage: vi.fn(async () => { + // What a 2xx with an unexpected body raises past `response.ok`. + return zAgentTurnAccepted.parse({ thread_id: 'th-1' }) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + expect(await session.sendMessage('make me a cat')).toBe(true) + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'request_failed', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'inline_notice' + }) + }) + + it('treats an ack body the client could not read as an accepted turn', async () => { + const rest = fakeRest({ + postMessage: vi.fn(async () => { + throw new AgentResponseUnreadableError( + '/agent/threads/new/messages', + new SyntaxError('Unexpected end of JSON input') + ) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + expect(await session.sendMessage('make me a cat')).toBe(true) + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'request_failed', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'inline_notice' + }) + }) + + it('reports a stashed live turn when the resume history load fails', async () => { + const getMessages = vi + .fn() + .mockRejectedValue(new Error('history boom')) + const session = useAgentSession({ + rest: fakeRest({ getMessages }), + events: fakeEvents().source + }) + session.start() + await session.sendMessage('go') + expect(useAgentConversationStore().activeTurnId).not.toBeNull() + + await session.loadThread('th-other') + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'history_load_failed', + failure_stage: 'pre_acceptance', + retryable: true, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + }) + + it('does not count a busy-state double-submit as an agent error', async () => { + let resolvePost: (value: AgentTurnAccepted) => void = () => undefined + const rest = fakeRest({ + postMessage: vi.fn( + () => + new Promise((resolve) => { + resolvePost = resolve + }) + ) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + const first = session.sendMessage('first') + const ok = await session.sendMessage('second') + + expect(ok).toBe(false) + expect(telemetry.trackAgentError).not.toHaveBeenCalled() + resolvePost({ thread_id: 'th-1', message_id: 'msg-1' }) + await first + }) + + it('tracks a post-acceptance cancel failure', async () => { + const rest = fakeRest({ + cancelMessage: vi.fn(async () => { + throw new AgentApiError('cancel boom', 500, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + await session.sendMessage('go') + + await session.stopTurn() + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'cancel_failed', + failure_stage: 'post_acceptance', + retryable: true, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + }) + + it('does not track a 409 cancel race as an error', async () => { + const rest = fakeRest({ + cancelMessage: vi.fn(async () => { + throw new AgentApiError('already done', 409, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + await session.sendMessage('go') + + await session.stopTurn() + + expect(telemetry.trackAgentError).not.toHaveBeenCalled() + }) + + it('tracks a post-acceptance malformed stream event for the active turn', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + await session.sendMessage('go') + + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'malformed_stream_event', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + }) + + it('does not claim an accepted turn for a malformed frame on an idle session', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'malformed_stream_event', + failure_stage: 'pre_acceptance', + retryable: false, + turn_accepted: false, + ui_treatment: 'error_overlay' + }) + }) + + it('bounds a repeating malformed stream to one report per turn', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + await session.sendMessage('go') + + for (let i = 0; i < 20; i++) + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + + // The aborted turn, then the idle session the other nineteen arrived into. + expect(telemetry.trackAgentError).toHaveBeenCalledTimes(2) + expect(session.notices.value).toHaveLength(2) + }) + + it('does not trust attacker-controlled message ids as telemetry keys', () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + + for (let i = 0; i < 100; i++) + emit({ type: 'agent_message_delta', data: { message_id: `spoof-${i}` } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledTimes(1) + }) + + it('tracks malformed frames of event types that never reach the user', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + await session.sendMessage('go') + + emit({ type: 'agent_message_delta', data: { thread_id: 'th-1' } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'malformed_stream_event', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'none' + }) + expect(session.notices.value).toEqual([]) + }) + + it('still reports the frame that escalates to the user after a silent one', async () => { + const { source, emit } = fakeEvents() + const session = useAgentSession({ rest: fakeRest(), events: source }) + session.start() + await session.sendMessage('go') + + emit({ type: 'agent_message_delta', data: { thread_id: 'th-1' } }) + emit({ type: 'agent_message_done', data: { thread_id: 'th-1' } }) + + expect(telemetry.trackAgentError).toHaveBeenCalledTimes(2) + expect(telemetry.trackAgentError).toHaveBeenLastCalledWith({ + error_class: 'malformed_stream_event', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + }) + + it('tracks a pre-acceptance thread-history load failure', async () => { + const rest = fakeRest({ + getMessages: vi.fn(async () => { + throw new Error('history boom') + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + await session.loadThread('th-9') + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'history_load_failed', + failure_stage: 'pre_acceptance', + retryable: true, + turn_accepted: false, + ui_treatment: 'error_overlay' + }) + }) + + it('tracks a failed ask answer, which leaves the running turn blocked', async () => { + const answerAsk = vi + .fn() + .mockRejectedValue(new AgentApiError('ask boom', 500, null)) + const { source, emit } = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ answerAsk }), + events: source + }) + session.start() + await session.sendMessage('build it') + emit(runApproval('msg-1')) + telemetry.trackAgentError.mockClear() + + await session.answerAsk('turn-1:call-1', 'run') + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'ask_answer_failed', + failure_stage: 'post_acceptance', + retryable: true, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + }) + + it('does not track a 409 stale ask answer as an error', async () => { + const answerAsk = vi + .fn() + .mockRejectedValue(new AgentApiError('already answered', 409, undefined)) + const { source, emit } = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ answerAsk }), + events: source + }) + session.start() + await session.sendMessage('build it') + emit(runApproval('msg-1')) + telemetry.trackAgentError.mockClear() + + await session.answerAsk('turn-1:call-1', 'cancel') + + expect(telemetry.trackAgentError).not.toHaveBeenCalled() + }) + + it('marks a 403 ask-answer failure as non-retryable', async () => { + const answerAsk = vi + .fn() + .mockRejectedValue(new AgentApiError('forbidden', 403, undefined)) + const { source, emit } = fakeEvents() + const session = useAgentSession({ + rest: fakeRest({ answerAsk }), + events: source + }) + session.start() + await session.sendMessage('build it') + emit(runApproval('msg-1')) + telemetry.trackAgentError.mockClear() + + await session.answerAsk('turn-1:call-1', 'run') + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'ask_answer_failed', + failure_stage: 'post_acceptance', + retryable: false, + turn_accepted: true, + ui_treatment: 'error_overlay' + }) + }) + + it('derives history-load retryability from the status, as request_failed does', async () => { + const rest = fakeRest({ + getMessages: vi.fn(async () => { + throw new AgentApiError('access denied', 403, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + await session.loadThread('th-9') + + expect(telemetry.trackAgentError).toHaveBeenCalledWith({ + error_class: 'history_load_failed', + failure_stage: 'pre_acceptance', + retryable: false, + turn_accepted: false, + ui_treatment: 'error_overlay' + }) + }) + + it('does not track a 404 thread-not-found history load as an error', async () => { + const rest = fakeRest({ + getMessages: vi.fn(async () => { + throw new AgentApiError('gone', 404, null) + }) + }) + const session = useAgentSession({ rest, events: fakeEvents().source }) + session.start() + + await session.loadThread('th-gone') + + expect(telemetry.trackAgentError).not.toHaveBeenCalled() + expect(localStorage.getItem('Comfy.Agent.ThreadId')).toBeNull() + }) +}) diff --git a/src/workbench/extensions/agent/composables/agent/useAgentSession.ts b/src/workbench/extensions/agent/composables/agent/useAgentSession.ts index cc8e61138eb..8e3b0fa58ad 100644 --- a/src/workbench/extensions/agent/composables/agent/useAgentSession.ts +++ b/src/workbench/extensions/agent/composables/agent/useAgentSession.ts @@ -1,8 +1,11 @@ import { computed, ref } from 'vue' +import { ZodError } from 'zod' import { i18n } from '@/i18n' import { reportError } from '@/platform/telemetry/reportError' import type { + AgentErrorClass, + AgentErrorMetadata, AgentStopClickedMetadata, AgentStopMethod, AgentThreadStartSource, @@ -23,7 +26,10 @@ import { zAgentAdmissionError, zDisownedWorkflowError } from '../../schemas/agentApiSchema' -import { AgentApiError } from '../../services/agent/agentRestClient' +import { + AgentApiError, + AgentResponseUnreadableError +} from '../../services/agent/agentRestClient' import type { AgentRestClient, DraftSnapshot, @@ -118,6 +124,46 @@ export interface AgentSessionDeps { const THREAD_STORAGE_KEY = 'Comfy.Agent.ThreadId' const PREPARE_TIMEOUT_MS = 3000 +const NON_RETRYABLE_REQUEST_STATUSES = new Set([ + 400, 401, 403, 404, 405, 409, 410, 422 +]) + +export function isRetryableRequestFailure( + error: unknown, + accepted: boolean +): boolean { + if (accepted) return false + if ( + error instanceof ZodError || + error instanceof AgentResponseUnreadableError + ) + return false + if (error instanceof AgentApiError) + return !NON_RETRYABLE_REQUEST_STATUSES.has(error.status) + return true +} + +function isUnreadableAckFailure(error: unknown): boolean { + return ( + error instanceof ZodError || error instanceof AgentResponseUnreadableError + ) +} + +export function trackAgentError( + errorClass: AgentErrorClass, + stage: AgentErrorMetadata['failure_stage'], + uiTreatment: AgentErrorMetadata['ui_treatment'], + overrides: { retryable?: boolean; turnAccepted?: boolean } = {} +): void { + useTelemetry()?.trackAgentError({ + error_class: errorClass, + failure_stage: stage, + retryable: overrides.retryable ?? stage === 'pre_acceptance', + turn_accepted: overrides.turnAccepted ?? stage === 'post_acceptance', + ui_treatment: uiTreatment + }) +} + let sessionGeneration = 0 /** @@ -242,6 +288,44 @@ export function useAgentSession(deps: AgentSessionDeps) { notices.value.push({ level: 'error', text }) } + const malformedStreamReports = new Map() + + function trackMalformedStreamEvent( + cause: ZodError, + eventType: string, + turnId: TurnId | null, + uiTreatment: AgentErrorMetadata['ui_treatment'] + ): boolean { + const visible = uiTreatment !== 'none' + const priorVisible = malformedStreamReports.get(turnId) + if (priorVisible === true || (priorVisible === false && !visible)) + return false + if ( + !malformedStreamReports.has(turnId) && + malformedStreamReports.size >= 32 + ) + return false + malformedStreamReports.set(turnId, visible) + reportError(new Error('Malformed agent stream event'), { + errorType: 'agent_malformed_stream_event', + tags: { ui_treatment: uiTreatment, event_type: eventType }, + context: { + issues: cause.issues.slice(0, 10).map(({ code, path, message }) => ({ + code, + path, + message + })) + } + }) + trackAgentError( + 'malformed_stream_event', + turnId === null ? 'pre_acceptance' : 'post_acceptance', + uiTreatment, + { retryable: false } + ) + return true + } + function start(): void { ownedGeneration = ++sessionGeneration everLive = false @@ -266,8 +350,9 @@ export function useAgentSession(deps: AgentSessionDeps) { const generation = ++loadGeneration const isCurrent = () => generation === loadGeneration && ownedGeneration === sessionGeneration + const stashedTurn = conversationStore.activeTurnId !== null conversationStore.stashActiveTurn() - void hydrateFromServer(surviving, isCurrent).then(() => { + void hydrateFromServer(surviving, isCurrent, stashedTurn).then(() => { if (isCurrent() && conversationStore.threadId === surviving) conversationStore.resumeBackgroundTurn() }) @@ -286,7 +371,8 @@ export function useAgentSession(deps: AgentSessionDeps) { async function hydrateFromServer( threadId: string, - isCurrent: () => boolean = () => true + isCurrent: () => boolean = () => true, + stashedTurn = false ): Promise { try { const history = await rest.getMessages(threadId) @@ -296,16 +382,30 @@ export function useAgentSession(deps: AgentSessionDeps) { if (conversationStore.threadId !== threadId || !isCurrent()) return false return true } catch (error) { - if (!isCurrent()) return false - if (error instanceof AgentApiError && error.status === 404) { - if (conversationStore.threadId === threadId) - conversationStore.setThreadId(null) - localStorage.removeItem(THREAD_STORAGE_KEY) - return false - } - pushError(error instanceof Error ? error.message : String(error)) + return handleHistoryLoadError(error, threadId, isCurrent, stashedTurn) + } + } + + function handleHistoryLoadError( + error: unknown, + threadId: string, + isCurrent: () => boolean, + stashedTurn: boolean + ): false { + if (!isCurrent()) return false + if (error instanceof AgentApiError && error.status === 404) { + if (conversationStore.threadId === threadId) + conversationStore.setThreadId(null) + localStorage.removeItem(THREAD_STORAGE_KEY) return false } + reportError(error, { errorType: 'agent_history_load_failed' }) + pushError(error instanceof Error ? error.message : String(error)) + trackAgentError('history_load_failed', 'pre_acceptance', 'error_overlay', { + retryable: isRetryableRequestFailure(error, false), + turnAccepted: stashedTurn + }) + return false } function stop(): void { @@ -518,7 +618,11 @@ export function useAgentSession(deps: AgentSessionDeps) { if (pendingStop !== null) void stopTurn(pendingStop.method) } - function recordSendError(error: unknown, text: string): void { + function recordSendError( + error: unknown, + text: string, + accepted: boolean + ): boolean { const admission = parseAdmissionError(error) if (admission?.reason === 'no_funds') { conversationStore.recordPaywall( @@ -526,7 +630,7 @@ export function useAgentSession(deps: AgentSessionDeps) { text, admission.message ) - return + return false } if (admission !== undefined) { conversationStore.recordFailedSend( @@ -537,7 +641,7 @@ export function useAgentSession(deps: AgentSessionDeps) { ? admission.retryAfterSeconds : undefined ) - return + return false } const message = error instanceof AgentApiError @@ -550,6 +654,20 @@ export function useAgentSession(deps: AgentSessionDeps) { text, `${i18n.global.t('agent.sendFailed')}: ${message}` ) + const turnAccepted = accepted || isUnreadableAckFailure(error) + const disowned = + error instanceof AgentApiError && + error.status === 403 && + zDisownedWorkflowError.safeParse(error.body).success + if (!disowned) + reportError(error, { errorType: 'agent_send_message_failed' }) + trackAgentError( + 'request_failed', + turnAccepted ? 'post_acceptance' : 'pre_acceptance', + 'inline_notice', + { retryable: isRetryableRequestFailure(error, turnAccepted) } + ) + return turnAccepted } function releaseDisownedWorkflow( @@ -582,6 +700,7 @@ export function useAgentSession(deps: AgentSessionDeps) { const origin: TurnOrigin = originContext === undefined ? null : { tabPath: originContext.tabPath } let sentContext: WorkflowTurnContext | undefined + let accepted = false try { await prepareWorkflow() if (sendWasSuperseded(generation)) return false @@ -601,14 +720,14 @@ export function useAgentSession(deps: AgentSessionDeps) { workflowReferences, selectionWorkflowId ) - if (sendWasSuperseded(generation)) return false + accepted = true + if (generation !== loadGeneration) return false acceptTurn(ack, text, wfContext, attachments, tags, workflowReferences) return true } catch (error) { releaseDisownedWorkflow(sentContext, error) - if (sendWasSuperseded(generation)) return false - recordSendError(error, text) - return false + if (generation !== loadGeneration) return false + return recordSendError(error, text, accepted) } } @@ -691,11 +810,19 @@ export function useAgentSession(deps: AgentSessionDeps) { if (error instanceof AgentApiError) { if (error.status === 409) return promptEditState.value = { phase: 'idle' } + reportError(error, { errorType: 'agent_cancel_turn_failed' }) pushError(error.message) + trackAgentError('cancel_failed', 'post_acceptance', 'error_overlay', { + retryable: isRetryableRequestFailure(error, false) + }) return } promptEditState.value = { phase: 'idle' } + reportError(error, { errorType: 'agent_cancel_turn_failed' }) pushError(error instanceof Error ? error.message : String(error)) + trackAgentError('cancel_failed', 'post_acceptance', 'error_overlay', { + retryable: true + }) } async function stopTurn(method?: AgentStopMethod): Promise { @@ -756,6 +883,9 @@ export function useAgentSession(deps: AgentSessionDeps) { } reportError(error, { errorType: 'agent_ask_answer_failed' }) pushError(error instanceof Error ? error.message : String(error)) + trackAgentError('ask_answer_failed', 'post_acceptance', 'error_overlay', { + retryable: isRetryableRequestFailure(error, false) + }) return false } } @@ -772,6 +902,7 @@ export function useAgentSession(deps: AgentSessionDeps) { boundWorkflowId.value = null rememberedWorkflowId = null pendingWorkflowBind = null + malformedStreamReports.clear() localStorage.removeItem(THREAD_STORAGE_KEY) pendingThreadSource.value = source ?? null } @@ -785,13 +916,15 @@ export function useAgentSession(deps: AgentSessionDeps) { promptEditState.value = { phase: 'idle' } const isCurrent = () => generation === loadGeneration && ownedGeneration === sessionGeneration + const stashedTurn = conversationStore.activeTurnId !== null conversationStore.stashActiveTurn() boundWorkflowId.value = null rememberedWorkflowId = null pendingWorkflowBind = null + malformedStreamReports.clear() conversationStore.setThreadId(threadId) localStorage.setItem(THREAD_STORAGE_KEY, threadId) - const hydrated = await hydrateFromServer(threadId, isCurrent) + const hydrated = await hydrateFromServer(threadId, isCurrent, stashedTurn) if (hydrated && isCurrent()) conversationStore.resumeBackgroundTurn() return hydrated && isCurrent() } @@ -807,19 +940,30 @@ export function useAgentSession(deps: AgentSessionDeps) { function handleMalformedEvent( type: string, raw: object, - error: unknown + error: ZodError ): void { const turnId = malformedEventTurnId(raw) + let reportedTurnId = + turnId !== undefined && conversationStore.hasPendingTurn(turnId) + ? turnId + : conversationStore.activeTurnId + let uiTreatment: AgentErrorMetadata['ui_treatment'] = 'none' if (type === 'agent_message_done') { if (turnId !== undefined) turnStartedAt.delete(turnId) if (turnId === undefined || turnId === conversationStore.activeTurnId) { forgetActiveTurnStartedAt() conversationStore.abortActiveTurn() - pushError(i18n.global.t('agent.malformedEvent')) + uiTreatment = 'error_overlay' } else { - conversationStore.settleBackgroundTurn(turnId) + reportedTurnId = + conversationStore.settleBackgroundTurn(turnId) ?? reportedTurnId } } + if ( + trackMalformedStreamEvent(error, type, reportedTurnId, uiTreatment) && + uiTreatment === 'error_overlay' + ) + pushError(i18n.global.t('agent.malformedEvent')) console.warn('[agent] dropping malformed agent event', error) } diff --git a/src/workbench/extensions/agent/services/agent/agentRestClient.test.ts b/src/workbench/extensions/agent/services/agent/agentRestClient.test.ts index 8624ba4e545..1fb94c96aff 100644 --- a/src/workbench/extensions/agent/services/agent/agentRestClient.test.ts +++ b/src/workbench/extensions/agent/services/agent/agentRestClient.test.ts @@ -7,7 +7,11 @@ const fetchApi = vi.hoisted(() => ) vi.mock('@/scripts/api', () => ({ api: { fetchApi } })) -import { AgentApiError, createAgentRestClient } from './agentRestClient' +import { + AgentApiError, + AgentResponseUnreadableError, + createAgentRestClient +} from './agentRestClient' import type { AgentRestClient } from './agentRestClient' function jsonResponse( @@ -387,6 +391,22 @@ describe('error mapping', () => { expect(error).toBeInstanceOf(Error) expect(error).not.toBeInstanceOf(AgentApiError) }) + + it('distinguishes a truncated 2xx body from a rejected request', async () => { + respond( + new Response('{"message_id":"m1","thread_', { + status: 202, + headers: { 'Content-Type': 'application/json' } + }) + ) + + const error = await makeClient() + .postMessage('t1', { content: 'hi' }) + .catch((e: unknown) => e) + + expect(error).toBeInstanceOf(AgentResponseUnreadableError) + expect(error).not.toBeInstanceOf(AgentApiError) + }) }) describe('Retry-After contract', () => { diff --git a/src/workbench/extensions/agent/services/agent/agentRestClient.ts b/src/workbench/extensions/agent/services/agent/agentRestClient.ts index 07204085471..256d50285b8 100644 --- a/src/workbench/extensions/agent/services/agent/agentRestClient.ts +++ b/src/workbench/extensions/agent/services/agent/agentRestClient.ts @@ -48,6 +48,13 @@ export class AgentApiError extends Error { } } +export class AgentResponseUnreadableError extends Error { + constructor(route: string, cause: unknown) { + super(`Unreadable agent response body from ${route}`, { cause }) + this.name = 'AgentResponseUnreadableError' + } +} + export type OpenTabsSnapshot = Pick< AgentPostMessageRequest, 'open_tabs' | 'current_tab' @@ -337,7 +344,13 @@ export function createAgentRestClient() { ): Promise { const response = await api.fetchApi(route, init) if (!response.ok) throw await toApiError(response) - return schema.parse(await response.json()) + let payload: unknown + try { + payload = await response.json() + } catch (error) { + throw new AgentResponseUnreadableError(route, error) + } + return schema.parse(payload) } function jsonInit(method: string, body: unknown): RequestInit { diff --git a/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts b/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts index a77e2d1636d..4a6e387cf18 100644 --- a/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts +++ b/src/workbench/extensions/agent/stores/agent/agentConversationStore.ts @@ -388,7 +388,7 @@ export const useAgentConversationStore = defineStore( return true } - function settleBackgroundTurn(turnId: string): void { + function settleBackgroundTurn(turnId: string): TurnId | null { for (const [key, entry] of backgroundTurns) { if (entry.messageId !== turnId) continue entry.transport.settle() @@ -397,8 +397,16 @@ export const useAgentConversationStore = defineStore( // will keep it reachable afterwards, so flush its held parts now. entry.transport.dispose() backgroundTurns.delete(key) - return + return entry.messageId } + return null + } + + function hasPendingTurn(turnId: string): boolean { + if (activeTurnId.value === turnId) return true + for (const entry of backgroundTurns.values()) + if (entry.messageId === turnId) return true + return false } function dropBackgroundTurns(): void { @@ -551,6 +559,7 @@ export const useAgentConversationStore = defineStore( stashActiveTurn, resumeBackgroundTurn, settleBackgroundTurn, + hasPendingTurn, dropBackgroundTurns, reset, hydrate