code-puppy 0.0.163__tar.gz → 0.0.165__tar.gz

{code_puppy-0.0.163 → code_puppy-0.0.165}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.163
+Version: 0.0.165
 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.163 → code_puppy-0.0.165}/code_puppy/agent.py

@@ -6,7 +6,6 @@ from pydantic_ai import Agent
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import UsageLimits
 
-from code_puppy.agents import get_current_agent_config
 from code_puppy.message_history_processor import (
     get_model_context_length,
     message_history_accumulator,
@@ -136,11 +135,12 @@ def reload_code_generation_agent(message_group: str | None):
 
     # Check if current agent has a pinned model
     from code_puppy.agents import get_current_agent_config
+
     agent_config = get_current_agent_config()
     agent_model_name = None
-    if hasattr(agent_config, 'get_model_name'):
+    if hasattr(agent_config, "get_model_name"):
         agent_model_name = agent_config.get_model_name()
-    
+
     # Use agent-specific model if pinned, otherwise use global model
     model_name = agent_model_name if agent_model_name else get_model_name()
     emit_info(
@@ -203,17 +203,18 @@ def get_code_generation_agent(force_reload=False, message_group: str | None = No
 
     # Get the global model name
     global_model_name = get_model_name()
-    
+
     # Check if current agent has a pinned model
     from code_puppy.agents import get_current_agent_config
+
     agent_config = get_current_agent_config()
     agent_model_name = None
-    if hasattr(agent_config, 'get_model_name'):
+    if hasattr(agent_config, "get_model_name"):
         agent_model_name = agent_config.get_model_name()
-    
+
     # Use agent-specific model if pinned, otherwise use global model
     model_name = agent_model_name if agent_model_name else global_model_name
-    
+
     if _code_generation_agent is None or _LAST_MODEL_NAME != model_name or force_reload:
         return reload_code_generation_agent(message_group)
     return _code_generation_agent

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/agents/agent_creator_agent.py

@@ -28,15 +28,17 @@ class AgentCreatorAgent(BaseAgent):
     def get_system_prompt(self) -> str:
         available_tools = get_available_tool_names()
         agents_dir = get_user_agents_directory()
-        
+
         # Load available models dynamically
         models_config = ModelFactory.load_config()
         model_descriptions = []
         for model_name, model_info in models_config.items():
-            model_type = model_info.get('type', 'Unknown')
-            context_length = model_info.get('context_length', 'Unknown')
-            model_descriptions.append(f"- **{model_name}**: {model_type} model with {context_length} context")
-        
+            model_type = model_info.get("type", "Unknown")
+            context_length = model_info.get("context_length", "Unknown")
+            model_descriptions.append(
+                f"- **{model_name}**: {model_type} model with {context_length} context"
+            )
+
         available_models_str = "\n".join(model_descriptions)
 
         return f"""You are the Agent Creator! 🏗️ Your mission is to help users create awesome JSON agent files through an interactive process.

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/command_line/command_handler.py

@@ -57,7 +57,9 @@ def get_commands_help():
     )
     help_lines.append(
         Text("/compact", style="cyan")
-        + Text("              Summarize and compact current chat history (uses compaction_strategy config)")
+        + Text(
+            "              Summarize and compact current chat history (uses compaction_strategy config)"
+        )
     )
     help_lines.append(
         Text("/dump_context", style="cyan")
@@ -371,7 +373,7 @@ def handle_command(command: str):
 
         # If no model matched, show available models
         from code_puppy.command_line.model_picker_completion import load_model_names
-        
+
         new_input = update_model_in_input(model_command)
         if new_input is not None:
             from code_puppy.agents.runtime_manager import get_runtime_agent_manager
@@ -406,76 +408,76 @@ def handle_command(command: str):
         from code_puppy.agents.json_agent import discover_json_agents
         from code_puppy.command_line.model_picker_completion import load_model_names
         import json
-        
+
         tokens = command.split()
-        
+
         if len(tokens) != 3:
             emit_warning("Usage: /pin_model <agent-name> <model-name>")
-            
+
             # Show available models and JSON agents
             available_models = load_model_names()
             json_agents = discover_json_agents()
-            
+
             emit_info("Available models:")
             for model in available_models:
                 emit_info(f"  [cyan]{model}[/cyan]")
-                
+
             if json_agents:
                 emit_info("\nAvailable JSON agents:")
                 for agent_name, agent_path in json_agents.items():
                     emit_info(f"  [cyan]{agent_name}[/cyan] ({agent_path})")
             return True
-            
+
         agent_name = tokens[1].lower()
         model_name = tokens[2]
-        
+
         # Check if model exists
         available_models = load_model_names()
         if model_name not in available_models:
             emit_error(f"Model '{model_name}' not found")
             emit_warning(f"Available models: {', '.join(available_models)}")
             return True
-            
+
         # Check that we're modifying a JSON agent (not a built-in Python agent)
         json_agents = discover_json_agents()
         if agent_name not in json_agents:
             emit_error(f"JSON agent '{agent_name}' not found")
-            
+
             # Show available JSON agents
             if json_agents:
                 emit_info("Available JSON agents:")
                 for name, path in json_agents.items():
                     emit_info(f"  [cyan]{name}[/cyan] ({path})")
             return True
-            
+
         agent_file_path = json_agents[agent_name]
-        
+
         # Load, modify, and save the agent configuration
         try:
             with open(agent_file_path, "r", encoding="utf-8") as f:
                 agent_config = json.load(f)
-                
+
             # Set the model
             agent_config["model"] = model_name
-            
+
             # Save the updated configuration
             with open(agent_file_path, "w", encoding="utf-8") as f:
                 json.dump(agent_config, f, indent=2, ensure_ascii=False)
-                
+
             emit_success(f"Model '{model_name}' pinned to agent '{agent_name}'")
-            
+
             # If this is the current agent, reload it to use the new model
             from code_puppy.agents import get_current_agent_config
             from code_puppy.agents.runtime_manager import get_runtime_agent_manager
-            
+
             current_agent = get_current_agent_config()
             if current_agent.name == agent_name:
                 manager = get_runtime_agent_manager()
                 manager.reload_agent()
                 emit_info(f"Active agent reloaded with pinned model '{model_name}'")
-            
+
             return True
-            
+
         except Exception as e:
             emit_error(f"Failed to pin model to agent '{agent_name}': {e}")
             return True

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/command_line/prompt_toolkit_completion.py

@@ -147,9 +147,9 @@ def get_prompt_with_active_model(base: str = ">>> "):
 
     # Check if current agent has a pinned model
     agent_model = None
-    if current_agent and hasattr(current_agent, 'get_model_name'):
+    if current_agent and hasattr(current_agent, "get_model_name"):
         agent_model = current_agent.get_model_name()
-    
+
     # Determine which model to display
     if agent_model and agent_model != global_model:
         # Show both models when they differ

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/config.py

@@ -492,4 +492,4 @@ def save_command_to_history(command: str):
         error_msg = (
             f"❌ An unexpected error occurred while saving command history: {str(e)}"
         )
-        direct_console.print(f"[bold red]{error_msg}[/bold red]")
+        direct_console.print(f"[bold red]{error_msg}[/bold red]")

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/message_history_processor.py

@@ -1,15 +1,15 @@
 import json
 import queue
-from typing import Any, List, Set, Tuple
+from typing import Any, Dict, List, Set, Tuple
 
 import pydantic
 from pydantic_ai.messages import ModelMessage, ModelRequest, TextPart, ToolCallPart
 
 from code_puppy.config import (
+    get_compaction_strategy,
+    get_compaction_threshold,
     get_model_name,
     get_protected_token_count,
-    get_compaction_threshold,
-    get_compaction_strategy,
 )
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.model_factory import ModelFactory
@@ -82,7 +82,9 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
 
 
 def filter_huge_messages(messages: List[ModelMessage]) -> List[ModelMessage]:
-    filtered = [m for m in messages if estimate_tokens_for_message(m) < 50000]
+    # First deduplicate tool returns to clean up any duplicates
+    deduplicated = deduplicate_tool_returns(messages)
+    filtered = [m for m in deduplicated if estimate_tokens_for_message(m) < 50000]
     pruned = prune_interrupted_tool_calls(filtered)
     return pruned
 
@@ -234,21 +236,100 @@ def get_model_context_length() -> int:
     return int(context_length)
 
 
+def deduplicate_tool_returns(messages: List[ModelMessage]) -> List[ModelMessage]:
+    """
+    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.
+    """
+    if not messages:
+        return messages
+
+    seen_tool_returns: Set[str] = set()
+    deduplicated: List[ModelMessage] = []
+    removed_count = 0
+
+    for msg in messages:
+        # Check if this message has any parts we need to filter
+        if not hasattr(msg, "parts") or not msg.parts:
+            deduplicated.append(msg)
+            continue
+
+        # Filter parts within this message
+        filtered_parts = []
+        msg_had_duplicates = False
+
+        for part in msg.parts:
+            tool_call_id = getattr(part, "tool_call_id", None)
+            part_kind = getattr(part, "part_kind", None)
+
+            # Check if this is a tool-return part
+            if tool_call_id and part_kind in {
+                "tool-return",
+                "tool-result",
+                "tool_result",
+            }:
+                if tool_call_id in seen_tool_returns:
+                    # This is a duplicate return, skip it
+                    msg_had_duplicates = True
+                    removed_count += 1
+                    continue
+                else:
+                    # First occurrence of this return, keep it
+                    seen_tool_returns.add(tool_call_id)
+                    filtered_parts.append(part)
+            else:
+                # Not a tool return, always keep
+                filtered_parts.append(part)
+
+        # If we filtered out parts, create a new message with filtered parts
+        if msg_had_duplicates and filtered_parts:
+            # Create a new message with the same attributes but filtered parts
+            new_msg = type(msg)(parts=filtered_parts)
+            # Copy over other attributes if they exist
+            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):
+                        # Skip attributes that can't be set
+                        pass
+            deduplicated.append(new_msg)
+        elif filtered_parts:  # No duplicates but has parts
+            deduplicated.append(msg)
+        # If no parts remain after filtering, drop the entire message
+
+    if removed_count > 0:
+        emit_warning(f"Removed {removed_count} duplicate tool-return part(s)")
+
+    return deduplicated
+
+
 def prune_interrupted_tool_calls(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.
+    without a corresponding tool return, or vice versa. We enforce a strict 1:1 ratio
+    between tool calls and tool returns. 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 deduplicate tool returns to clean up any duplicate returns
+    messages = deduplicate_tool_returns(messages)
 
-    # First pass: collect ids for calls vs returns
+    tool_call_counts: Dict[str, int] = {}
+    tool_return_counts: Dict[str, int] = {}
+
+    # First pass: count occurrences of each tool_call_id for calls vs returns
     for msg in messages:
         for part in getattr(msg, "parts", []) or []:
             tool_call_id = getattr(part, "tool_call_id", None)
@@ -257,11 +338,25 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
             # Heuristic: if it's an explicit ToolCallPart or has a tool_name/args,
             # consider it a call; otherwise it's a return/result.
             if part.part_kind == "tool-call":
-                tool_call_ids.add(tool_call_id)
+                tool_call_counts[tool_call_id] = (
+                    tool_call_counts.get(tool_call_id, 0) + 1
+                )
             else:
-                tool_return_ids.add(tool_call_id)
+                tool_return_counts[tool_call_id] = (
+                    tool_return_counts.get(tool_call_id, 0) + 1
+                )
+
+    # Find mismatched tool_call_ids (not exactly 1:1 ratio)
+    all_tool_ids = set(tool_call_counts.keys()) | set(tool_return_counts.keys())
+    mismatched: Set[str] = set()
+
+    for tool_id in all_tool_ids:
+        call_count = tool_call_counts.get(tool_id, 0)
+        return_count = tool_return_counts.get(tool_id, 0)
+        # Enforce strict 1:1 ratio - both must be exactly 1
+        if call_count != 1 or return_count != 1:
+            mismatched.add(tool_id)
 
-    mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
     if not mismatched:
         return messages
 
@@ -287,7 +382,10 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
 
 
 def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
-    # First, prune any interrupted/mismatched tool-call conversations
+    # First, deduplicate tool returns to clean up any duplicates
+    messages = deduplicate_tool_returns(messages)
+
+    # Then, prune any interrupted/mismatched tool-call conversations
     total_current_tokens = sum(estimate_tokens_for_message(msg) for msg in messages)
 
     model_max = get_model_context_length()
@@ -379,6 +477,8 @@ def truncation(
     messages: List[ModelMessage], protected_tokens: int
 ) -> List[ModelMessage]:
     emit_info("Truncating message history to manage token usage")
+    # First deduplicate tool returns to clean up any duplicates
+    messages = deduplicate_tool_returns(messages)
     result = [messages[0]]  # Always keep the first message (system prompt)
     num_tokens = 0
     stack = queue.LifoQueue()
@@ -401,6 +501,10 @@ def truncation(
 
 def message_history_accumulator(messages: List[Any]):
     _message_history = get_message_history()
+
+    # Deduplicate tool returns in current history before processing new messages
+    _message_history = deduplicate_tool_returns(_message_history)
+
     message_history_hashes = set([hash_message(m) for m in _message_history])
     for msg in messages:
         if (
@@ -409,6 +513,12 @@ def message_history_accumulator(messages: List[Any]):
         ):
             _message_history.append(msg)
 
+    # Deduplicate tool returns again after adding new messages to ensure no duplicates
+    _message_history = deduplicate_tool_returns(_message_history)
+
+    # Update the message history with deduplicated messages
+    set_message_history(_message_history)
+
     # Apply message history trimming using the main processor
     # This ensures we maintain global state while still managing context limits
     message_history_processor(_message_history)

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/model_factory.py

@@ -95,9 +95,20 @@ class ModelFactory:
                 config = json.load(f)
 
         if pathlib.Path(EXTRA_MODELS_FILE).exists():
-            with open(EXTRA_MODELS_FILE, "r") as f:
-                extra_config = json.load(f)
-                config.update(extra_config)
+            try:
+                with open(EXTRA_MODELS_FILE, "r") as f:
+                    extra_config = json.load(f)
+                    config.update(extra_config)
+            except json.JSONDecodeError as e:
+                logging.getLogger(__name__).warning(
+                    f"Failed to load extra models config from {EXTRA_MODELS_FILE}: Invalid JSON - {e}\n"
+                    f"Please check your extra_models.json file for syntax errors."
+                )
+            except Exception as e:
+                logging.getLogger(__name__).warning(
+                    f"Failed to load extra models config from {EXTRA_MODELS_FILE}: {e}\n"
+                    f"The extra models configuration will be ignored."
+                )
         return config
 
     @staticmethod

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/tools/command_runner.py

@@ -12,7 +12,6 @@ from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.text import Text
 
-from code_puppy.callbacks import on_run_shell_command
 from code_puppy.messaging import (
     emit_divider,
     emit_error,

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/tools/file_modifications.py

@@ -20,7 +20,6 @@ import json_repair
 from pydantic import BaseModel
 from pydantic_ai import RunContext
 
-from code_puppy.callbacks import on_delete_file, on_edit_file
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.tools.common import _find_best_window, generate_group_id
 
@@ -567,9 +566,9 @@ def register_edit_file(agent):
             except Exception as e:
                 return {
                     "success": False,
-                    "path": 'Not retrievable in Payload',
+                    "path": "Not retrievable in Payload",
                     "message": f"edit_file call failed: {str(e)} - this means the tool failed to parse your inputs. Refer to the following examples: {parse_error_message}",
-                    "changed": False
+                    "changed": False,
                 }
 
         # Call _edit_file which will extract file_path from payload and handle group_id generation

{code_puppy-0.0.163 → code_puppy-0.0.165}/code_puppy/tui/components/chat_view.py

@@ -262,29 +262,35 @@ class ChatView(VerticalScroll):
             separator = "\n"
 
         # Handle content concatenation carefully to preserve Rich objects
-        if hasattr(last_message.content, "__rich_console__") or hasattr(message.content, "__rich_console__"):
+        if hasattr(last_message.content, "__rich_console__") or hasattr(
+            message.content, "__rich_console__"
+        ):
             # If either content is a Rich object, convert both to text and concatenate
             from io import StringIO
             from rich.console import Console
-            
+
             # Convert existing content to string
             if hasattr(last_message.content, "__rich_console__"):
                 string_io = StringIO()
-                temp_console = Console(file=string_io, width=80, legacy_windows=False, markup=False)
+                temp_console = Console(
+                    file=string_io, width=80, legacy_windows=False, markup=False
+                )
                 temp_console.print(last_message.content)
                 existing_content = string_io.getvalue().rstrip("\n")
             else:
                 existing_content = str(last_message.content)
-            
+
             # Convert new content to string
             if hasattr(message.content, "__rich_console__"):
                 string_io = StringIO()
-                temp_console = Console(file=string_io, width=80, legacy_windows=False, markup=False)
+                temp_console = Console(
+                    file=string_io, width=80, legacy_windows=False, markup=False
+                )
                 temp_console.print(message.content)
                 new_content = string_io.getvalue().rstrip("\n")
             else:
                 new_content = str(message.content)
-            
+
             # Combine as plain text
             last_message.content = existing_content + separator + new_content
         else:

{code_puppy-0.0.163 → code_puppy-0.0.165}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.163"
+version = "0.0.165"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11"