code-puppy 0.0.154__tar.gz → 0.0.155__tar.gz

{code_puppy-0.0.154 → code_puppy-0.0.155}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.154
+Version: 0.0.155
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Code Generators
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: fastapi>=0.110.0
 Requires-Dist: httpx-limiter>=0.3.0

{code_puppy-0.0.154 → code_puppy-0.0.155}/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
 
@@ -206,4 +206,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-0.0.154 → code_puppy-0.0.155}/code_puppy/agents/agent_creator_agent.py

@@ -390,7 +390,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 +492,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-0.0.154 → code_puppy-0.0.155}/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-0.0.154 → code_puppy-0.0.155}/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-0.0.154 → code_puppy-0.0.155}/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-0.0.154 → code_puppy-0.0.155}/code_puppy/config.py

@@ -106,7 +106,13 @@ def get_config_keys():
     Returns the list of all config keys currently in puppy.cfg,
     plus certain preset expected keys (e.g. "yolo_mode", "model", "compaction_strategy", "message_limit", "allow_recursion").
     """
-    default_keys = ["yolo_mode", "model", "compaction_strategy", "message_limit", "allow_recursion"]
+    default_keys = [
+        "yolo_mode",
+        "model",
+        "compaction_strategy",
+        "message_limit",
+        "allow_recursion",
+    ]
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     keys = set(config[DEFAULT_SECTION].keys()) if DEFAULT_SECTION in config else set()
@@ -173,7 +179,7 @@ def _default_model_from_models_json():
         first_key = next(iter(models_config))  # Raises StopIteration if empty
         _default_model_cache = first_key
         return first_key
-    except Exception as e:
+    except Exception:
         # Any problem (network, file missing, empty dict, etc.) => fall back
         _default_model_cache = "gpt-5"
         return "gpt-5"

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/main.py

@@ -290,7 +290,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             if awaiting_input:
                 # No spinner - use agent_manager's run_with_mcp method
                 response = await agent_manager.run_with_mcp(
-                    initial_command, usage_limits=get_custom_usage_limits()
+                    initial_command,
+                    message_history=get_message_history(),
+                    usage_limits=get_custom_usage_limits(),
                 )
             else:
                 # Use our custom spinner for better compatibility with user input
@@ -299,7 +301,11 @@ 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(
-                        initial_command, usage_limits=get_custom_usage_limits()
+                        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())
@@ -426,7 +432,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
                 runtime_manager = get_runtime_agent_manager()
                 with ConsoleSpinner(console=message_renderer.console):
-                    result = await runtime_manager.run_with_mcp(task, get_custom_usage_limits())
+                    result = await runtime_manager.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:
                     continue
@@ -495,7 +507,8 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
 
         with ConsoleSpinner(console=message_renderer.console):
             response = await agent_manager.run_with_mcp(
-                prompt, usage_limits=get_custom_usage_limits()
+                prompt,
+                usage_limits=get_custom_usage_limits(),
             )
 
         agent_response = response.output

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/mcp/__init__.py

@@ -1,7 +1,7 @@
 """MCP (Model Context Protocol) management system for Code Puppy.
 
-Note: Be careful not to create circular imports with config_wizard.py. 
-config_wizard.py imports ServerConfig and get_mcp_manager directly from 
+Note: Be careful not to create circular imports with config_wizard.py.
+config_wizard.py imports ServerConfig and get_mcp_manager directly from
 .manager to avoid circular dependencies with this package __init__.py
 """
 

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/mcp/config_wizard.py

@@ -1,7 +1,7 @@
 """
 MCP Configuration Wizard - Interactive setup for MCP servers.
 
-Note: This module imports ServerConfig and get_mcp_manager directly from 
+Note: This module imports ServerConfig and get_mcp_manager directly from
 .code_puppy.mcp.manager to avoid circular imports with the package __init__.py
 """
 

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/messaging/spinner/console_spinner.py

@@ -125,7 +125,7 @@ class ConsoleSpinner(SpinnerBase):
                     self._live.refresh()
 
                 # Short sleep to control animation speed
-                time.sleep(0.1)
+                time.sleep(0.05)
         except Exception as e:
             print(f"\nSpinner error: {e}")
             self._is_spinning = False

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/model_factory.py

@@ -6,9 +6,8 @@ from typing import Any, Dict
 
 import httpx
 from anthropic import AsyncAnthropic
-from openai import AsyncAzureOpenAI  # For Azure OpenAI client
+from openai import AsyncAzureOpenAI
 from pydantic_ai.models.anthropic import AnthropicModel
-from pydantic_ai.models.fallback import infer_model
 from pydantic_ai.models.gemini import GeminiModel
 from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.providers.anthropic import AnthropicProvider
@@ -87,13 +86,13 @@ class ModelFactory:
         else:
             from code_puppy.config import MODELS_FILE
 
-            if not pathlib.Path(MODELS_FILE).exists():
-                with open(pathlib.Path(__file__).parent / "models.json", "r") as src:
-                    with open(pathlib.Path(MODELS_FILE), "w") as target:
-                        target.write(src.read())
+            with open(pathlib.Path(__file__).parent / "models.json", "r") as src:
+                with open(pathlib.Path(MODELS_FILE), "w") as target:
+                    target.write(src.read())
 
             with open(MODELS_FILE, "r") as f:
                 config = json.load(f)
+
         if pathlib.Path(EXTRA_MODELS_FILE).exists():
             with open(EXTRA_MODELS_FILE, "r") as f:
                 extra_config = json.load(f)
@@ -248,25 +247,27 @@ class ModelFactory:
             model = OpenAIChatModel(model_name=model_config["name"], provider=provider)
             setattr(model, "provider", provider)
             return model
-        
+
         elif model_type == "round_robin":
             # Get the list of model names to use in the round-robin
             model_names = model_config.get("models")
             if not model_names or not isinstance(model_names, list):
-                raise ValueError(f"Round-robin model '{model_name}' requires a 'models' list in its configuration.")
-            
+                raise ValueError(
+                    f"Round-robin model '{model_name}' requires a 'models' list in its configuration."
+                )
+
             # Get the rotate_every parameter (default: 1)
             rotate_every = model_config.get("rotate_every", 1)
-            
+
             # Resolve each model name to an actual model instance
             models = []
             for name in model_names:
                 # Recursively get each model using the factory
                 model = ModelFactory.get_model(name, config)
                 models.append(model)
-            
+
             # Create and return the round-robin model
             return RoundRobinModel(*models, rotate_every=rotate_every)
-        
+
         else:
             raise ValueError(f"Unsupported model type: {model_type}")

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/models.json

@@ -1,4 +1,30 @@
 {
+  "openrouter-sonoma-dusk-alpha": {
+    "type": "custom_openai",
+    "name": "openrouter/sonoma-dusk-alpha",
+    "custom_endpoint": {
+      "url": "https://openrouter.ai/api/v1",
+      "api_key": "$OPENROUTER_API_KEY",
+      "headers": {
+        "HTTP-Referer": "https://github.com/mpfaffenberger/code_puppy",
+        "X-Title": "Code Puppy"
+      }
+    },
+    "context_length": 2000000
+  },
+  "openrouter-sonoma-sky-alpha": {
+    "type": "custom_openai",
+    "name": "openrouter/sonoma-sky-alpha",
+    "custom_endpoint": {
+      "url": "https://openrouter.ai/api/v1",
+      "api_key": "$OPENROUTER_API_KEY",
+      "headers": {
+        "HTTP-Referer": "https://github.com/mpfaffenberger/code_puppy",
+        "X-Title": "Code Puppy"
+      }
+    },
+    "context_length": 2000000
+  },
   "gpt-5": {
     "type": "openai",
     "name": "gpt-5",

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/round_robin_model.py

@@ -1,10 +1,18 @@
-
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, field
-from typing import Any, Callable, AsyncIterator, List
+from typing import Any, AsyncIterator, List
 
-from pydantic_ai.models import Model, ModelMessage, ModelSettings, ModelRequestParameters, ModelResponse, StreamedResponse
-from pydantic_ai.models.fallback import KnownModelName, infer_model, merge_model_settings
+from pydantic_ai.models import (
+    Model,
+    ModelMessage,
+    ModelSettings,
+    ModelRequestParameters,
+    ModelResponse,
+    StreamedResponse,
+)
+from pydantic_ai.models.fallback import (
+    merge_model_settings,
+)
 from pydantic_ai.result import RunContext
 
 try:
@@ -15,18 +23,21 @@ except ImportError:
         class DummySpan:
             def is_recording(self):
                 return False
+
             def set_attributes(self, attributes):
                 pass
+
         return DummySpan()
 
+
 @dataclass(init=False)
 class RoundRobinModel(Model):
     """A model that cycles through multiple models in a round-robin fashion.
-    
+
     This model distributes requests across multiple candidate models to help
     overcome rate limits or distribute load.
     """
-    
+
     models: List[Model]
     _current_index: int = field(default=0, repr=False)
     _model_name: str = field(repr=False)
@@ -37,10 +48,10 @@ class RoundRobinModel(Model):
         self,
         *models: Model,
         rotate_every: int = 1,
-        settings: ModelSettings | None = None
+        settings: ModelSettings | None = None,
     ):
         """Initialize a round-robin model instance.
-        
+
         Args:
             models: The model instances to cycle through.
             rotate_every: Number of requests before rotating to the next model (default: 1).
@@ -59,9 +70,9 @@ class RoundRobinModel(Model):
     @property
     def model_name(self) -> str:
         """The model name showing this is a round-robin model with its candidates."""
-        base_name = f'round_robin:{",".join(model.model_name for model in self.models)}'
+        base_name = f"round_robin:{','.join(model.model_name for model in self.models)}"
         if self._rotate_every != 1:
-            return f'{base_name}:rotate_every={self._rotate_every}'
+            return f"{base_name}:rotate_every={self._rotate_every}"
         return base_name
 
     @property
@@ -93,10 +104,14 @@ class RoundRobinModel(Model):
         current_model = self._get_next_model()
         # Use the current model's settings as base, then merge with provided settings
         merged_settings = merge_model_settings(current_model.settings, model_settings)
-        customized_model_request_parameters = current_model.customize_request_parameters(model_request_parameters)
-        
+        customized_model_request_parameters = (
+            current_model.customize_request_parameters(model_request_parameters)
+        )
+
         try:
-            response = await current_model.request(messages, merged_settings, customized_model_request_parameters)
+            response = await current_model.request(
+                messages, merged_settings, customized_model_request_parameters
+            )
             self._set_span_attributes(current_model)
             return response
         except Exception as exc:
@@ -116,8 +131,10 @@ class RoundRobinModel(Model):
         current_model = self._get_next_model()
         # Use the current model's settings as base, then merge with provided settings
         merged_settings = merge_model_settings(current_model.settings, model_settings)
-        customized_model_request_parameters = current_model.customize_request_parameters(model_request_parameters)
-        
+        customized_model_request_parameters = (
+            current_model.customize_request_parameters(model_request_parameters)
+        )
+
         async with current_model.request_stream(
             messages, merged_settings, customized_model_request_parameters, run_context
         ) as response:
@@ -129,6 +146,6 @@ class RoundRobinModel(Model):
         with suppress(Exception):
             span = get_current_span()
             if span.is_recording():
-                attributes = getattr(span, 'attributes', {})
-                if attributes.get('gen_ai.request.model') == self.model_name:
-                    span.set_attributes(model.model_attributes(model))
+                attributes = getattr(span, "attributes", {})
+                if attributes.get("gen_ai.request.model") == self.model_name:
+                    span.set_attributes(model.model_attributes(model))

{code_puppy-0.0.154 → code_puppy-0.0.155}/code_puppy/summarization_agent.py

@@ -53,9 +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 = "gemini-2.5-pro"
-    if model_name not in models_config:
-        model_name = get_model_name()
+    model_name = get_model_name()
     model = ModelFactory.get_model(model_name, models_config)
 
     # Specialized instructions for summarization