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

code_puppy/{mcp → mcp_}/config_wizard.py

@@ -11,7 +11,7 @@ from urllib.parse import urlparse
 
 from rich.console import Console
 
-from code_puppy.mcp.manager import ServerConfig, get_mcp_manager
+from code_puppy.mcp_.manager import ServerConfig, get_mcp_manager
 from code_puppy.messaging import (
     emit_error,
     emit_info,

code_puppy/{mcp → mcp_}/examples/retry_example.py

@@ -17,7 +17,7 @@ from typing import Any
 project_root = Path(__file__).parents[3]
 sys.path.insert(0, str(project_root))
 
-from code_puppy.mcp.retry_manager import get_retry_manager, retry_mcp_call  # noqa: E402
+from code_puppy.mcp_.retry_manager import get_retry_manager, retry_mcp_call  # noqa: E402
 
 logger = logging.getLogger(__name__)
 

code_puppy/{mcp → mcp_}/managed_server.py

@@ -24,7 +24,7 @@ from pydantic_ai.mcp import (
 )
 
 from code_puppy.http_utils import create_async_client
-from code_puppy.mcp.blocking_startup import BlockingMCPServerStdio
+from code_puppy.mcp_.blocking_startup import BlockingMCPServerStdio
 from code_puppy.messaging import emit_info
 
 # Configure logging

code_puppy/{mcp → mcp_}/server_registry_catalog.py

@@ -794,9 +794,7 @@ MCP_SERVER_REGISTRY: List[MCPServerTemplate] = [
         type="http",
         config={
             "url": "https://mcp.context7.com/mcp",
-             "headers": {
-                "Authorization": "Bearer $CONTEXT7_API_KEY"
-             }
+            "headers": {"Authorization": "Bearer $CONTEXT7_API_KEY"},
         },
         verified=True,
         popular=True,

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,62 +156,16 @@ def split_messages_for_protected_summarization(
     return messages_to_summarize, protected_messages
 
 
-def deduplicate_tool_returns(messages: List[ModelMessage]) -> List[ModelMessage]:
+def run_summarization_sync(
+    instructions: str,
+    message_history: List[ModelMessage],
+) -> Union[List[ModelMessage], str]:
     """
-    Remove duplicate tool returns while preserving the first occurrence for each tool_call_id.
-
-    This function identifies tool-return parts that share the same tool_call_id and
-    removes duplicates, keeping only the first return for each id. This prevents
-    conversation corruption from duplicate tool_result blocks.
+    Run summarization synchronously using the configured summarization agent.
+    This is exposed as a global function so tests can mock it.
     """
-    if not messages:
-        return messages
-
-    seen_tool_returns: Set[str] = set()
-    deduplicated: List[ModelMessage] = []
-    removed_count = 0
-
-    for msg in messages:
-        if not hasattr(msg, "parts") or not msg.parts:
-            deduplicated.append(msg)
-            continue
-
-        filtered_parts = []
-        msg_had_duplicates = False
-
-        for part in msg.parts:
-            tool_call_id = getattr(part, "tool_call_id", None)
-            if tool_call_id and _is_tool_return_part(part):
-                if tool_call_id in seen_tool_returns:
-                    msg_had_duplicates = True
-                    removed_count += 1
-                    continue
-                seen_tool_returns.add(tool_call_id)
-            filtered_parts.append(part)
-
-        if not filtered_parts:
-            continue
-
-        if msg_had_duplicates:
-            new_msg = type(msg)(parts=filtered_parts)
-            for attr_name in dir(msg):
-                if (
-                    not attr_name.startswith("_")
-                    and attr_name != "parts"
-                    and hasattr(msg, attr_name)
-                ):
-                    try:
-                        setattr(new_msg, attr_name, getattr(msg, attr_name))
-                    except (AttributeError, TypeError):
-                        pass
-            deduplicated.append(new_msg)
-        else:
-            deduplicated.append(msg)
-
-    if removed_count > 0:
-        emit_warning(f"Removed {removed_count} duplicate tool-return part(s)")
-
-    return deduplicated
+    from code_puppy.summarization_agent import run_summarization_sync as _run_summarization_sync
+    return _run_summarization_sync(instructions, message_history)
 
 
 def summarize_messages(
@@ -261,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."
@@ -293,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
         )
@@ -303,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
@@ -317,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]:
@@ -368,64 +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(
-        deduplicate_tool_returns(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()
@@ -461,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()
@@ -473,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():
@@ -498,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)
@@ -531,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,11 +1,7 @@
-import json
 from types import ModuleType
 from typing import Any, List, Set
 
-import pydantic
-
-_tui_mode: bool = False
-_tui_app_instance: Any = None
+from code_puppy.messaging import emit_info
 
 
 def _require_agent_manager() -> ModuleType:
@@ -29,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()
@@ -106,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)}")
-
-    return "|".join(attributes)
-
-
-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)