fix(main): cancel nested vision work

Author: zerob13

src/main/presenter/deepchatAgentPresenter/index.ts

@@ -108,6 +108,16 @@ const isReasoningEffort = (value: unknown): value is 'minimal' | 'low' | 'medium
 const isVerbosity = (value: unknown): value is 'low' | 'medium' | 'high' =>
   value === 'low' || value === 'medium' || value === 'high'
 
+const createAbortError = (): Error => {
+  if (typeof DOMException !== 'undefined') {
+    return new DOMException('Aborted', 'AbortError')
+  }
+
+  const error = new Error('Aborted')
+  error.name = 'AbortError'
+  return error
+}
+
 export class DeepChatAgentPresenter implements IAgentImplementation {
   private readonly llmProviderPresenter: ILlmProviderPresenter
   private readonly configPresenter: IConfigPresenter
@@ -1012,6 +1022,23 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
     return undefined
   }
 
+  private getAbortSignalForSession(sessionId: string): AbortSignal | undefined {
+    return (
+      this.activeGenerations.get(sessionId)?.abortController.signal ??
+      this.abortControllers.get(sessionId)?.signal
+    )
+  }
+
+  private throwIfAbortRequested(signal?: AbortSignal): void {
+    if (signal?.aborted) {
+      throw createAbortError()
+    }
+  }
+
+  private isAbortError(error: unknown): boolean {
+    return error instanceof Error && (error.name === 'AbortError' || error.name === 'CanceledError')
+  }
+
   private dispatchResolvedToolHook(params: {
     sessionId: string
     messageId: string
@@ -1433,7 +1460,8 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
               toolName: tool.toolName,
               toolArgs: tool.toolArgs,
               content: tool.content,
-              isError: tool.isError
+              isError: tool.isError,
+              abortSignal: abortController.signal
             })
         },
         io: {
@@ -2883,7 +2911,8 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
         toolName,
         toolArgs: toolCall.params || '{}',
         content: rawData.content,
-        isError: rawData.isError === true
+        isError: rawData.isError === true,
+        abortSignal: this.getAbortSignalForSession(sessionId)
       })
       const responseText = this.toolContentToText(normalizedContent)
       const prepared = await this.toolOutputGuard.prepareToolOutput({
@@ -2981,11 +3010,13 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
     toolArgs: string
     content: MCPToolResponse['content']
     isError: boolean
+    abortSignal?: AbortSignal
   }): Promise<MCPToolResponse['content']> {
     if (params.isError) {
       return params.content
     }
 
+    const abortSignal = params.abortSignal ?? this.getAbortSignalForSession(params.sessionId)
     const screenshotPayload = this.extractScreenshotToolPayload(
       params.toolName,
       params.toolArgs,
@@ -2995,12 +3026,15 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
       return params.content
     }
 
-    const visionModel = await this.resolveScreenshotVisionModel(params.sessionId)
-    if (!visionModel) {
-      return 'Screenshot captured, but automatic English analysis is unavailable because neither the current session model nor the agent vision model can analyze images.'
-    }
-
     try {
+      this.throwIfAbortRequested(abortSignal)
+      const visionModel = await this.resolveScreenshotVisionModel(params.sessionId, abortSignal)
+      this.throwIfAbortRequested(abortSignal)
+
+      if (!visionModel) {
+        return 'Screenshot captured, but automatic English analysis is unavailable because neither the current session model nor the agent vision model can analyze images.'
+      }
+
       const messages: ChatMessage[] = [
         {
           role: 'user',
@@ -3029,14 +3063,20 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
         messages,
         visionModel.modelId,
         modelConfig?.temperature ?? 0.2,
-        Math.min(modelConfig?.maxTokens ?? 900, 900)
+        Math.min(modelConfig?.maxTokens ?? 900, 900),
+        abortSignal ? { signal: abortSignal } : undefined
       )
+      this.throwIfAbortRequested(abortSignal)
       const normalized = response.trim()
       if (!normalized) {
         return 'Screenshot captured, but automatic English analysis returned no usable description.'
       }
       return normalized
     } catch (error) {
+      if (this.isAbortError(error)) {
+        return 'Screenshot captured, but automatic English analysis was canceled.'
+      }
+
       const message = error instanceof Error ? error.message : String(error)
       console.warn('[DeepChatAgent] Failed to normalize screenshot tool output:', {
         sessionId: params.sessionId,
@@ -3110,8 +3150,10 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
   }
 
   private async resolveScreenshotVisionModel(
-    sessionId: string
+    sessionId: string,
+    abortSignal?: AbortSignal
   ): Promise<{ providerId: string; modelId: string } | null> {
+    this.throwIfAbortRequested(abortSignal)
     const state = this.runtimeState.get(sessionId)
     const dbSession = this.sessionStore.get(sessionId)
     const agentId = this.getSessionAgentId(sessionId) ?? 'deepchat'
@@ -3120,8 +3162,10 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
       modelId: state?.modelId ?? dbSession?.model_id,
       agentId,
       configPresenter: this.configPresenter,
+      signal: abortSignal,
       logLabel: `screenshot:${sessionId}`
     })
+    this.throwIfAbortRequested(abortSignal)
 
     if (!resolved) {
       return null
@@ -3130,6 +3174,7 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
     if (resolved.source === 'agent-vision-model') {
       const agentSupportsVision =
         (await this.configPresenter.agentSupportsCapability?.(agentId, 'vision')) === true
+      this.throwIfAbortRequested(abortSignal)
       if (!agentSupportsVision) {
         return null
       }

src/main/presenter/llmProviderPresenter/index.ts

@@ -33,6 +33,16 @@ import { AcpSessionPersistence } from './acp'
 import { AcpProvider } from './providers/acpProvider'
 import type { ProviderMcpRuntimePort } from './runtimePorts'
 
+const createAbortError = (): Error => {
+  if (typeof DOMException !== 'undefined') {
+    return new DOMException('Aborted', 'AbortError')
+  }
+
+  const error = new Error('Aborted')
+  error.name = 'AbortError'
+  return error
+}
+
 export class LLMProviderPresenter implements ILlmProviderPresenter {
   private currentProviderId: string | null = null
   private readonly activeStreams: Map<string, StreamState> = new Map()
@@ -258,16 +268,37 @@ export class LLMProviderPresenter implements ILlmProviderPresenter {
     messages: ChatMessage[],
     modelId: string,
     temperature?: number,
-    maxTokens?: number
+    maxTokens?: number,
+    options?: { signal?: AbortSignal }
   ): Promise<string> {
     const provider = this.getProviderInstance(providerId)
     let response = ''
+    const signal = options?.signal
+
+    if (signal?.aborted) {
+      throw createAbortError()
+    }
+
+    const completionPromise = provider.completions(messages, modelId, temperature, maxTokens)
+    const abortPromise =
+      signal &&
+      new Promise<never>((_, reject) => {
+        const onAbort = () => reject(createAbortError())
+        signal.addEventListener('abort', onAbort, { once: true })
+        completionPromise.finally(() => signal.removeEventListener('abort', onAbort))
+      })
+
     try {
-      const llmResponse = await provider.completions(messages, modelId, temperature, maxTokens)
+      const llmResponse = await (abortPromise
+        ? Promise.race([completionPromise, abortPromise])
+        : completionPromise)
       response = llmResponse.content
 
       return response
     } catch (error) {
+      if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
+        throw error
+      }
       console.error('Stream error:', error)
       return ''
     }

src/main/presenter/vision/sessionVisionResolver.ts

@@ -10,16 +10,34 @@ type SessionVisionResolverParams = {
   providerId?: string | null
   modelId?: string | null
   agentId?: string | null
+  signal?: AbortSignal
   configPresenter: Pick<
     IConfigPresenter,
     'getModelConfig' | 'resolveDeepChatAgentConfig' | 'isKnownModel'
   >
   logLabel?: string
 }
 
+const createAbortError = (): Error => {
+  if (typeof DOMException !== 'undefined') {
+    return new DOMException('Aborted', 'AbortError')
+  }
+
+  const error = new Error('Aborted')
+  error.name = 'AbortError'
+  return error
+}
+
+const throwIfAbortRequested = (signal?: AbortSignal): void => {
+  if (signal?.aborted) {
+    throw createAbortError()
+  }
+}
+
 export async function resolveSessionVisionTarget(
   params: SessionVisionResolverParams
 ): Promise<SessionVisionTarget | null> {
+  throwIfAbortRequested(params.signal)
   const sessionProviderId = params.providerId?.trim()
   const sessionModelId = params.modelId?.trim()
   const sessionModelConfig =
@@ -46,7 +64,9 @@ export async function resolveSessionVisionTarget(
   }
 
   try {
+    throwIfAbortRequested(params.signal)
     const agentConfig = await params.configPresenter.resolveDeepChatAgentConfig(agentId)
+    throwIfAbortRequested(params.signal)
     const providerId = agentConfig.visionModel?.providerId?.trim()
     const modelId = agentConfig.visionModel?.modelId?.trim()
     if (providerId && modelId) {
@@ -57,6 +77,9 @@ export async function resolveSessionVisionTarget(
       }
     }
   } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      throw error
+    }
     console.warn('[Vision] Failed to resolve agent vision model:', {
       agentId,
       context: params.logLabel ?? 'unknown',

src/shared/types/presenters/legacy.presenters.d.ts

@@ -1159,7 +1159,8 @@ export interface ILlmProviderPresenter {
     messages: ChatMessage[],
     modelId: string,
     temperature?: number,
-    maxTokens?: number
+    maxTokens?: number,
+    options?: { signal?: AbortSignal }
   ): Promise<string>
   getAcpWorkdir(conversationId: string, agentId: string): Promise<AcpWorkdirInfo>
   setAcpWorkdir(conversationId: string, agentId: string, workdir: string | null): Promise<void>

src/shared/types/presenters/llmprovider.presenter.d.ts

@@ -269,7 +269,8 @@ export interface ILlmProviderPresenter {
     messages: ChatMessage[],
     modelId: string,
     temperature?: number,
-    maxTokens?: number
+    maxTokens?: number,
+    options?: { signal?: AbortSignal }
   ): Promise<string>
 
   getAcpWorkdir(conversationId: string, agentId: string): Promise<AcpWorkdirInfo>

test/main/presenter/configPresenter/anthropicProviderMigration.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { eventBus } from '@/eventbus'
 import { CONFIG_EVENTS } from '../../../../src/main/events'
 
@@ -155,6 +155,10 @@ describe('getAnthropicModelSelectionKeysToClear', () => {
 })
 
 describe('migrateLegacyDefaultVisionModelToBuiltinAgent', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
   it('migrates a valid legacy vision model with trimmed ids', () => {
     const store = {
       get: vi.fn().mockReturnValue({ providerId: ' openai ', modelId: ' gpt-4o ' }),

test/main/presenter/deepchatAgentPresenter/deepchatAgentPresenter.test.ts

@@ -2846,7 +2846,8 @@ describe('DeepChatAgentPresenter', () => {
         ],
         'gpt-4o',
         expect.any(Number),
-        expect.any(Number)
+        expect.any(Number),
+        undefined
       )
       expect(configPresenter.resolveDeepChatAgentConfig).not.toHaveBeenCalled()
       expect(result).toEqual(
@@ -2896,11 +2897,30 @@ describe('DeepChatAgentPresenter', () => {
         expect.any(Array),
         'gemini-2.5-flash',
         expect.any(Number),
-        expect.any(Number)
+        expect.any(Number),
+        undefined
       )
       expect(normalized).toBe('English screenshot summary')
     })
 
+    it('returns a cancellation message when screenshot normalization is aborted', async () => {
+      const abortController = new AbortController()
+      abortController.abort()
+
+      const normalized = await (agent as any).normalizeToolResultContent({
+        sessionId: 's1',
+        toolCallId: 'tc1',
+        toolName: 'cdp_send',
+        toolArgs: '{"method":"Page.captureScreenshot"}',
+        content: '{"data":"YWJj"}',
+        isError: false,
+        abortSignal: abortController.signal
+      })
+
+      expect(llmProvider.generateCompletionStandalone).not.toHaveBeenCalled()
+      expect(normalized).toBe('Screenshot captured, but automatic English analysis was canceled.')
+    })
+
     it('ignores fallback agent vision models when the agent does not support vision', async () => {
       sqlitePresenter.newSessionsTable.get.mockReturnValue({
         id: 's1',