code-puppy 0.0.287__py3-none-any.whl → 0.0.323__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
 
@@ -127,7 +158,10 @@ class ConsoleSpinner(SpinnerBase):
                 # Short sleep to control animation speed
                 time.sleep(0.05)
         except Exception as e:
-            print(f"\nSpinner error: {e}")
+            # Note: Using sys.stderr - can't use messaging during spinner
+            import sys
+
+            sys.stderr.write(f"\nSpinner error: {e}\n")
             self._is_spinning = False
 
     def pause(self):
@@ -168,11 +202,14 @@ 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,
                         refresh_per_second=20,
-                        transient=True,  # Clear the spinner line when stopped (no puppy litter!)
+                        transient=True,  # Clear spinner line when stopped
                         auto_refresh=False,
                     )
                     self._live.start()

code_puppy/model_factory.py

@@ -23,17 +23,35 @@ from pydantic_ai.providers.openrouter import OpenRouterProvider
 from pydantic_ai.settings import ModelSettings
 
 from code_puppy.messaging import emit_warning
-from code_puppy.plugins.chatgpt_oauth.config import get_chatgpt_models_path
-from code_puppy.plugins.claude_code_oauth.config import get_claude_models_path
-from code_puppy.plugins.claude_code_oauth.utils import load_claude_models_filtered
 
 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:
@@ -42,10 +60,12 @@ def make_model_settings(
     This handles model-specific settings:
     - GPT-5 models: reasoning_effort and verbosity (non-codex only)
     - Claude/Anthropic models: extended_thinking and budget_tokens
+    - Automatic max_tokens calculation based on model context length
 
     Args:
         model_name: The name of the model to create settings for.
-        max_tokens: Optional max tokens limit to include in settings.
+        max_tokens: Optional max tokens limit. If None, automatically calculated
+            as: max(2048, min(15% of context_length, 65536))
 
     Returns:
         Appropriate ModelSettings subclass instance for the model.
@@ -57,8 +77,21 @@ def make_model_settings(
     )
 
     model_settings_dict: dict = {}
-    if max_tokens is not None:
-        model_settings_dict["max_tokens"] = max_tokens
+
+    # Calculate max_tokens if not explicitly provided
+    if max_tokens is None:
+        # Load model config to get context length
+        try:
+            models_config = ModelFactory.load_config()
+            model_config = models_config.get(model_name, {})
+            context_length = model_config.get("context_length", 128000)
+        except Exception:
+            # Fallback if config loading fails (e.g., in CI environments)
+            context_length = 128000
+        # min 2048, 15% of context, max 65536
+        max_tokens = max(2048, min(int(0.15 * context_length), 65536))
+
+    model_settings_dict["max_tokens"] = max_tokens
     effective_settings = get_effective_model_settings(model_name)
     model_settings_dict.update(effective_settings)
 
@@ -75,8 +108,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",
@@ -106,10 +145,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
@@ -119,10 +158,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:
@@ -135,10 +174,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"]
@@ -171,36 +210,51 @@ class ModelFactory:
             with open(MODELS_FILE, "r") as f:
                 config = json.load(f)
 
-        extra_sources = [
-            (pathlib.Path(EXTRA_MODELS_FILE), "extra models"),
-            (get_chatgpt_models_path(), "ChatGPT OAuth models"),
-            (get_claude_models_path(), "Claude Code OAuth models"),
+        # Import OAuth model file paths from main config
+        from code_puppy.config import (
+            CHATGPT_MODELS_FILE,
+            CLAUDE_MODELS_FILE,
+            GEMINI_MODELS_FILE,
+        )
+
+        # Build list of extra model sources
+        extra_sources: list[tuple[pathlib.Path, str, bool]] = [
+            (pathlib.Path(EXTRA_MODELS_FILE), "extra models", False),
+            (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),
         ]
 
-        for source_path, label in extra_sources:
-            # source_path is already a Path object from the functions above
-            # Use hasattr to check if it's Path-like (works with mocks too)
-            if hasattr(source_path, "exists"):
-                path = source_path
-            else:
-                path = pathlib.Path(source_path).expanduser()
-            if not path.exists():
+        for source_path, label, use_filtered in extra_sources:
+            if not source_path.exists():
                 continue
             try:
                 # Use filtered loading for Claude Code OAuth models to show only latest versions
-                if "Claude Code OAuth" in label:
-                    extra_config = load_claude_models_filtered()
+                if use_filtered:
+                    try:
+                        from code_puppy.plugins.claude_code_oauth.utils import (
+                            load_claude_models_filtered,
+                        )
+
+                        extra_config = load_claude_models_filtered()
+                    except ImportError:
+                        # Plugin not available, fall back to standard JSON loading
+                        logging.getLogger(__name__).debug(
+                            f"claude_code_oauth plugin not available, loading {label} as plain JSON"
+                        )
+                        with open(source_path, "r") as f:
+                            extra_config = json.load(f)
                 else:
-                    with open(path, "r") as f:
+                    with open(source_path, "r") as f:
                         extra_config = json.load(f)
                 config.update(extra_config)
             except json.JSONDecodeError as exc:
                 logging.getLogger(__name__).warning(
-                    f"Failed to load {label} config from {path}: Invalid JSON - {exc}"
+                    f"Failed to load {label} config from {source_path}: Invalid JSON - {exc}"
                 )
             except Exception as exc:
                 logging.getLogger(__name__).warning(
-                    f"Failed to load {label} config from {path}: {exc}"
+                    f"Failed to load {label} config from {source_path}: {exc}"
                 )
         return config
 
@@ -218,10 +272,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
 
@@ -231,10 +285,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
 
@@ -248,10 +302,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
 
@@ -265,9 +319,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
@@ -297,10 +363,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
@@ -316,6 +393,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()
@@ -349,10 +451,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
 
@@ -363,10 +465,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
 
@@ -377,10 +479,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
 
@@ -414,10 +516,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(
@@ -431,10 +533,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(
@@ -510,21 +612,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
 
@@ -534,6 +636,143 @@ class ModelFactory:
             setattr(model, "provider", provider)
             return model
 
+        elif model_type == "gemini_oauth":
+            # Gemini OAuth models use the Code Assist API (cloudcode-pa.googleapis.com)
+            # This is a different API than the standard Generative Language API
+            try:
+                # Try user plugin first, then built-in plugin
+                try:
+                    from gemini_oauth.config import GEMINI_OAUTH_CONFIG
+                    from gemini_oauth.utils import (
+                        get_project_id,
+                        get_valid_access_token,
+                    )
+                except ImportError:
+                    from code_puppy.plugins.gemini_oauth.config import (
+                        GEMINI_OAUTH_CONFIG,
+                    )
+                    from code_puppy.plugins.gemini_oauth.utils import (
+                        get_project_id,
+                        get_valid_access_token,
+                    )
+            except ImportError as exc:
+                emit_warning(
+                    f"Gemini 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 Gemini OAuth token; skipping model '{model_config.get('name')}'. "
+                    "Run /gemini-auth to re-authenticate."
+                )
+                return None
+
+            # Get project ID from stored tokens
+            project_id = get_project_id()
+            if not project_id:
+                emit_warning(
+                    f"No Code Assist project ID found; skipping model '{model_config.get('name')}'. "
+                    "Run /gemini-auth to re-authenticate."
+                )
+                return None
+
+            # Import the Code Assist model wrapper
+            from code_puppy.gemini_code_assist import GeminiCodeAssistModel
+
+            # Create the Code Assist model
+            model = GeminiCodeAssistModel(
+                model_name=model_config["name"],
+                access_token=access_token,
+                project_id=project_id,
+                api_base_url=GEMINI_OAUTH_CONFIG["api_base_url"],
+                api_version=GEMINI_OAUTH_CONFIG["api_version"],
+            )
+            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")