code-puppy 0.0.140__py3-none-any.whl → 0.0.141__py3-none-any.whl

code_puppy/agent.py

@@ -150,7 +150,7 @@ def reload_code_generation_agent(message_group: str | None):
 
     # Configure model settings with max_tokens if set
     model_settings_dict = {"seed": 42}
-    output_tokens = min(int(0.05 * get_model_context_length()) - 1024, 16384)
+    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
 

code_puppy/agents/agent_code_puppy.py

@@ -23,6 +23,8 @@ class CodePuppyAgent(BaseAgent):
     def get_available_tools(self) -> list[str]:
         """Get the list of tools available to Code-Puppy."""
         return [
+            "list_agents",
+            "invoke_agent",
             "list_files",
             "read_file",
             "grep",
@@ -128,6 +130,10 @@ DONT USE THE TERMINAL TOOL TO RUN THE CODE WE WROTE UNLESS THE USER ASKS YOU TO.
 Reasoning & Explanation:
    - share_your_reasoning(reasoning, next_steps=None): Use this to explicitly share your thought process and planned next steps
 
+Agent Management:
+   - list_agents(): Use this to list all available sub-agents that can be invoked
+   - invoke_agent(agent_name: str, prompt: str): Use this to invoke a specific sub-agent with a given prompt
+
 Important rules:
 - You MUST use tools to accomplish tasks - DO NOT just output code or descriptions
 - Before every other tool use, you must use "share_your_reasoning" to explain your thought process and planned next steps

code_puppy/agents/agent_creator_agent.py

@@ -95,6 +95,8 @@ Here's the complete schema for JSON agent files:
 
 ### 🧠 **Communication & Reasoning** (for all agents):
 - `agent_share_your_reasoning` - Explain thought processes (recommended for most agents)
+- `list_agents` - List all available sub-agents (recommended for agent managers)
+- `invoke_agent` - Invoke other agents with specific prompts (recommended for agent managers)
 
 ## Detailed Tool Documentation (Instructions for Agent Creation)
 
@@ -178,6 +180,27 @@ DONT USE THE TERMINAL TOOL TO RUN THE CODE WE WROTE UNLESS THE USER ASKS YOU TO.
 #### `agent_share_your_reasoning(reasoning, next_steps=None)`
 Use this to explicitly share your thought process and planned next steps
 
+#### `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")
+```
+
+Best-practice guidelines for `invoke_agent`:
+• Only invoke agents that exist (use `list_agents` to verify)
+• Clearly specify what you want the invoked agent to do
+• Be specific in your prompts to get better results
+• Avoid circular dependencies (don't invoke yourself!)
+
 ### Important Rules for Agent Creation:
 - You MUST use tools to accomplish tasks - DO NOT just output code or descriptions
 - Before every other tool use, you must use "share_your_reasoning" to explain your thought process and planned next steps
@@ -207,6 +230,8 @@ Available templates for tools:
 - `grep`: Standard text search operations
 - `agent_run_shell_command`: Standard shell command execution
 - `agent_share_your_reasoning`: Standard reasoning sharing operations
+- `list_agents`: Standard agent listing operations
+- `invoke_agent`: Standard agent invocation operations
 
 Each agent you create should only include templates for tools it actually uses. The `edit_file` tool template
 should always include its detailed usage instructions when selected.
@@ -275,6 +300,7 @@ This detailed documentation should be copied verbatim into any agent that will b
 **For "System admin helper":** → Suggest `agent_run_shell_command`, `list_files`, `read_file`, `agent_share_your_reasoning`
 **For "Code reviewer":** → Suggest `list_files`, `read_file`, `grep`, `agent_share_your_reasoning`
 **For "File organizer":** → Suggest `list_files`, `read_file`, `edit_file`, `delete_file`, `agent_share_your_reasoning`
+**For "Agent orchestrator":** → Suggest `list_agents`, `invoke_agent`, `agent_share_your_reasoning`
 
 ## Best Practices
 
@@ -322,6 +348,22 @@ This detailed documentation should be copied verbatim into any agent that will b
 }}
 ```
 
+**Agent Manager:**
+```json
+{{
+  "name": "agent-manager",
+  "display_name": "Agent Manager 🎭",
+  "description": "Manages and orchestrates other agents to accomplish complex tasks",
+  "system_prompt": [
+    "You are an agent manager that orchestrates other specialized agents.",
+    "You help users accomplish tasks by delegating to the appropriate sub-agent.",
+    "You coordinate between multiple agents to get complex work done."
+  ],
+  "tools": ["list_agents", "invoke_agent", "agent_share_your_reasoning"],
+  "user_prompt": "What can I help you accomplish today?"
+}}
+```
+
 You're fun, enthusiastic, and love helping people create amazing agents! 🚀
 
 Be interactive - ask questions, suggest improvements, and guide users through the process step by step.
@@ -348,7 +390,7 @@ Your goal is to take users from idea to working agent in one smooth conversation
 
     def get_available_tools(self) -> List[str]:
         """Get all tools needed for agent creation."""
-        return ["list_files", "read_file", "edit_file", "agent_share_your_reasoning"]
+        return ["list_files", "read_file", "edit_file", "agent_share_your_reasoning", "list_agents", "invoke_agent"]
 
     def validate_agent_json(self, agent_config: Dict) -> List[str]:
         """Validate a JSON agent configuration.
@@ -443,4 +485,4 @@ Your goal is to take users from idea to working agent in one smooth conversation
 
     def get_user_prompt(self) -> Optional[str]:
         """Get the initial user prompt."""
-        return "Hi! I'm the Agent Creator 🏗️ Let's build an awesome agent together!"
+        return "Hi! I'm the Agent Creator 🏗️ Let's build an awesome agent together!"

code_puppy/agents/agent_orchestrator.json

@@ -0,0 +1,26 @@
+{
+  "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

@@ -24,6 +24,7 @@ else:
 
 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, emit_warning
@@ -110,26 +111,31 @@ class RuntimeAgentManager:
             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_warning(f"MCP server error: {str(mcp_error)}", group_id=group_id)
-                emit_warning(f"{str(mcp_error)}", group_id=group_id)
-                emit_warning(
+                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_warning(f"Interrupted: {str(ie)}")
+                emit_info(f"Interrupted: {str(ie)}")
             except* Exception as other_error:
-                # Filter out CancelledError from the exception group - let it propagate
+                # 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):
+                    elif not isinstance(exc, (asyncio.CancelledError, UsageLimitExceeded)):
                         remaining_exceptions.append(exc)
-                        emit_warning(f"Unexpected error: {str(exc)}", group_id=group_id)
-                        emit_warning(f"{str(exc.args)}", group_id=group_id)
+                        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)
 
@@ -156,26 +162,20 @@ class RuntimeAgentManager:
         from code_puppy.tools.command_runner import kill_all_running_shell_processes
 
         # Ensure the interrupt handler only acts once per task
-        handled = False
-
         def keyboard_interrupt_handler(sig, frame):
             """Signal handler for Ctrl+C - replicating exact original logic"""
-            nonlocal handled
-            if handled:
-                return
-            handled = True
 
             # First, nuke any running shell processes triggered by tools
             try:
                 killed = kill_all_running_shell_processes()
                 if killed:
-                    emit_warning(f"Cancelled {killed} running shell process(es).")
+                    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_warning(f"Shell kill error: {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()
@@ -221,7 +221,14 @@ class RuntimeAgentManager:
             The agent's response
         """
         agent = self.get_agent()
-        return await agent.run(prompt, usage_limits=usage_limits, **kwargs)
+        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:
         """

code_puppy/main.py

@@ -132,7 +132,7 @@ async def main():
             )
             direct_console.print("[yellow]Press Ctrl+C to stop the server.[/yellow]\n")
             process = subprocess.Popen(textual_serve_cmd)
-            time.sleep(2)
+            time.sleep(0.3)
             try:
                 direct_console.print(
                     "[cyan]🚀 Opening web interface in your default browser...[/cyan]"
@@ -424,81 +424,11 @@ 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
 
-                # Create a task that mimics TUI behavior - avoid signal handler conflicts
-                current_task = None
-                signal_handled = (
-                    False  # Prevent multiple signal handler calls (reset per task)
-                )
-
-                async def run_task():
-                    # Use the simpler run() method instead of run_with_mcp() to avoid signal handler
-                    agent = agent_manager.get_agent()
-                    async with agent:
-                        return await agent.run(
-                            task,
-                            message_history=get_message_history(),
-                            usage_limits=get_custom_usage_limits(),
-                        )
-
-                def handle_keyboard_interrupt():
-                    """Handle Ctrl+C like TUI does - kill processes but only cancel task if no processes killed"""
-                    nonlocal signal_handled
-                    if signal_handled:
-                        return
-                    signal_handled = True
-
-                    from code_puppy.tools.command_runner import (
-                        kill_all_running_shell_processes,
-                    )
-
-                    killed = kill_all_running_shell_processes()
-                    if killed:
-                        emit_warning(f"🔥 Cancelled {killed} running shell process(es)")
-                        # Don't cancel the agent task - let it continue processing
-                        # Shell processes killed, but agent continues running
-                    else:
-                        # Only cancel the agent task if NO processes were killed
-                        if current_task and not current_task.done():
-                            current_task.cancel()
-                            emit_warning("⚠️  Processing cancelled by user")
-
-                # Set up proper signal handling to override asyncio's default behavior
-                import signal
-
-                def signal_handler(sig, frame):
-                    """Handle Ctrl+C by killing processes and cancelling the current task"""
-                    handle_keyboard_interrupt()
-
-                # Replace asyncio's SIGINT handler with our own
-                original_handler = signal.signal(signal.SIGINT, signal_handler)
-
-                # Use ConsoleSpinner for better user experience
-                try:
-                    with ConsoleSpinner(console=display_console):
-                        current_task = asyncio.create_task(run_task())
-                        result = await current_task
-                except asyncio.CancelledError:
-                    # Agent was cancelled by our signal handler
-                    result = None
-                except KeyboardInterrupt:
-                    # Fallback - handle Ctrl+C if it gets through as KeyboardInterrupt
-                    emit_warning("\n⚠️ Caught KeyboardInterrupt")
-                    handle_keyboard_interrupt()
-                    result = None
-                finally:
-                    # Restore original signal handler
-                    if "original_handler" in locals():
-                        signal.signal(signal.SIGINT, original_handler)
-                    set_message_history(
-                        prune_interrupted_tool_calls(get_message_history())
-                    )
-
+                runtime_manager = get_runtime_agent_manager()
+                with ConsoleSpinner(console=message_renderer.console):
+                    result = await runtime_manager.run_with_mcp(task, get_custom_usage_limits())
                 # Check if the task was cancelled (but don't show message if we just killed processes)
                 if result is None:
-                    # Only show cancellation message if we actually cancelled the agent task
-                    # If we just killed shell processes, the agent should continue normally
-                    pass  # Don't always show this message
-                    # Skip the rest of this loop iteration
                     continue
                 # Get the structured response
                 agent_response = result.output
@@ -512,9 +442,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 new_msgs = result.all_messages()
                 message_history_accumulator(new_msgs)
 
-                # Show context status
-                from code_puppy.messaging import emit_system_message
-
                 emit_system_message(
                     f"Context: {len(get_message_history())} messages in history\n"
                 )

code_puppy/mcp/retry_manager.py

@@ -31,8 +31,9 @@ class RetryStats:
     def calculate_average(self, new_attempts: int) -> None:
         """Update the average attempts calculation."""
         if self.total_retries == 0:
-            self.average_attempts = new_attempts
+            self.average_attempts = float(new_attempts)
         else:
+            # Calculate new average: (old_average * old_count + new_value) / new_count
             total_attempts = (self.average_attempts * self.total_retries) + new_attempts
             self.average_attempts = total_attempts / (self.total_retries + 1)
 
@@ -214,7 +215,6 @@ class RetryManager:
         """
         async with self._lock:
             stats = self._stats[server_id]
-            stats.total_retries += 1
             stats.last_retry = datetime.now()
 
             if success:
@@ -223,6 +223,7 @@ class RetryManager:
                 stats.failed_retries += 1
 
             stats.calculate_average(attempts)
+            stats.total_retries += 1
 
     async def get_retry_stats(self, server_id: str) -> RetryStats:
         """

code_puppy/tools/__init__.py

@@ -1,4 +1,8 @@
 from code_puppy.messaging import emit_warning
+from code_puppy.tools.agent_tools import (
+    register_list_agents,
+    register_invoke_agent,
+)
 from code_puppy.tools.command_runner import (
     register_agent_run_shell_command,
     register_agent_share_your_reasoning,
@@ -13,6 +17,9 @@ from code_puppy.tools.file_operations import (
 
 # Map of tool names to their individual registration functions
 TOOL_REGISTRY = {
+    # Agent Tools
+    "list_agents": register_list_agents,
+    "invoke_agent": register_invoke_agent,
     # File Operations
     "list_files": register_list_files,
     "read_file": register_read_file,

code_puppy/tools/agent_tools.py

@@ -0,0 +1,272 @@
+# agent_tools.py
+
+from typing import List
+from pydantic import BaseModel
+from pydantic_ai import RunContext
+
+from code_puppy.messaging import (
+    emit_info,
+    emit_divider,
+    emit_system_message,
+    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
+
+
+class AgentInfo(BaseModel):
+    """Information about an available agent."""
+    name: str
+    display_name: str
+
+
+class ListAgentsOutput(BaseModel):
+    """Output for the list_agents tool."""
+    agents: List[AgentInfo]
+    error: str | None = None
+
+
+class AgentInvokeOutput(BaseModel):
+    """Output for the invoke_agent tool."""
+    response: str | None
+    agent_name: str
+    error: str | None = None
+
+
+def _list_agents(context: RunContext) -> ListAgentsOutput:
+    """List all available sub-agents that can be invoked.
+    
+    Returns:
+        ListAgentsOutput: A list of available agents with their names and display names.
+    """
+    group_id = generate_group_id("list_agents")
+    
+    emit_info(
+        "\n[bold white on blue] LIST AGENTS [/bold white on blue]",
+        message_group=group_id
+    )
+    emit_divider(message_group=group_id)
+    
+    try:
+        # Get available agents from the agent manager
+        agents_dict = get_available_agents()
+        
+        # Convert to list of AgentInfo objects
+        agents = [
+            AgentInfo(name=name, display_name=display_name)
+            for name, display_name in agents_dict.items()
+        ]
+        
+        # Display the agents in the console
+        for agent in agents:
+            emit_system_message(
+                f"- [bold]{agent.name}[/bold]: {agent.display_name}", 
+                message_group=group_id
+            )
+            
+        emit_divider(message_group=group_id)
+        return ListAgentsOutput(agents=agents)
+        
+    except Exception as e:
+        error_msg = f"Error listing agents: {str(e)}"
+        emit_error(error_msg, message_group=group_id)
+        emit_divider(message_group=group_id)
+        return ListAgentsOutput(agents=[], error=error_msg)
+
+
+def _invoke_agent(context: RunContext, agent_name: str, prompt: str) -> AgentInvokeOutput:
+    """Invoke a specific sub-agent with a given prompt.
+    
+    Args:
+        agent_name: The name of the agent to invoke
+        prompt: The prompt to send to the agent
+        
+    Returns:
+        AgentInvokeOutput: The agent's response to the prompt
+    """
+    group_id = generate_group_id("invoke_agent", agent_name)
+    
+    emit_info(
+        f"\n[bold white on blue] INVOKE AGENT [/bold white on blue] {agent_name}",
+        message_group=group_id
+    )
+    emit_divider(message_group=group_id)
+    emit_system_message(f"Prompt: {prompt}", message_group=group_id)
+    emit_divider(message_group=group_id)
+    
+    try:
+        # Load the specified agent config
+        agent_config = load_agent_config(agent_name)
+        
+        # Get the current model for creating a temporary agent
+        model_name = get_model_name()
+        models_config = ModelFactory.load_config()
+        model = ModelFactory.get_model(model_name, models_config)
+        
+        # Create a temporary agent instance to avoid interfering with current agent state
+        instructions = agent_config.get_system_prompt()
+        temp_agent = Agent(
+            model=model,
+            instructions=instructions,
+            output_type=str,
+            retries=3,
+        )
+        
+        # Register the tools that the agent needs
+        from code_puppy.tools import register_tools_for_agent
+        agent_tools = agent_config.get_available_tools()
+        
+        # Avoid recursive tool registration - if the agent has the same tools
+        # as the current agent, skip registration to prevent conflicts
+        current_agent_tools = ["list_agents", "invoke_agent"]
+        if set(agent_tools) != set(current_agent_tools):
+            register_tools_for_agent(temp_agent, agent_tools)
+        
+        # Run the temporary agent with the provided prompt
+        result = temp_agent.run_sync(prompt)
+        
+        # Extract the response from the result
+        response = result.output
+        
+        emit_system_message(f"Response: {response}", message_group=group_id)
+        emit_divider(message_group=group_id)
+        
+        return AgentInvokeOutput(response=response, agent_name=agent_name)
+        
+    except Exception as e:
+        error_msg = f"Error invoking agent '{agent_name}': {str(e)}"
+        emit_error(error_msg, message_group=group_id)
+        emit_divider(message_group=group_id)
+        return AgentInvokeOutput(response=None, agent_name=agent_name, error=error_msg)
+
+
+def register_list_agents(agent):
+    """Register the list_agents tool with the provided agent.
+    
+    Args:
+        agent: The agent to register the tool with
+    """
+    @agent.tool
+    def list_agents(context: RunContext) -> ListAgentsOutput:
+        """List all available sub-agents that can be invoked.
+        
+        Returns:
+            ListAgentsOutput: A list of available agents with their names and display names.
+        """
+        # Generate a group ID for this tool execution
+        group_id = generate_group_id("list_agents")
+        
+        emit_info(
+            "\n[bold white on blue] LIST AGENTS [/bold white on blue]",
+            message_group=group_id
+        )
+        emit_divider(message_group=group_id)
+        
+        try:
+            # Get available agents from the agent manager
+            agents_dict = get_available_agents()
+            
+            # Convert to list of AgentInfo objects
+            agents = [
+                AgentInfo(name=name, display_name=display_name)
+                for name, display_name in agents_dict.items()
+            ]
+            
+            # Display the agents in the console
+            for agent_item in agents:
+                emit_system_message(
+                    f"- [bold]{agent_item.name}[/bold]: {agent_item.display_name}", 
+                    message_group=group_id
+                )
+                
+            emit_divider(message_group=group_id)
+            return ListAgentsOutput(agents=agents)
+            
+        except Exception as e:
+            error_msg = f"Error listing agents: {str(e)}"
+            emit_error(error_msg, message_group=group_id)
+            emit_divider(message_group=group_id)
+            return ListAgentsOutput(agents=[], error=error_msg)
+        
+    return list_agents
+
+
+def register_invoke_agent(agent):
+    """Register the invoke_agent tool with the provided agent.
+    
+    Args:
+        agent: The agent to register the tool with
+    """
+    @agent.tool
+    def invoke_agent(context: RunContext, agent_name: str, prompt: str) -> AgentInvokeOutput:
+        """Invoke a specific sub-agent with a given prompt.
+        
+        Args:
+            agent_name: The name of the agent to invoke
+            prompt: The prompt to send to the agent
+            
+        Returns:
+            AgentInvokeOutput: The agent's response to the prompt
+        """
+        # Generate a group ID for this tool execution
+        group_id = generate_group_id("invoke_agent", agent_name)
+        
+        emit_info(
+            f"\n[bold white on blue] INVOKE AGENT [/bold white on blue] {agent_name}",
+            message_group=group_id
+        )
+        emit_divider(message_group=group_id)
+        emit_system_message(f"Prompt: {prompt}", message_group=group_id)
+        emit_divider(message_group=group_id)
+        
+        try:
+            # Load the specified agent config
+            agent_config = load_agent_config(agent_name)
+            
+            # Get the current model for creating a temporary agent
+            model_name = get_model_name()
+            models_config = ModelFactory.load_config()
+
+            # Only proceed if we have a valid model configuration
+            if model_name not in models_config:
+                raise ValueError(f"Model '{model_name}' not found in configuration")
+                
+            model = ModelFactory.get_model(model_name, models_config)
+            
+            # Create a temporary agent instance to avoid interfering with current agent state
+            instructions = agent_config.get_system_prompt()
+            temp_agent = Agent(
+                model=model,
+                instructions=instructions,
+                output_type=str,
+                retries=3,
+            )
+            
+            # Register the tools that the agent needs
+            from code_puppy.tools import register_tools_for_agent
+            agent_tools = agent_config.get_available_tools()
+            register_tools_for_agent(temp_agent, agent_tools)
+            
+            # Run the temporary agent with the provided prompt
+            result = temp_agent.run_sync(prompt)
+            
+            # Extract the response from the result
+            response = result.output
+            
+            emit_system_message(f"Response: {response}", message_group=group_id)
+            emit_divider(message_group=group_id)
+            
+            return AgentInvokeOutput(response=response, agent_name=agent_name)
+            
+        except Exception as e:
+            error_msg = f"Error invoking agent '{agent_name}': {str(e)}"
+            emit_error(error_msg, message_group=group_id)
+            emit_divider(message_group=group_id)
+            return AgentInvokeOutput(response=None, agent_name=agent_name, error=error_msg)
+            
+    return invoke_agent

{code_puppy-0.0.140.dist-info → code_puppy-0.0.141.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.140
+Version: 0.0.141
 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.140.dist-info → code_puppy-0.0.141.dist-info}/RECORD

@@ -1,10 +1,10 @@
 code_puppy/__init__.py,sha256=ehbM1-wMjNmOXk_DBhhJECFyBv2dRHwwo7ucjHeM68E,107
 code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
-code_puppy/agent.py,sha256=AIu0fg2VfRDXaf4gOmcqx5W06JRxSmfxGh8zFTrpts8,6914
+code_puppy/agent.py,sha256=ZQb1YWvBJXzGzXML1wI4gPf_-2kClMrYFleFMtA-9RA,6925
 code_puppy/callbacks.py,sha256=6wYB6K_fGSCkKKEFaYOYkJT45WaV5W_NhUIzcvVH_nU,5060
 code_puppy/config.py,sha256=9yWKHKjLJ2Ddl4frrBI9VRIwPvoWpIx1fAd1YpAvOSQ,15330
 code_puppy/http_utils.py,sha256=BAvt4hed7fVMXglA7eS9gOb08h2YTuOyai6VmQq09fg,3432
-code_puppy/main.py,sha256=Pm5h-s0MQIc7IsitwVmN3DsGqgeKpvI6qUxBnbgvpI4,25272
+code_puppy/main.py,sha256=Vv5HSJnkgZhCvvOoXrJ2zqM5P-i47-RcYAU00Z1Pfx0,21733
 code_puppy/message_history_processor.py,sha256=O2rKp7W6YeIg93W8b0XySTUEQgIZm0f_06--_kzHugM,16145
 code_puppy/model_factory.py,sha256=NoG9wDTosaaDrFIGtq3oq8gDe0J_7N6CUKuesXz87qM,10878
 code_puppy/models.json,sha256=dAfpMMI2EEeOMv0ynHSmMuJAYDLcZrs5gCLX3voC4-A,3252
@@ -15,12 +15,13 @@ code_puppy/summarization_agent.py,sha256=-e6yUGZ22ahSaF0y7QhgVcQBfx5ktNUkPxBIWQf
 code_puppy/token_utils.py,sha256=inLo-S2YERGA-JmV-nrSFN7KMswSfHxpawAuK6YiDHc,1982
 code_puppy/version_checker.py,sha256=bjLDmgGPrl7XnYwX1u13O8uFlsfikV90PK6nbA9Z9QU,1150
 code_puppy/agents/__init__.py,sha256=SwtHGNG1GIgDBv7y3EGIXOXEWrG_Ou7fEknNgFbrHv8,594
-code_puppy/agents/agent_code_puppy.py,sha256=C9qS8qNeYZadWDNlY6eBaqUPzhbNsNj3nclb75zHqqU,7712
-code_puppy/agents/agent_creator_agent.py,sha256=hpmr3UmTaoDfcJ0tbMdxyUyxQ941N9XX6Upe_BGEpE8,18664
+code_puppy/agents/agent_code_puppy.py,sha256=At4PDmBsBFCrKKvdOKlCGa6XLu1PB23kXJb3SEHjT1I,7977
+code_puppy/agents/agent_creator_agent.py,sha256=IUPLJDhhqIQ8NAjNTFQ_3Z5kZYYxVAUE0RPkcz90reY,20450
 code_puppy/agents/agent_manager.py,sha256=nXvro6fpX8KA-NedRoVJuhJW966trrePOrH4eAnqq40,17034
+code_puppy/agents/agent_orchestrator.json,sha256=Iqnc0p6ICoAlUTMkEsi1XXMXJi4pdxVnWZUMaih6s5o,1267
 code_puppy/agents/base_agent.py,sha256=XYSff6IQX9Z6C7hPVbN_YXC2xfjwd268e2jtG3ZGnVk,3450
 code_puppy/agents/json_agent.py,sha256=0j6_P1ppje7TsjaZIbxKn8meiuvoBngvjVLNdtCkGwc,4272
-code_puppy/agents/runtime_manager.py,sha256=7Lw8Hxi95DCIaTXk3k-coLVJ36aNk0tTT7zV0iAPw4M,9163
+code_puppy/agents/runtime_manager.py,sha256=t8F37mYX3txUqVoOrGwt0VR4Yc-M8AKIxSo22P0TOmg,9921
 code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
 code_puppy/command_line/command_handler.py,sha256=1o9tKAGycpHFDBldYRAAvY5HJ6QAfikLPrXTEkfw37o,21137
 code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
@@ -61,7 +62,7 @@ code_puppy/mcp/health_monitor.py,sha256=n5R6EeYOYbUucUFe74qGWCU3g6Mep5UEQbLF0wbT
 code_puppy/mcp/managed_server.py,sha256=vYD_uwHJDyRB7iHNIZHTNEin5bVe9lCMMjJyFMWNjc8,14381
 code_puppy/mcp/manager.py,sha256=Yx9zxukdXgdPDgeJiiQPYlPae0zQPofHWB-axuoMNc8,26426
 code_puppy/mcp/registry.py,sha256=IvbIL-pETQ7HS7iRgsoT5j7eY8TOJXqYczSiigT2ofU,15752
-code_puppy/mcp/retry_manager.py,sha256=eTM2cZ6_6tHk5lMjDbyaz_pdOkF-1yVqQqnwS--nuuw,10571
+code_puppy/mcp/retry_manager.py,sha256=evVxbtrsHNyo8UoI7zpO-NVDegibn82RLlgN8VKewA8,10665
 code_puppy/mcp/server_registry_catalog.py,sha256=jYx__H-b-f4Ucpczx-wwpU-TRx6fXzFDR0kr2Qhwqb0,38857
 code_puppy/mcp/status_tracker.py,sha256=uekxrzkzIWrv3OfSVgblaPuoGFcAh_dBYwCcaHZ_CrM,12183
 code_puppy/mcp/system_tools.py,sha256=7_oR8k0c8YjtCcYF9g7A946oAGuKOf_i-92aJH7VmlQ,7331
@@ -75,7 +76,8 @@ code_puppy/messaging/spinner/console_spinner.py,sha256=cuOXQH99dJ1cq0l_rpCLVCGNs
 code_puppy/messaging/spinner/spinner_base.py,sha256=474qMrTYpNfWcprFzmhaOJEOC-2rRHpTFCLsnl54bXA,1689
 code_puppy/messaging/spinner/textual_spinner.py,sha256=Omx9A-FSPkxYDMYgBXgYMBQnK-DMlyqLOgkFVG8cmo4,3465
 code_puppy/plugins/__init__.py,sha256=fksDqMUiXPJ5WNuMsYsVR8ulueQRCXPlvECEyicHPtQ,1312
-code_puppy/tools/__init__.py,sha256=YfTN-2aWH2av4YBV8cA-W69AlPLOM_me0BFiAjhE9H0,1919
+code_puppy/tools/__init__.py,sha256=YiiXRqxU1BEJ5t0Oe163lSqOneI9sKtwDW0swCPgBt4,2119
+code_puppy/tools/agent_tools.py,sha256=tG11PMmjuU-pYG1MFCgqsYiC1Q8C-zPsitAYXxl3mRA,9726
 code_puppy/tools/command_runner.py,sha256=GVNsgwjTFD9tkNlycgMNmMoVPdmMkZkbAcHH5y6iMww,26070
 code_puppy/tools/common.py,sha256=pL-9xcRs3rxU7Fl9X9EUgbDp2-csh2LLJ5DHH_KAHKY,10596
 code_puppy/tools/file_modifications.py,sha256=oeNEQItqwMhGOeEN2TzGR7TjmgLsfFFdPaVMzWbfXIQ,30398
@@ -123,9 +125,9 @@ code_puppy/tui/tests/test_sidebar_history_navigation.py,sha256=JGiyua8A2B8dLfwiE
 code_puppy/tui/tests/test_status_bar.py,sha256=nYT_FZGdmqnnbn6o0ZuOkLtNUtJzLSmtX8P72liQ5Vo,1797
 code_puppy/tui/tests/test_timestamped_history.py,sha256=nVXt9hExZZ_8MFP-AZj4L4bB_1Eo_mc-ZhVICzTuw3I,1799
 code_puppy/tui/tests/test_tools.py,sha256=kgzzAkK4r0DPzQwHHD4cePpVNgrHor6cFr05Pg6DBWg,2687
-code_puppy-0.0.140.data/data/code_puppy/models.json,sha256=dAfpMMI2EEeOMv0ynHSmMuJAYDLcZrs5gCLX3voC4-A,3252
-code_puppy-0.0.140.dist-info/METADATA,sha256=1-4HD5LYa4pdJPfjQwj0-x5nFnsJnQQEAgbcwSMX6-w,19873
-code_puppy-0.0.140.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.140.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.140.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.140.dist-info/RECORD,,
+code_puppy-0.0.141.data/data/code_puppy/models.json,sha256=dAfpMMI2EEeOMv0ynHSmMuJAYDLcZrs5gCLX3voC4-A,3252
+code_puppy-0.0.141.dist-info/METADATA,sha256=09qtNO_oD5YGszPMVCR3mZ2YsvcqrXn-PU31tLRE8sE,19873
+code_puppy-0.0.141.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.141.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.141.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.141.dist-info/RECORD,,