code-puppy 0.0.172__py3-none-any.whl → 0.0.173__py3-none-any.whl

code_puppy/agent.py

@@ -7,10 +7,7 @@ from pydantic_ai import Agent
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import UsageLimits
 
-from code_puppy.message_history_processor import (
-    get_model_context_length,
-    message_history_accumulator,
-)
+from code_puppy.message_history_processor import message_history_accumulator
 from code_puppy.messaging.message_queue import (
     emit_error,
     emit_info,
@@ -167,7 +164,10 @@ def reload_code_generation_agent(message_group: str | None):
 
     # Configure model settings with max_tokens if set
     model_settings_dict = {"seed": 42}
-    output_tokens = max(2048, min(int(0.05 * get_model_context_length()) - 1024, 16384))
+    # Get current agent to use its method
+    from code_puppy.agents import get_current_agent_config
+    current_agent = get_current_agent_config()
+    output_tokens = max(2048, min(int(0.05 * current_agent.get_model_context_length()) - 1024, 16384))
     console.print(f"Max output tokens per message: {output_tokens}")
     model_settings_dict["max_tokens"] = output_tokens
 

code_puppy/agents/base_agent.py

@@ -1,13 +1,26 @@
 """Base agent configuration class for defining agent properties."""
 
+import json
+import queue
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+import pydantic
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelRequest,
+    TextPart,
+    ToolCallPart,
+    ToolCallPartDelta,
+    ToolReturn,
+    ToolReturnPart,
+)
 
 
 class BaseAgent(ABC):
     """Base class for all agent configurations."""
-
+    
     def __init__(self):
         self.id = str(uuid.uuid4())
         self._message_history: List[Any] = []
@@ -123,3 +136,377 @@ class BaseAgent(ABC):
         """
         from ..config import get_agent_pinned_model
         return get_agent_pinned_model(self.name)
+
+    # Message history processing methods (moved from state_management.py and message_history_processor.py)
+    def _stringify_part(self, part: Any) -> str:
+        """Create a stable string representation for a message part.
+
+        We deliberately ignore timestamps so identical content hashes the same even when
+        emitted at different times. This prevents status updates from blowing up the
+        history when they are repeated with new timestamps."""
+
+        attributes: List[str] = [part.__class__.__name__]
+
+        # Role/instructions help disambiguate parts that otherwise share content
+        if hasattr(part, "role") and part.role:
+            attributes.append(f"role={part.role}")
+        if hasattr(part, "instructions") and part.instructions:
+            attributes.append(f"instructions={part.instructions}")
+
+        if hasattr(part, "tool_call_id") and part.tool_call_id:
+            attributes.append(f"tool_call_id={part.tool_call_id}")
+
+        if hasattr(part, "tool_name") and part.tool_name:
+            attributes.append(f"tool_name={part.tool_name}")
+
+        content = getattr(part, "content", None)
+        if content is None:
+            attributes.append("content=None")
+        elif isinstance(content, str):
+            attributes.append(f"content={content}")
+        elif isinstance(content, pydantic.BaseModel):
+            attributes.append(f"content={json.dumps(content.model_dump(), sort_keys=True)}")
+        elif isinstance(content, dict):
+            attributes.append(f"content={json.dumps(content, sort_keys=True)}")
+        else:
+            attributes.append(f"content={repr(content)}")
+        result = "|".join(attributes)
+        return result
+
+    def hash_message(self, message: Any) -> int:
+        """Create a stable hash for a model message that ignores timestamps."""
+        role = getattr(message, "role", None)
+        instructions = getattr(message, "instructions", None)
+        header_bits: List[str] = []
+        if role:
+            header_bits.append(f"role={role}")
+        if instructions:
+            header_bits.append(f"instructions={instructions}")
+
+        part_strings = [self._stringify_part(part) for part in getattr(message, "parts", [])]
+        canonical = "||".join(header_bits + part_strings)
+        return hash(canonical)
+
+    def stringify_message_part(self, part) -> str:
+        """
+        Convert a message part to a string representation for token estimation or other uses.
+
+        Args:
+            part: A message part that may contain content or be a tool call
+
+        Returns:
+            String representation of the message part
+        """
+        result = ""
+        if hasattr(part, "part_kind"):
+            result += part.part_kind + ": "
+        else:
+            result += str(type(part)) + ": "
+
+        # Handle content
+        if hasattr(part, "content") and part.content:
+            # Handle different content types
+            if isinstance(part.content, str):
+                result = part.content
+            elif isinstance(part.content, pydantic.BaseModel):
+                result = json.dumps(part.content.model_dump())
+            elif isinstance(part.content, dict):
+                result = json.dumps(part.content)
+            else:
+                result = str(part.content)
+
+        # Handle tool calls which may have additional token costs
+        # If part also has content, we'll process tool calls separately
+        if hasattr(part, "tool_name") and part.tool_name:
+            # Estimate tokens for tool name and parameters
+            tool_text = part.tool_name
+            if hasattr(part, "args"):
+                tool_text += f" {str(part.args)}"
+            result += tool_text
+
+        return result
+
+    def estimate_tokens_for_message(self, message: ModelMessage) -> int:
+        """
+        Estimate the number of tokens in a message using len(message) - 4.
+        Simple and fast replacement for tiktoken.
+        """
+        total_tokens = 0
+
+        for part in message.parts:
+            part_str = self.stringify_message_part(part)
+            if part_str:
+                total_tokens += len(part_str)
+
+        return int(max(1, total_tokens) / 4)
+
+    def _is_tool_call_part(self, part: Any) -> bool:
+        if isinstance(part, (ToolCallPart, ToolCallPartDelta)):
+            return True
+
+        part_kind = (getattr(part, "part_kind", "") or "").replace("_", "-")
+        if part_kind == "tool-call":
+            return True
+
+        has_tool_name = getattr(part, "tool_name", None) is not None
+        has_args = getattr(part, "args", None) is not None
+        has_args_delta = getattr(part, "args_delta", None) is not None
+
+        return bool(has_tool_name and (has_args or has_args_delta))
+
+    def _is_tool_return_part(self, part: Any) -> bool:
+        if isinstance(part, (ToolReturnPart, ToolReturn)):
+            return True
+
+        part_kind = (getattr(part, "part_kind", "") or "").replace("_", "-")
+        if part_kind in {"tool-return", "tool-result"}:
+            return True
+
+        if getattr(part, "tool_call_id", None) is None:
+            return False
+
+        has_content = getattr(part, "content", None) is not None
+        has_content_delta = getattr(part, "content_delta", None) is not None
+        return bool(has_content or has_content_delta)
+
+    def filter_huge_messages(self, messages: List[ModelMessage]) -> List[ModelMessage]:
+        if not messages:
+            return []
+
+        # Never drop the system prompt, even if it is extremely large.
+        system_message, *rest = messages
+        filtered_rest = [
+            m for m in rest if self.estimate_tokens_for_message(m) < 50000
+        ]
+        return [system_message] + filtered_rest
+
+    def split_messages_for_protected_summarization(
+        self,
+        messages: List[ModelMessage],
+    ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
+        """
+        Split messages into two groups: messages to summarize and protected recent messages.
+
+        Returns:
+            Tuple of (messages_to_summarize, protected_messages)
+
+        The protected_messages are the most recent messages that total up to the configured protected token count.
+        The system message (first message) is always protected.
+        All other messages that don't fit in the protected zone will be summarized.
+        """
+        if len(messages) <= 1:  # Just system message or empty
+            return [], messages
+
+        # Always protect the system message (first message)
+        system_message = messages[0]
+        system_tokens = self.estimate_tokens_for_message(system_message)
+
+        if len(messages) == 1:
+            return [], messages
+
+        # Get the configured protected token count
+        from ..config import get_protected_token_count
+        protected_tokens_limit = get_protected_token_count()
+
+        # Calculate tokens for messages from most recent backwards (excluding system message)
+        protected_messages = []
+        protected_token_count = system_tokens  # Start with system message tokens
+
+        # Go backwards through non-system messages to find protected zone
+        for i in range(len(messages) - 1, 0, -1):  # Stop at 1, not 0 (skip system message)
+            message = messages[i]
+            message_tokens = self.estimate_tokens_for_message(message)
+
+            # If adding this message would exceed protected tokens, stop here
+            if protected_token_count + message_tokens > protected_tokens_limit:
+                break
+
+            protected_messages.append(message)
+            protected_token_count += message_tokens
+
+        # Messages that were added while scanning backwards are currently in reverse order.
+        # Reverse them to restore chronological ordering, then prepend the system prompt.
+        protected_messages.reverse()
+        protected_messages.insert(0, system_message)
+
+        # Messages to summarize are everything between the system message and the
+        # protected tail zone we just constructed.
+        protected_start_idx = max(1, len(messages) - (len(protected_messages) - 1))
+        messages_to_summarize = messages[1:protected_start_idx]
+
+        # Emit info messages
+        from ..messaging import emit_info
+        emit_info(
+            f"🔒 Protecting {len(protected_messages)} recent messages ({protected_token_count} tokens, limit: {protected_tokens_limit})"
+        )
+        emit_info(f"📝 Summarizing {len(messages_to_summarize)} older messages")
+
+        return messages_to_summarize, protected_messages
+
+    def summarize_messages(
+        self,
+        messages: List[ModelMessage],
+        with_protection: bool = True
+    ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
+        """
+        Summarize messages while protecting recent messages up to PROTECTED_TOKENS.
+
+        Returns:
+            Tuple of (compacted_messages, summarized_source_messages)
+            where compacted_messages always preserves the original system message
+            as the first entry.
+        """
+        messages_to_summarize: List[ModelMessage]
+        protected_messages: List[ModelMessage]
+
+        if with_protection:
+            messages_to_summarize, protected_messages = (
+                self.split_messages_for_protected_summarization(messages)
+            )
+        else:
+            messages_to_summarize = messages[1:] if messages else []
+            protected_messages = messages[:1]
+
+        if not messages:
+            return [], []
+
+        system_message = messages[0]
+
+        if not messages_to_summarize:
+            # Nothing to summarize, so just return the original sequence
+            return self.prune_interrupted_tool_calls(messages), []
+
+        instructions = (
+            "The input will be a log of Agentic AI steps that have been taken"
+            " as well as user queries, etc. Summarize the contents of these steps."
+            " The high level details should remain but the bulk of the content from tool-call"
+            " responses should be compacted and summarized. For example if you see a tool-call"
+            " reading a file, and the file contents are large, then in your summary you might just"
+            " write: * used read_file on space_invaders.cpp - contents removed."
+            "\n Make sure your result is a bulleted list of all steps and interactions."
+            "\n\nNOTE: This summary represents older conversation history. Recent messages are preserved separately."
+        )
+
+        try:
+            from ..summarization_agent import run_summarization_sync
+            new_messages = run_summarization_sync(
+                instructions, message_history=messages_to_summarize
+            )
+
+            if not isinstance(new_messages, list):
+                from ..messaging import emit_warning
+                emit_warning(
+                    "Summarization agent returned non-list output; wrapping into message request"
+                )
+                new_messages = [ModelRequest([TextPart(str(new_messages))])]
+
+            compacted: List[ModelMessage] = [system_message] + list(new_messages)
+
+            # Drop the system message from protected_messages because we already included it
+            protected_tail = [msg for msg in protected_messages if msg is not system_message]
+
+            compacted.extend(protected_tail)
+
+            return self.prune_interrupted_tool_calls(compacted), messages_to_summarize
+        except Exception as e:
+            from ..messaging import emit_error
+            emit_error(f"Summarization failed during compaction: {e}")
+            return messages, []  # Return original messages on failure
+
+    def summarize_message(self, message: ModelMessage) -> ModelMessage:
+        try:
+            # If the message looks like a system/instructions message, skip summarization
+            instructions = getattr(message, "instructions", None)
+            if instructions:
+                return message
+            # If any part is a tool call, skip summarization
+            for part in message.parts:
+                if isinstance(part, ToolCallPart) or getattr(part, "tool_name", None):
+                    return message
+            # Build prompt from textual content parts
+            content_bits: List[str] = []
+            for part in message.parts:
+                s = self.stringify_message_part(part)
+                if s:
+                    content_bits.append(s)
+            if not content_bits:
+                return message
+            prompt = "Please summarize the following user message:\n" + "\n".join(
+                content_bits
+            )
+            
+            from ..summarization_agent import run_summarization_sync
+            output_text = run_summarization_sync(prompt)
+            summarized = ModelRequest([TextPart(output_text)])
+            return summarized
+        except Exception as e:
+            from ..messaging import emit_error
+            emit_error(f"Summarization failed: {e}")
+            return message
+
+    def get_model_context_length(self) -> int:
+        """
+        Get the context length for the currently configured model from models.json
+        """
+        from ..config import get_model_name
+        from ..model_factory import ModelFactory
+
+        model_configs = ModelFactory.load_config()
+        model_name = get_model_name()
+
+        # Get context length from model config
+        model_config = model_configs.get(model_name, {})
+        context_length = model_config.get("context_length", 128000)  # Default value
+
+        return int(context_length)
+
+    def prune_interrupted_tool_calls(self, messages: List[ModelMessage]) -> List[ModelMessage]:
+        """
+        Remove any messages that participate in mismatched tool call sequences.
+
+        A mismatched tool call id is one that appears in a ToolCall (model/tool request)
+        without a corresponding tool return, or vice versa. We preserve original order
+        and only drop messages that contain parts referencing mismatched tool_call_ids.
+        """
+        if not messages:
+            return messages
+
+        tool_call_ids: Set[str] = set()
+        tool_return_ids: Set[str] = set()
+
+        # First pass: collect ids for calls vs returns
+        for msg in messages:
+            for part in getattr(msg, "parts", []) or []:
+                tool_call_id = getattr(part, "tool_call_id", None)
+                if not tool_call_id:
+                    continue
+
+                if self._is_tool_call_part(part) and not self._is_tool_return_part(part):
+                    tool_call_ids.add(tool_call_id)
+                elif self._is_tool_return_part(part):
+                    tool_return_ids.add(tool_call_id)
+
+        mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
+        if not mismatched:
+            return messages
+
+        pruned: List[ModelMessage] = []
+        dropped_count = 0
+        for msg in messages:
+            has_mismatched = False
+            for part in getattr(msg, "parts", []) or []:
+                tcid = getattr(part, "tool_call_id", None)
+                if tcid and tcid in mismatched:
+                    has_mismatched = True
+                    break
+            if has_mismatched:
+                dropped_count += 1
+                continue
+            pruned.append(msg)
+
+        if dropped_count:
+            from ..messaging import emit_warning
+            emit_warning(
+                f"Pruned {dropped_count} message(s) with mismatched tool_call_id pairs"
+            )
+        return pruned

code_puppy/command_line/mcp/add_command.py

@@ -8,7 +8,7 @@ import os
 from typing import List, Optional
 
 from code_puppy.messaging import emit_info
-from code_puppy.state_management import is_tui_mode
+from code_puppy.tui_state import is_tui_mode
 
 from .base import MCPCommandBase
 from .wizard_utils import run_interactive_install_wizard

code_puppy/command_line/mcp/install_command.py

@@ -6,7 +6,7 @@ import logging
 from typing import List, Optional
 
 from code_puppy.messaging import emit_info
-from code_puppy.state_management import is_tui_mode
+from code_puppy.tui_state import is_tui_mode
 
 from .base import MCPCommandBase
 from .wizard_utils import run_interactive_install_wizard

code_puppy/config.py

@@ -115,7 +115,6 @@ def get_config_keys():
     default_keys = [
         "yolo_mode",
         "model",
-        "vqa_model_name",
         "compaction_strategy",
         "protected_token_count",
         "compaction_threshold",

code_puppy/main.py

@@ -29,7 +29,8 @@ from code_puppy.message_history_processor import (
     message_history_accumulator,
     prune_interrupted_tool_calls,
 )
-from code_puppy.state_management import is_tui_mode, set_message_history, set_tui_mode
+from code_puppy.state_management import set_message_history
+from code_puppy.tui_state import is_tui_mode, set_tui_mode
 from code_puppy.tools.common import console
 from code_puppy.version_checker import default_version_mismatch_behavior
 

code_puppy/message_history_processor.py

@@ -1,6 +1,6 @@
 import json
 import queue
-from typing import Any, List, Set, Tuple
+from typing import Any, List, Set, Tuple, Union
 
 import pydantic
 from pydantic_ai.messages import (
@@ -25,7 +25,6 @@ from code_puppy.state_management import (
     add_compacted_message_hash,
     get_compacted_message_hashes,
     get_message_history,
-    hash_message,
     set_message_history,
 )
 from code_puppy.summarization_agent import run_summarization_sync
@@ -44,34 +43,10 @@ def stringify_message_part(part) -> str:
     Returns:
         String representation of the message part
     """
-    result = ""
-    if hasattr(part, "part_kind"):
-        result += part.part_kind + ": "
-    else:
-        result += str(type(part)) + ": "
-
-    # Handle content
-    if hasattr(part, "content") and part.content:
-        # Handle different content types
-        if isinstance(part.content, str):
-            result = part.content
-        elif isinstance(part.content, pydantic.BaseModel):
-            result = json.dumps(part.content.model_dump())
-        elif isinstance(part.content, dict):
-            result = json.dumps(part.content)
-        else:
-            result = str(part.content)
-
-    # Handle tool calls which may have additional token costs
-    # If part also has content, we'll process tool calls separately
-    if hasattr(part, "tool_name") and part.tool_name:
-        # Estimate tokens for tool name and parameters
-        tool_text = part.tool_name
-        if hasattr(part, "args"):
-            tool_text += f" {str(part.args)}"
-        result += tool_text
-
-    return result
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    return current_agent.stringify_message_part(part)
 
 
 def estimate_tokens_for_message(message: ModelMessage) -> int:
@@ -79,61 +54,44 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
     Estimate the number of tokens in a message using len(message) - 4.
     Simple and fast replacement for tiktoken.
     """
-    total_tokens = 0
-
-    for part in message.parts:
-        part_str = stringify_message_part(part)
-        if part_str:
-            total_tokens += len(part_str)
-
-    return int(max(1, total_tokens) / 4)
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    return current_agent.estimate_tokens_for_message(message)
 
 
 def filter_huge_messages(messages: List[ModelMessage]) -> List[ModelMessage]:
     if not messages:
         return []
 
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    
     # Never drop the system prompt, even if it is extremely large.
     system_message, *rest = messages
     filtered_rest = [
-        m for m in rest if estimate_tokens_for_message(m) < 50000
+        m for m in rest if current_agent.estimate_tokens_for_message(m) < 50000
     ]
     return [system_message] + filtered_rest
 
 
 def _is_tool_call_part(part: Any) -> bool:
-    if isinstance(part, (ToolCallPart, ToolCallPartDelta)):
-        return True
-
-    part_kind = (getattr(part, "part_kind", "") or "").replace("_", "-")
-    if part_kind == "tool-call":
-        return True
-
-    has_tool_name = getattr(part, "tool_name", None) is not None
-    has_args = getattr(part, "args", None) is not None
-    has_args_delta = getattr(part, "args_delta", None) is not None
-
-    return bool(has_tool_name and (has_args or has_args_delta))
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    return current_agent._is_tool_call_part(part)
 
 
 def _is_tool_return_part(part: Any) -> bool:
-    if isinstance(part, (ToolReturnPart, ToolReturn)):
-        return True
-
-    part_kind = (getattr(part, "part_kind", "") or "").replace("_", "-")
-    if part_kind in {"tool-return", "tool-result"}:
-        return True
-
-    if getattr(part, "tool_call_id", None) is None:
-        return False
-
-    has_content = getattr(part, "content", None) is not None
-    has_content_delta = getattr(part, "content_delta", None) is not None
-    return bool(has_content or has_content_delta)
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    return current_agent._is_tool_return_part(part)
 
 
 def split_messages_for_protected_summarization(
-    messages: List[ModelMessage],
+    messages: List[ModelMessage], with_protection: bool = True
 ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
     """
     Split messages into two groups: messages to summarize and protected recent messages.
@@ -150,7 +108,13 @@ def split_messages_for_protected_summarization(
 
     # Always protect the system message (first message)
     system_message = messages[0]
-    system_tokens = estimate_tokens_for_message(system_message)
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    system_tokens = current_agent.estimate_tokens_for_message(system_message)
+
+    if not with_protection:
+        # If not protecting, summarize everything except the system message
+        return messages[1:], [system_message]
 
     if len(messages) == 1:
         return [], messages
@@ -165,7 +129,7 @@ def split_messages_for_protected_summarization(
     # Go backwards through non-system messages to find protected zone
     for i in range(len(messages) - 1, 0, -1):  # Stop at 1, not 0 (skip system message)
         message = messages[i]
-        message_tokens = estimate_tokens_for_message(message)
+        message_tokens = current_agent.estimate_tokens_for_message(message)
 
         # If adding this message would exceed protected tokens, stop here
         if protected_token_count + message_tokens > protected_tokens_limit:
@@ -192,6 +156,18 @@ def split_messages_for_protected_summarization(
     return messages_to_summarize, protected_messages
 
 
+def run_summarization_sync(
+    instructions: str,
+    message_history: List[ModelMessage],
+) -> Union[List[ModelMessage], str]:
+    """
+    Run summarization synchronously using the configured summarization agent.
+    This is exposed as a global function so tests can mock it.
+    """
+    from code_puppy.summarization_agent import run_summarization_sync as _run_summarization_sync
+    return _run_summarization_sync(instructions, message_history)
+
+
 def summarize_messages(
     messages: List[ModelMessage], with_protection: bool = True
 ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
@@ -203,26 +179,22 @@ def summarize_messages(
         where compacted_messages always preserves the original system message
         as the first entry.
     """
-    messages_to_summarize: List[ModelMessage]
-    protected_messages: List[ModelMessage]
-
-    if with_protection:
-        messages_to_summarize, protected_messages = (
-            split_messages_for_protected_summarization(messages)
-        )
-    else:
-        messages_to_summarize = messages[1:] if messages else []
-        protected_messages = messages[:1]
-
     if not messages:
         return [], []
 
-    system_message = messages[0]
+    # Split messages into those to summarize and those to protect
+    messages_to_summarize, protected_messages = split_messages_for_protected_summarization(
+        messages, with_protection
+    )
 
+    # If nothing to summarize, return the original list
     if not messages_to_summarize:
-        # Nothing to summarize, so just return the original sequence
         return prune_interrupted_tool_calls(messages), []
 
+    # Get the system message (always the first message)
+    system_message = messages[0]
+
+    # Instructions for the summarization agent
     instructions = (
         "The input will be a log of Agentic AI steps that have been taken"
         " as well as user queries, etc. Summarize the contents of these steps."
@@ -235,6 +207,7 @@ def summarize_messages(
     )
 
     try:
+        # Use the global function so tests can mock it
         new_messages = run_summarization_sync(
             instructions, message_history=messages_to_summarize
         )
@@ -245,6 +218,7 @@ def summarize_messages(
             )
             new_messages = [ModelRequest([TextPart(str(new_messages))])]
 
+        # Construct compacted messages: system message + new summarized messages + protected tail
         compacted: List[ModelMessage] = [system_message] + list(new_messages)
 
         # Drop the system message from protected_messages because we already included it
@@ -259,47 +233,22 @@ def summarize_messages(
 
 
 def summarize_message(message: ModelMessage) -> ModelMessage:
-    try:
-        # If the message looks like a system/instructions message, skip summarization
-        instructions = getattr(message, "instructions", None)
-        if instructions:
-            return message
-        # If any part is a tool call, skip summarization
-        for part in message.parts:
-            if isinstance(part, ToolCallPart) or getattr(part, "tool_name", None):
-                return message
-        # Build prompt from textual content parts
-        content_bits: List[str] = []
-        for part in message.parts:
-            s = stringify_message_part(part)
-            if s:
-                content_bits.append(s)
-        if not content_bits:
-            return message
-        prompt = "Please summarize the following user message:\n" + "\n".join(
-            content_bits
-        )
-        output_text = run_summarization_sync(prompt)
-        summarized = ModelRequest([TextPart(output_text)])
-        return summarized
-    except Exception as e:
-        emit_error(f"Summarization failed: {e}")
-        return message
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    
+    return current_agent.summarize_message(message)
 
 
 def get_model_context_length() -> int:
     """
     Get the context length for the currently configured model from models.json
     """
-    model_configs = ModelFactory.load_config()
-    model_name = get_model_name()
-
-    # Get context length from model config
-    model_config = model_configs.get(model_name, {})
-    context_length = model_config.get("context_length", 128000)  # Default value
-
-    # Reserve 10% of context for response
-    return int(context_length)
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    
+    return current_agent.get_model_context_length()
 
 
 def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMessage]:
@@ -310,62 +259,30 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
     without a corresponding tool return, or vice versa. We preserve original order
     and only drop messages that contain parts referencing mismatched tool_call_ids.
     """
-    if not messages:
-        return messages
-
-    tool_call_ids: Set[str] = set()
-    tool_return_ids: Set[str] = set()
-
-    # First pass: collect ids for calls vs returns
-    for msg in messages:
-        for part in getattr(msg, "parts", []) or []:
-            tool_call_id = getattr(part, "tool_call_id", None)
-            if not tool_call_id:
-                continue
-
-            if _is_tool_call_part(part) and not _is_tool_return_part(part):
-                tool_call_ids.add(tool_call_id)
-            elif _is_tool_return_part(part):
-                tool_return_ids.add(tool_call_id)
-
-    mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
-    if not mismatched:
-        return messages
-
-    pruned: List[ModelMessage] = []
-    dropped_count = 0
-    for msg in messages:
-        has_mismatched = False
-        for part in getattr(msg, "parts", []) or []:
-            tcid = getattr(part, "tool_call_id", None)
-            if tcid and tcid in mismatched:
-                has_mismatched = True
-                break
-        if has_mismatched:
-            dropped_count += 1
-            continue
-        pruned.append(msg)
-
-    if dropped_count:
-        emit_warning(
-            f"Pruned {dropped_count} message(s) with mismatched tool_call_id pairs"
-        )
-    return pruned
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    
+    return current_agent.prune_interrupted_tool_calls(messages)
 
 
 def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
-    cleaned_history = prune_interrupted_tool_calls(messages)
+    # Get current agent to use its methods
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    
+    cleaned_history = current_agent.prune_interrupted_tool_calls(messages)
 
     total_current_tokens = sum(
-        estimate_tokens_for_message(msg) for msg in cleaned_history
+        current_agent.estimate_tokens_for_message(msg) for msg in cleaned_history
     )
 
-    model_max = get_model_context_length()
+    model_max = current_agent.get_model_context_length()
 
     proportion_used = total_current_tokens / model_max if model_max else 0
 
     # Check if we're in TUI mode and can update the status bar
-    from code_puppy.state_management import get_tui_app_instance, is_tui_mode
+    from code_puppy.tui_state import get_tui_app_instance, is_tui_mode
 
     if is_tui_mode():
         tui_app = get_tui_app_instance()
@@ -401,7 +318,7 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
     compaction_strategy = get_compaction_strategy()
 
     if proportion_used > compaction_threshold:
-        filtered_history = filter_huge_messages(cleaned_history)
+        filtered_history = current_agent.filter_huge_messages(cleaned_history)
 
         if compaction_strategy == "truncation":
             protected_tokens = get_protected_token_count()
@@ -413,7 +330,7 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
             )
 
         final_token_count = sum(
-            estimate_tokens_for_message(msg) for msg in result_messages
+            current_agent.estimate_tokens_for_message(msg) for msg in result_messages
         )
         # Update status bar with final token count if in TUI mode
         if is_tui_mode():
@@ -438,7 +355,7 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
             emit_info(f"Final token count after processing: {final_token_count}")
         set_message_history(result_messages)
         for m in summarized_messages:
-            add_compacted_message_hash(hash_message(m))
+            add_compacted_message_hash(current_agent.hash_message(m))
         return result_messages
 
     set_message_history(cleaned_history)
@@ -471,11 +388,16 @@ def truncation(
 
 def message_history_accumulator(messages: List[Any]):
     existing_history = list(get_message_history())
-    seen_hashes = {hash_message(message) for message in existing_history}
+    
+    # Get current agent to use its method
+    from code_puppy.agents.agent_manager import get_current_agent_config
+    current_agent = get_current_agent_config()
+    
+    seen_hashes = {current_agent.hash_message(message) for message in existing_history}
     compacted_hashes = get_compacted_message_hashes()
 
     for message in messages:
-        message_hash = hash_message(message)
+        message_hash = current_agent.hash_message(message)
         if message_hash in seen_hashes or message_hash in compacted_hashes:
             continue
         existing_history.append(message)

code_puppy/messaging/message_queue.py

@@ -219,7 +219,7 @@ class MessageQueue:
         start_time = time.time()
 
         # Check if we're in TUI mode - if so, try to yield control to the event loop
-        from code_puppy.state_management import is_tui_mode
+        from code_puppy.tui_state import is_tui_mode
 
         sleep_interval = 0.05 if is_tui_mode() else 0.1
 
@@ -243,7 +243,7 @@ class MessageQueue:
 
     def provide_prompt_response(self, prompt_id: str, response: str):
         """Provide a response to a human input request."""
-        from code_puppy.state_management import is_tui_mode
+        from code_puppy.tui_state import is_tui_mode
 
         if is_tui_mode():
             print(f"[DEBUG] Providing response for {prompt_id}: {response[:20]}...")
@@ -337,7 +337,7 @@ def emit_system_message(content: Any, **metadata):
 
 def emit_divider(content: str = "[dim]" + "─" * 100 + "\n" + "[/dim]", **metadata):
     """Emit a divider line"""
-    from code_puppy.state_management import is_tui_mode
+    from code_puppy.tui_state import is_tui_mode
 
     if not is_tui_mode():
         emit_message(MessageType.DIVIDER, content, **metadata)
@@ -347,7 +347,7 @@ def emit_divider(content: str = "[dim]" + "─" * 100 + "\n" + "[/dim]", **metad
 
 def emit_prompt(prompt_text: str, timeout: float = None) -> str:
     """Emit a human input request and wait for response."""
-    from code_puppy.state_management import is_tui_mode
+    from code_puppy.tui_state import is_tui_mode
 
     # In interactive mode, use direct input instead of the queue system
     if not is_tui_mode():

code_puppy/state_management.py

@@ -1,14 +1,8 @@
-import json
 from types import ModuleType
 from typing import Any, List, Set
 
-import pydantic
-
 from code_puppy.messaging import emit_info
 
-_tui_mode: bool = False
-_tui_app_instance: Any = None
-
 
 def _require_agent_manager() -> ModuleType:
     """Import the agent manager module, raising if it is unavailable."""
@@ -31,53 +25,6 @@ def get_compacted_message_hashes() -> Set[str]:
     return manager.get_current_agent_compacted_message_hashes()
 
 
-def set_tui_mode(enabled: bool) -> None:
-    """Set the global TUI mode state.
-
-    Args:
-        enabled: True if running in TUI mode, False otherwise
-    """
-    global _tui_mode
-    _tui_mode = enabled
-
-
-def is_tui_mode() -> bool:
-    """Check if the application is running in TUI mode.
-
-    Returns:
-        True if running in TUI mode, False otherwise
-    """
-    return _tui_mode
-
-
-def set_tui_app_instance(app_instance: Any) -> None:
-    """Set the global TUI app instance reference.
-
-    Args:
-        app_instance: The TUI app instance
-    """
-    global _tui_app_instance
-    _tui_app_instance = app_instance
-
-
-def get_tui_app_instance() -> Any:
-    """Get the current TUI app instance.
-
-    Returns:
-        The TUI app instance if available, None otherwise
-    """
-    return _tui_app_instance
-
-
-def get_tui_mode() -> bool:
-    """Get the current TUI mode state.
-
-    Returns:
-        True if running in TUI mode, False otherwise
-    """
-    return _tui_mode
-
-
 def get_message_history() -> List[Any]:
     """Get message history for the active agent."""
     manager = _require_agent_manager()
@@ -108,52 +55,4 @@ def extend_message_history(history: List[Any]) -> None:
     manager.extend_current_agent_message_history(history)
 
 
-def _stringify_part(part: Any) -> str:
-    """Create a stable string representation for a message part.
-
-    We deliberately ignore timestamps so identical content hashes the same even when
-    emitted at different times. This prevents status updates from blowing up the
-    history when they are repeated with new timestamps."""
-
-    attributes: List[str] = [part.__class__.__name__]
-
-    # Role/instructions help disambiguate parts that otherwise share content
-    if hasattr(part, "role") and part.role:
-        attributes.append(f"role={part.role}")
-    if hasattr(part, "instructions") and part.instructions:
-        attributes.append(f"instructions={part.instructions}")
-
-    if hasattr(part, "tool_call_id") and part.tool_call_id:
-        attributes.append(f"tool_call_id={part.tool_call_id}")
-
-    if hasattr(part, "tool_name") and part.tool_name:
-        attributes.append(f"tool_name={part.tool_name}")
-
-    content = getattr(part, "content", None)
-    if content is None:
-        attributes.append("content=None")
-    elif isinstance(content, str):
-        attributes.append(f"content={content}")
-    elif isinstance(content, pydantic.BaseModel):
-        attributes.append(f"content={json.dumps(content.model_dump(), sort_keys=True)}")
-    elif isinstance(content, dict):
-        attributes.append(f"content={json.dumps(content, sort_keys=True)}")
-    else:
-        attributes.append(f"content={repr(content)}")
-    result = "|".join(attributes)
-    return result
-
-
-def hash_message(message: Any) -> int:
-    """Create a stable hash for a model message that ignores timestamps."""
-    role = getattr(message, "role", None)
-    instructions = getattr(message, "instructions", None)
-    header_bits: List[str] = []
-    if role:
-        header_bits.append(f"role={role}")
-    if instructions:
-        header_bits.append(f"instructions={instructions}")
-
-    part_strings = [_stringify_part(part) for part in getattr(message, "parts", [])]
-    canonical = "||".join(header_bits + part_strings)
-    return hash(canonical)
+

code_puppy/tools/command_runner.py

@@ -19,7 +19,7 @@ from code_puppy.messaging import (
     emit_system_message,
     emit_warning,
 )
-from code_puppy.state_management import is_tui_mode
+from code_puppy.tui_state import is_tui_mode
 from code_puppy.tools.common import generate_group_id
 
 # Maximum line length for shell command output to prevent massive token usage

code_puppy/tui/app.py

@@ -149,7 +149,7 @@ class CodePuppyTUI(App):
     def on_mount(self) -> None:
         """Initialize the application when mounted."""
         # Register this app instance for global access
-        from code_puppy.state_management import set_tui_app_instance
+        from code_puppy.tui_state import set_tui_app_instance
 
         set_tui_app_instance(self)
 

code_puppy/tui_state.py

@@ -0,0 +1,55 @@
+# TUI State Management
+# This module contains functions for managing the global TUI state
+
+from typing import Any
+
+# Global TUI state variables
+_tui_mode: bool = False
+_tui_app_instance: Any = None
+
+
+def set_tui_mode(enabled: bool) -> None:
+    """Set the global TUI mode state.
+
+    Args:
+        enabled: True if running in TUI mode, False otherwise
+    """
+    global _tui_mode
+    _tui_mode = enabled
+
+
+def is_tui_mode() -> bool:
+    """Check if the application is running in TUI mode.
+
+    Returns:
+        True if running in TUI mode, False otherwise
+    """
+    return _tui_mode
+
+
+def set_tui_app_instance(app_instance: Any) -> None:
+    """Set the global TUI app instance reference.
+
+    Args:
+        app_instance: The TUI app instance
+    """
+    global _tui_app_instance
+    _tui_app_instance = app_instance
+
+
+def get_tui_app_instance() -> Any:
+    """Get the current TUI app instance.
+
+    Returns:
+        The TUI app instance if available, None otherwise
+    """
+    return _tui_app_instance
+
+
+def get_tui_mode() -> bool:
+    """Get the current TUI mode state.
+
+    Returns:
+        True if running in TUI mode, False otherwise
+    """
+    return _tui_mode

{code_puppy-0.0.172.dist-info → code_puppy-0.0.173.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.172
+Version: 0.0.173
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.172.dist-info → code_puppy-0.0.173.dist-info}/RECORD

@@ -1,18 +1,19 @@
 code_puppy/__init__.py,sha256=ehbM1-wMjNmOXk_DBhhJECFyBv2dRHwwo7ucjHeM68E,107
 code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
-code_puppy/agent.py,sha256=G0eSd7RLFw0A1Jf6ZJFgtnzMD9PX9HA-QuKmbtHs4v8,8403
+code_puppy/agent.py,sha256=rBe7OS_ekZvMuteLuIp9lor9zIP7KHBsxZ22pWM9_fg,8526
 code_puppy/callbacks.py,sha256=6wYB6K_fGSCkKKEFaYOYkJT45WaV5W_NhUIzcvVH_nU,5060
-code_puppy/config.py,sha256=g0X-X_Wieo94k0hmwSXqpB5nPIif1H5p7Zw47A7aDmo,20651
+code_puppy/config.py,sha256=A3l5gSJGz9kGXJb2pZVyoksDGclIhMdKmAv-EdDSleY,20625
 code_puppy/http_utils.py,sha256=jnElpVNNIK-_gcqwsBYRImDGU-tYNfsLR7Gtme5CYzs,8423
-code_puppy/main.py,sha256=tYLfhUjPTJ-4S1r-pr-jSbn6kIU1iYvt2Z8lxI7zDFY,22220
-code_puppy/message_history_processor.py,sha256=TsmH4L4srbk0JStaVIcLFoFqm6DVkj1yW3yyY2X_RqY,17823
+code_puppy/main.py,sha256=VlH8fXPapXblSagOjrezeSTtFij_-X3dzq1cfHPXwDI,22252
+code_puppy/message_history_processor.py,sha256=SnVpUCMkbtM4RX5b6ioeG-fh--ri0bh8_yHp7ZQIAPE,16005
 code_puppy/model_factory.py,sha256=z9vQbcGllgMwU0On8rPvzYxkygW2Uyd3NJmRzbKv-is,13759
 code_puppy/models.json,sha256=iXmLZGflnQcu2DRh4WUlgAhoXdvoxUc7KBhB8YxawXM,3088
 code_puppy/reopenable_async_client.py,sha256=4UJRaMp5np8cbef9F0zKQ7TPKOfyf5U-Kv-0zYUWDho,8274
 code_puppy/round_robin_model.py,sha256=SEN3VSwTgC5wHjx2sZsHQLPWOycf4jGwzB-EydgqkdY,5643
-code_puppy/state_management.py,sha256=wAK8J63DHta0FQg89dn_FihW60aNU-wZI9cYv5XsfH0,4999
+code_puppy/state_management.py,sha256=OyBSfdicKN7ObZEGs6Kbyy1JC8R8n4FZBOLIBvQZTBc,1916
 code_puppy/status_display.py,sha256=F6eEAkGePDp4StM2BWj-uLLQTDGtJrf0IufzCeP1rRg,8336
 code_puppy/summarization_agent.py,sha256=kos4_YK-l_YjYRq4Fs4X5YoTUbmAcDhhPqefL-rdenI,3197
+code_puppy/tui_state.py,sha256=TT76XBVapKj6fKjFzz6oxCONeN_BZwcMILxxZcxu6-Y,1171
 code_puppy/version_checker.py,sha256=bjLDmgGPrl7XnYwX1u13O8uFlsfikV90PK6nbA9Z9QU,1150
 code_puppy/agents/__init__.py,sha256=SwtHGNG1GIgDBv7y3EGIXOXEWrG_Ou7fEknNgFbrHv8,594
 code_puppy/agents/agent_code_puppy.py,sha256=sbuQxLzlkMbPOyLbILbXOAHecRsxbFdQt13HJ_GEqQo,7972
@@ -20,7 +21,7 @@ code_puppy/agents/agent_creator_agent.py,sha256=eNOlJssQdyoQm1F7d-TZWcMXpkYmZ-w9
 code_puppy/agents/agent_manager.py,sha256=nXvro6fpX8KA-NedRoVJuhJW966trrePOrH4eAnqq40,17034
 code_puppy/agents/agent_orchestrator.json,sha256=Iqnc0p6ICoAlUTMkEsi1XXMXJi4pdxVnWZUMaih6s5o,1267
 code_puppy/agents/agent_qa_kitten.py,sha256=5PeFFSwCFlTUvP6h5bGntx0xv5NmRwBiw0HnMqY8nLI,9107
-code_puppy/agents/base_agent.py,sha256=mll5s4Lsc6V-YcBJJT-oyXC50LZBGeR7xAJLBk62Zf8,3769
+code_puppy/agents/base_agent.py,sha256=XUsziIf0ZGCe6ZLjt-kJqbeYTy9gTQE3_BPq7THQ3X8,19538
 code_puppy/agents/json_agent.py,sha256=y6AYE3Fx9LhmemcPzt46d7359MNnkGIjU83YBGNer2g,4533
 code_puppy/agents/runtime_manager.py,sha256=fUOBpmETo3wTyLc5wWBfGKSX1HFRQWSpuwxYAOyA-_8,10059
 code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
@@ -33,11 +34,11 @@ code_puppy/command_line/motd.py,sha256=PEdkp3ZnydVfvd7mNJylm8YyFNUKg9jmY6uwkA1em
 code_puppy/command_line/prompt_toolkit_completion.py,sha256=PLb1Yt_65iQI2mzPEPxPsSaRww5Ur951Qn-K-TLMCGQ,10006
 code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
 code_puppy/command_line/mcp/__init__.py,sha256=0-OQuwjq_pLiTVJ1_NrirVwdRerghyKs_MTZkwPC7YY,315
-code_puppy/command_line/mcp/add_command.py,sha256=f65ZVb_LF4y9KjAms66bPxGrxUW6EeEJCT4HrZXdkqY,6416
+code_puppy/command_line/mcp/add_command.py,sha256=lZ09RpFDIeghX1zhc2YIAqBASs5Ra52x5YAasUKvqJg,6409
 code_puppy/command_line/mcp/base.py,sha256=0uessGekNM37X3tLrKImkhZpgxjAoR7fqskbmkBjcf8,890
 code_puppy/command_line/mcp/handler.py,sha256=ZPWNfJEwGurNQh4KUCRRRsHXuB0kHlaGG4oLN1sFhBg,4412
 code_puppy/command_line/mcp/help_command.py,sha256=Z55-ObpUQFMdqMWAkSJkRi_v2uZhDFVxg6DcIdjVY6Q,5250
-code_puppy/command_line/mcp/install_command.py,sha256=Smp7nCDTwXplltQi2OPlUIwWdFvNEMcg-6h62EI5AhM,8827
+code_puppy/command_line/mcp/install_command.py,sha256=kNASwQ-CUL_5zBTzJhBy_G2ClI6kRzgLJx7EeQX4TmE,8820
 code_puppy/command_line/mcp/list_command.py,sha256=tjxCMmK6yrmjM5L-lFY_qdL_dKTPdBZ_q0bEoAmBADg,3179
 code_puppy/command_line/mcp/logs_command.py,sha256=x_QsVGPpI5XY7RCZtiNFegc6R3csiwF_IEB_Rh2575w,4453
 code_puppy/command_line/mcp/remove_command.py,sha256=MrWmXQ9jZTq1wrohFDO3ls0a1faTHCqRZocN-ynTzh8,2753
@@ -69,7 +70,7 @@ code_puppy/mcp_/status_tracker.py,sha256=uekxrzkzIWrv3OfSVgblaPuoGFcAh_dBYwCcaHZ
 code_puppy/mcp_/system_tools.py,sha256=7_oR8k0c8YjtCcYF9g7A946oAGuKOf_i-92aJH7VmlQ,7331
 code_puppy/mcp_/examples/retry_example.py,sha256=VVdSr7Jq7PPS7AVU1Ev5LnUZe2uBpdZYG7oJSo05TKM,7221
 code_puppy/messaging/__init__.py,sha256=h2eZ7nJblKF71_dNUIBj3vL5RDw7WGy8nh6T_EYVrcA,1176
-code_puppy/messaging/message_queue.py,sha256=CDVpstLee_RbCBeJWv2eON3c3qhlEISf2i9aSXJTLU4,12600
+code_puppy/messaging/message_queue.py,sha256=A6_CVn55tA5cINrIML9N_fS6fGQP-n8gC8abnkwF034,12572
 code_puppy/messaging/queue_console.py,sha256=hf32bKfAOdAaxYuARnmDuWhq4ET77xMWDvu5_T2JggY,10912
 code_puppy/messaging/renderers.py,sha256=9VOpVmu7emyyg1CXgm17u4IzMNcLHvueBl7G14pLQho,16123
 code_puppy/messaging/spinner/__init__.py,sha256=9mkXPYojafydBOAMh9ZUrB4X6uH5Iqz_-E-Obpd72ko,1365
@@ -87,7 +88,7 @@ code_puppy/tools/browser_screenshot.py,sha256=QSwxS37G4LSo-Q9SBiuIofxWKnyInM90TY
 code_puppy/tools/browser_scripts.py,sha256=BLSx1Q2F_mOOoGCoyXat3HvazTb1XaFYPXAF8CYVeX8,15071
 code_puppy/tools/browser_workflows.py,sha256=4u4u59arpY65hdcDMvJGpT02vks0ufnXNJVujzKe_dg,6430
 code_puppy/tools/camoufox_manager.py,sha256=bYnwyOETGDe_h8Q3kXH7w6kFr-OCpMi_Zuh4y11p__E,5097
-code_puppy/tools/command_runner.py,sha256=sum09fxhHtQ0-8xBpVYyVGbQyLjscGQh0fHNYsoU09E,22424
+code_puppy/tools/command_runner.py,sha256=5H4wK-v3UQ713_0JRefpAwyxGBWD9R5yLptR6BhZyIY,22417
 code_puppy/tools/common.py,sha256=pL-9xcRs3rxU7Fl9X9EUgbDp2-csh2LLJ5DHH_KAHKY,10596
 code_puppy/tools/file_modifications.py,sha256=EaDWcv6gi8wAvpgyeJdKSKPWg9fTpZoEkxQiLCE6rn4,23218
 code_puppy/tools/file_operations.py,sha256=3RX-eqhIukle3KA-QTEaiTMIefOWy_JhmPQaijEAt6U,32481
@@ -103,7 +104,7 @@ code_puppy/tools/browser/browser_workflows.py,sha256=HZ0lPmEyAobPIWR-SK1E0ngW1Of
 code_puppy/tools/browser/camoufox_manager.py,sha256=E1CJwQtzPFoDQiXSHHk28niWuJhk3soZ-ItxXCXWO0M,6938
 code_puppy/tools/browser/vqa_agent.py,sha256=u3EhZQHNBiWUn-XLDK9MnVyd2ChshPnVZbB9iEkEqH4,2118
 code_puppy/tui/__init__.py,sha256=XesAxIn32zLPOmvpR2wIDxDAnnJr81a5pBJB4cZp1Xs,321
-code_puppy/tui/app.py,sha256=6yNOC7_93WjfwUxI6LBLmhTZl1FAXO03ErsSq5HxBVs,39434
+code_puppy/tui/app.py,sha256=WW-O8myM_yl05NIdj_aSp7zN56AwimgdMA9TmEOE54Y,39427
 code_puppy/tui/messages.py,sha256=zQoToWI0eWdT36NEsY6RdCFzcDfAmfvoPlHv8jiCbgo,720
 code_puppy/tui/components/__init__.py,sha256=uj5pnk3s6SEN3SbFI0ZnzaA2KK1NNg8TfUj6U-Z732U,455
 code_puppy/tui/components/chat_view.py,sha256=NfyNXuN2idPht1rKJB4YhHVXb1AIRNO5q_nLdt8Ocug,19913
@@ -123,9 +124,9 @@ code_puppy/tui/screens/help.py,sha256=eJuPaOOCp7ZSUlecearqsuX6caxWv7NQszUh0tZJjB
 code_puppy/tui/screens/mcp_install_wizard.py,sha256=vObpQwLbXjQsxmSg-WCasoev1usEi0pollKnL0SHu9U,27693
 code_puppy/tui/screens/settings.py,sha256=GMpv-qa08rorAE9mj3AjmqjZFPhmeJ_GWd-DBHG6iAA,10671
 code_puppy/tui/screens/tools.py,sha256=3pr2Xkpa9Js6Yhf1A3_wQVRzFOui-KDB82LwrsdBtyk,1715
-code_puppy-0.0.172.data/data/code_puppy/models.json,sha256=iXmLZGflnQcu2DRh4WUlgAhoXdvoxUc7KBhB8YxawXM,3088
-code_puppy-0.0.172.dist-info/METADATA,sha256=VjpMGSIgA_Trvm70on6SEy3_9eFjgsOoakkVueRMWvA,20106
-code_puppy-0.0.172.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.172.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
-code_puppy-0.0.172.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.172.dist-info/RECORD,,
+code_puppy-0.0.173.data/data/code_puppy/models.json,sha256=iXmLZGflnQcu2DRh4WUlgAhoXdvoxUc7KBhB8YxawXM,3088
+code_puppy-0.0.173.dist-info/METADATA,sha256=4qImoiksA3Y_7gc-YlHc7cAdJJa6pnP2xhOUQbQ9vCY,20106
+code_puppy-0.0.173.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.173.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
+code_puppy-0.0.173.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.173.dist-info/RECORD,,