fix: preserve legacy aggregate image limits

Signed-off-by: DragonFSKY <38503900+DragonFSKY@users.noreply.github.com>

Author: DragonFSKY

tests/test_base_tool_image_validation.py

@@ -92,3 +92,32 @@ def test_validate_image_limits_respects_custom_total_cap(tmp_path):
     assert result is not None
     assert result["status"] == "error"
     assert "Total image size limit exceeded" in result["content"]
+
+
+def test_validate_image_limits_uses_legacy_total_cap_when_total_limit_missing(tmp_path):
+    tool = ChatTool()
+    caps = FakeCapabilities(provider=ProviderType.GOOGLE, max_image_size_mb=0.002, max_total_image_size_mb=0.0)
+    ctx = FakeModelContext(caps)
+
+    img1 = tmp_path / "img1.bin"
+    img2 = tmp_path / "img2.bin"
+    for path in (img1, img2):
+        path.write_bytes(b"\x00" * 1536)
+
+    result = tool._validate_image_limits([str(img1), str(img2)], model_context=ctx)
+    assert result is not None
+    assert result["status"] == "error"
+    assert "Total image size limit exceeded" in result["content"]
+
+
+def test_validate_image_limits_does_not_apply_openrouter_total_cap_without_total_limit(tmp_path):
+    tool = ChatTool()
+    caps = FakeCapabilities(provider=ProviderType.OPENROUTER, max_image_size_mb=0.002, max_total_image_size_mb=0.0)
+    ctx = FakeModelContext(caps)
+
+    img1 = tmp_path / "img1.bin"
+    img2 = tmp_path / "img2.bin"
+    for path in (img1, img2):
+        path.write_bytes(b"\x00" * 1536)
+
+    assert tool._validate_image_limits([str(img1), str(img2)], model_context=ctx) is None

tools/shared/base_tool.py

@@ -24,6 +24,7 @@
 
 from config import MCP_PROMPT_SIZE_LIMIT
 from providers import ModelProvider, ModelProviderRegistry
+from providers.shared import ProviderType
 from utils import estimate_tokens
 from utils.conversation_memory import (
     ConversationTurn,
@@ -1460,17 +1461,21 @@ def _get_effective_limit(self, configured_limit_mb: float, capabilities: Any) ->
         if configured_limit_mb <= 0:
             return configured_limit_mb
 
-        effective_limit_mb = configured_limit_mb
-        try:
-            from providers.shared import ProviderType
+        if capabilities.provider == ProviderType.CUSTOM:
+            return min(configured_limit_mb, 40.0)
 
-            if getattr(capabilities, "provider", None) == ProviderType.CUSTOM:
-                effective_limit_mb = min(configured_limit_mb, 40.0)
-        except Exception:
-            # Fall back to configured limit on any exception
-            logger.debug("Failed to apply provider-specific limit; using configured limit", exc_info=True)
+        return configured_limit_mb
 
-        return effective_limit_mb
+    def _get_total_image_size_limit(self, capabilities: Any, max_image_size_mb: float) -> float:
+        """Return the total image size limit while preserving legacy provider config semantics."""
+        max_total_size_mb = capabilities.max_total_image_size_mb
+        if max_total_size_mb > 0:
+            return max_total_size_mb
+
+        if capabilities.provider != ProviderType.OPENROUTER and max_image_size_mb > 0:
+            return max_image_size_mb
+
+        return 0.0
 
     def _calculate_image_size(self, image_path: str) -> tuple[Optional[float], Optional[str]]:
         """
@@ -1642,13 +1647,13 @@ def _validate_image_limits(
                         },
                     }
 
-        # Check total request size limit (only if model has explicit total limit)
-        # If max_total_image_size_mb is 0, skip total size validation (no official limit documented)
+        # Check total request size limit. Older provider configs used max_image_size_mb
+        # as a total request cap, while OpenRouter uses it as a per-image cap.
         # NOTE: We validate against original image sizes, not base64-encoded sizes.
         # Provider-specific limits (e.g. Google 15MB, Anthropic 24MB) are already adjusted
         # to account for base64 encoding overhead (~33% increase) and text content.
         # This keeps validation simple and performant while providing adequate safety margin.
-        max_total_size_mb = capabilities.max_total_image_size_mb
+        max_total_size_mb = self._get_total_image_size_limit(capabilities, max_size_mb)
         if max_total_size_mb > 0:
             effective_total_limit_mb = self._get_effective_limit(max_total_size_mb, capabilities)
             # Check if total size exceeds the request limit