code-puppy 0.0.154__py3-none-any.whl → 0.0.156__py3-none-any.whl

code_puppy/agent.py

@@ -24,17 +24,17 @@ 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
 
@@ -134,7 +134,15 @@ def reload_code_generation_agent(message_group: str | None):
     clear_model_cache()
     clear_agent_cache()
 
-    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 get_model_name()
     emit_info(
         f"[bold cyan]Loading Model: {model_name}[/bold cyan]",
         message_group=message_group,
@@ -193,7 +201,19 @@ def get_code_generation_agent(force_reload=False, message_group: str | None = No
         message_group = str(uuid.uuid4())
     from code_puppy.config import get_model_name
 
-    model_name = 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
@@ -206,4 +226,5 @@ def get_custom_usage_limits():
     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_creator_agent.py

@@ -6,6 +6,7 @@ from typing import Dict, List, Optional
 
 from .base_agent import BaseAgent
 from code_puppy.config import get_user_agents_directory
+from code_puppy.model_factory import ModelFactory
 from code_puppy.tools import get_available_tool_names
 
 
@@ -27,6 +28,16 @@ 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")
+        
+        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.
 
@@ -39,7 +50,7 @@ You specialize in:
 - Creating properly structured JSON agent files
 - Explaining agent capabilities and best practices
 
-## MANDATORY TOOL SELECTION PROCESS
+## MANDATORY AGENT CREATION PROCESS
 
 **YOU MUST ALWAYS:**
 1. Ask the user what the agent should be able to do
@@ -47,6 +58,8 @@ You specialize in:
 3. List ALL available tools so they can see other options
 4. Ask them to confirm their tool selection
 5. Explain why each selected tool is useful for their agent
+6. Ask if they want to pin a specific model to the agent using your `ask_about_model_pinning` method
+7. Include the model in the final JSON if the user chooses to pin one
 
 ## JSON Agent Schema
 
@@ -63,7 +76,8 @@ Here's the complete schema for JSON agent files:
   "user_prompt": "How can I help?",     // OPTIONAL: Custom greeting
   "tools_config": {{                    // OPTIONAL: Tool configuration
     "timeout": 60
-  }}
+  }},
+  "model": "model-name"               // OPTIONAL: Pin a specific model for this agent
 }}
 ```
 
@@ -77,10 +91,24 @@ Here's the complete schema for JSON agent files:
 - `display_name`: Pretty display name (defaults to title-cased name + 🤖)
 - `user_prompt`: Custom user greeting
 - `tools_config`: Tool configuration object
+- `model`: Pin a specific model for this agent (defaults to global model)
 
 ## ALL AVAILABLE TOOLS:
 {", ".join(f"- **{tool}**" for tool in available_tools)}
 
+## ALL AVAILABLE MODELS:
+{available_models_str}
+
+Users can optionally pin a specific model to their agent to override the global default.
+
+### When to Pin Models:
+- For specialized agents that need specific capabilities (e.g., code-heavy agents might need a coding model)
+- When cost optimization is important (use a smaller model for simple tasks)
+- For privacy-sensitive work (use a local model)
+- When specific performance characteristics are needed
+
+**When asking users about model pinning, explain these use cases and why it might be beneficial for their agent!**
+
 ## Tool Categories & Suggestions:
 
 ### 📁 **File Operations** (for agents working with files):
@@ -122,13 +150,15 @@ Use this to recursively search for a string across files starting from the speci
 
 ### Tool Usage Instructions:
 
-#### `edit_file` tool usage details:
+#### `ask_about_model_pinning(agent_config)`
+Use this method to ask the user whether they want to pin a specific model to their agent. Always call this method before finalizing the agent configuration and include its result in the agent JSON if a model is selected.
 This is an all-in-one file-modification tool. It supports the following Pydantic Object payload types:
 1. ContentPayload: {{ file_path="example.py", "content": "…", "overwrite": true|false }}  →  Create or overwrite a file with the provided content.
 2. ReplacementsPayload: {{  file_path="example.py", "replacements": [ {{ "old_str": "…", "new_str": "…" }}, … ] }}  →  Perform exact text replacements inside an existing file.
 3. DeleteSnippetPayload: {{ file_path="example.py", "delete_snippet": "…" }}  →  Remove a snippet of text from an existing file.
 
 Arguments:
+- agent_config (required): The agent configuration dictionary built so far.
 - payload (required): One of the Pydantic payload types above.
 
 Example (create):
@@ -271,11 +301,12 @@ This detailed documentation should be copied verbatim into any agent that will b
 3. **🎯 SUGGEST TOOLS** based on their answer with explanations
 4. **📋 SHOW ALL TOOLS** so they know all options
 5. **✅ CONFIRM TOOL SELECTION** and explain choices
-6. **Craft system prompt** that defines agent behavior, including ALL detailed tool documentation for selected tools
-7. **Generate complete JSON** with proper structure
-8. **🚨 MANDATORY: ASK FOR USER CONFIRMATION** of the generated JSON
-9. **🤖 AUTOMATICALLY CREATE THE FILE** once user confirms (no additional asking)
-10. **Validate and test** the new agent
+6. **Ask about model pinning**: "Do you want to pin a specific model to this agent?" with list of options
+7. **Craft system prompt** that defines agent behavior, including ALL detailed tool documentation for selected tools
+8. **Generate complete JSON** with proper structure
+9. **🚨 MANDATORY: ASK FOR USER CONFIRMATION** of the generated JSON
+10. **🤖 AUTOMATICALLY CREATE THE FILE** once user confirms (no additional asking)
+11. **Validate and test** the new agent
 
 ## CRITICAL WORKFLOW RULES:
 
@@ -302,6 +333,14 @@ This detailed documentation should be copied verbatim into any agent that will b
 **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`
 
+## Model Selection Guidance:
+
+**For code-heavy tasks**: → Suggest `Cerebras-Qwen3-Coder-480b`, `grok-code-fast-1`, or `gpt-4.1`
+**For document analysis**: → Suggest `gemini-2.5-flash-preview-05-20` or `claude-4-0-sonnet`
+**For general reasoning**: → Suggest `gpt-5` or `o3`
+**For cost-conscious tasks**: → Suggest `gpt-4.1-mini` or `gpt-4.1-nano`
+**For local/private work**: → Suggest `ollama-llama3.3` or `gpt-4.1-custom`
+
 ## Best Practices
 
 - Use descriptive names with hyphens (e.g., "python-tutor", "code-reviewer")
@@ -320,6 +359,7 @@ This detailed documentation should be copied verbatim into any agent that will b
   "name": "python-tutor",
   "display_name": "Python Tutor 🐍",
   "description": "Teaches Python programming concepts with examples",
+  "model": "gpt-5",
   "system_prompt": [
     "You are a patient Python programming tutor.",
     "You explain concepts clearly with practical examples.",
@@ -327,7 +367,8 @@ This detailed documentation should be copied verbatim into any agent that will b
     "Always encourage learning and provide constructive feedback."
   ],
   "tools": ["read_file", "edit_file", "agent_share_your_reasoning"],
-  "user_prompt": "What Python concept would you like to learn today?"
+  "user_prompt": "What Python concept would you like to learn today?",
+  "model": "Cerebras-Qwen3-Coder-480b"  // Optional: Pin to a specific code model
 }}
 ```
 
@@ -344,7 +385,8 @@ This detailed documentation should be copied verbatim into any agent that will b
     "You follow language-specific best practices and conventions."
   ],
   "tools": ["list_files", "read_file", "grep", "agent_share_your_reasoning"],
-  "user_prompt": "Which code would you like me to review?"
+  "user_prompt": "Which code would you like me to review?",
+  "model": "claude-4-0-sonnet"  // Optional: Pin to a model good at analysis
 }}
 ```
 
@@ -360,7 +402,8 @@ This detailed documentation should be copied verbatim into any agent that will b
     "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?"
+  "user_prompt": "What can I help you accomplish today?",
+  "model": "gpt-5"  // Optional: Pin to a reasoning-focused model
 }}
 ```
 
@@ -370,9 +413,11 @@ Be interactive - ask questions, suggest improvements, and guide users through th
 
 ## REMEMBER: COMPLETE THE WORKFLOW!
 - After generating JSON, ALWAYS get confirmation
+- Ask about model pinning using your `ask_about_model_pinning` method
 - Once confirmed, IMMEDIATELY create the file (don't ask again)
 - Use your `edit_file` tool to save the JSON
 - Always explain how to use the new agent with `/agent agent-name`
+- Mention that users can later change or pin the model with `/pin_model agent-name model-name`
 
 ## Tool Documentation Requirements
 
@@ -390,7 +435,14 @@ 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", "list_agents", "invoke_agent"]
+        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.
@@ -485,4 +537,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/json_agent.py

@@ -101,6 +101,14 @@ class JSONAgent(BaseAgent):
         """Get tool configuration from JSON config."""
         return self._config.get("tools_config")
 
+    def get_model_name(self) -> Optional[str]:
+        """Get pinned model name from JSON config, if specified.
+
+        Returns:
+            Model name to use for this agent, or None to use global default.
+        """
+        return self._config.get("model")
+
 
 def discover_json_agents() -> Dict[str, str]:
     """Discover JSON agent files in the user's agents directory.

code_puppy/agents/runtime_manager.py

@@ -27,7 +27,7 @@ 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
+from code_puppy.messaging.message_queue import emit_info
 
 
 class RuntimeAgentManager:
@@ -113,7 +113,10 @@ class RuntimeAgentManager:
                     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)
+                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)
@@ -132,7 +135,9 @@ class RuntimeAgentManager:
                     if isinstance(exc, ExceptionGroup):
                         for sub_exc in exc.exceptions:
                             collect_non_cancelled_exceptions(sub_exc)
-                    elif not isinstance(exc, (asyncio.CancelledError, UsageLimitExceeded)):
+                    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)
@@ -226,7 +231,10 @@ class RuntimeAgentManager:
         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)
+            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
 

code_puppy/command_line/command_handler.py

@@ -42,6 +42,10 @@ def get_commands_help():
     help_lines.append(
         Text("/model, /m", style="cyan") + Text(" <model>   Set active model")
     )
+    help_lines.append(
+        Text("/pin_model", style="cyan")
+        + Text(" <agent> <model>  Pin a specific model to an agent")
+    )
     help_lines.append(
         Text("/mcp", style="cyan")
         + Text("                  Manage MCP servers (list, start, stop, status, etc.)")
@@ -398,6 +402,85 @@ def handle_command(command: str):
         emit_info(help_text, message_group_id=group_id)
         return True
 
+    if command.startswith("/pin_model"):
+        # Handle agent model pinning
+        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
+
     if command.startswith("/generate-pr-description"):
         # Parse directory argument (e.g., /generate-pr-description @some/dir)
         tokens = command.split()

code_puppy/command_line/mcp/install_command.py

@@ -158,10 +158,59 @@ class InstallCommand(MCPCommandBase):
                     emit_info("Installation cancelled", message_group=group_id)
                     return False
 
-            # Install with default configuration (simplified)
+            # Collect environment variables and command line arguments
             env_vars = {}
             cmd_args = {}
 
+            # Get environment variables
+            required_env_vars = selected_server.get_environment_vars()
+            if required_env_vars:
+                emit_info(
+                    "\n[yellow]Required Environment Variables:[/yellow]",
+                    message_group=group_id,
+                )
+                for var in required_env_vars:
+                    # Check if already set in environment
+                    import os
+
+                    current_value = os.environ.get(var, "")
+                    if current_value:
+                        emit_info(
+                            f"  {var}: [green]Already set[/green]",
+                            message_group=group_id,
+                        )
+                        env_vars[var] = current_value
+                    else:
+                        value = emit_prompt(f"  Enter value for {var}: ").strip()
+                        if value:
+                            env_vars[var] = value
+
+            # Get command line arguments
+            required_cmd_args = selected_server.get_command_line_args()
+            if required_cmd_args:
+                emit_info(
+                    "\n[yellow]Command Line Arguments:[/yellow]", message_group=group_id
+                )
+                for arg_config in required_cmd_args:
+                    name = arg_config.get("name", "")
+                    prompt = arg_config.get("prompt", name)
+                    default = arg_config.get("default", "")
+                    required = arg_config.get("required", True)
+
+                    # If required or has default, prompt user
+                    if required or default:
+                        arg_prompt = f"  {prompt}"
+                        if default:
+                            arg_prompt += f" [{default}]"
+                        if not required:
+                            arg_prompt += " (optional)"
+
+                        value = emit_prompt(f"{arg_prompt}: ").strip()
+                        if value:
+                            cmd_args[name] = value
+                        elif default:
+                            cmd_args[name] = default
+
             # Install the server
             return install_server_from_catalog(
                 self.manager, selected_server, server_name, env_vars, cmd_args, group_id

code_puppy/command_line/mcp/wizard_utils.py

@@ -43,9 +43,61 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
         if not server_name:
             return False
 
+        # Collect environment variables and command line arguments
+        env_vars = {}
+        cmd_args = {}
+
+        # Get environment variables
+        required_env_vars = selected_server.get_environment_vars()
+        if required_env_vars:
+            emit_info(
+                "\n[yellow]Required Environment Variables:[/yellow]",
+                message_group=group_id,
+            )
+            for var in required_env_vars:
+                # Check if already set in environment
+                import os
+
+                current_value = os.environ.get(var, "")
+                if current_value:
+                    emit_info(
+                        f"  {var}: [green]Already set[/green]", message_group=group_id
+                    )
+                    env_vars[var] = current_value
+                else:
+                    value = emit_prompt(f"  Enter value for {var}: ").strip()
+                    if value:
+                        env_vars[var] = value
+
+        # Get command line arguments
+        required_cmd_args = selected_server.get_command_line_args()
+        if required_cmd_args:
+            emit_info(
+                "\n[yellow]Command Line Arguments:[/yellow]", message_group=group_id
+            )
+            for arg_config in required_cmd_args:
+                name = arg_config.get("name", "")
+                prompt = arg_config.get("prompt", name)
+                default = arg_config.get("default", "")
+                required = arg_config.get("required", True)
+
+                # If required or has default, prompt user
+                if required or default:
+                    arg_prompt = f"  {prompt}"
+                    if default:
+                        arg_prompt += f" [{default}]"
+                    if not required:
+                        arg_prompt += " (optional)"
+
+                    value = emit_prompt(f"{arg_prompt}: ").strip()
+                    if value:
+                        cmd_args[name] = value
+                    elif default:
+                        cmd_args[name] = default
+
         # Configure the server
         return interactive_configure_server(
-            manager, selected_server, server_name, group_id
+            manager, selected_server, server_name, group_id, env_vars, cmd_args
         )
 
     except ImportError:
@@ -131,7 +183,12 @@ def interactive_get_server_name(selected_server, group_id: str) -> Optional[str]
 
 
 def interactive_configure_server(
-    manager, selected_server, server_name: str, group_id: str
+    manager,
+    selected_server,
+    server_name: str,
+    group_id: str,
+    env_vars: Dict[str, Any],
+    cmd_args: Dict[str, Any],
 ) -> bool:
     """
     Configure and install the selected server.
@@ -151,15 +208,20 @@ def interactive_configure_server(
                 emit_info("Installation cancelled", message_group=group_id)
                 return False
 
-        # For now, use defaults - a full implementation would collect env vars, etc.
-        # requirements = selected_server.get_requirements()  # TODO: Use for validation
-        env_vars = {}
-        cmd_args = {}
-
         # Show confirmation
         emit_info(f"Installing: {selected_server.display_name}", message_group=group_id)
         emit_info(f"Name: {server_name}", message_group=group_id)
 
+        if env_vars:
+            emit_info("Environment Variables:", message_group=group_id)
+            for var, value in env_vars.items():
+                emit_info(f"  {var}: [hidden]{value}[/hidden]", message_group=group_id)
+
+        if cmd_args:
+            emit_info("Command Line Arguments:", message_group=group_id)
+            for arg, value in cmd_args.items():
+                emit_info(f"  {arg}: {value}", message_group=group_id)
+
         confirm = emit_prompt("Proceed with installation? [Y/n]: ")
         if confirm.lower().startswith("n"):
             emit_info("Installation cancelled", message_group=group_id)
@@ -196,18 +258,25 @@ def install_server_from_catalog(
         from code_puppy.config import MCP_SERVERS_FILE
         from code_puppy.mcp.managed_server import ServerConfig
 
-        # Create server configuration
-        config_dict = selected_server.get_config_template()
+        # Set environment variables in the current environment
+        for var, value in env_vars.items():
+            os.environ[var] = value
 
-        # Apply environment variables and command args
-        if env_vars:
-            config_dict.update(env_vars)
-        if cmd_args:
-            config_dict.update(cmd_args)
+        # Get server config with command line argument overrides
+        config_dict = selected_server.to_server_config(server_name, **cmd_args)
+
+        # Update the config with actual environment variable values
+        if "env" in config_dict:
+            for env_key, env_value in config_dict["env"].items():
+                # If it's a placeholder like $GITHUB_TOKEN, replace with actual value
+                if env_value.startswith("$"):
+                    var_name = env_value[1:]  # Remove the $
+                    if var_name in env_vars:
+                        config_dict["env"][env_key] = env_vars[var_name]
 
         # Create ServerConfig
         server_config = ServerConfig(
-            id=f"{server_name}_{hash(server_name)}",
+            id=server_name,
             name=server_name,
             type=selected_server.type,
             enabled=True,
@@ -234,8 +303,10 @@ def install_server_from_catalog(
             data = {"mcp_servers": servers}
 
         # Add new server
-        servers[server_name] = config_dict.copy()
-        servers[server_name]["type"] = selected_server.type
+        # Copy the config dict and add type before saving
+        save_config = config_dict.copy()
+        save_config["type"] = selected_server.type
+        servers[server_name] = save_config
 
         # Save back
         os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)

code_puppy/command_line/prompt_toolkit_completion.py

@@ -139,12 +139,28 @@ def get_prompt_with_active_model(base: str = ">>> "):
     from code_puppy.agents.agent_manager import get_current_agent_config
 
     puppy = get_puppy_name()
-    model = get_active_model() or "(default)"
+    global_model = get_active_model() or "(default)"
 
     # Get current agent information
     current_agent = get_current_agent_config()
     agent_display = current_agent.display_name if current_agent else "code-puppy"
 
+    # Check if current agent has a pinned model
+    agent_model = None
+    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
+        model_display = f"[{global_model} → {agent_model}]"
+    elif agent_model:
+        # Show only the agent model when pinned
+        model_display = f"[{agent_model}]"
+    else:
+        # Show only the global model when no agent model is pinned
+        model_display = f"[{global_model}]"
+
     cwd = os.getcwd()
     home = os.path.expanduser("~")
     if cwd.startswith(home):
@@ -157,7 +173,7 @@ def get_prompt_with_active_model(base: str = ">>> "):
             ("class:puppy", f"{puppy}"),
             ("", " "),
             ("class:agent", f"[{agent_display}] "),
-            ("class:model", "[" + str(model) + "] "),
+            ("class:model", model_display + " "),
             ("class:cwd", "(" + str(cwd_display) + ") "),
             ("class:arrow", str(base)),
         ]