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

code_puppy/command_line/command_handler.py

@@ -1,5 +1,6 @@
 import os
 
+from code_puppy.agents import get_current_agent
 from code_puppy.command_line.model_picker_completion import update_model_in_input
 from code_puppy.command_line.motd import print_motd
 from code_puppy.command_line.utils import make_directory_table
@@ -120,39 +121,38 @@ def handle_command(command: str):
 
     if command.strip().startswith("/compact"):
         from code_puppy.config import get_compaction_strategy
-        from code_puppy.message_history_processor import (
-            estimate_tokens_for_message,
-            get_protected_token_count,
-            summarize_messages,
-            truncation,
-        )
+        # Functions have been moved to BaseAgent class
+        from code_puppy.agents.agent_manager import get_current_agent
+        from code_puppy.config import get_protected_token_count
         from code_puppy.messaging import (
             emit_error,
             emit_info,
             emit_success,
             emit_warning,
         )
-        from code_puppy.state_management import get_message_history, set_message_history
 
         try:
-            history = get_message_history()
+            agent = get_current_agent()
+            history = agent.get_message_history()
             if not history:
                 emit_warning("No history to compact yet. Ask me something first!")
                 return True
 
-            before_tokens = sum(estimate_tokens_for_message(m) for m in history)
+            current_agent = get_current_agent()
+            before_tokens = sum(current_agent.estimate_tokens_for_message(m) for m in history)
             compaction_strategy = get_compaction_strategy()
             protected_tokens = get_protected_token_count()
             emit_info(
                 f"🤔 Compacting {len(history)} messages using {compaction_strategy} strategy... (~{before_tokens} tokens)"
             )
 
+            current_agent = get_current_agent()
             if compaction_strategy == "truncation":
-                compacted = truncation(history, protected_tokens)
+                compacted = current_agent.truncation(history, protected_tokens)
                 summarized_messages = []  # No summarization in truncation mode
             else:
                 # Default to summarization
-                compacted, summarized_messages = summarize_messages(
+                compacted, summarized_messages = current_agent.summarize_messages(
                     history, with_protection=True
                 )
 
@@ -160,9 +160,10 @@ def handle_command(command: str):
                 emit_error("Compaction failed. History unchanged.")
                 return True
 
-            set_message_history(compacted)
+            agent.set_message_history(compacted)
 
-            after_tokens = sum(estimate_tokens_for_message(m) for m in compacted)
+            current_agent = get_current_agent()
+            after_tokens = sum(current_agent.estimate_tokens_for_message(m) for m in compacted)
             reduction_pct = (
                 ((before_tokens - after_tokens) / before_tokens * 100)
                 if before_tokens > 0
@@ -205,7 +206,7 @@ def handle_command(command: str):
             return True
 
     if command.strip().startswith("/show"):
-        from code_puppy.agents import get_current_agent_config
+        from code_puppy.agents import get_current_agent
         from code_puppy.command_line.model_picker_completion import get_active_model
         from code_puppy.config import (
             get_compaction_strategy,
@@ -225,7 +226,7 @@ def handle_command(command: str):
         compaction_strategy = get_compaction_strategy()
 
         # Get current agent info
-        current_agent = get_current_agent_config()
+        current_agent = get_current_agent()
 
         status_msg = f"""[bold magenta]🐶 Puppy Status[/bold magenta]
 
@@ -288,16 +289,15 @@ def handle_command(command: str):
         from code_puppy.agents import (
             get_agent_descriptions,
             get_available_agents,
-            get_current_agent_config,
+            get_current_agent,
             set_current_agent,
         )
-        from code_puppy.agents.runtime_manager import get_runtime_agent_manager
 
         tokens = command.split()
 
         if len(tokens) == 1:
             # Show current agent and available agents
-            current_agent = get_current_agent_config()
+            current_agent = get_current_agent()
             available_agents = get_available_agents()
             descriptions = get_agent_descriptions()
 
@@ -343,9 +343,9 @@ def handle_command(command: str):
 
             if set_current_agent(agent_name):
                 # Reload the agent with new configuration
-                manager = get_runtime_agent_manager()
-                manager.reload_agent()
-                new_agent = get_current_agent_config()
+                agent = get_current_agent()
+                agent.reload_code_generation_agent()
+                new_agent = get_current_agent()
                 emit_success(
                     f"Switched to agent: {new_agent.display_name}",
                     message_group=group_id,
@@ -382,13 +382,10 @@ def handle_command(command: str):
 
         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
             from code_puppy.command_line.model_picker_completion import get_active_model
 
             model = get_active_model()
             # Make sure this is called for the test
-            manager = get_runtime_agent_manager()
-            manager.reload_agent()
             emit_success(f"Active model set and loaded: {model}")
             return True
         model_names = load_model_names()
@@ -503,13 +500,11 @@ def handle_command(command: str):
             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
+            from code_puppy.agents import get_current_agent
 
-            current_agent = get_current_agent_config()
+            current_agent = get_current_agent()
             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
@@ -560,8 +555,8 @@ def handle_command(command: str):
         from pathlib import Path
 
         from code_puppy.config import CONFIG_DIR
-        from code_puppy.message_history_processor import estimate_tokens_for_message
-        from code_puppy.state_management import get_message_history
+        # estimate_tokens_for_message has been moved to BaseAgent class
+        from code_puppy.agents.agent_manager import get_current_agent
 
         tokens = command.split()
         if len(tokens) != 2:
@@ -569,7 +564,8 @@ def handle_command(command: str):
             return True
 
         session_name = tokens[1]
-        history = get_message_history()
+        agent = get_current_agent()
+        history = agent.get_message_history()
 
         if not history:
             emit_warning("No message history to dump!")
@@ -587,11 +583,12 @@ def handle_command(command: str):
 
             # Also save metadata as JSON for readability
             meta_file = contexts_dir / f"{session_name}_meta.json"
+            current_agent = get_current_agent()
             metadata = {
                 "session_name": session_name,
                 "timestamp": datetime.now().isoformat(),
                 "message_count": len(history),
-                "total_tokens": sum(estimate_tokens_for_message(m) for m in history),
+                "total_tokens": sum(current_agent.estimate_tokens_for_message(m) for m in history),
                 "file_path": str(pickle_file),
             }
 
@@ -613,8 +610,8 @@ def handle_command(command: str):
         from pathlib import Path
 
         from code_puppy.config import CONFIG_DIR
-        from code_puppy.message_history_processor import estimate_tokens_for_message
-        from code_puppy.state_management import set_message_history
+        # estimate_tokens_for_message has been moved to BaseAgent class
+        from code_puppy.agents.agent_manager import get_current_agent
 
         tokens = command.split()
         if len(tokens) != 2:
@@ -638,8 +635,10 @@ def handle_command(command: str):
             with open(pickle_file, "rb") as f:
                 history = pickle.load(f)
 
-            set_message_history(history)
-            total_tokens = sum(estimate_tokens_for_message(m) for m in history)
+            agent = get_current_agent()
+            agent.set_message_history(history)
+            current_agent = get_current_agent()
+            total_tokens = sum(current_agent.estimate_tokens_for_message(m) for m in history)
 
             emit_success(
                 f"✅ Context loaded: {len(history)} messages ({total_tokens} tokens)\n"
@@ -652,6 +651,7 @@ def handle_command(command: str):
             return True
 
     if command.startswith("/truncate"):
+        from code_puppy.agents.agent_manager import get_current_agent
         tokens = command.split()
         if len(tokens) != 2:
             emit_error(
@@ -668,9 +668,8 @@ def handle_command(command: str):
             emit_error("N must be a valid integer")
             return True
 
-        from code_puppy.state_management import get_message_history, set_message_history
-
-        history = get_message_history()
+        agent = get_current_agent()
+        history = agent.get_message_history()
         if not history:
             emit_warning("No history to truncate yet. Ask me something first!")
             return True
@@ -686,7 +685,7 @@ def handle_command(command: str):
             [history[0]] + history[-(n - 1) :] if n > 1 else [history[0]]
         )
 
-        set_message_history(truncated_history)
+        agent.set_message_history(truncated_history)
         emit_success(
             f"Truncated message history from {len(history)} to {len(truncated_history)} messages (keeping system message and {n - 1} most recent)"
         )

code_puppy/command_line/mcp/start_all_command.py

@@ -10,6 +10,7 @@ from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
 from .base import MCPCommandBase
+from ...agents import get_current_agent
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -106,12 +107,8 @@ class StartAllCommand(MCPCommandBase):
                     pass  # No async loop, servers will start when agent uses them
 
                 try:
-                    from code_puppy.agents.runtime_manager import (
-                        get_runtime_agent_manager,
-                    )
-
-                    manager = get_runtime_agent_manager()
-                    manager.reload_agent()
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
                     emit_info(
                         "[dim]Agent reloaded with updated servers[/dim]",
                         message_group=group_id,

code_puppy/command_line/mcp/start_command.py

@@ -75,12 +75,7 @@ class StartCommand(MCPCommandBase):
 
                 # Reload the agent to pick up the newly enabled server
                 try:
-                    from code_puppy.agents.runtime_manager import (
-                        get_runtime_agent_manager,
-                    )
 
-                    manager = get_runtime_agent_manager()
-                    manager.reload_agent()
                     emit_info(
                         "[dim]Agent reloaded with updated servers[/dim]",
                         message_group=group_id,

code_puppy/command_line/mcp/stop_all_command.py

@@ -10,6 +10,7 @@ from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
 from .base import MCPCommandBase
+from ...agents import get_current_agent
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -91,12 +92,8 @@ class StopAllCommand(MCPCommandBase):
                     pass  # No async loop, servers will stop when needed
 
                 try:
-                    from code_puppy.agents.runtime_manager import (
-                        get_runtime_agent_manager,
-                    )
-
-                    manager = get_runtime_agent_manager()
-                    manager.reload_agent()
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
                     emit_info(
                         "[dim]Agent reloaded with updated servers[/dim]",
                         message_group=group_id,

code_puppy/command_line/mcp/stop_command.py

@@ -57,12 +57,8 @@ class StopCommand(MCPCommandBase):
 
                 # Reload the agent to remove the disabled server
                 try:
-                    from code_puppy.agents.runtime_manager import (
-                        get_runtime_agent_manager,
-                    )
-
-                    manager = get_runtime_agent_manager()
-                    manager.reload_agent()
+                    agent = get_current_agent()
+                    agent.reload_code_generation_agent()
                     emit_info(
                         "[dim]Agent reloaded with updated servers[/dim]",
                         message_group=group_id,

code_puppy/command_line/model_picker_completion.py

@@ -6,7 +6,7 @@ from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.document import Document
 from prompt_toolkit.history import FileHistory
 
-from code_puppy.config import get_model_name, set_model_name
+from code_puppy.config import get_global_model_name, set_model_name
 from code_puppy.model_factory import ModelFactory
 
 
@@ -21,7 +21,7 @@ def get_active_model():
     Returns the active model from the config using get_model_name().
     This ensures consistency across the codebase by always using the config value.
     """
-    return get_model_name()
+    return get_global_model_name()
 
 
 def set_active_model(model_name: str):

code_puppy/command_line/prompt_toolkit_completion.py

@@ -136,13 +136,13 @@ class CDCompleter(Completer):
 
 
 def get_prompt_with_active_model(base: str = ">>> "):
-    from code_puppy.agents.agent_manager import get_current_agent_config
+    from code_puppy.agents.agent_manager import get_current_agent
 
     puppy = get_puppy_name()
     global_model = get_active_model() or "(default)"
 
     # Get current agent information
-    current_agent = get_current_agent_config()
+    current_agent = get_current_agent()
     agent_display = current_agent.display_name if current_agent else "code-puppy"
 
     # Check if current agent has a pinned model

code_puppy/config.py

@@ -94,7 +94,7 @@ def get_model_context_length() -> int:
         from code_puppy.model_factory import ModelFactory
 
         model_configs = ModelFactory.load_config()
-        model_name = get_model_name()
+        model_name = get_global_model_name()
 
         # Get context length from model config
         model_config = model_configs.get(model_name, {})
@@ -305,7 +305,7 @@ def clear_model_cache():
     _default_vqa_model_cache = None
 
 
-def get_model_name():
+def get_global_model_name():
     """Return a valid model name for Code Puppy to use.
 
     1. Look at ``model`` in *puppy.cfg*.

code_puppy/main.py

@@ -12,8 +12,7 @@ from rich.syntax import Syntax
 from rich.text import Text
 
 from code_puppy import __version__, callbacks, plugins
-from code_puppy.agent import get_custom_usage_limits
-from code_puppy.agents.runtime_manager import get_runtime_agent_manager
+from code_puppy.agents import get_current_agent
 from code_puppy.command_line.prompt_toolkit_completion import (
     get_input_with_combined_completion,
     get_prompt_with_active_model,
@@ -25,15 +24,10 @@ from code_puppy.config import (
     save_command_to_history,
 )
 from code_puppy.http_utils import find_available_port
-from code_puppy.message_history_processor import (
-    message_history_accumulator,
-    prune_interrupted_tool_calls,
-)
-from code_puppy.state_management import set_message_history
+# message_history_accumulator and prune_interrupted_tool_calls have been moved to BaseAgent class
 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
-
 plugins.load_plugin_callbacks()
 
 
@@ -237,9 +231,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     from code_puppy.command_line.command_handler import handle_command
 
     """Run the agent in interactive mode."""
-    from code_puppy.state_management import clear_message_history, get_message_history
 
-    clear_message_history()
     display_console = message_renderer.console
     from code_puppy.messaging import emit_info, emit_system_message
 
@@ -264,16 +256,14 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
         from code_puppy.messaging import emit_warning
 
         emit_warning(f"MOTD error: {e}")
-    from code_puppy.agents.runtime_manager import get_runtime_agent_manager
     from code_puppy.messaging import emit_info
 
     emit_info("[bold cyan]Initializing agent...[/bold cyan]")
     # Initialize the runtime agent manager
-    agent_manager = get_runtime_agent_manager()
-    agent_manager.get_agent()
     if initial_command:
         from code_puppy.messaging import emit_info, emit_system_message
-
+        from code_puppy.agents import get_current_agent
+        agent = get_current_agent()
         emit_info(
             f"[bold blue]Processing initial command:[/bold blue] {initial_command}"
         )
@@ -290,10 +280,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             # Run with or without spinner based on whether we're awaiting input
             if awaiting_input:
                 # No spinner - use agent_manager's run_with_mcp method
-                response = await agent_manager.run_with_mcp(
+
+                response = await agent.run_with_mcp(
                     initial_command,
-                    message_history=get_message_history(),
-                    usage_limits=get_custom_usage_limits(),
                 )
             else:
                 # Use our custom spinner for better compatibility with user input
@@ -301,15 +290,8 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
                 with ConsoleSpinner(console=display_console):
                     # Use agent_manager's run_with_mcp method
-                    response = await agent_manager.run_with_mcp(
+                    response = await agent.run_with_mcp(
                         initial_command,
-                        message_history=prune_interrupted_tool_calls(
-                            get_message_history()
-                        ),
-                        usage_limits=get_custom_usage_limits(),
-                    )
-                    set_message_history(
-                        prune_interrupted_tool_calls(get_message_history())
                     )
 
             agent_response = response.output
@@ -317,9 +299,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             emit_system_message(
                 f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response}"
             )
-            new_msgs = response.all_messages()
-            message_history_accumulator(new_msgs)
-            set_message_history(prune_interrupted_tool_calls(get_message_history()))
             emit_system_message("\n" + "=" * 50)
             emit_info("[bold green]🐶 Continuing in Interactive Mode[/bold green]")
             emit_system_message(
@@ -359,11 +338,11 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             emit_warning("Falling back to basic input without tab completion")
 
     while True:
-        from code_puppy.agents.agent_manager import get_current_agent_config
+        from code_puppy.agents.agent_manager import get_current_agent
         from code_puppy.messaging import emit_info
 
         # Get the custom prompt from the current agent, or use default
-        current_agent = get_current_agent_config()
+        current_agent = get_current_agent()
         user_prompt = current_agent.get_user_prompt() or "Enter your coding task:"
 
         emit_info(f"[bold blue]{user_prompt}[/bold blue]")
@@ -399,7 +378,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
         # Check for clear command (supports both `clear` and `/clear`)
         if task.strip().lower() in ("clear", "/clear"):
-            clear_message_history()
             from code_puppy.messaging import emit_system_message, emit_warning
 
             emit_warning("Conversation history cleared!")
@@ -431,14 +409,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 from code_puppy.messaging import emit_warning
                 from code_puppy.messaging.spinner import ConsoleSpinner
 
-                runtime_manager = get_runtime_agent_manager()
                 with ConsoleSpinner(console=message_renderer.console):
-                    result = await runtime_manager.run_with_mcp(
+                    result = await current_agent.run_with_mcp(
                         task,
-                        get_custom_usage_limits(),
-                        message_history=prune_interrupted_tool_calls(
-                            get_message_history()
-                        ),
                     )
                 # Check if the task was cancelled (but don't show message if we just killed processes)
                 if result is None:
@@ -451,14 +424,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                     f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response}"
                 )
 
-                # Update message history - the agent's history processor will handle truncation
-                new_msgs = result.all_messages()
-                message_history_accumulator(new_msgs)
-
-                emit_system_message(
-                    f"Context: {len(get_message_history())} messages in history\n"
-                )
-
                 # Ensure console output is flushed before next prompt
                 # This fixes the issue where prompt doesn't appear after agent response
                 display_console.file.flush() if hasattr(
@@ -502,14 +467,12 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
 
     try:
         # Get agent through runtime manager and use its run_with_mcp method
-        agent_manager = get_runtime_agent_manager()
-
+        agent = get_current_agent()
         from code_puppy.messaging.spinner import ConsoleSpinner
 
         with ConsoleSpinner(console=message_renderer.console):
-            response = await agent_manager.run_with_mcp(
+            response = await agent.run_with_mcp(
                 prompt,
-                usage_limits=get_custom_usage_limits(),
             )
 
         agent_response = response.output

code_puppy/summarization_agent.py

@@ -4,7 +4,7 @@ from typing import List
 
 from pydantic_ai import Agent
 
-from code_puppy.config import get_model_name
+from code_puppy.config import get_global_model_name
 from code_puppy.model_factory import ModelFactory
 
 # Keep a module-level agent reference to avoid rebuilding per call
@@ -53,7 +53,7 @@ def run_summarization_sync(prompt: str, message_history: List) -> List:
 def reload_summarization_agent():
     """Create a specialized agent for summarizing messages when context limit is reached."""
     models_config = ModelFactory.load_config()
-    model_name = get_model_name()
+    model_name = get_global_model_name()
     model = ModelFactory.get_model(model_name, models_config)
 
     # Specialized instructions for summarization

code_puppy/tools/agent_tools.py

@@ -11,12 +11,11 @@ from code_puppy.messaging import (
     emit_error,
 )
 from code_puppy.tools.common import generate_group_id
-from code_puppy.agents.agent_manager import get_available_agents, load_agent_config
 
 # Import Agent from pydantic_ai to create temporary agents for invocation
 from pydantic_ai import Agent
 from code_puppy.model_factory import ModelFactory
-from code_puppy.config import get_model_name
+from code_puppy.config import get_global_model_name
 
 
 class AgentInfo(BaseModel):
@@ -65,6 +64,7 @@ def register_list_agents(agent):
         emit_divider(message_group=group_id)
 
         try:
+            from code_puppy.agents import get_available_agents
             # Get available agents from the agent manager
             agents_dict = get_available_agents()
 
@@ -113,6 +113,7 @@ def register_invoke_agent(agent):
         Returns:
             AgentInvokeOutput: The agent's response to the prompt
         """
+        from code_puppy.agents.agent_manager import load_agent
         # Generate a group ID for this tool execution
         group_id = generate_group_id("invoke_agent", agent_name)
 
@@ -126,10 +127,10 @@ def register_invoke_agent(agent):
 
         try:
             # Load the specified agent config
-            agent_config = load_agent_config(agent_name)
+            agent_config = load_agent(agent_name)
 
             # Get the current model for creating a temporary agent
-            model_name = get_model_name()
+            model_name = get_global_model_name()
             models_config = ModelFactory.load_config()
 
             # Only proceed if we have a valid model configuration

code_puppy/tools/browser/vqa_agent.py

@@ -6,7 +6,7 @@ from functools import lru_cache
 from typing import Optional
 
 from pydantic import BaseModel, Field
-from pydantic_ai import Agent, BinaryContent, InstrumentationSettings
+from pydantic_ai import Agent, BinaryContent
 
 from code_puppy.config import get_vqa_model_name
 from code_puppy.model_factory import ModelFactory
@@ -26,8 +26,6 @@ def _load_vqa_agent(model_name: str) -> Agent[None, VisualAnalysisResult]:
     models_config = ModelFactory.load_config()
     model = ModelFactory.get_model(model_name, models_config)
 
-    instrumentation = InstrumentationSettings(include_binary_content=False)
-
     instructions = (
         "You are a visual analysis specialist. Answer the user's question about the provided image. "
         "Always respond using the structured schema: answer, confidence (0-1 float), observations. "