newcode 0.2.4__tar.gz → 0.2.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: newcode
-Version: 0.2.4
+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.4 → 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.4 → 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.4 → newcode-0.2.6}/newcode/claude_cache_client.py

@@ -371,12 +371,10 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                 is_auth_error = response.status_code in (401, 403)
 
                 if response.status_code == 400:
-                    is_auth_error = self._is_cloudflare_html_error(
-                        response
-                    ) or self._is_token_expired_error(response)
+                    is_auth_error = self._is_cloudflare_html_error(response)
                     if is_auth_error:
                         logger.info(
-                            "Detected 400 auth/token error, attempting token refresh"
+                            "Detected Cloudflare 400 error (expired token), attempting token refresh"
                         )
 
                 if is_auth_error:
@@ -537,79 +535,35 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         """Check if this is a Cloudflare HTML error response.
 
         Cloudflare often returns HTML error pages with status 400 when
-        there are authentication issues.
+        there are authentication issues. The response looks like:
+            <html>
+            <head><title>400 Bad Request</title></head>
+            <body>
+            <center><h1>400 Bad Request</h1></center>
+            <hr><center>cloudflare</center>
+            </body>
+            </html>
         """
-        # Check content type
-        content_type = response.headers.get("content-type", "")
-        if "text/html" not in content_type.lower():
-            return False
-
-        # Check if body contains Cloudflare markers
         try:
-            # Read response body if not already consumed
+            body = None
+            # Try reading the body from _content first (already consumed)
             if hasattr(response, "_content") and response._content:
                 body = response._content.decode("utf-8", errors="ignore")
             else:
-                # Try to read the text (this might be already consumed)
                 try:
                     body = response.text
                 except Exception:
                     return False
 
-            # Look for Cloudflare and 400 Bad Request markers
+            if not body:
+                return False
+
             body_lower = body.lower()
             return "cloudflare" in body_lower and "400 bad request" in body_lower
         except Exception as exc:
             logger.debug("Error checking for Cloudflare error: %s", exc)
             return False
 
-    @staticmethod
-    def _is_token_expired_error(response: httpx.Response) -> bool:
-        """Check if a 400 response indicates an expired or invalid OAuth token.
-
-        The Anthropic API returns JSON 400 errors when the token is expired.
-        Also checks stored token expiry as a heuristic.
-        """
-        try:
-            # Check if the JSON body mentions auth/token issues
-            body = None
-            if hasattr(response, "_content") and response._content:
-                body = response._content.decode("utf-8", errors="ignore")
-            else:
-                try:
-                    body = response.text
-                except Exception:
-                    pass
-
-            if body:
-                body_lower = body.lower()
-                auth_markers = (
-                    "expired",
-                    "invalid_token",
-                    "invalid_grant",
-                    "token",
-                    "unauthorized",
-                    "authentication",
-                )
-                if any(marker in body_lower for marker in auth_markers):
-                    return True
-
-            # Fallback: check if our stored token is actually expired
-            from newcode.plugins.claude_code_oauth.utils import (
-                is_token_expired,
-                load_stored_tokens,
-            )
-
-            tokens = load_stored_tokens()
-            if tokens and is_token_expired(tokens):
-                logger.info("Stored token is expired, treating 400 as auth error")
-                return True
-
-        except Exception as exc:
-            logger.debug("Error checking for token expired error: %s", exc)
-
-        return False
-
     def _refresh_claude_oauth_token(self) -> str | None:
         try:
             from newcode.plugins.claude_code_oauth.utils import refresh_access_token

{newcode-0.2.4 → 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.4 → 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