code-puppy 0.0.373__py3-none-any.whl → 0.0.375__py3-none-any.whl

code_puppy/plugins/antigravity_oauth/register_callbacks.py

@@ -1,4 +1,8 @@
-"""Antigravity OAuth Plugin callbacks for Code Puppy CLI."""
+"""Antigravity OAuth Plugin callbacks for Code Puppy CLI.
+
+Provides OAuth authentication for Antigravity models and registers
+the 'antigravity' model type handler.
+"""
 
 from __future__ import annotations
 
@@ -30,6 +34,8 @@ from .oauth import (
     prepare_oauth_context,
 )
 from .storage import clear_accounts
+from .token import is_token_expired, refresh_access_token
+from .transport import create_antigravity_client
 from .utils import (
     add_models_to_config,
     load_antigravity_models,
@@ -408,6 +414,105 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
     return None
 
 
+def _create_antigravity_model(model_name: str, model_config: Dict, config: Dict) -> Any:
+    """Create an Antigravity model instance.
+
+    This handler is registered via the 'register_model_type' callback to handle
+    models with type='antigravity'.
+    """
+    from code_puppy.gemini_model import GeminiModel
+    from code_puppy.model_factory import get_custom_config
+
+    # Try to import custom model for thinking signatures
+    try:
+        from .antigravity_model import AntigravityModel
+    except ImportError:
+        AntigravityModel = None  # type: ignore
+
+    url, headers, verify, api_key = get_custom_config(model_config)
+    if not api_key:
+        emit_warning(
+            f"API key is not set for Antigravity endpoint; skipping model '{model_config.get('name')}'."
+        )
+        return None
+
+    # Get fresh access token (refresh if needed)
+    tokens = load_stored_tokens()
+    if not tokens:
+        emit_warning("Antigravity tokens not found; run /antigravity-auth first.")
+        return None
+
+    access_token = tokens.get("access_token", "")
+    refresh_token = tokens.get("refresh_token", "")
+    expires_at = tokens.get("expires_at")
+
+    # Refresh if expired or about to expire (initial check)
+    if is_token_expired(expires_at):
+        new_tokens = refresh_access_token(refresh_token)
+        if new_tokens:
+            access_token = new_tokens.access_token
+            refresh_token = new_tokens.refresh_token
+            expires_at = new_tokens.expires_at
+            tokens["access_token"] = new_tokens.access_token
+            tokens["refresh_token"] = new_tokens.refresh_token
+            tokens["expires_at"] = new_tokens.expires_at
+            save_tokens(tokens)
+        else:
+            emit_warning(
+                "Failed to refresh Antigravity token; run /antigravity-auth again."
+            )
+            return None
+
+    # Callback to persist tokens when proactively refreshed during session
+    def on_token_refreshed(new_tokens: Any) -> None:
+        """Persist new tokens when proactively refreshed."""
+        try:
+            updated_tokens = load_stored_tokens() or {}
+            updated_tokens["access_token"] = new_tokens.access_token
+            updated_tokens["refresh_token"] = new_tokens.refresh_token
+            updated_tokens["expires_at"] = new_tokens.expires_at
+            save_tokens(updated_tokens)
+            logger.debug("Persisted proactively refreshed Antigravity tokens")
+        except Exception as e:
+            logger.warning("Failed to persist refreshed tokens: %s", e)
+
+    project_id = tokens.get("project_id", model_config.get("project_id", ""))
+    client = create_antigravity_client(
+        access_token=access_token,
+        project_id=project_id,
+        model_name=model_config["name"],
+        base_url=url,
+        headers=headers,
+        refresh_token=refresh_token,
+        expires_at=expires_at,
+        on_token_refreshed=on_token_refreshed,
+    )
+
+    # Use custom model with direct httpx client
+    if AntigravityModel:
+        model = AntigravityModel(
+            model_name=model_config["name"],
+            api_key=api_key or "",  # Antigravity uses OAuth, key may be empty
+            base_url=url,
+            http_client=client,
+        )
+    else:
+        model = GeminiModel(
+            model_name=model_config["name"],
+            api_key=api_key or "",
+            base_url=url,
+            http_client=client,
+        )
+
+    return model
+
+
+def _register_model_types() -> List[Dict[str, Any]]:
+    """Register the antigravity model type handler."""
+    return [{"type": "antigravity", "handler": _create_antigravity_model}]
+
+
 # Register callbacks
 register_callback("custom_command_help", _custom_help)
 register_callback("custom_command", _handle_custom_command)
+register_callback("register_model_type", _register_model_types)

code_puppy/plugins/antigravity_oauth/utils.py

@@ -77,9 +77,9 @@ def add_models_to_config(access_token: str, project_id: str = "") -> bool:
             # Build custom headers
             headers = dict(ANTIGRAVITY_HEADERS)
 
-            # Use custom_gemini type with Antigravity transport
+            # Use antigravity type - handled by the plugin's register_model_type callback
             models_config[prefixed_name] = {
-                "type": "custom_gemini",
+                "type": "antigravity",
                 "name": model_id,
                 "custom_endpoint": {
                     "url": ANTIGRAVITY_ENDPOINT,
@@ -90,7 +90,6 @@ def add_models_to_config(access_token: str, project_id: str = "") -> bool:
                 "context_length": model_info.get("context_length", 200000),
                 "family": model_info.get("family", "other"),
                 "oauth_source": "antigravity-plugin",
-                "antigravity": True,  # Flag to use Antigravity transport
             }
 
             # Add thinking budget if present

code_puppy/plugins/chatgpt_oauth/register_callbacks.py

@@ -1,9 +1,13 @@
-"""ChatGPT OAuth plugin callbacks aligned with ChatMock flow."""
+"""ChatGPT OAuth plugin callbacks aligned with ChatMock flow.
+
+Provides OAuth authentication for ChatGPT models and registers
+the 'chatgpt_oauth' model type handler.
+"""
 
 from __future__ import annotations
 
 import os
-from typing import List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 from code_puppy.callbacks import register_callback
 from code_puppy.messaging import emit_info, emit_success, emit_warning
@@ -11,7 +15,12 @@ from code_puppy.model_switching import set_model_and_reload_agent
 
 from .config import CHATGPT_OAUTH_CONFIG, get_token_storage_path
 from .oauth_flow import run_oauth_flow
-from .utils import load_chatgpt_models, load_stored_tokens, remove_chatgpt_models
+from .utils import (
+    get_valid_access_token,
+    load_chatgpt_models,
+    load_stored_tokens,
+    remove_chatgpt_models,
+)
 
 
 def _custom_help() -> List[Tuple[str, str]]:
@@ -90,5 +99,78 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
     return None
 
 
+def _create_chatgpt_oauth_model(
+    model_name: str, model_config: Dict, config: Dict
+) -> Any:
+    """Create a ChatGPT OAuth model instance.
+
+    This handler is registered via the 'register_model_type' callback to handle
+    models with type='chatgpt_oauth'.
+    """
+    from pydantic_ai.models.openai import OpenAIResponsesModel
+    from pydantic_ai.providers.openai import OpenAIProvider
+
+    from code_puppy.chatgpt_codex_client import create_codex_async_client
+    from code_puppy.http_utils import get_cert_bundle_path
+
+    # Get a valid access token (refreshing if needed)
+    access_token = get_valid_access_token()
+    if not access_token:
+        emit_warning(
+            f"Failed to get valid ChatGPT OAuth token; skipping model '{model_config.get('name')}'. "
+            "Run /chatgpt-auth to authenticate."
+        )
+        return None
+
+    # Get account_id from stored tokens (required for ChatGPT-Account-Id header)
+    tokens = load_stored_tokens()
+    account_id = tokens.get("account_id", "") if tokens else ""
+    if not account_id:
+        emit_warning(
+            f"No account_id found in ChatGPT OAuth tokens; skipping model '{model_config.get('name')}'. "
+            "Run /chatgpt-auth to re-authenticate."
+        )
+        return None
+
+    # Build headers for ChatGPT Codex API
+    originator = CHATGPT_OAUTH_CONFIG.get("originator", "codex_cli_rs")
+    client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.72.0")
+
+    headers = {
+        "ChatGPT-Account-Id": account_id,
+        "originator": originator,
+        "User-Agent": f"{originator}/{client_version}",
+    }
+    # Merge with any headers from model config
+    config_headers = model_config.get("custom_endpoint", {}).get("headers", {})
+    headers.update(config_headers)
+
+    # Get base URL - Codex API uses chatgpt.com, not api.openai.com
+    base_url = model_config.get("custom_endpoint", {}).get(
+        "url", CHATGPT_OAUTH_CONFIG["api_base_url"]
+    )
+
+    # Create HTTP client with Codex interceptor for store=false injection
+    verify = get_cert_bundle_path()
+    client = create_codex_async_client(headers=headers, verify=verify)
+
+    provider = OpenAIProvider(
+        api_key=access_token,
+        base_url=base_url,
+        http_client=client,
+    )
+
+    # ChatGPT Codex API only supports Responses format
+    model = OpenAIResponsesModel(model_name=model_config["name"], provider=provider)
+    setattr(model, "provider", provider)
+    return model
+
+
+def _register_model_types() -> List[Dict[str, Any]]:
+    """Register the chatgpt_oauth model type handler."""
+    return [{"type": "chatgpt_oauth", "handler": _create_chatgpt_oauth_model}]
+
+
 register_callback("custom_command_help", _custom_help)
 register_callback("custom_command", _handle_custom_command)
+register_callback("register_model_type", _register_model_types)

code_puppy/plugins/claude_code_oauth/register_callbacks.py

@@ -1,5 +1,8 @@
 """
 Claude Code OAuth Plugin for Code Puppy.
+
+Provides OAuth authentication for Claude Code models and registers
+the 'claude_code' model type handler.
 """
 
 from __future__ import annotations
@@ -24,6 +27,7 @@ from .utils import (
     build_authorization_url,
     exchange_code_for_tokens,
     fetch_claude_code_models,
+    get_valid_access_token,
     load_claude_models_filtered,
     load_stored_tokens,
     prepare_oauth_context,
@@ -276,5 +280,89 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
     return None
 
 
+def _create_claude_code_model(model_name: str, model_config: Dict, config: Dict) -> Any:
+    """Create a Claude Code model instance.
+
+    This handler is registered via the 'register_model_type' callback to handle
+    models with type='claude_code'.
+    """
+    from anthropic import AsyncAnthropic
+    from pydantic_ai.models.anthropic import AnthropicModel
+    from pydantic_ai.providers.anthropic import AnthropicProvider
+
+    from code_puppy.claude_cache_client import (
+        ClaudeCacheAsyncClient,
+        patch_anthropic_client_messages,
+    )
+    from code_puppy.config import get_effective_model_settings
+    from code_puppy.http_utils import get_cert_bundle_path, get_http2
+    from code_puppy.model_factory import get_custom_config
+
+    url, headers, verify, api_key = get_custom_config(model_config)
+
+    # Refresh token if this is from the plugin
+    if model_config.get("oauth_source") == "claude-code-plugin":
+        refreshed_token = get_valid_access_token()
+        if refreshed_token:
+            api_key = refreshed_token
+            custom_endpoint = model_config.get("custom_endpoint")
+            if isinstance(custom_endpoint, dict):
+                custom_endpoint["api_key"] = refreshed_token
+
+    if not api_key:
+        emit_warning(
+            f"API key is not set for Claude Code endpoint; skipping model '{model_config.get('name')}'."
+        )
+        return None
+
+    # Check if interleaved thinking is enabled (defaults to True for OAuth models)
+    effective_settings = get_effective_model_settings(model_name)
+    interleaved_thinking = effective_settings.get("interleaved_thinking", True)
+
+    # Handle anthropic-beta header based on interleaved_thinking setting
+    if "anthropic-beta" in headers:
+        beta_parts = [p.strip() for p in headers["anthropic-beta"].split(",")]
+        if interleaved_thinking:
+            if "interleaved-thinking-2025-05-14" not in beta_parts:
+                beta_parts.append("interleaved-thinking-2025-05-14")
+        else:
+            beta_parts = [p for p in beta_parts if "interleaved-thinking" not in p]
+        headers["anthropic-beta"] = ",".join(beta_parts) if beta_parts else None
+        if headers.get("anthropic-beta") is None:
+            del headers["anthropic-beta"]
+    elif interleaved_thinking:
+        headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
+    # Use a dedicated client wrapper that injects cache_control on /v1/messages
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    http2_enabled = get_http2()
+
+    client = ClaudeCacheAsyncClient(
+        headers=headers,
+        verify=verify,
+        timeout=180,
+        http2=http2_enabled,
+    )
+
+    anthropic_client = AsyncAnthropic(
+        base_url=url,
+        http_client=client,
+        auth_token=api_key,
+    )
+    patch_anthropic_client_messages(anthropic_client)
+    anthropic_client.api_key = None
+    anthropic_client.auth_token = api_key
+    provider = AnthropicProvider(anthropic_client=anthropic_client)
+    return AnthropicModel(model_name=model_config["name"], provider=provider)
+
+
+def _register_model_types() -> List[Dict[str, Any]]:
+    """Register the claude_code model type handler."""
+    return [{"type": "claude_code", "handler": _create_claude_code_model}]
+
+
 register_callback("custom_command_help", _custom_help)
 register_callback("custom_command", _handle_custom_command)
+register_callback("register_model_type", _register_model_types)

code_puppy/plugins/ralph/__init__.py

@@ -0,0 +1,13 @@
+"""Ralph Plugin - Autonomous AI agent loop for completing PRDs.
+
+Based on Geoffrey Huntley's Ralph pattern: https://ghuntley.com/ralph/
+
+This plugin provides:
+- PRD Generator agent for creating detailed requirements
+- Ralph Converter agent for converting PRDs to JSON format
+- Ralph Orchestrator agent for autonomous execution
+- Tools for managing prd.json and progress.txt
+- /ralph commands for controlling the workflow
+"""
+
+__version__ = "0.1.0"