newcode 0.2.5__tar.gz → 0.2.6__tar.gz

{newcode-0.2.5 → newcode-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newcode
-Version: 0.2.5
+Version: 0.2.6
 Summary: AI-powered code generation agent platform
 Project-URL: repository, https://github.com/janfeddersen-wq/new_code
 Project-URL: HomePage, https://github.com/janfeddersen-wq/new_code
@@ -57,7 +57,7 @@ NewCode is designed for practical software workflows in the terminal: inspect fi
 - Built-in agent system with a default coding agent and optional specialist workflows
 - MCP (Model Context Protocol) integration and server management
 - Interactive command-driven UX for model, agent, and settings management
-- Session autosave/restore and scheduler utilities
+- Session autosave/restore utilities
 - Plugin/callback extensibility hooks
 
 ## Quick start
@@ -94,7 +94,6 @@ On first run, NewCode starts onboarding to help configure API keys and defaults.
 /config         # Show current configuration
 /model          # Select or switch model
 /agent          # Select or switch agent
-/scheduler      # Manage scheduled tasks
 /colors         # Customize terminal UI colors
 /api            # Manage built-in API server (start|stop|status)
 ```

{newcode-0.2.5 → newcode-0.2.6}/README.md

@@ -15,7 +15,7 @@ NewCode is designed for practical software workflows in the terminal: inspect fi
 - Built-in agent system with a default coding agent and optional specialist workflows
 - MCP (Model Context Protocol) integration and server management
 - Interactive command-driven UX for model, agent, and settings management
-- Session autosave/restore and scheduler utilities
+- Session autosave/restore utilities
 - Plugin/callback extensibility hooks
 
 ## Quick start
@@ -52,7 +52,6 @@ On first run, NewCode starts onboarding to help configure API keys and defaults.
 /config         # Show current configuration
 /model          # Select or switch model
 /agent          # Select or switch agent
-/scheduler      # Manage scheduled tasks
 /colors         # Customize terminal UI colors
 /api            # Manage built-in API server (start|stop|status)
 ```

{newcode-0.2.5 → newcode-0.2.6}/newcode/agents/base_agent.py

@@ -71,6 +71,7 @@ from newcode.config import (
     get_value,
 )
 from newcode.error_logging import log_error
+from newcode.image_utils import constrain_image_dimensions
 from newcode.keymap import cancel_agent_uses_signal, get_cancel_agent_char_code
 from newcode.mcp_ import get_mcp_manager
 from newcode.messaging import (
@@ -95,6 +96,20 @@ _delayed_compaction_requested = False
 _reload_count = 0
 
 
+def _is_cloudflare_auth_error(exc: Exception) -> bool:
+    """Detect Cloudflare 400 auth failures from exception text."""
+    message = str(exc)
+    if not message:
+        return False
+
+    message_lower = message.lower()
+    return (
+        "cloudflare" in message_lower
+        and "400" in message_lower
+        and "bad request" in message_lower
+    )
+
+
 def _log_error_to_file(exc: Exception) -> Optional[str]:
     """Log detailed error information to ~/.newcode/error_logs/log_{timestamp}.txt.
 
@@ -1836,7 +1851,25 @@ class BaseAgent(ABC):
         # Build combined prompt payload when attachments are provided.
         attachment_parts: List[Any] = []
         if attachments:
-            attachment_parts.extend(list(attachments))
+            # Constrain image dimensions for API compliance (Claude max 2000px for many-image requests)
+            constrained = []
+            for att in attachments:
+                if (
+                    isinstance(att, BinaryContent)
+                    and hasattr(att, "media_type")
+                    and hasattr(att, "data")
+                ):
+                    media_type = getattr(att, "media_type", "") or ""
+                    if media_type.startswith("image/"):
+                        new_data = constrain_image_dimensions(
+                            att.data, media_type=media_type
+                        )
+                        if new_data is not att.data:
+                            att = BinaryContent(data=new_data, media_type=media_type)
+                    constrained.append(att)
+                else:
+                    constrained.append(att)
+            attachment_parts.extend(constrained)
         if link_attachments:
             attachment_parts.extend(list(link_attachments))
 
@@ -1849,41 +1882,58 @@ class BaseAgent(ABC):
             prompt_payload = prompt
 
         async def run_agent_task():
-            try:
-                self.set_message_history(
-                    self.prune_interrupted_tool_calls(self.get_message_history())
-                )
+            _cloudflare_retry_attempted = False
 
-                # DELAYED COMPACTION: Check if we should attempt delayed compaction
-                if self.should_attempt_delayed_compaction():
-                    emit_info(
-                        "🔄 Attempting delayed compaction (tool calls completed)",
-                        message_group="token_context_status",
+            while True:
+                _retry_after_cloudflare_refresh = False
+                try:
+                    self.set_message_history(
+                        self.prune_interrupted_tool_calls(self.get_message_history())
                     )
-                    current_messages = self.get_message_history()
-                    compacted_messages, _ = self.compact_messages(current_messages)
-                    if compacted_messages != current_messages:
-                        self.set_message_history(compacted_messages)
+
+                    # DELAYED COMPACTION: Check if we should attempt delayed compaction
+                    if self.should_attempt_delayed_compaction():
                         emit_info(
-                            "✅ Delayed compaction completed successfully",
+                            "🔄 Attempting delayed compaction (tool calls completed)",
                             message_group="token_context_status",
                         )
+                        current_messages = self.get_message_history()
+                        compacted_messages, _ = self.compact_messages(current_messages)
+                        if compacted_messages != current_messages:
+                            self.set_message_history(compacted_messages)
+                            emit_info(
+                                "✅ Delayed compaction completed successfully",
+                                message_group="token_context_status",
+                            )
 
-                usage_limits = UsageLimits(request_limit=get_message_limit())
+                    usage_limits = UsageLimits(request_limit=get_message_limit())
 
-                # Handle MCP servers - add them temporarily when using DBOS
-                if (
-                    get_use_dbos()
-                    and hasattr(self, "_mcp_servers")
-                    and self._mcp_servers
-                ):
-                    # Temporarily add MCP servers to the DBOS agent using internal _toolsets
-                    original_toolsets = pydantic_agent._toolsets
-                    pydantic_agent._toolsets = original_toolsets + self._mcp_servers
-                    pydantic_agent._toolsets = original_toolsets + self._mcp_servers
+                    # Handle MCP servers - add them temporarily when using DBOS
+                    if (
+                        get_use_dbos()
+                        and hasattr(self, "_mcp_servers")
+                        and self._mcp_servers
+                    ):
+                        # Temporarily add MCP servers to the DBOS agent using internal _toolsets
+                        original_toolsets = pydantic_agent._toolsets
+                        pydantic_agent._toolsets = original_toolsets + self._mcp_servers
+                        pydantic_agent._toolsets = original_toolsets + self._mcp_servers
 
-                    try:
-                        # Set the workflow ID for DBOS context so DBOS and the agent ID match
+                        try:
+                            # Set the workflow ID for DBOS context so DBOS and the agent ID match
+                            with SetWorkflowID(group_id):
+                                result_ = await pydantic_agent.run(
+                                    prompt_payload,
+                                    message_history=self.get_message_history(),
+                                    usage_limits=usage_limits,
+                                    event_stream_handler=event_stream_handler,
+                                    **kwargs,
+                                )
+                                return result_
+                        finally:
+                            # Always restore original toolsets
+                            pydantic_agent._toolsets = original_toolsets
+                    elif get_use_dbos():
                         with SetWorkflowID(group_id):
                             result_ = await pydantic_agent.run(
                                 prompt_payload,
@@ -1893,11 +1943,8 @@ class BaseAgent(ABC):
                                 **kwargs,
                             )
                             return result_
-                    finally:
-                        # Always restore original toolsets
-                        pydantic_agent._toolsets = original_toolsets
-                elif get_use_dbos():
-                    with SetWorkflowID(group_id):
+                    else:
+                        # Non-DBOS path (MCP servers are already included)
                         result_ = await pydantic_agent.run(
                             prompt_payload,
                             message_history=self.get_message_history(),
@@ -1906,74 +1953,111 @@ class BaseAgent(ABC):
                             **kwargs,
                         )
                         return result_
-                else:
-                    # Non-DBOS path (MCP servers are already included)
-                    result_ = await pydantic_agent.run(
-                        prompt_payload,
-                        message_history=self.get_message_history(),
-                        usage_limits=usage_limits,
-                        event_stream_handler=event_stream_handler,
-                        **kwargs,
+                except* UsageLimitExceeded as ule:
+                    emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
+                    emit_info(
+                        "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
+                        group_id=group_id,
                     )
-                    return result_
-            except* UsageLimitExceeded as ule:
-                emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
-                emit_info(
-                    "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
-                    group_id=group_id,
-                )
-            except* mcp.shared.exceptions.McpError as mcp_error:
-                emit_info(f"MCP server error: {str(mcp_error)}", group_id=group_id)
-                emit_info(f"{str(mcp_error)}", group_id=group_id)
-                emit_info(
-                    "Try disabling any malfunctioning MCP servers", group_id=group_id
-                )
-            except* asyncio.exceptions.CancelledError:
-                emit_info("Cancelled")
-                if get_use_dbos():
-                    await DBOS.cancel_workflow_async(group_id)
-            except* InterruptedError as ie:
-                emit_info(f"Interrupted: {str(ie)}")
-                if get_use_dbos():
-                    await DBOS.cancel_workflow_async(group_id)
-            except* Exception as other_error:
-                # Filter out CancelledError and UsageLimitExceeded from the exception group - let it propagate
-                remaining_exceptions = []
-
-                def collect_non_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_non_cancelled_exceptions(sub_exc)
-                    elif not isinstance(
-                        exc, (asyncio.CancelledError, UsageLimitExceeded)
+                except* mcp.shared.exceptions.McpError as mcp_error:
+                    emit_info(f"MCP server error: {str(mcp_error)}", group_id=group_id)
+                    emit_info(f"{str(mcp_error)}", group_id=group_id)
+                    emit_info(
+                        "Try disabling any malfunctioning MCP servers",
+                        group_id=group_id,
+                    )
+                except* asyncio.exceptions.CancelledError:
+                    emit_info("Cancelled")
+                    if get_use_dbos():
+                        await DBOS.cancel_workflow_async(group_id)
+                except* InterruptedError as ie:
+                    emit_info(f"Interrupted: {str(ie)}")
+                    if get_use_dbos():
+                        await DBOS.cancel_workflow_async(group_id)
+                except* Exception as other_error:
+
+                    def contains_cloudflare_auth_error(exc: Exception) -> bool:
+                        if isinstance(exc, ExceptionGroup):
+                            return any(
+                                contains_cloudflare_auth_error(sub_exc)
+                                for sub_exc in exc.exceptions
+                            )
+                        return _is_cloudflare_auth_error(exc)
+
+                    if (
+                        not _cloudflare_retry_attempted
+                        and contains_cloudflare_auth_error(other_error)
                     ):
-                        remaining_exceptions.append(exc)
-                        emit_info(f"Unexpected error: {str(exc)}", group_id=group_id)
-                        emit_info(f"{str(exc.args)}", group_id=group_id)
-                        # Log to file for debugging
-                        log_error(
-                            exc,
-                            context=f"Agent run (group_id={group_id})",
-                            include_traceback=True,
+                        _cloudflare_retry_attempted = True
+                        emit_info(
+                            "Detected Cloudflare 400 error (likely expired token), attempting refresh...",
+                            group_id=group_id,
                         )
+                        refreshed_token = None
+                        try:
+                            from newcode.plugins.claude_code_oauth.utils import (
+                                refresh_access_token,
+                            )
+
+                            refreshed_token = refresh_access_token(force=True)
+                        except Exception as refresh_error:
+                            emit_info(
+                                f"Token refresh failed: {str(refresh_error)}",
+                                group_id=group_id,
+                            )
+
+                        if refreshed_token:
+                            emit_info(
+                                "Token refresh successful, retrying request...",
+                                group_id=group_id,
+                            )
+                            _retry_after_cloudflare_refresh = True
+
+                    if not _retry_after_cloudflare_refresh:
+                        # Filter out CancelledError and UsageLimitExceeded from the exception group - let it propagate
+                        remaining_exceptions = []
+
+                        def collect_non_cancelled_exceptions(exc):
+                            if isinstance(exc, ExceptionGroup):
+                                for sub_exc in exc.exceptions:
+                                    collect_non_cancelled_exceptions(sub_exc)
+                            elif not isinstance(
+                                exc, (asyncio.CancelledError, UsageLimitExceeded)
+                            ):
+                                remaining_exceptions.append(exc)
+                                emit_info(
+                                    f"Unexpected error: {str(exc)}", group_id=group_id
+                                )
+                                emit_info(f"{str(exc.args)}", group_id=group_id)
+                                # Log to file for debugging
+                                log_error(
+                                    exc,
+                                    context=f"Agent run (group_id={group_id})",
+                                    include_traceback=True,
+                                )
 
-                collect_non_cancelled_exceptions(other_error)
+                        collect_non_cancelled_exceptions(other_error)
 
-                # If there are CancelledError exceptions in the group, re-raise them
-                cancelled_exceptions = []
+                        # If there are CancelledError exceptions in the group, re-raise them
+                        cancelled_exceptions = []
 
-                def collect_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_cancelled_exceptions(sub_exc)
-                    elif isinstance(exc, asyncio.CancelledError):
-                        cancelled_exceptions.append(exc)
+                        def collect_cancelled_exceptions(exc):
+                            if isinstance(exc, ExceptionGroup):
+                                for sub_exc in exc.exceptions:
+                                    collect_cancelled_exceptions(sub_exc)
+                            elif isinstance(exc, asyncio.CancelledError):
+                                cancelled_exceptions.append(exc)
 
-                collect_cancelled_exceptions(other_error)
-            finally:
-                self.set_message_history(
-                    self.prune_interrupted_tool_calls(self.get_message_history())
-                )
+                        collect_cancelled_exceptions(other_error)
+                finally:
+                    self.set_message_history(
+                        self.prune_interrupted_tool_calls(self.get_message_history())
+                    )
+
+                if _retry_after_cloudflare_refresh:
+                    continue
+
+                break
 
         # Create the task FIRST
         agent_task = asyncio.create_task(run_agent_task())

{newcode-0.2.5 → newcode-0.2.6}/newcode/command_line/attachments.py

@@ -11,6 +11,8 @@ from typing import Iterable, List, Sequence
 
 from pydantic_ai import BinaryContent, DocumentUrl, ImageUrl
 
+from newcode.image_utils import constrain_image_dimensions
+
 SUPPORTED_INLINE_SCHEMES = {"http", "https"}
 
 # Maximum path length to consider - conservative limit to avoid OS errors
@@ -341,6 +343,8 @@ def parse_prompt_attachments(prompt: str) -> ProcessedPrompt:
         except AttachmentParsingError:
             # Silently ignore unreadable attachments to reduce prompt noise
             continue
+        # Constrain image dimensions for API compliance (Claude max 2000px for many-image requests)
+        data = constrain_image_dimensions(data, media_type=media_type)
         attachments.append(
             PromptAttachment(
                 placeholder=detection.placeholder,

{newcode-0.2.5 → newcode-0.2.6}/newcode/command_line/clipboard.py

@@ -16,6 +16,8 @@ import threading
 import time
 from typing import Optional
 
+from newcode.image_utils import constrain_image_dimensions
+
 # Try to import PIL - it's optional but needed for clipboard image support
 try:
     from PIL import Image, ImageGrab
@@ -42,7 +44,7 @@ logger = logging.getLogger(__name__)
 
 # Constants
 MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024  # 10MB
-MAX_IMAGE_DIMENSION = 4096  # Max width/height for resize
+MAX_IMAGE_DIMENSION = 1920  # Max width/height for resize
 MAX_PENDING_IMAGES = (
     10  # SEC-CLIP-001: Limit pending images to prevent memory exhaustion
 )
@@ -317,6 +319,7 @@ def get_clipboard_image() -> Optional[bytes]:
                     )
                     return None
 
+        image_bytes = constrain_image_dimensions(image_bytes)
         return image_bytes
 
     # Windows/macOS path - use PIL
@@ -356,6 +359,7 @@ def get_clipboard_image() -> Optional[bytes]:
         image_bytes = buffer.getvalue()
 
         logger.info(f"Clipboard image size: {len(image_bytes) / 1024:.1f}KB")
+        image_bytes = constrain_image_dimensions(image_bytes)
         return image_bytes
 
     except Exception as e:

newcode-0.2.6/newcode/image_utils.py

@@ -0,0 +1,85 @@
+"""Image processing utilities for API compliance.
+
+Ensures images sent to LLM APIs respect dimension limits.
+The Claude API enforces a 2000px max dimension for many-image requests.
+We use 1920px as default to provide a safety margin.
+"""
+
+import io
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Claude API max dimension for many-image requests is 2000px.
+# Use 1920 for safety margin.
+MAX_IMAGE_DIMENSION = 1920
+
+try:
+    from PIL import Image
+
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+    Image = None  # type: ignore[misc, assignment]
+
+
+def constrain_image_dimensions(
+    image_bytes: bytes,
+    max_dim: int = MAX_IMAGE_DIMENSION,
+    media_type: Optional[str] = None,
+) -> bytes:
+    """Resize image if any dimension exceeds max_dim, preserving aspect ratio.
+
+    Args:
+        image_bytes: Raw image bytes (PNG, JPEG, etc.).
+        max_dim: Maximum allowed width or height in pixels.
+        media_type: Optional MIME type hint. If provided and not an image
+                    type, returns bytes unchanged.
+
+    Returns:
+        Original bytes if within limits or PIL unavailable, resized PNG bytes otherwise.
+    """
+    # Skip non-image content
+    if media_type and not media_type.startswith("image/"):
+        return image_bytes
+
+    if not PIL_AVAILABLE or Image is None:
+        logger.debug("PIL not available, skipping image dimension check")
+        return image_bytes
+
+    if not image_bytes:
+        return image_bytes
+
+    try:
+        img = Image.open(io.BytesIO(image_bytes))
+        width, height = img.size
+
+        if width <= max_dim and height <= max_dim:
+            return image_bytes
+
+        # Calculate scale factor based on the larger dimension
+        scale = max_dim / max(width, height)
+        new_width = int(width * scale)
+        new_height = int(height * scale)
+
+        # Ensure minimum dimensions
+        new_width = max(new_width, 1)
+        new_height = max(new_height, 1)
+
+        resized = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+        # Save as PNG to preserve quality
+        output = io.BytesIO()
+        resized.save(output, format="PNG", optimize=True)
+        output.seek(0)
+
+        logger.info(
+            f"Constrained image dimensions from {width}x{height} "
+            f"to {new_width}x{new_height} (max_dim={max_dim})"
+        )
+        return output.read()
+
+    except Exception as e:
+        logger.warning(f"Failed to constrain image dimensions: {e}")
+        return image_bytes

{newcode-0.2.5 → newcode-0.2.6}/newcode/plugins/claude_code_oauth/register_callbacks.py

@@ -380,6 +380,55 @@ def _register_model_types() -> List[Dict[str, Any]]:
 # Using a dict to allow multiple concurrent agent runs (keyed by session_id)
 _active_heartbeats: Dict[str, Any] = {}
 
+# Persistent session-level heartbeat that runs for the entire app lifetime
+_session_heartbeat: Optional[Any] = None
+
+
+async def _on_startup() -> None:
+    """Start a persistent token refresh heartbeat for idle sessions."""
+    global _session_heartbeat
+
+    try:
+        if _session_heartbeat is not None:
+            return
+
+        tokens = load_stored_tokens()
+        if not tokens:
+            return
+
+        from .token_refresh_heartbeat import (
+            SESSION_HEARTBEAT_INTERVAL_SECONDS,
+            TokenRefreshHeartbeat,
+        )
+
+        heartbeat = TokenRefreshHeartbeat(interval=SESSION_HEARTBEAT_INTERVAL_SECONDS)
+        await heartbeat.start()
+        _session_heartbeat = heartbeat
+        logger.debug(
+            "Started persistent session-level token refresh heartbeat (interval: 1h)"
+        )
+    except Exception as exc:
+        logger.debug(
+            "Failed to start persistent session-level token refresh heartbeat: %s", exc
+        )
+
+
+async def _on_shutdown() -> None:
+    """Stop the persistent session-level token refresh heartbeat."""
+    global _session_heartbeat
+
+    try:
+        if _session_heartbeat is None:
+            return
+
+        await _session_heartbeat.stop()
+        _session_heartbeat = None
+        logger.debug("Stopped persistent session-level token refresh heartbeat")
+    except Exception as exc:
+        logger.debug(
+            "Failed to stop persistent session-level token refresh heartbeat: %s", exc
+        )
+
 
 async def _on_agent_run_start(
     agent_name: str,
@@ -449,5 +498,7 @@ async def _on_agent_run_end(
 register_callback("custom_command_help", _custom_help)
 register_callback("custom_command", _handle_custom_command)
 register_callback("register_model_type", _register_model_types)
+register_callback("startup", _on_startup)
+register_callback("shutdown", _on_shutdown)
 register_callback("agent_run_start", _on_agent_run_start)
 register_callback("agent_run_end", _on_agent_run_end)

{newcode-0.2.5 → newcode-0.2.6}/newcode/plugins/claude_code_oauth/token_refresh_heartbeat.py

@@ -28,6 +28,10 @@ HEARTBEAT_INTERVAL_SECONDS = 120
 # Minimum time between refresh attempts to avoid hammering the endpoint
 MIN_REFRESH_INTERVAL_SECONDS = 60
 
+# Session-level heartbeat interval - refresh token once per hour during idle sessions
+# This prevents tokens from expiring when the app is open but no agent is running
+SESSION_HEARTBEAT_INTERVAL_SECONDS = 3600
+
 # Global tracking of last refresh time to coordinate across heartbeats
 _last_refresh_time: float = 0.0
 

{newcode-0.2.5 → newcode-0.2.6}/newcode/tools/__init__.py

@@ -88,19 +88,6 @@ from newcode.tools.file_operations import (
     register_list_files,
     register_read_file,
 )
-
-# Scheduler tools
-from newcode.tools.scheduler_tools import (
-    register_scheduler_create_task,
-    register_scheduler_daemon_status,
-    register_scheduler_delete_task,
-    register_scheduler_list_tasks,
-    register_scheduler_run_task,
-    register_scheduler_start_daemon,
-    register_scheduler_stop_daemon,
-    register_scheduler_toggle_task,
-    register_scheduler_view_log,
-)
 from newcode.tools.skills_tools import (
     register_activate_skill,
     register_list_or_search_skills,
@@ -188,16 +175,6 @@ TOOL_REGISTRY = {
     "list_or_search_skills": register_list_or_search_skills,
     # Universal Constructor
     "universal_constructor": register_universal_constructor,
-    # Scheduler Tools
-    "scheduler_list_tasks": register_scheduler_list_tasks,
-    "scheduler_create_task": register_scheduler_create_task,
-    "scheduler_delete_task": register_scheduler_delete_task,
-    "scheduler_toggle_task": register_scheduler_toggle_task,
-    "scheduler_daemon_status": register_scheduler_daemon_status,
-    "scheduler_start_daemon": register_scheduler_start_daemon,
-    "scheduler_stop_daemon": register_scheduler_stop_daemon,
-    "scheduler_run_task": register_scheduler_run_task,
-    "scheduler_view_log": register_scheduler_view_log,
 }
 
 

{newcode-0.2.5 → newcode-0.2.6}/newcode/tools/browser/browser_screenshot.py

@@ -12,6 +12,7 @@ from typing import Any, Dict, Optional, Union
 
 from pydantic_ai import BinaryContent, RunContext, ToolReturn
 
+from newcode.image_utils import constrain_image_dimensions
 from newcode.messaging import emit_error, emit_info, emit_success
 from newcode.tools.common import generate_group_id
 
@@ -122,13 +123,16 @@ async def take_screenshot(
 
         screenshot_path = result.get("screenshot_path", "(not saved)")
 
+        # Constrain dimensions for API compliance (Claude max 2000px for many-image requests)
+        constrained_bytes = constrain_image_dimensions(result["screenshot_bytes"])
+
         # Return as ToolReturn with BinaryContent so the model can SEE the image!
         return ToolReturn(
             return_value=f"Screenshot captured successfully. Saved to: {screenshot_path}",
             content=[
                 f"Here's the browser screenshot ({target}):",
                 BinaryContent(
-                    data=result["screenshot_bytes"],
+                    data=constrained_bytes,
                     media_type="image/png",
                 ),
                 "Please analyze what you see and describe any relevant details.",