fix(main): harden vision resolution

Author: zerob13

src/main/presenter/configPresenter/index.ts

@@ -153,6 +153,15 @@ const isModelSelection = (value: unknown): value is ModelSelection => {
   return typeof record.providerId === 'string' && typeof record.modelId === 'string'
 }
 
+const normalizeKnownModelId = (modelId: string): string => {
+  const normalizedModelId = modelId.trim().toLowerCase()
+  return normalizedModelId.replace(/^models\//, '')
+}
+
+const normalizeKnownProviderId = (providerId: string): string =>
+  modelCapabilities.resolveProviderId(providerId.trim().toLowerCase()) ||
+  providerId.trim().toLowerCase()
+
 export const getAnthropicModelSelectionKeysToClear = (
   settings: Partial<
     Record<
@@ -398,16 +407,20 @@ export class ConfigPresenter implements IConfigPresenter {
   }
 
   private migrateLegacyDefaultVisionModelToBuiltinAgent(): void {
-    const legacySelection = this.store.get('defaultVisionModel') as ModelSelection | undefined
-    if (!legacySelection) {
+    const legacySelection = this.store.get('defaultVisionModel') as unknown
+    if (legacySelection === undefined) {
       return
     }
 
-    const providerId = legacySelection.providerId?.trim()
-    const modelId = legacySelection.modelId?.trim()
     const builtinVisionModel = this.getBuiltinDeepChatConfig().visionModel
 
-    if (!builtinVisionModel?.providerId || !builtinVisionModel?.modelId) {
+    if (
+      isModelSelection(legacySelection) &&
+      (!builtinVisionModel?.providerId || !builtinVisionModel?.modelId)
+    ) {
+      const providerId = legacySelection.providerId.trim()
+      const modelId = legacySelection.modelId.trim()
+
       if (providerId && modelId) {
         this.updateBuiltinDeepChatConfig({
           visionModel: {
@@ -1036,6 +1049,26 @@ export class ConfigPresenter implements IConfigPresenter {
     return this.providerModelHelper.getCustomModels(providerId)
   }
 
+  isKnownModel(providerId: string, modelId: string): boolean {
+    const normalizedProviderId = normalizeKnownProviderId(providerId)
+    const normalizedModelId = normalizeKnownModelId(modelId)
+
+    if (!normalizedProviderId || !normalizedModelId) {
+      return false
+    }
+
+    const hasKnownModel = (models: Array<{ id: string }> | undefined): boolean =>
+      Array.isArray(models) &&
+      models.some((model) => normalizeKnownModelId(model.id) === normalizedModelId)
+
+    return (
+      this.hasUserModelConfig(normalizedModelId, normalizedProviderId) ||
+      hasKnownModel(this.getProviderModels(normalizedProviderId)) ||
+      hasKnownModel(this.getCustomModels(normalizedProviderId)) ||
+      hasKnownModel(this.getDbProviderModels(normalizedProviderId))
+    )
+  }
+
   setCustomModels(providerId: string, models: MODEL_META[]): void {
     this.providerModelHelper.setCustomModels(providerId, models)
   }
@@ -1709,6 +1742,18 @@ export class ConfigPresenter implements IConfigPresenter {
     )
   }
 
+  async agentSupportsCapability(agentId: string, capability: 'vision'): Promise<boolean> {
+    if (capability !== 'vision') {
+      return false
+    }
+
+    const agentConfig = await this.resolveDeepChatAgentConfig(agentId)
+    const providerId = agentConfig.visionModel?.providerId?.trim()
+    const modelId = agentConfig.visionModel?.modelId?.trim()
+
+    return Boolean(providerId && modelId && this.getModelConfig(modelId, providerId)?.vision)
+  }
+
   async createDeepChatAgent(input: CreateDeepChatAgentInput): Promise<Agent> {
     const created = this.getAgentRepositoryOrThrow().createDeepChatAgent(input)
     this.notifyAcpAgentsChanged()

src/main/presenter/deepchatAgentPresenter/index.ts

@@ -3114,10 +3114,11 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
   ): Promise<{ providerId: string; modelId: string } | null> {
     const state = this.runtimeState.get(sessionId)
     const dbSession = this.sessionStore.get(sessionId)
+    const agentId = this.getSessionAgentId(sessionId) ?? 'deepchat'
     const resolved = await resolveSessionVisionTarget({
       providerId: state?.providerId ?? dbSession?.provider_id,
       modelId: state?.modelId ?? dbSession?.model_id,
-      agentId: this.getSessionAgentId(sessionId) ?? 'deepchat',
+      agentId,
       configPresenter: this.configPresenter,
       logLabel: `screenshot:${sessionId}`
     })
@@ -3126,6 +3127,14 @@ export class DeepChatAgentPresenter implements IAgentImplementation {
       return null
     }
 
+    if (resolved.source === 'agent-vision-model') {
+      const agentSupportsVision =
+        (await this.configPresenter.agentSupportsCapability?.(agentId, 'vision')) === true
+      if (!agentSupportsVision) {
+        return null
+      }
+    }
+
     return {
       providerId: resolved.providerId,
       modelId: resolved.modelId

src/main/presenter/index.ts

@@ -260,24 +260,16 @@ export class Presenter implements IPresenter {
         return null
       },
       resolveConversationSessionInfo: async (conversationId) => {
-        try {
-          const session = await this.newAgentPresenter?.getSession(conversationId)
-          if (!session) {
-            return null
-          }
-
-          return {
-            agentId: session.agentId,
-            providerId: session.providerId,
-            modelId: session.modelId
-          }
-        } catch (error) {
-          console.warn('[Presenter] Failed to resolve new session info:', {
-            conversationId,
-            error
-          })
+        const session = await this.newAgentPresenter?.getSession(conversationId)
+        if (!session) {
           return null
         }
+
+        return {
+          agentId: session.agentId,
+          providerId: session.providerId,
+          modelId: session.modelId
+        }
       },
       getSkillPresenter: () => this.skillPresenter,
       getYoBrowserToolHandler: () => this.yoBrowserPresenter.toolHandler,

src/main/presenter/toolPresenter/agentTools/agentToolManager.ts

@@ -1071,7 +1071,18 @@ export class AgentToolManager {
   ): Promise<string> {
     const fileBuffer = await fs.promises.readFile(filePath)
     const metadata = this.buildImageMetadataBlock(filePath, mimeType, fileBuffer.length)
-    const visionTarget = await this.resolveVisionTargetForConversation(conversationId)
+    let visionTarget: Awaited<ReturnType<typeof this.resolveVisionTargetForConversation>>
+
+    try {
+      visionTarget = await this.resolveVisionTargetForConversation(conversationId)
+    } catch (error) {
+      logger.warn('[AgentToolManager] Failed to resolve vision target for image read:', {
+        conversationId,
+        filePath,
+        error
+      })
+      throw error
+    }
 
     if (!visionTarget) {
       return `${metadata}\n\nImage analysis unavailable because neither the current session model nor the agent vision model can analyze images.`
@@ -1133,11 +1144,11 @@ export class AgentToolManager {
         logLabel: `read:${conversationId}`
       })
     } catch (error) {
-      logger.warn('[AgentToolManager] Failed to resolve vision target for conversation:', {
-        conversationId,
-        error
-      })
-      return null
+      if (this.isConversationNotFoundError(error)) {
+        return null
+      }
+
+      throw error
     }
   }
 

src/main/presenter/vision/sessionVisionResolver.ts

@@ -10,7 +10,10 @@ type SessionVisionResolverParams = {
   providerId?: string | null
   modelId?: string | null
   agentId?: string | null
-  configPresenter: Pick<IConfigPresenter, 'getModelConfig' | 'resolveDeepChatAgentConfig'>
+  configPresenter: Pick<
+    IConfigPresenter,
+    'getModelConfig' | 'resolveDeepChatAgentConfig' | 'isKnownModel'
+  >
   logLabel?: string
 }
 
@@ -19,11 +22,16 @@ export async function resolveSessionVisionTarget(
 ): Promise<SessionVisionTarget | null> {
   const sessionProviderId = params.providerId?.trim()
   const sessionModelId = params.modelId?.trim()
+  const sessionModelConfig =
+    sessionProviderId && sessionModelId
+      ? params.configPresenter.getModelConfig(sessionModelId, sessionProviderId)
+      : null
 
   if (
     sessionProviderId &&
     sessionModelId &&
-    params.configPresenter.getModelConfig(sessionModelId, sessionProviderId)?.vision
+    params.configPresenter.isKnownModel?.(sessionProviderId, sessionModelId) === true &&
+    sessionModelConfig?.vision
   ) {
     return {
       providerId: sessionProviderId,

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

@@ -650,6 +650,7 @@ export interface IConfigPresenter {
   getAgentType(agentId: string): Promise<AgentType | null>
   getDeepChatAgentConfig(agentId: string): Promise<DeepChatAgentConfig | null>
   resolveDeepChatAgentConfig(agentId: string): Promise<DeepChatAgentConfig>
+  agentSupportsCapability?(agentId: string, capability: 'vision'): Promise<boolean>
   createDeepChatAgent(input: CreateDeepChatAgentInput): Promise<Agent>
   updateDeepChatAgent(agentId: string, updates: UpdateDeepChatAgentInput): Promise<Agent | null>
   deleteDeepChatAgent(agentId: string): Promise<boolean>
@@ -666,6 +667,7 @@ export interface IConfigPresenter {
   addMcpToAgent(agentId: string, isBuiltin: boolean, mcpId: string): Promise<void>
   removeMcpFromAgent(agentId: string, isBuiltin: boolean, mcpId: string): Promise<void>
   getMcpConfHelper(): any // Used to get MCP configuration helper
+  isKnownModel?(providerId: string, modelId: string): boolean
   getModelConfig(modelId: string, providerId?: string): ModelConfig
   setModelConfig(
     modelId: string,

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

@@ -1,4 +1,6 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
+import { eventBus } from '@/eventbus'
+import { CONFIG_EVENTS } from '../../../../src/main/events'
 
 vi.mock('@/eventbus', () => ({
   eventBus: {
@@ -32,6 +34,7 @@ vi.mock('electron', () => ({
 }))
 
 import {
+  ConfigPresenter,
   getAnthropicModelSelectionKeysToClear,
   normalizeAnthropicProviderForApiOnly
 } from '../../../../src/main/presenter/configPresenter'
@@ -150,3 +153,68 @@ describe('getAnthropicModelSelectionKeysToClear', () => {
     expect(keysToClear).toEqual([])
   })
 })
+
+describe('migrateLegacyDefaultVisionModelToBuiltinAgent', () => {
+  it('migrates a valid legacy vision model with trimmed ids', () => {
+    const store = {
+      get: vi.fn().mockReturnValue({ providerId: ' openai ', modelId: ' gpt-4o ' }),
+      delete: vi.fn()
+    }
+    const updateBuiltinDeepChatConfig = vi.fn()
+    const presenter = Object.assign(Object.create(ConfigPresenter.prototype), {
+      store,
+      getBuiltinDeepChatConfig: vi.fn().mockReturnValue({}),
+      updateBuiltinDeepChatConfig
+    })
+
+    expect(() =>
+      (
+        presenter as ConfigPresenter & {
+          migrateLegacyDefaultVisionModelToBuiltinAgent: () => void
+        }
+      ).migrateLegacyDefaultVisionModelToBuiltinAgent()
+    ).not.toThrow()
+
+    expect(updateBuiltinDeepChatConfig).toHaveBeenCalledWith({
+      visionModel: {
+        providerId: 'openai',
+        modelId: 'gpt-4o'
+      }
+    })
+    expect(store.delete).toHaveBeenCalledWith('defaultVisionModel')
+    expect(eventBus.sendToMain).toHaveBeenCalledWith(
+      CONFIG_EVENTS.SETTING_CHANGED,
+      'defaultVisionModel',
+      undefined
+    )
+  })
+
+  it('cleans up malformed legacy vision model without throwing', () => {
+    const store = {
+      get: vi.fn().mockReturnValue({ providerId: { bad: true }, modelId: 'gpt-4o' }),
+      delete: vi.fn()
+    }
+    const updateBuiltinDeepChatConfig = vi.fn()
+    const presenter = Object.assign(Object.create(ConfigPresenter.prototype), {
+      store,
+      getBuiltinDeepChatConfig: vi.fn().mockReturnValue({}),
+      updateBuiltinDeepChatConfig
+    })
+
+    expect(() =>
+      (
+        presenter as ConfigPresenter & {
+          migrateLegacyDefaultVisionModelToBuiltinAgent: () => void
+        }
+      ).migrateLegacyDefaultVisionModelToBuiltinAgent()
+    ).not.toThrow()
+
+    expect(updateBuiltinDeepChatConfig).not.toHaveBeenCalled()
+    expect(store.delete).toHaveBeenCalledWith('defaultVisionModel')
+    expect(eventBus.sendToMain).toHaveBeenCalledWith(
+      CONFIG_EVENTS.SETTING_CHANGED,
+      'defaultVisionModel',
+      undefined
+    )
+  })
+})

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

@@ -226,7 +226,9 @@ function createMockConfigPresenter() {
     getAutoCompactionTriggerThreshold: vi.fn().mockReturnValue(80),
     getAutoCompactionRetainRecentPairs: vi.fn().mockReturnValue(2),
     getSetting: vi.fn().mockReturnValue(undefined),
-    resolveDeepChatAgentConfig: vi.fn().mockResolvedValue({})
+    isKnownModel: vi.fn().mockReturnValue(true),
+    resolveDeepChatAgentConfig: vi.fn().mockResolvedValue({}),
+    agentSupportsCapability: vi.fn().mockResolvedValue(true)
   } as any
 }
 
@@ -2885,6 +2887,10 @@ describe('DeepChatAgentPresenter', () => {
       })
 
       expect(configPresenter.resolveDeepChatAgentConfig).toHaveBeenCalledWith('persisted-agent')
+      expect(configPresenter.agentSupportsCapability).toHaveBeenCalledWith(
+        'persisted-agent',
+        'vision'
+      )
       expect(llmProvider.generateCompletionStandalone).toHaveBeenCalledWith(
         'google',
         expect.any(Array),
@@ -2895,6 +2901,47 @@ describe('DeepChatAgentPresenter', () => {
       expect(normalized).toBe('English screenshot summary')
     })
 
+    it('ignores fallback agent vision models when the agent does not support vision', async () => {
+      sqlitePresenter.newSessionsTable.get.mockReturnValue({
+        id: 's1',
+        agent_id: 'persisted-agent'
+      })
+      configPresenter.resolveDeepChatAgentConfig.mockResolvedValueOnce({
+        visionModel: { providerId: 'google', modelId: 'gemini-2.5-flash' }
+      })
+      configPresenter.agentSupportsCapability.mockResolvedValueOnce(false)
+      configPresenter.getModelConfig.mockImplementation((modelId: string, providerId?: string) => ({
+        temperature: 0.7,
+        maxTokens: 4096,
+        contextLength: 128000,
+        thinkingBudget: 512,
+        reasoningEffort: 'medium',
+        verbosity: 'medium',
+        vision: providerId === 'google' && modelId === 'gemini-2.5-flash'
+      }))
+
+      await agent.initSession('s1', { providerId: 'openai', modelId: 'gpt-4' })
+
+      const normalized = await (agent as any).normalizeToolResultContent({
+        sessionId: 's1',
+        toolCallId: 'tc1',
+        toolName: 'cdp_send',
+        toolArgs: '{"method":"Page.captureScreenshot"}',
+        content: '{"data":"YWJj"}',
+        isError: false
+      })
+
+      expect(configPresenter.resolveDeepChatAgentConfig).toHaveBeenCalledWith('persisted-agent')
+      expect(configPresenter.agentSupportsCapability).toHaveBeenCalledWith(
+        'persisted-agent',
+        'vision'
+      )
+      expect(llmProvider.generateCompletionStandalone).not.toHaveBeenCalled()
+      expect(normalized).toBe(
+        'Screenshot captured, but automatic English analysis is unavailable because neither the current session model nor the agent vision model can analyze images.'
+      )
+    })
+
     it('returns a readable error when neither the current model nor the agent can analyze images', async () => {
       configPresenter.resolveDeepChatAgentConfig.mockResolvedValueOnce({})