code-puppy 0.0.302__py3-none-any.whl → 0.0.335__py3-none-any.whl

code_puppy/messaging/spinner/console_spinner.py

@@ -2,6 +2,7 @@
 Console spinner implementation for CLI mode using Rich's Live Display.
 """
 
+import platform
 import threading
 import time
 
@@ -43,6 +44,9 @@ class ConsoleSpinner(SpinnerBase):
         if self._thread and self._thread.is_alive():
             return
 
+        # Print blank line before spinner for visual separation from content
+        self.console.print()
+
         # Create a Live display for the spinner
         self._live = Live(
             self._generate_spinner_panel(),
@@ -75,6 +79,33 @@ class ConsoleSpinner(SpinnerBase):
 
         self._thread = None
 
+        # Windows-specific cleanup: Rich's Live display can leave terminal in corrupted state
+        if platform.system() == "Windows":
+            import sys
+
+            try:
+                # Reset ANSI formatting for both stdout and stderr
+                sys.stdout.write("\x1b[0m")  # Reset all attributes
+                sys.stdout.flush()
+                sys.stderr.write("\x1b[0m")
+                sys.stderr.flush()
+
+                # Clear the line and reposition cursor
+                sys.stdout.write("\r")  # Return to start of line
+                sys.stdout.write("\x1b[K")  # Clear to end of line
+                sys.stdout.flush()
+
+                # Flush keyboard input buffer to clear any stuck keys
+                try:
+                    import msvcrt
+
+                    while msvcrt.kbhit():
+                        msvcrt.getch()
+                except ImportError:
+                    pass  # msvcrt not available (not Windows or different Python impl)
+            except Exception:
+                pass  # Fail silently if cleanup doesn't work
+
         # Unregister this spinner from global management
         from . import unregister_spinner
 
@@ -171,6 +202,9 @@ class ConsoleSpinner(SpinnerBase):
                     sys.stdout.write("\x1b[K")  # Clear to end of line
                     sys.stdout.flush()
 
+                    # Print blank line before spinner for visual separation
+                    self.console.print()
+
                     self._live = Live(
                         self._generate_spinner_panel(),
                         console=self.console,

code_puppy/model_factory.py

@@ -4,7 +4,6 @@ import os
 import pathlib
 from typing import Any, Dict
 
-import httpx
 from anthropic import AsyncAnthropic
 from openai import AsyncAzureOpenAI
 from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
@@ -26,11 +25,32 @@ from code_puppy.messaging import emit_warning
 
 from . import callbacks
 from .claude_cache_client import ClaudeCacheAsyncClient, patch_anthropic_client_messages
-from .config import EXTRA_MODELS_FILE
+from .config import EXTRA_MODELS_FILE, get_value
 from .http_utils import create_async_client, get_cert_bundle_path, get_http2
 from .round_robin_model import RoundRobinModel
 
 
+def get_api_key(env_var_name: str) -> str | None:
+    """Get an API key from config first, then fall back to environment variable.
+
+    This allows users to set API keys via `/set KIMI_API_KEY=xxx` in addition to
+    setting them as environment variables.
+
+    Args:
+        env_var_name: The name of the environment variable (e.g., "OPENAI_API_KEY")
+
+    Returns:
+        The API key value, or None if not found in either config or environment.
+    """
+    # First check config (case-insensitive key lookup)
+    config_value = get_value(env_var_name.lower())
+    if config_value:
+        return config_value
+
+    # Fall back to environment variable
+    return os.environ.get(env_var_name)
+
+
 def make_model_settings(
     model_name: str, max_tokens: int | None = None
 ) -> ModelSettings:
@@ -87,8 +107,14 @@ def make_model_settings(
         # Handle Anthropic extended thinking settings
         # Remove top_p as Anthropic doesn't support it with extended thinking
         model_settings_dict.pop("top_p", None)
-        extended_thinking = effective_settings.get("extended_thinking", False)
-        budget_tokens = effective_settings.get("budget_tokens")
+
+        # Claude extended thinking requires temperature=1.0 (API restriction)
+        # Default to 1.0 if not explicitly set by user
+        if model_settings_dict.get("temperature") is None:
+            model_settings_dict["temperature"] = 1.0
+
+        extended_thinking = effective_settings.get("extended_thinking", True)
+        budget_tokens = effective_settings.get("budget_tokens", 10000)
         if extended_thinking and budget_tokens:
             model_settings_dict["anthropic_thinking"] = {
                 "type": "enabled",
@@ -118,10 +144,10 @@ def get_custom_config(model_config):
     for key, value in custom_config.get("headers", {}).items():
         if value.startswith("$"):
             env_var_name = value[1:]
-            resolved_value = os.environ.get(env_var_name)
+            resolved_value = get_api_key(env_var_name)
             if resolved_value is None:
                 emit_warning(
-                    f"Environment variable '{env_var_name}' is not set for custom endpoint header '{key}'. Proceeding with empty value."
+                    f"'{env_var_name}' is not set (check config or environment) for custom endpoint header '{key}'. Proceeding with empty value."
                 )
                 resolved_value = ""
             value = resolved_value
@@ -131,10 +157,10 @@ def get_custom_config(model_config):
             for token in tokens:
                 if token.startswith("$"):
                     env_var = token[1:]
-                    resolved_value = os.environ.get(env_var)
+                    resolved_value = get_api_key(env_var)
                     if resolved_value is None:
                         emit_warning(
-                            f"Environment variable '{env_var}' is not set for custom endpoint header '{key}'. Proceeding with empty value."
+                            f"'{env_var}' is not set (check config or environment) for custom endpoint header '{key}'. Proceeding with empty value."
                         )
                         resolved_values.append("")
                     else:
@@ -147,10 +173,10 @@ def get_custom_config(model_config):
     if "api_key" in custom_config:
         if custom_config["api_key"].startswith("$"):
             env_var_name = custom_config["api_key"][1:]
-            api_key = os.environ.get(env_var_name)
+            api_key = get_api_key(env_var_name)
             if api_key is None:
                 emit_warning(
-                    f"Environment variable '{env_var_name}' is not set for custom endpoint API key; proceeding without API key."
+                    f"API key '{env_var_name}' is not set (checked config and environment); proceeding without API key."
                 )
         else:
             api_key = custom_config["api_key"]
@@ -185,6 +211,7 @@ class ModelFactory:
 
         # Import OAuth model file paths from main config
         from code_puppy.config import (
+            ANTIGRAVITY_MODELS_FILE,
             CHATGPT_MODELS_FILE,
             CLAUDE_MODELS_FILE,
             GEMINI_MODELS_FILE,
@@ -196,6 +223,7 @@ class ModelFactory:
             (pathlib.Path(CHATGPT_MODELS_FILE), "ChatGPT OAuth models", False),
             (pathlib.Path(CLAUDE_MODELS_FILE), "Claude Code OAuth models", True),
             (pathlib.Path(GEMINI_MODELS_FILE), "Gemini OAuth models", False),
+            (pathlib.Path(ANTIGRAVITY_MODELS_FILE), "Antigravity OAuth models", False),
         ]
 
         for source_path, label, use_filtered in extra_sources:
@@ -245,10 +273,10 @@ class ModelFactory:
         model_type = model_config.get("type")
 
         if model_type == "gemini":
-            api_key = os.environ.get("GEMINI_API_KEY")
+            api_key = get_api_key("GEMINI_API_KEY")
             if not api_key:
                 emit_warning(
-                    f"GEMINI_API_KEY is not set; skipping Gemini model '{model_config.get('name')}'."
+                    f"GEMINI_API_KEY is not set (check config or environment); skipping Gemini model '{model_config.get('name')}'."
                 )
                 return None
 
@@ -258,10 +286,10 @@ class ModelFactory:
             return model
 
         elif model_type == "openai":
-            api_key = os.environ.get("OPENAI_API_KEY")
+            api_key = get_api_key("OPENAI_API_KEY")
             if not api_key:
                 emit_warning(
-                    f"OPENAI_API_KEY is not set; skipping OpenAI model '{model_config.get('name')}'."
+                    f"OPENAI_API_KEY is not set (check config or environment); skipping OpenAI model '{model_config.get('name')}'."
                 )
                 return None
 
@@ -275,10 +303,10 @@ class ModelFactory:
             return model
 
         elif model_type == "anthropic":
-            api_key = os.environ.get("ANTHROPIC_API_KEY", None)
+            api_key = get_api_key("ANTHROPIC_API_KEY")
             if not api_key:
                 emit_warning(
-                    f"ANTHROPIC_API_KEY is not set; skipping Anthropic model '{model_config.get('name')}'."
+                    f"ANTHROPIC_API_KEY is not set (check config or environment); skipping Anthropic model '{model_config.get('name')}'."
                 )
                 return None
 
@@ -292,9 +320,21 @@ class ModelFactory:
                 http2=http2_enabled,
             )
 
+            # Check if interleaved thinking is enabled for this model
+            # Only applies to Claude 4 models (Opus 4.5, Opus 4.1, Opus 4, Sonnet 4)
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", False)
+
+            default_headers = {}
+            if interleaved_thinking:
+                default_headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             anthropic_client = AsyncAnthropic(
                 api_key=api_key,
                 http_client=client,
+                default_headers=default_headers if default_headers else None,
             )
 
             # Ensure cache_control is injected at the Anthropic SDK layer
@@ -324,10 +364,21 @@ class ModelFactory:
                 http2=http2_enabled,
             )
 
+            # Check if interleaved thinking is enabled for this model
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", False)
+
+            default_headers = {}
+            if interleaved_thinking:
+                default_headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             anthropic_client = AsyncAnthropic(
                 base_url=url,
                 http_client=client,
                 api_key=api_key,
+                default_headers=default_headers if default_headers else None,
             )
 
             # Ensure cache_control is injected at the Anthropic SDK layer
@@ -343,6 +394,31 @@ class ModelFactory:
                 )
                 return None
 
+            # Check if interleaved thinking is enabled (defaults to True for OAuth models)
+            from code_puppy.config import get_effective_model_settings
+
+            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:
+                    # Ensure interleaved-thinking is in the header
+                    if "interleaved-thinking-2025-05-14" not in beta_parts:
+                        beta_parts.append("interleaved-thinking-2025-05-14")
+                else:
+                    # Remove interleaved-thinking from the header
+                    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:
+                # No existing beta header, add one for 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()
@@ -376,10 +452,10 @@ class ModelFactory:
                 )
             azure_endpoint = azure_endpoint_config
             if azure_endpoint_config.startswith("$"):
-                azure_endpoint = os.environ.get(azure_endpoint_config[1:])
+                azure_endpoint = get_api_key(azure_endpoint_config[1:])
             if not azure_endpoint:
                 emit_warning(
-                    f"Azure OpenAI endpoint environment variable '{azure_endpoint_config[1:] if azure_endpoint_config.startswith('$') else azure_endpoint_config}' not found or is empty; skipping model '{model_config.get('name')}'."
+                    f"Azure OpenAI endpoint '{azure_endpoint_config[1:] if azure_endpoint_config.startswith('$') else azure_endpoint_config}' not found (check config or environment); skipping model '{model_config.get('name')}'."
                 )
                 return None
 
@@ -390,10 +466,10 @@ class ModelFactory:
                 )
             api_version = api_version_config
             if api_version_config.startswith("$"):
-                api_version = os.environ.get(api_version_config[1:])
+                api_version = get_api_key(api_version_config[1:])
             if not api_version:
                 emit_warning(
-                    f"Azure OpenAI API version environment variable '{api_version_config[1:] if api_version_config.startswith('$') else api_version_config}' not found or is empty; skipping model '{model_config.get('name')}'."
+                    f"Azure OpenAI API version '{api_version_config[1:] if api_version_config.startswith('$') else api_version_config}' not found (check config or environment); skipping model '{model_config.get('name')}'."
                 )
                 return None
 
@@ -404,10 +480,10 @@ class ModelFactory:
                 )
             api_key = api_key_config
             if api_key_config.startswith("$"):
-                api_key = os.environ.get(api_key_config[1:])
+                api_key = get_api_key(api_key_config[1:])
             if not api_key:
                 emit_warning(
-                    f"Azure OpenAI API key environment variable '{api_key_config[1:] if api_key_config.startswith('$') else api_key_config}' not found or is empty; skipping model '{model_config.get('name')}'."
+                    f"Azure OpenAI API key '{api_key_config[1:] if api_key_config.startswith('$') else api_key_config}' not found (check config or environment); skipping model '{model_config.get('name')}'."
                 )
                 return None
 
@@ -441,10 +517,10 @@ class ModelFactory:
             setattr(model, "provider", provider)
             return model
         elif model_type == "zai_coding":
-            api_key = os.getenv("ZAI_API_KEY")
+            api_key = get_api_key("ZAI_API_KEY")
             if not api_key:
                 emit_warning(
-                    f"ZAI_API_KEY is not set; skipping ZAI coding model '{model_config.get('name')}'."
+                    f"ZAI_API_KEY is not set (check config or environment); skipping ZAI coding model '{model_config.get('name')}'."
                 )
                 return None
             provider = OpenAIProvider(
@@ -458,10 +534,10 @@ class ModelFactory:
             setattr(zai_model, "provider", provider)
             return zai_model
         elif model_type == "zai_api":
-            api_key = os.getenv("ZAI_API_KEY")
+            api_key = get_api_key("ZAI_API_KEY")
             if not api_key:
                 emit_warning(
-                    f"ZAI_API_KEY is not set; skipping ZAI API model '{model_config.get('name')}'."
+                    f"ZAI_API_KEY is not set (check config or environment); skipping ZAI API model '{model_config.get('name')}'."
                 )
                 return None
             provider = OpenAIProvider(
@@ -481,24 +557,94 @@ class ModelFactory:
                     f"API key is not set for custom Gemini endpoint; skipping model '{model_config.get('name')}'."
                 )
                 return None
-            os.environ["GEMINI_API_KEY"] = api_key
 
-            class CustomGoogleGLAProvider(GoogleProvider):
-                def __init__(self, *args, **kwargs):
-                    super().__init__(*args, **kwargs)
+            # Check if this is an Antigravity model
+            if model_config.get("antigravity"):
+                try:
+                    from code_puppy.plugins.antigravity_oauth.token import (
+                        is_token_expired,
+                        refresh_access_token,
+                    )
+                    from code_puppy.plugins.antigravity_oauth.transport import (
+                        create_antigravity_client,
+                    )
+                    from code_puppy.plugins.antigravity_oauth.utils import (
+                        load_stored_tokens,
+                        save_tokens,
+                    )
+
+                    # Try to import custom model for thinking signatures
+                    try:
+                        from code_puppy.plugins.antigravity_oauth.antigravity_model import (
+                            AntigravityModel,
+                        )
+                    except ImportError:
+                        AntigravityModel = 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
+                    if is_token_expired(expires_at):
+                        new_tokens = refresh_access_token(refresh_token)
+                        if new_tokens:
+                            access_token = new_tokens.access_token
+                            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
+
+                    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,
+                    )
 
-                @property
-                def base_url(self):
-                    return url
+                    provider = GoogleProvider(
+                        api_key=api_key, base_url=url, http_client=client
+                    )
 
-                @property
-                def client(self) -> httpx.AsyncClient:
-                    _client = create_async_client(headers=headers, verify=verify)
-                    _client.base_url = self.base_url
-                    return _client
+                    # Use custom model if available to preserve thinking signatures
+                    if AntigravityModel:
+                        model = AntigravityModel(
+                            model_name=model_config["name"], provider=provider
+                        )
+                    else:
+                        model = GoogleModel(
+                            model_name=model_config["name"], provider=provider
+                        )
 
-            google_gla = CustomGoogleGLAProvider(api_key=api_key)
-            model = GoogleModel(model_name=model_config["name"], provider=google_gla)
+                    return model
+
+                except ImportError:
+                    emit_warning(
+                        f"Antigravity transport not available; skipping model '{model_config.get('name')}'."
+                    )
+                    return None
+            else:
+                client = create_async_client(headers=headers, verify=verify)
+
+            provider = GoogleProvider(api_key=api_key, base_url=url, http_client=client)
+            model = GoogleModel(model_name=model_config["name"], provider=provider)
             return model
         elif model_type == "cerebras":
 
@@ -537,21 +683,21 @@ class ModelFactory:
                 if api_key_config.startswith("$"):
                     # It's an environment variable reference
                     env_var_name = api_key_config[1:]  # Remove the $ prefix
-                    api_key = os.environ.get(env_var_name)
+                    api_key = get_api_key(env_var_name)
                     if api_key is None:
                         emit_warning(
-                            f"OpenRouter API key environment variable '{env_var_name}' not found or is empty; skipping model '{model_config.get('name')}'."
+                            f"OpenRouter API key '{env_var_name}' not found (check config or environment); skipping model '{model_config.get('name')}'."
                         )
                         return None
                 else:
                     # It's a raw API key value
                     api_key = api_key_config
             else:
-                # No API key in config, try to get it from the default environment variable
-                api_key = os.environ.get("OPENROUTER_API_KEY")
+                # No API key in config, try to get it from config or the default environment variable
+                api_key = get_api_key("OPENROUTER_API_KEY")
                 if api_key is None:
                     emit_warning(
-                        f"OPENROUTER_API_KEY is not set; skipping OpenRouter model '{model_config.get('name')}'."
+                        f"OPENROUTER_API_KEY is not set (check config or environment); skipping OpenRouter model '{model_config.get('name')}'."
                     )
                     return None
 
@@ -618,6 +764,86 @@ class ModelFactory:
             )
             return model
 
+        elif model_type == "chatgpt_oauth":
+            # ChatGPT OAuth models use the Codex API at chatgpt.com
+            try:
+                try:
+                    from chatgpt_oauth.config import CHATGPT_OAUTH_CONFIG
+                    from chatgpt_oauth.utils import (
+                        get_valid_access_token,
+                        load_stored_tokens,
+                    )
+                except ImportError:
+                    from code_puppy.plugins.chatgpt_oauth.config import (
+                        CHATGPT_OAUTH_CONFIG,
+                    )
+                    from code_puppy.plugins.chatgpt_oauth.utils import (
+                        get_valid_access_token,
+                        load_stored_tokens,
+                    )
+            except ImportError as exc:
+                emit_warning(
+                    f"ChatGPT OAuth plugin not available; skipping model '{model_config.get('name')}'. "
+                    f"Error: {exc}"
+                )
+                return None
+
+            # 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
+            from code_puppy.chatgpt_codex_client import create_codex_async_client
+
+            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
+
         elif model_type == "round_robin":
             # Get the list of model names to use in the round-robin
             model_names = model_config.get("models")