code-puppy 0.0.169__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/agent.py

@@ -1,231 +0,0 @@
-import uuid
-from pathlib import Path
-from typing import Dict, Optional
-
-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.messaging.message_queue import (
-    emit_error,
-    emit_info,
-    emit_system_message,
-)
-from code_puppy.model_factory import ModelFactory
-
-# Tool registration is imported on demand
-from code_puppy.tools.common import console
-
-
-def load_puppy_rules():
-    global PUPPY_RULES
-
-    # Check for all 4 combinations of the rules file
-    possible_paths = ["AGENTS.md", "AGENT.md", "agents.md", "agent.md"]
-
-    for path_str in possible_paths:
-        puppy_rules_path = Path(path_str)
-        if puppy_rules_path.exists():
-            with open(puppy_rules_path, "r") as f:
-                puppy_rules = f.read()
-                return puppy_rules
-
-    # If none of the files exist, return None
-    return None
-
-
-# Load at import
-PUPPY_RULES = load_puppy_rules()
-_LAST_MODEL_NAME = None
-_code_generation_agent = None
-
-
-def _load_mcp_servers(extra_headers: Optional[Dict[str, str]] = None):
-    """Load MCP servers using the new manager while maintaining backward compatibility."""
-    from code_puppy.config import get_value, load_mcp_server_configs
-    from code_puppy.mcp import ServerConfig, get_mcp_manager
-
-    # Check if MCP servers are disabled
-    mcp_disabled = get_value("disable_mcp_servers")
-    if mcp_disabled and str(mcp_disabled).lower() in ("1", "true", "yes", "on"):
-        emit_system_message("[dim]MCP servers disabled via config[/dim]")
-        return []
-
-    # Get the MCP manager singleton
-    manager = get_mcp_manager()
-
-    # Load configurations from legacy file for backward compatibility
-    configs = load_mcp_server_configs()
-    if not configs:
-        # Check if manager already has servers (could be from new system)
-        existing_servers = manager.list_servers()
-        if not existing_servers:
-            emit_system_message("[dim]No MCP servers configured[/dim]")
-            return []
-    else:
-        # Register servers from legacy config with manager
-        for name, conf in configs.items():
-            try:
-                # Convert legacy format to new ServerConfig
-                server_config = ServerConfig(
-                    id=conf.get("id", f"{name}_{hash(name)}"),
-                    name=name,
-                    type=conf.get("type", "sse"),
-                    enabled=conf.get("enabled", True),
-                    config=conf,
-                )
-
-                # Check if server already registered
-                existing = manager.get_server_by_name(name)
-                if not existing:
-                    # Register new server
-                    manager.register_server(server_config)
-                    emit_system_message(f"[dim]Registered MCP server: {name}[/dim]")
-                else:
-                    # Update existing server config if needed
-                    if existing.config != server_config.config:
-                        manager.update_server(existing.id, server_config)
-                        emit_system_message(f"[dim]Updated MCP server: {name}[/dim]")
-
-            except Exception as e:
-                emit_error(f"Failed to register MCP server '{name}': {str(e)}")
-                continue
-
-    # Get pydantic-ai compatible servers from manager
-    servers = manager.get_servers_for_agent()
-
-    if servers:
-        emit_system_message(
-            f"[green]Successfully loaded {len(servers)} MCP server(s)[/green]"
-        )
-    else:
-        emit_system_message(
-            "[yellow]No MCP servers available (check if servers are enabled)[/yellow]"
-        )
-
-    return servers
-
-
-def reload_mcp_servers():
-    """Reload MCP servers without restarting the agent."""
-    from code_puppy.mcp import get_mcp_manager
-
-    manager = get_mcp_manager()
-    # Reload configurations
-    _load_mcp_servers()
-    # Return updated servers
-    return manager.get_servers_for_agent()
-
-
-def reload_code_generation_agent(message_group: str | None):
-    """Force-reload the agent, usually after a model change."""
-    if message_group is None:
-        message_group = str(uuid.uuid4())
-    global _code_generation_agent, _LAST_MODEL_NAME
-    from code_puppy.agents import clear_agent_cache
-    from code_puppy.config import clear_model_cache, get_model_name
-
-    # Clear both ModelFactory cache and config cache when force reloading
-    clear_model_cache()
-    clear_agent_cache()
-
-    # 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"):
-        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(
-        f"[bold cyan]Loading Model: {model_name}[/bold cyan]",
-        message_group=message_group,
-    )
-    models_config = ModelFactory.load_config()
-    model = ModelFactory.get_model(model_name, models_config)
-
-    # Get agent-specific system prompt
-    agent_config = get_current_agent_config()
-    emit_info(
-        f"[bold magenta]Loading Agent: {agent_config.display_name}[/bold magenta]",
-        message_group=message_group,
-    )
-
-    instructions = agent_config.get_system_prompt()
-
-    if PUPPY_RULES:
-        instructions += f"\n{PUPPY_RULES}"
-
-    mcp_servers = _load_mcp_servers()
-
-    # 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))
-    console.print(f"Max output tokens per message: {output_tokens}")
-    model_settings_dict["max_tokens"] = output_tokens
-
-    model_settings = ModelSettings(**model_settings_dict)
-    agent = Agent(
-        model=model,
-        instructions=instructions,
-        output_type=str,
-        retries=3,
-        mcp_servers=mcp_servers,
-        history_processors=[message_history_accumulator],
-        model_settings=model_settings,
-    )
-
-    # Register tools specified by the agent
-    from code_puppy.tools import register_tools_for_agent
-
-    agent_tools = agent_config.get_available_tools()
-    register_tools_for_agent(agent, agent_tools)
-    _code_generation_agent = agent
-    _LAST_MODEL_NAME = model_name
-    return _code_generation_agent
-
-
-def get_code_generation_agent(force_reload=False, message_group: str | None = None):
-    """
-    Retrieve the agent with the currently configured model.
-    Forces a reload if the model has changed, or if force_reload is passed.
-    """
-    global _code_generation_agent, _LAST_MODEL_NAME
-    if message_group is None:
-        message_group = str(uuid.uuid4())
-    from code_puppy.config import get_model_name
-
-    # 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"):
-        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
-
-
-def get_custom_usage_limits():
-    """
-    Returns custom usage limits with configurable request limit.
-    This centralizes the configuration of rate limiting for the agent.
-    Default pydantic-ai limit is 50, this increases it to the configured value (default 100).
-    """
-    from code_puppy.config import get_message_limit
-
-    return UsageLimits(request_limit=get_message_limit())

code_puppy/agents/agent_orchestrator.json

@@ -1,26 +0,0 @@
-{
-  "id": "agent-orchestrator-id",
-  "name": "agent-orchestrator",
-  "display_name": "Agent Orchestrator 🎭",
-  "description": "Coordinates and manages various specialized agents to accomplish tasks",
-  "system_prompt": [
-    "You are an agent orchestrator that coordinates various specialized agents.",
-    "When given a task, first list the available agents to understand what's at your disposal.",
-    "Then, invoke the most appropriate agent to handle the task. If needed, you can invoke multiple agents.",
-    "",
-    "#### `list_agents()`",
-    "Use this to list all available sub-agents that can be invoked",
-    "",
-    "#### `invoke_agent(agent_name: str, user_prompt: str)`",
-    "Use this to invoke another agent with a specific prompt. This allows agents to delegate tasks to specialized sub-agents.",
-    "Arguments:",
-    "- agent_name (required): Name of the agent to invoke",
-    "- user_prompt (required): The prompt to send to the invoked agent",
-    "Example usage:",
-    "```python",
-    "invoke_agent(agent_name=\"python-tutor\", user_prompt=\"Explain how to use list comprehensions\")",
-    "```"
-  ],
-  "tools": ["list_agents", "invoke_agent", "agent_share_your_reasoning"],
-  "user_prompt": "What would you like me to coordinate for you?"
-}

code_puppy/agents/runtime_manager.py

@@ -1,272 +0,0 @@
-"""
-Runtime agent manager that ensures proper agent instance updates.
-
-This module provides a wrapper around the agent singleton that ensures
-all references to the agent are properly updated when it's reloaded.
-"""
-
-import asyncio
-import signal
-import sys
-import uuid
-from typing import Any, Optional
-
-# ExceptionGroup is available in Python 3.11+
-if sys.version_info >= (3, 11):
-    from builtins import ExceptionGroup
-else:
-    # For Python 3.10 and below, we can define a simple fallback
-    class ExceptionGroup(Exception):
-        def __init__(self, message, exceptions):
-            super().__init__(message)
-            self.exceptions = exceptions
-
-
-import mcp
-from pydantic_ai import Agent
-from pydantic_ai.exceptions import UsageLimitExceeded
-from pydantic_ai.usage import UsageLimits
-
-from code_puppy.messaging.message_queue import emit_info
-
-
-class RuntimeAgentManager:
-    """
-    Manages the runtime agent instance and ensures proper updates.
-
-    This class acts as a proxy that always returns the current agent instance,
-    ensuring that when the agent is reloaded, all code using this manager
-    automatically gets the updated instance.
-    """
-
-    def __init__(self):
-        """Initialize the runtime agent manager."""
-        self._agent: Optional[Agent] = None
-        self._last_model_name: Optional[str] = None
-
-    def get_agent(self, force_reload: bool = False, message_group: str = "") -> Agent:
-        """
-        Get the current agent instance.
-
-        This method always returns the most recent agent instance,
-        automatically handling reloads when the model changes.
-
-        Args:
-            force_reload: If True, force a reload of the agent
-
-        Returns:
-            The current agent instance
-        """
-        from code_puppy.agent import get_code_generation_agent
-
-        # Always get the current singleton - this ensures we have the latest
-        current_agent = get_code_generation_agent(
-            force_reload=force_reload, message_group=message_group
-        )
-        self._agent = current_agent
-
-        return self._agent
-
-    def reload_agent(self) -> Agent:
-        """
-        Force reload the agent.
-
-        This is typically called after MCP servers are started/stopped.
-
-        Returns:
-            The newly loaded agent instance
-        """
-        message_group = uuid.uuid4()
-        emit_info(
-            "[bold cyan]Reloading agent with updated configuration...[/bold cyan]",
-            message_group=message_group,
-        )
-        return self.get_agent(force_reload=True, message_group=message_group)
-
-    async def run_with_mcp(
-        self, prompt: str, usage_limits: Optional[UsageLimits] = None, **kwargs
-    ) -> Any:
-        """
-        Run the agent with MCP servers and full cancellation support.
-
-        This method ensures we're always using the current agent instance
-        and handles Ctrl+C interruption properly by creating a cancellable task.
-
-        Args:
-            prompt: The user prompt to process
-            usage_limits: Optional usage limits for the agent
-            **kwargs: Additional arguments to pass to agent.run (e.g., message_history)
-
-        Returns:
-            The agent's response
-
-        Raises:
-            asyncio.CancelledError: When execution is cancelled by user
-        """
-        agent = self.get_agent()
-        group_id = str(uuid.uuid4())
-
-        # Function to run agent with MCP
-        async def run_agent_task():
-            try:
-                async with agent:
-                    return await agent.run(prompt, usage_limits=usage_limits, **kwargs)
-            except* UsageLimitExceeded as ule:
-                emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
-                emit_info(
-                    "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
-                    group_id=group_id,
-                )
-            except* mcp.shared.exceptions.McpError as mcp_error:
-                emit_info(f"MCP server error: {str(mcp_error)}", group_id=group_id)
-                emit_info(f"{str(mcp_error)}", group_id=group_id)
-                emit_info(
-                    "Try disabling any malfunctioning MCP servers", group_id=group_id
-                )
-            except* asyncio.exceptions.CancelledError:
-                emit_info("Cancelled")
-            except* InterruptedError as ie:
-                emit_info(f"Interrupted: {str(ie)}")
-            except* Exception as other_error:
-                # Filter out CancelledError and UsageLimitExceeded from the exception group - let it propagate
-                remaining_exceptions = []
-
-                def collect_non_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_non_cancelled_exceptions(sub_exc)
-                    elif not isinstance(
-                        exc, (asyncio.CancelledError, UsageLimitExceeded)
-                    ):
-                        remaining_exceptions.append(exc)
-                        emit_info(f"Unexpected error: {str(exc)}", group_id=group_id)
-                        emit_info(f"{str(exc.args)}", group_id=group_id)
-
-                collect_non_cancelled_exceptions(other_error)
-
-                # If there are CancelledError exceptions in the group, re-raise them
-                cancelled_exceptions = []
-
-                def collect_cancelled_exceptions(exc):
-                    if isinstance(exc, ExceptionGroup):
-                        for sub_exc in exc.exceptions:
-                            collect_cancelled_exceptions(sub_exc)
-                    elif isinstance(exc, asyncio.CancelledError):
-                        cancelled_exceptions.append(exc)
-
-                collect_cancelled_exceptions(other_error)
-
-                if cancelled_exceptions:
-                    # Re-raise the first CancelledError to propagate cancellation
-                    raise cancelled_exceptions[0]
-
-        # Create the task FIRST
-        agent_task = asyncio.create_task(run_agent_task())
-
-        # Import shell process killer
-        from code_puppy.tools.command_runner import kill_all_running_shell_processes
-
-        # Ensure the interrupt handler only acts once per task
-        def keyboard_interrupt_handler(sig, frame):
-            """Signal handler for Ctrl+C - replicating exact original logic"""
-
-            # First, nuke any running shell processes triggered by tools
-            try:
-                killed = kill_all_running_shell_processes()
-                if killed:
-                    emit_info(f"Cancelled {killed} running shell process(es).")
-                else:
-                    # Only cancel the agent task if no shell processes were killed
-                    if not agent_task.done():
-                        agent_task.cancel()
-            except Exception as e:
-                emit_info(f"Shell kill error: {e}")
-                # If shell kill failed, still try to cancel the agent task
-                if not agent_task.done():
-                    agent_task.cancel()
-            # Don't call the original handler
-            # This prevents the application from exiting
-
-        try:
-            # Save original handler and set our custom one AFTER task is created
-            original_handler = signal.signal(signal.SIGINT, keyboard_interrupt_handler)
-
-            # Wait for the task to complete or be cancelled
-            result = await agent_task
-            return result
-        except asyncio.CancelledError:
-            # Task was cancelled by our handler
-            raise
-        except KeyboardInterrupt:
-            # Handle direct keyboard interrupt during await
-            if not agent_task.done():
-                agent_task.cancel()
-            try:
-                await agent_task
-            except asyncio.CancelledError:
-                pass
-            raise asyncio.CancelledError()
-        finally:
-            # Restore original signal handler
-            if original_handler:
-                signal.signal(signal.SIGINT, original_handler)
-
-    async def run(
-        self, prompt: str, usage_limits: Optional[UsageLimits] = None, **kwargs
-    ) -> Any:
-        """
-        Run the agent without explicitly managing MCP servers.
-
-        Args:
-            prompt: The user prompt to process
-            usage_limits: Optional usage limits for the agent
-            **kwargs: Additional arguments to pass to agent.run (e.g., message_history)
-
-        Returns:
-            The agent's response
-        """
-        agent = self.get_agent()
-        try:
-            return await agent.run(prompt, usage_limits=usage_limits, **kwargs)
-        except UsageLimitExceeded as ule:
-            group_id = str(uuid.uuid4())
-            emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
-            emit_info(
-                "The agent has reached its usage limit. You can ask it to continue by saying 'please continue' or similar.",
-                group_id=group_id,
-            )
-            # Return None or some default value to indicate the limit was reached
-            return None
-
-    def __getattr__(self, name: str) -> Any:
-        """
-        Proxy all other attribute access to the current agent.
-
-        This allows the manager to be used as a drop-in replacement
-        for direct agent access.
-
-        Args:
-            name: The attribute name to access
-
-        Returns:
-            The attribute from the current agent
-        """
-        agent = self.get_agent()
-        return getattr(agent, name)
-
-
-# Global singleton instance
-_runtime_manager: Optional[RuntimeAgentManager] = None
-
-
-def get_runtime_agent_manager() -> RuntimeAgentManager:
-    """
-    Get the global runtime agent manager instance.
-
-    Returns:
-        The singleton RuntimeAgentManager instance
-    """
-    global _runtime_manager
-    if _runtime_manager is None:
-        _runtime_manager = RuntimeAgentManager()
-    return _runtime_manager