code-puppy 0.0.287__py3-none-any.whl → 0.0.323__py3-none-any.whl

code_puppy/plugins/chatgpt_oauth/utils.py

@@ -149,6 +149,98 @@ def load_stored_tokens() -> Optional[Dict[str, Any]]:
     return None
 
 
+def get_valid_access_token() -> Optional[str]:
+    """Get a valid access token, refreshing if expired.
+
+    Returns:
+        Valid access token string, or None if not authenticated or refresh failed.
+    """
+    tokens = load_stored_tokens()
+    if not tokens:
+        logger.debug("No stored ChatGPT OAuth tokens found")
+        return None
+
+    access_token = tokens.get("access_token")
+    if not access_token:
+        logger.debug("No access_token in stored tokens")
+        return None
+
+    # Check if token is expired by parsing JWT claims
+    claims = parse_jwt_claims(access_token)
+    if claims:
+        exp = claims.get("exp")
+        if exp and isinstance(exp, (int, float)):
+            # Add 30 second buffer before expiry
+            if time.time() > exp - 30:
+                logger.info("ChatGPT OAuth token expired, attempting refresh")
+                refreshed = refresh_access_token()
+                if refreshed:
+                    return refreshed
+                logger.warning("Token refresh failed")
+                return None
+
+    return access_token
+
+
+def refresh_access_token() -> Optional[str]:
+    """Refresh the access token using the refresh token.
+
+    Returns:
+        New access token if refresh succeeded, None otherwise.
+    """
+    tokens = load_stored_tokens()
+    if not tokens:
+        return None
+
+    refresh_token = tokens.get("refresh_token")
+    if not refresh_token:
+        logger.debug("No refresh_token available")
+        return None
+
+    payload = {
+        "grant_type": "refresh_token",
+        "refresh_token": refresh_token,
+        "client_id": CHATGPT_OAUTH_CONFIG["client_id"],
+    }
+
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+
+    try:
+        response = requests.post(
+            CHATGPT_OAUTH_CONFIG["token_url"],
+            data=payload,
+            headers=headers,
+            timeout=30,
+        )
+
+        if response.status_code == 200:
+            new_tokens = response.json()
+            # Merge with existing tokens (preserve account_id, etc.)
+            tokens.update(
+                {
+                    "access_token": new_tokens.get("access_token"),
+                    "refresh_token": new_tokens.get("refresh_token", refresh_token),
+                    "id_token": new_tokens.get("id_token", tokens.get("id_token")),
+                    "last_refresh": datetime.datetime.now(datetime.timezone.utc)
+                    .isoformat()
+                    .replace("+00:00", "Z"),
+                }
+            )
+            if save_tokens(tokens):
+                logger.info("Successfully refreshed ChatGPT OAuth token")
+                return tokens["access_token"]
+        else:
+            logger.error(
+                "Token refresh failed: %s - %s", response.status_code, response.text
+            )
+    except Exception as exc:
+        logger.error("Token refresh error: %s", exc)
+
+    return None
+
+
 def save_tokens(tokens: Dict[str, Any]) -> bool:
     if tokens is None:
         raise TypeError("tokens cannot be None")
@@ -248,103 +340,126 @@ def exchange_code_for_tokens(
     return None
 
 
-def fetch_chatgpt_models(api_key: str) -> Optional[List[str]]:
-    """Fetch available models from OpenAI API.
+# Default models available via ChatGPT Codex API
+# These are the known models that work with ChatGPT OAuth tokens
+# Based on codex-rs CLI and shell-scripts/codex-call.sh
+DEFAULT_CODEX_MODELS = [
+    "gpt-5.2",
+    "gpt-5.2-codex",
+]
+
 
-    Makes a real HTTP GET request to OpenAI's models endpoint and filters
-    the results to include only GPT series models while preserving server order.
+def fetch_chatgpt_models(access_token: str, account_id: str) -> Optional[List[str]]:
+    """Fetch available models from ChatGPT Codex API.
+
+    Attempts to fetch models from the API, but falls back to a default list
+    of known Codex-compatible models if the API is unavailable.
 
     Args:
-        api_key: OpenAI API key for authentication
+        access_token: OAuth access token for authentication
+        account_id: ChatGPT account ID (required for the API)
 
     Returns:
-        List of filtered model IDs preserving server order, or None if request fails
+        List of model IDs, or default list if API fails
     """
-    # Build the models URL, ensuring it ends with /v1/models
-    base_url = CHATGPT_OAUTH_CONFIG["api_base_url"].rstrip("/")
-    models_url = f"{base_url}/v1/models"
+    import platform
 
-    # Blocklist of model IDs to exclude
-    blocklist = {"whisper-1"}
+    # Build the models URL with client version
+    client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.72.0")
+    base_url = CHATGPT_OAUTH_CONFIG["api_base_url"].rstrip("/")
+    models_url = f"{base_url}/models"
+
+    # Build User-Agent to match codex-rs CLI format
+    originator = CHATGPT_OAUTH_CONFIG.get("originator", "codex_cli_rs")
+    os_name = platform.system()
+    if os_name == "Darwin":
+        os_name = "Mac OS"
+    os_version = platform.release()
+    arch = platform.machine()
+    user_agent = (
+        f"{originator}/{client_version} ({os_name} {os_version}; {arch}) "
+        "Terminal_Codex_CLI"
+    )
 
     headers = {
-        "Authorization": f"Bearer {api_key}",
+        "Authorization": f"Bearer {access_token}",
+        "ChatGPT-Account-Id": account_id,
+        "User-Agent": user_agent,
+        "originator": originator,
+        "Accept": "application/json",
     }
 
-    try:
-        response = requests.get(models_url, headers=headers, timeout=30)
-
-        if response.status_code != 200:
-            logger.error(
-                "Failed to fetch models: HTTP %d - %s",
-                response.status_code,
-                response.text,
-            )
-            return None
-
-        # Parse JSON response
-        try:
-            data = response.json()
-            if "data" not in data or not isinstance(data["data"], list):
-                logger.error("Invalid response format: missing 'data' list")
-                return None
-        except (json.JSONDecodeError, ValueError) as exc:
-            logger.error("Failed to parse JSON response: %s", exc)
-            return None
-
-        # Filter models: start with "gpt-" or "o1-" and not in blocklist
-        filtered_models = []
-        seen_models = set()  # For deduplication while preserving order
-
-        for model in data["data"]:
-            # Skip None entries
-            if model is None:
-                continue
+    # Query params
+    params = {"client_version": client_version}
 
-            model_id = model.get("id")
-            if not model_id:
-                continue
-
-            # Skip if already seen (deduplication)
-            if model_id in seen_models:
-                continue
-
-            # Check if model starts with allowed prefixes and not in blocklist
-            if (
-                model_id.startswith("gpt-") or model_id.startswith("o1-")
-            ) and model_id not in blocklist:
-                filtered_models.append(model_id)
-                seen_models.add(model_id)
+    try:
+        response = requests.get(models_url, headers=headers, params=params, timeout=30)
 
-        return filtered_models
+        if response.status_code == 200:
+            # Parse JSON response
+            try:
+                data = response.json()
+                # The response has a "models" key with list of model objects
+                if "models" in data and isinstance(data["models"], list):
+                    models = []
+                    for model in data["models"]:
+                        if model is None:
+                            continue
+                        model_id = (
+                            model.get("slug") or model.get("id") or model.get("name")
+                        )
+                        if model_id:
+                            models.append(model_id)
+                    if models:
+                        return models
+            except (json.JSONDecodeError, ValueError) as exc:
+                logger.warning("Failed to parse models response: %s", exc)
+
+        # API didn't return valid models, use default list
+        logger.info(
+            "Models endpoint returned %d, using default model list",
+            response.status_code,
+        )
 
     except requests.exceptions.Timeout:
-        logger.error("Timeout while fetching models after 30 seconds")
-        return None
+        logger.warning("Timeout fetching models, using default list")
     except requests.exceptions.RequestException as exc:
-        logger.error("Network error while fetching models: %s", exc)
-        return None
+        logger.warning("Network error fetching models: %s, using default list", exc)
     except Exception as exc:
-        logger.error("Unexpected error while fetching models: %s", exc)
-        return None
+        logger.warning("Error fetching models: %s, using default list", exc)
 
+    # Return default models when API fails
+    logger.info("Using default Codex models: %s", DEFAULT_CODEX_MODELS)
+    return DEFAULT_CODEX_MODELS
 
-def add_models_to_extra_config(models: List[str], api_key: str) -> bool:
+
+def add_models_to_extra_config(models: List[str]) -> bool:
     """Add ChatGPT models to chatgpt_models.json configuration."""
     try:
         chatgpt_models = load_chatgpt_models()
         added = 0
         for model_name in models:
             prefixed = f"{CHATGPT_OAUTH_CONFIG['prefix']}{model_name}"
+
+            # Determine supported settings based on model type
+            # All GPT-5.x models support reasoning_effort and verbosity
+            supported_settings = ["reasoning_effort", "verbosity"]
+
+            # Only codex models support xhigh reasoning effort
+            # Regular gpt-5.2 is capped at "high"
+            is_codex = "codex" in model_name.lower()
+
             chatgpt_models[prefixed] = {
-                "type": "openai",
+                "type": "chatgpt_oauth",
                 "name": model_name,
                 "custom_endpoint": {
+                    # Codex API uses chatgpt.com/backend-api/codex, not api.openai.com
                     "url": CHATGPT_OAUTH_CONFIG["api_base_url"],
-                    "api_key": "${" + CHATGPT_OAUTH_CONFIG["api_key_env_var"] + "}",
                 },
                 "context_length": CHATGPT_OAUTH_CONFIG["default_context_length"],
                 "oauth_source": "chatgpt-oauth-plugin",
+                "supported_settings": supported_settings,
+                "supports_xhigh_reasoning": is_codex,
             }
             added += 1
         if save_chatgpt_models(chatgpt_models):

code_puppy/plugins/claude_code_oauth/config.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 from typing import Any, Dict
 
+from code_puppy import config
+
 # Claude Code OAuth configuration
 CLAUDE_CODE_OAUTH_CONFIG: Dict[str, Any] = {
     # OAuth endpoints inferred from official Claude Code OAuth flow
@@ -17,8 +19,8 @@ CLAUDE_CODE_OAUTH_CONFIG: Dict[str, Any] = {
     "callback_timeout": 180,
     # Console redirect fallback (for manual flows, if needed)
     "console_redirect_uri": "https://console.anthropic.com/oauth/code/callback",
-    # Local configuration
-    "token_storage": "~/.code_puppy/claude_code_oauth.json",
+    # Local configuration (uses XDG_DATA_HOME)
+    "token_storage": None,  # Set dynamically in get_token_storage_path()
     # Model configuration
     "prefix": "claude-code-",
     "default_context_length": 200000,
@@ -28,19 +30,21 @@ CLAUDE_CODE_OAUTH_CONFIG: Dict[str, Any] = {
 
 
 def get_token_storage_path() -> Path:
-    """Get the path for storing OAuth tokens."""
-    storage_path = Path(CLAUDE_CODE_OAUTH_CONFIG["token_storage"]).expanduser()
-    storage_path.parent.mkdir(parents=True, exist_ok=True)
-    return storage_path
+    """Get the path for storing OAuth tokens (uses XDG_DATA_HOME)."""
+    data_dir = Path(config.DATA_DIR)
+    data_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    return data_dir / "claude_code_oauth.json"
 
 
 def get_config_dir() -> Path:
-    """Get the Code Puppy configuration directory."""
-    config_dir = Path("~/.code_puppy").expanduser()
-    config_dir.mkdir(parents=True, exist_ok=True)
+    """Get the Code Puppy configuration directory (uses XDG_CONFIG_HOME)."""
+    config_dir = Path(config.CONFIG_DIR)
+    config_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
     return config_dir
 
 
 def get_claude_models_path() -> Path:
-    """Get the path to the dedicated claude_models.json file."""
-    return get_config_dir() / "claude_models.json"
+    """Get the path to the dedicated claude_models.json file (uses XDG_DATA_HOME)."""
+    data_dir = Path(config.DATA_DIR)
+    data_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    return data_dir / "claude_models.json"

code_puppy/plugins/claude_code_oauth/register_callbacks.py

@@ -180,6 +180,31 @@ def _custom_help() -> List[Tuple[str, str]]:
     ]
 
 
+def _reload_current_agent() -> None:
+    """Reload the current agent so new auth tokens are picked up immediately."""
+    try:
+        from code_puppy.agents import get_current_agent
+
+        current_agent = get_current_agent()
+        if current_agent is None:
+            logger.debug("No current agent to reload")
+            return
+
+        # JSON agents may need to refresh their config before reload
+        if hasattr(current_agent, "refresh_config"):
+            try:
+                current_agent.refresh_config()
+            except Exception:
+                # Non-fatal, continue to reload
+                pass
+
+        current_agent.reload_code_generation_agent()
+        emit_info("Active agent reloaded with new authentication")
+    except Exception as e:
+        emit_warning(f"Authentication succeeded but agent reload failed: {e}")
+        logger.exception("Failed to reload agent after authentication")
+
+
 def _perform_authentication() -> None:
     context = prepare_oauth_context()
     code = _await_callback(context)
@@ -219,6 +244,9 @@ def _perform_authentication() -> None:
             "Claude Code models added to your configuration. Use the `claude-code-` prefix!"
         )
 
+    # Reload the current agent so the new auth token is picked up immediately
+    _reload_current_agent()
+
 
 def _handle_custom_command(command: str, name: str) -> Optional[bool]:
     if not name:

code_puppy/plugins/claude_code_oauth/utils.py

@@ -356,7 +356,11 @@ def add_models_to_extra_config(models: List[str]) -> bool:
                 "custom_endpoint": {
                     "url": CLAUDE_CODE_OAUTH_CONFIG["api_base_url"],
                     "api_key": access_token,
-                    "headers": {"anthropic-beta": "oauth-2025-04-20"},
+                    "headers": {
+                        "anthropic-beta": "oauth-2025-04-20,interleaved-thinking-2025-05-14",
+                        "x-app": "cli",
+                        "User-Agent": "claude-cli/2.0.61 (external, cli)",
+                    },
                 },
                 "context_length": CLAUDE_CODE_OAUTH_CONFIG["default_context_length"],
                 "oauth_source": "claude-code-plugin",
@@ -364,6 +368,7 @@ def add_models_to_extra_config(models: List[str]) -> bool:
                     "temperature",
                     "extended_thinking",
                     "budget_tokens",
+                    "interleaved_thinking",
                 ],
             }
             added += 1

code_puppy/plugins/example_custom_command/register_callbacks.py

@@ -39,9 +39,9 @@ def _handle_custom_command(command: str, name: str):
         rest = command.split(maxsplit=1)
         if len(rest) == 2:
             text = rest[1]
-            emit_info(f"[dim]example plugin echo ->[/dim] {text}")
+            emit_info(f"example plugin echo -> {text}")
             return text
-        emit_info("[dim]example plugin echo (empty)[/dim]")
+        emit_info("example plugin echo (empty)")
         return ""
 
     return None

code_puppy/plugins/oauth_puppy_html.py

@@ -8,6 +8,7 @@ CLAUDE_LOGO_URL = "https://voideditor.com/claude-icon.png"
 CHATGPT_LOGO_URL = (
     "https://freelogopng.com/images/all_img/1681038325chatgpt-logo-transparent.png"
 )
+GEMINI_LOGO_URL = "https://upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Google_Gemini_logo.svg/512px-Google_Gemini_logo.svg.png"
 
 
 def oauth_success_html(service_name: str, extra_message: Optional[str] = None) -> str:
@@ -222,4 +223,6 @@ def _service_targets(service_name: str) -> Tuple[str, str, str, str]:
         return "🐕‍🦺🧨", CLAUDE_LOGO_URL, "Claude logo", ""
     if "chat" in normalized or "gpt" in normalized:
         return "🐶🚀", CHATGPT_LOGO_URL, "ChatGPT logo", "invert"
+    if "gemini" in normalized or "google" in normalized:
+        return "🐶✨", GEMINI_LOGO_URL, "Gemini logo", ""
     return "🐾💥", CHATGPT_LOGO_URL, "mystery logo", "invert"

code_puppy/plugins/shell_safety/agent_shell_safety.py

@@ -5,13 +5,12 @@ It's designed to be ultra-lightweight with a concise prompt (<200 tokens) and
 uses structured output for reliable parsing.
 """
 
-import asyncio
 from typing import TYPE_CHECKING, List
 
 from code_puppy.agents.base_agent import BaseAgent
 
 if TYPE_CHECKING:
-    from code_puppy.tools.command_runner import ShellSafetyAssessment
+    pass
 
 
 class ShellSafetyAgent(BaseAgent):
@@ -68,135 +67,3 @@ class ShellSafetyAgent(BaseAgent):
     def get_available_tools(self) -> List[str]:
         """This agent uses no tools - pure reasoning only."""
         return []
-
-    async def assess_command(
-        self, command: str, cwd: str | None = None
-    ) -> "ShellSafetyAssessment":
-        """Assess the safety risk of a shell command.
-
-        Args:
-            command: The shell command to assess
-            cwd: Optional working directory context
-
-        Returns:
-            ShellSafetyAssessment with risk level and reasoning
-
-        Note:
-            On timeout or error, defaults to 'high' risk with error reasoning
-            to fail safe. Optionally uses DBOS for durable execution tracking.
-        """
-        import uuid
-
-        from pydantic_ai import Agent, UsageLimits
-
-        from code_puppy.config import get_use_dbos
-        from code_puppy.model_factory import ModelFactory
-        from code_puppy.tools.command_runner import ShellSafetyAssessment
-
-        try:
-            # Build the assessment prompt
-            prompt = f"Assess this shell command:\n\nCommand: {command}"
-            if cwd:
-                prompt += f"\nWorking directory: {cwd}"
-
-            # Get the current model
-            model_name = self.get_model_name()
-            models_config = ModelFactory.load_config()
-
-            if model_name not in models_config:
-                # Fall back to high risk if model config fails
-                return ShellSafetyAssessment(
-                    risk="high",
-                    reasoning="Model configuration unavailable - failing safe",
-                )
-
-            model = ModelFactory.get_model(model_name, models_config)
-
-            # Handle claude-code models: swap instructions and prepend system prompt
-            from code_puppy.model_utils import prepare_prompt_for_model
-
-            instructions = self.get_system_prompt()
-            prepared = prepare_prompt_for_model(model_name, instructions, prompt)
-            instructions = prepared.instructions
-            prompt = prepared.user_prompt
-
-            from code_puppy.model_factory import make_model_settings
-
-            model_settings = make_model_settings(model_name)
-
-            temp_agent = Agent(
-                model=model,
-                system_prompt=instructions,
-                retries=1,
-                output_type=ShellSafetyAssessment,
-                model_settings=model_settings,
-            )
-
-            # Generate unique agent name and workflow ID for DBOS (if enabled)
-            agent_name = f"shell-safety-{uuid.uuid4().hex[:8]}"
-            workflow_id = f"shell-safety-{uuid.uuid4().hex[:8]}"
-
-            # Wrap with DBOS if enabled (same pattern as agent_tools.py)
-            if get_use_dbos():
-                from pydantic_ai.durable_exec.dbos import DBOSAgent
-
-                dbos_agent = DBOSAgent(temp_agent, name=agent_name)
-                temp_agent = dbos_agent
-
-            # Run the agent as a cancellable task
-            # Import the shared task registry for cancellation support
-            from code_puppy.tools.agent_tools import _active_subagent_tasks
-
-            if get_use_dbos():
-                from dbos import DBOS, SetWorkflowID
-
-                with SetWorkflowID(workflow_id):
-                    task = asyncio.create_task(
-                        temp_agent.run(
-                            prompt,
-                            usage_limits=UsageLimits(request_limit=1),
-                        )
-                    )
-                    _active_subagent_tasks.add(task)
-            else:
-                task = asyncio.create_task(
-                    temp_agent.run(
-                        prompt,
-                        usage_limits=UsageLimits(request_limit=1),
-                    )
-                )
-                _active_subagent_tasks.add(task)
-
-            try:
-                result = await task
-            finally:
-                _active_subagent_tasks.discard(task)
-                if task.cancelled():
-                    if get_use_dbos():
-                        DBOS.cancel_workflow(workflow_id)
-
-            # Return the structured output
-            # The result.output should be a ShellSafetyAssessment due to the generic type
-            output = result.output
-
-            # If it's a string, try to parse it as JSON into ShellSafetyAssessment
-            if isinstance(output, str):
-                import json
-
-                try:
-                    data = json.loads(output)
-                    return ShellSafetyAssessment(**data)
-                except Exception:
-                    # If parsing fails, fail safe
-                    return ShellSafetyAssessment(
-                        risk="high",
-                        reasoning=f"Could not parse assessment output: {output[:100]}",
-                    )
-
-            return output
-
-        except Exception as e:
-            return ShellSafetyAssessment(
-                risk="high",
-                reasoning=f"Safety assessment failed: {str(e)[:200]} - failing safe",
-            )