code-puppy 0.0.361__py3-none-any.whl → 0.0.372__py3-none-any.whl

code_puppy/agents/__init__.py

@@ -5,9 +5,12 @@ configurations, each with their own system prompts and tool sets.
 """
 
 from .agent_manager import (
+    clone_agent,
+    delete_clone_agent,
     get_agent_descriptions,
     get_available_agents,
     get_current_agent,
+    is_clone_agent_name,
     load_agent,
     refresh_agents,
     set_current_agent,
@@ -15,8 +18,11 @@ from .agent_manager import (
 from .subagent_stream_handler import subagent_stream_handler
 
 __all__ = [
+    "clone_agent",
+    "delete_clone_agent",
     "get_available_agents",
     "get_current_agent",
+    "is_clone_agent_name",
     "set_current_agent",
     "load_agent",
     "get_agent_descriptions",

code_puppy/agents/agent_manager.py

@@ -4,6 +4,7 @@ import importlib
 import json
 import os
 import pkgutil
+import re
 import uuid
 from pathlib import Path
 from typing import Dict, List, Optional, Type, Union
@@ -13,7 +14,7 @@ from pydantic_ai.messages import ModelMessage
 from code_puppy.agents.base_agent import BaseAgent
 from code_puppy.agents.json_agent import JSONAgent, discover_json_agents
 from code_puppy.callbacks import on_agent_reload
-from code_puppy.messaging import emit_warning
+from code_puppy.messaging import emit_success, emit_warning
 
 # Registry of available agents (Python classes and JSON file paths)
 _AGENT_REGISTRY: Dict[str, Union[Type[BaseAgent], str]] = {}
@@ -295,12 +296,21 @@ def get_available_agents() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to display names.
     """
+    from ..config import PACK_AGENT_NAMES, get_pack_agents_enabled
+
     # Generate a message group ID for this operation
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
 
+    # Check if pack agents are enabled
+    pack_agents_enabled = get_pack_agents_enabled()
+
     agents = {}
     for name, agent_ref in _AGENT_REGISTRY.items():
+        # Filter out pack agents if disabled
+        if not pack_agents_enabled and name in PACK_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -423,12 +433,21 @@ def get_agent_descriptions() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to their descriptions.
     """
+    from ..config import PACK_AGENT_NAMES, get_pack_agents_enabled
+
     # Generate a message group ID for this operation
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
 
+    # Check if pack agents are enabled
+    pack_agents_enabled = get_pack_agents_enabled()
+
     descriptions = {}
     for name, agent_ref in _AGENT_REGISTRY.items():
+        # Filter out pack agents if disabled
+        if not pack_agents_enabled and name in PACK_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -449,3 +468,206 @@ def refresh_agents():
     # Generate a message group ID for agent refreshing
     message_group_id = str(uuid.uuid4())
     _discover_agents(message_group_id=message_group_id)
+
+
+_CLONE_NAME_PATTERN = re.compile(r"^(?P<base>.+)-clone-(?P<index>\d+)$")
+_CLONE_DISPLAY_PATTERN = re.compile(r"\s*\(Clone\s+\d+\)$", re.IGNORECASE)
+
+
+def _strip_clone_suffix(agent_name: str) -> str:
+    """Strip a trailing -clone-N suffix from a name if present."""
+    match = _CLONE_NAME_PATTERN.match(agent_name)
+    return match.group("base") if match else agent_name
+
+
+def _strip_clone_display_suffix(display_name: str) -> str:
+    """Remove a trailing "(Clone N)" suffix from display names."""
+    cleaned = _CLONE_DISPLAY_PATTERN.sub("", display_name).strip()
+    return cleaned or display_name
+
+
+def is_clone_agent_name(agent_name: str) -> bool:
+    """Return True if the agent name looks like a clone."""
+    return bool(_CLONE_NAME_PATTERN.match(agent_name))
+
+
+def _default_display_name(agent_name: str) -> str:
+    """Build a default display name from an agent name."""
+    title = agent_name.title()
+    return f"{title} 🤖"
+
+
+def _build_clone_display_name(display_name: str, clone_index: int) -> str:
+    """Build a clone display name based on the source display name."""
+    base_name = _strip_clone_display_suffix(display_name)
+    return f"{base_name} (Clone {clone_index})"
+
+
+def _filter_available_tools(tool_names: List[str]) -> List[str]:
+    """Filter a tool list to only available tool names."""
+    from code_puppy.tools import get_available_tool_names
+
+    available_tools = set(get_available_tool_names())
+    return [tool for tool in tool_names if tool in available_tools]
+
+
+def _next_clone_index(
+    base_name: str, existing_names: set[str], agents_dir: Path
+) -> int:
+    """Compute the next clone index for a base name."""
+    clone_pattern = re.compile(rf"^{re.escape(base_name)}-clone-(\\d+)$")
+    indices = []
+    for name in existing_names:
+        match = clone_pattern.match(name)
+        if match:
+            indices.append(int(match.group(1)))
+
+    next_index = max(indices, default=0) + 1
+    while True:
+        clone_name = f"{base_name}-clone-{next_index}"
+        clone_path = agents_dir / f"{clone_name}.json"
+        if clone_name not in existing_names and not clone_path.exists():
+            return next_index
+        next_index += 1
+
+
+def clone_agent(agent_name: str) -> Optional[str]:
+    """Clone an agent definition into the user agents directory.
+
+    Args:
+        agent_name: Source agent name to clone.
+
+    Returns:
+        The cloned agent name, or None if cloning failed.
+    """
+    # Generate a message group ID for agent cloning
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    agent_ref = _AGENT_REGISTRY.get(agent_name)
+    if agent_ref is None:
+        emit_warning(f"Agent '{agent_name}' not found for cloning.")
+        return None
+
+    from ..config import get_agent_pinned_model, get_user_agents_directory
+
+    agents_dir = Path(get_user_agents_directory())
+    base_name = _strip_clone_suffix(agent_name)
+    existing_names = set(_AGENT_REGISTRY.keys())
+    clone_index = _next_clone_index(base_name, existing_names, agents_dir)
+    clone_name = f"{base_name}-clone-{clone_index}"
+    clone_path = agents_dir / f"{clone_name}.json"
+
+    try:
+        if isinstance(agent_ref, str):
+            with open(agent_ref, "r", encoding="utf-8") as f:
+                source_config = json.load(f)
+
+            source_display_name = source_config.get("display_name")
+            if not source_display_name:
+                source_display_name = _default_display_name(base_name)
+
+            clone_config = dict(source_config)
+            clone_config["name"] = clone_name
+            clone_config["display_name"] = _build_clone_display_name(
+                source_display_name, clone_index
+            )
+
+            tools = source_config.get("tools", [])
+            clone_config["tools"] = (
+                _filter_available_tools(tools) if isinstance(tools, list) else []
+            )
+
+            if not clone_config.get("model"):
+                clone_config.pop("model", None)
+        else:
+            agent_instance = agent_ref()
+            clone_config = {
+                "name": clone_name,
+                "display_name": _build_clone_display_name(
+                    agent_instance.display_name, clone_index
+                ),
+                "description": agent_instance.description,
+                "system_prompt": agent_instance.get_system_prompt(),
+                "tools": _filter_available_tools(agent_instance.get_available_tools()),
+            }
+
+            user_prompt = agent_instance.get_user_prompt()
+            if user_prompt is not None:
+                clone_config["user_prompt"] = user_prompt
+
+            tools_config = agent_instance.get_tools_config()
+            if tools_config is not None:
+                clone_config["tools_config"] = tools_config
+
+            pinned_model = get_agent_pinned_model(agent_instance.name)
+            if pinned_model:
+                clone_config["model"] = pinned_model
+    except Exception as exc:
+        emit_warning(f"Failed to build clone for '{agent_name}': {exc}")
+        return None
+
+    if clone_path.exists():
+        emit_warning(f"Clone target '{clone_name}' already exists.")
+        return None
+
+    try:
+        with open(clone_path, "w", encoding="utf-8") as f:
+            json.dump(clone_config, f, indent=2, ensure_ascii=False)
+        emit_success(f"Cloned '{agent_name}' to '{clone_name}'.")
+        return clone_name
+    except Exception as exc:
+        emit_warning(f"Failed to write clone file '{clone_path}': {exc}")
+        return None
+
+
+def delete_clone_agent(agent_name: str) -> bool:
+    """Delete a cloned JSON agent definition.
+
+    Args:
+        agent_name: Clone agent name to delete.
+
+    Returns:
+        True if the clone was deleted, False otherwise.
+    """
+    message_group_id = str(uuid.uuid4())
+    _discover_agents(message_group_id=message_group_id)
+
+    if not is_clone_agent_name(agent_name):
+        emit_warning(f"Agent '{agent_name}' is not a clone.")
+        return False
+
+    if get_current_agent_name() == agent_name:
+        emit_warning("Cannot delete the active agent. Switch agents first.")
+        return False
+
+    agent_ref = _AGENT_REGISTRY.get(agent_name)
+    if agent_ref is None:
+        emit_warning(f"Clone '{agent_name}' not found.")
+        return False
+
+    if not isinstance(agent_ref, str):
+        emit_warning(f"Clone '{agent_name}' is not a JSON agent.")
+        return False
+
+    clone_path = Path(agent_ref)
+    if not clone_path.exists():
+        emit_warning(f"Clone file for '{agent_name}' does not exist.")
+        return False
+
+    from ..config import get_user_agents_directory
+
+    agents_dir = Path(get_user_agents_directory()).resolve()
+    if clone_path.resolve().parent != agents_dir:
+        emit_warning(f"Refusing to delete non-user clone '{agent_name}'.")
+        return False
+
+    try:
+        clone_path.unlink()
+        emit_success(f"Deleted clone '{agent_name}'.")
+        _AGENT_REGISTRY.pop(agent_name, None)
+        _AGENT_HISTORIES.pop(agent_name, None)
+        return True
+    except Exception as exc:
+        emit_warning(f"Failed to delete clone '{agent_name}': {exc}")
+        return False

code_puppy/agents/base_agent.py

@@ -378,10 +378,8 @@ class BaseAgent(ABC):
         try:
             from code_puppy.model_utils import (
                 get_antigravity_instructions,
-                get_chatgpt_codex_instructions,
                 get_claude_code_instructions,
                 is_antigravity_model,
-                is_chatgpt_codex_model,
                 is_claude_code_model,
             )
 
@@ -393,11 +391,6 @@ class BaseAgent(ABC):
                 # The full system prompt is already in the message history
                 instructions = get_claude_code_instructions()
                 total_tokens += self.estimate_token_count(instructions)
-            elif is_chatgpt_codex_model(model_name):
-                # For ChatGPT Codex models, only count the short fixed instructions
-                # The full system prompt is already in the message history
-                instructions = get_chatgpt_codex_instructions()
-                total_tokens += self.estimate_token_count(instructions)
             elif is_antigravity_model(model_name):
                 # For Antigravity models, only count the short fixed instructions
                 # The full system prompt is already in the message history
@@ -1568,14 +1561,11 @@ class BaseAgent(ABC):
         # Handle claude-code, chatgpt-codex, and antigravity models: prepend system prompt to first user message
         from code_puppy.model_utils import (
             is_antigravity_model,
-            is_chatgpt_codex_model,
             is_claude_code_model,
         )
 
-        if (
-            is_claude_code_model(self.get_model_name())
-            or is_chatgpt_codex_model(self.get_model_name())
-            or is_antigravity_model(self.get_model_name())
+        if is_claude_code_model(self.get_model_name()) or is_antigravity_model(
+            self.get_model_name()
         ):
             if len(self.get_message_history()) == 0:
                 system_prompt = self.get_system_prompt()

code_puppy/chatgpt_codex_client.py

@@ -156,6 +156,59 @@ class ChatGPTCodexAsyncClient(httpx.AsyncClient):
             }
             modified = True
 
+        # When `store=false` (Codex requirement), the backend does NOT persist input items.
+        # That means any later request that tries to reference a previous item by id will 404.
+        # We defensively strip reference-style items (especially reasoning_content) to avoid:
+        #   "Item with id 'rs_...' not found. Items are not persisted when store is false."
+        input_items = data.get("input")
+        if data.get("store") is False and isinstance(input_items, list):
+            original_len = len(input_items)
+
+            def _looks_like_unpersisted_reference(it: dict) -> bool:
+                it_id = it.get("id")
+                if it_id in {"reasoning_content", "rs_reasoning_content"}:
+                    return True
+
+                # Common reference-ish shapes: {"type": "input_item_reference", "id": "..."}
+                it_type = it.get("type")
+                if it_type in {"input_item_reference", "item_reference", "reference"}:
+                    return True
+
+                # Ultra-conservative: if it's basically just an id (no actual content), drop it.
+                # A legit content item will typically have fields like `content`, `text`, `role`, etc.
+                non_id_keys = {k for k in it.keys() if k not in {"id", "type"}}
+                if not non_id_keys and isinstance(it_id, str) and it_id:
+                    return True
+
+                return False
+
+            filtered: list[object] = []
+            for item in input_items:
+                if isinstance(item, dict) and _looks_like_unpersisted_reference(item):
+                    modified = True
+                    continue
+                filtered.append(item)
+
+            if len(filtered) != original_len:
+                data["input"] = filtered
+
+        # Normalize invalid input IDs (Codex expects reasoning ids to start with "rs_")
+        # Note: this is only safe for actual content items, NOT references.
+        input_items = data.get("input")
+        if isinstance(input_items, list):
+            for item in input_items:
+                if not isinstance(item, dict):
+                    continue
+                item_id = item.get("id")
+                if (
+                    isinstance(item_id, str)
+                    and item_id
+                    and "reasoning" in item_id
+                    and not item_id.startswith("rs_")
+                ):
+                    item["id"] = f"rs_{item_id}"
+                    modified = True
+
         # Remove unsupported parameters
         # Note: verbosity should be under "text" object, not top-level
         unsupported_params = ["max_output_tokens", "max_tokens", "verbosity"]

code_puppy/claude_cache_client.py

@@ -119,24 +119,62 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         return None
 
     def _should_refresh_token(self, request: httpx.Request) -> bool:
-        """Check if the token in the request is older than 1 hour."""
+        """Check if the token should be refreshed (within 1 hour of expiry).
+
+        Uses two strategies:
+        1. Decode JWT to check token age (if possible)
+        2. Fall back to stored expires_at from token file
+
+        Returns True if token expires within TOKEN_MAX_AGE_SECONDS (1 hour).
+        """
         token = self._extract_bearer_token(request)
         if not token:
             return False
 
+        # Strategy 1: Try to decode JWT age
         age = self._get_jwt_age_seconds(token)
-        if age is None:
-            return False
-
-        should_refresh = age >= TOKEN_MAX_AGE_SECONDS
+        if age is not None:
+            should_refresh = age >= TOKEN_MAX_AGE_SECONDS
+            if should_refresh:
+                logger.info(
+                    "JWT token is %.1f seconds old (>= %d), will refresh proactively",
+                    age,
+                    TOKEN_MAX_AGE_SECONDS,
+                )
+            return should_refresh
+
+        # Strategy 2: Fall back to stored expires_at from token file
+        should_refresh = self._check_stored_token_expiry()
         if should_refresh:
             logger.info(
-                "JWT token is %.1f seconds old (>= %d), will refresh proactively",
-                age,
+                "Stored token expires within %d seconds, will refresh proactively",
                 TOKEN_MAX_AGE_SECONDS,
             )
         return should_refresh
 
+    @staticmethod
+    def _check_stored_token_expiry() -> bool:
+        """Check if the stored token expires within TOKEN_MAX_AGE_SECONDS.
+
+        This is a fallback for when JWT decoding fails or isn't available.
+        Uses the expires_at timestamp from the stored token file.
+        """
+        try:
+            from code_puppy.plugins.claude_code_oauth.utils import (
+                is_token_expired,
+                load_stored_tokens,
+            )
+
+            tokens = load_stored_tokens()
+            if not tokens:
+                return False
+
+            # is_token_expired already uses TOKEN_REFRESH_BUFFER_SECONDS (1 hour)
+            return is_token_expired(tokens)
+        except Exception as exc:
+            logger.debug("Error checking stored token expiry: %s", exc)
+            return False
+
     @staticmethod
     def _prefix_tool_names(body: bytes) -> bytes | None:
         """Prefix all tool names in the request body with TOOL_PREFIX.

code_puppy/command_line/add_model_menu.py

@@ -626,12 +626,21 @@ class AddModelMenu:
         elif model_type == "openai" and "gpt-5" in model.model_id:
             # GPT-5 models have special settings
             if "codex" in model.model_id:
-                config["supported_settings"] = ["reasoning_effort"]
+                config["supported_settings"] = [
+                    "temperature",
+                    "top_p",
+                    "reasoning_effort",
+                ]
             else:
-                config["supported_settings"] = ["reasoning_effort", "verbosity"]
+                config["supported_settings"] = [
+                    "temperature",
+                    "top_p",
+                    "reasoning_effort",
+                    "verbosity",
+                ]
         else:
-            # Default settings for most models (no top_p)
-            config["supported_settings"] = ["temperature", "seed"]
+            # Default settings for most models
+            config["supported_settings"] = ["temperature", "seed", "top_p"]
 
         return config