refactor(acp): honour explicit acp_model in supports_vision

Now that ACPAgent.model_post_init() writes acp_model into llm.model
(merged in #2881), llm.vision_is_active() gives an authoritative
answer for explicitly-configured models via LiteLLM. Use it when the
user has set acp_model — even if they pick a non-vision variant,
that choice wins over the server-identity default.

The provider-identity fallback only kicks in when acp_model is unset
and we can't know which default model the server will pick; for all
three providers we support, that default is vision-capable.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Debug Agent

openhands-sdk/openhands/sdk/agent/acp_agent.py

@@ -803,13 +803,17 @@ def agent_version(self) -> str:
     def supports_vision(self) -> bool:
         """Whether the wrapped ACP server forwards images to a vision model.
 
-        The sentinel ``self.llm`` uses ``model="acp-managed"`` which LiteLLM
-        does not recognise, so the base-class ``llm.vision_is_active()``
-        always returns False for ACP agents. Resolve the real capability
-        from the ACP server identity (launch command or the agent name
-        reported by InitializeResponse) instead. Unknown servers fall back
-        to False so we don't silently send images a server may drop.
+        When ``acp_model`` is set, ``self.llm.model`` carries the real
+        model name so ``llm.vision_is_active()`` gives an authoritative
+        answer via LiteLLM — honour the user's explicit model choice even
+        if it's a non-vision variant.
+
+        Without ``acp_model``, the ACP server picks a default we can't
+        see from here, so fall back to the server's identity: all three
+        ACP servers OpenHands supports default to vision-capable models.
         """
+        if self.acp_model:
+            return self.llm.vision_is_active()
         probe = f"{self._agent_name} {' '.join(self.acp_command)}".lower()
         return any(marker in probe for marker in _VISION_CAPABLE_ACP_SERVERS)
 

tests/sdk/agent/test_acp_agent.py

@@ -2119,13 +2119,33 @@ def test_unknown_acp_server_defaults_to_false(self):
         assert agent.supports_vision() is False
 
     def test_vision_not_derived_from_sentinel_llm(self):
-        # The sentinel ``acp-managed`` model is unknown to LiteLLM, so
-        # the base-class llm.vision_is_active() reports False. The
-        # ACPAgent override must still return True for known providers.
+        # Without acp_model, llm.model stays "acp-managed" (unknown to
+        # LiteLLM), so the base-class llm.vision_is_active() reports
+        # False. The ACPAgent override must still return True for known
+        # providers via the server-identity fallback.
         agent = ACPAgent(acp_command=["npx", "-y", "claude-agent-acp"])
         assert agent.llm.vision_is_active() is False
         assert agent.supports_vision() is True
 
+    def test_explicit_acp_model_honours_llm_vision_check(self):
+        # When acp_model is set, llm.model carries the real model name
+        # (via ACPAgent.model_post_init) so we trust LiteLLM's answer —
+        # even when the server marker says vision-capable, the user's
+        # explicit non-vision model choice wins.
+        vision_agent = ACPAgent(
+            acp_command=["npx", "-y", "claude-agent-acp"],
+            acp_model="claude-sonnet-4-5",
+        )
+        assert vision_agent.llm.vision_is_active() is True
+        assert vision_agent.supports_vision() is True
+
+        text_only_agent = ACPAgent(
+            acp_command=["codex-acp"],
+            acp_model="gpt-3.5-turbo",
+        )
+        assert text_only_agent.llm.vision_is_active() is False
+        assert text_only_agent.supports_vision() is False
+
 
 # ---------------------------------------------------------------------------
 # acp_session_mode field