pdd-cli 0.0.90__py3-none-any.whl → 0.0.118__py3-none-any.whl

pdd/core/cloud.py

@@ -0,0 +1,237 @@
+"""
+Centralized cloud configuration for PDD CLI commands.
+
+Provides consistent cloud URL configuration and JWT token handling
+across all cloud-enabled commands (generate, fix, test, sync, etc.).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Optional
+
+from rich.console import Console
+
+from ..get_jwt_token import (
+    AuthError,
+    NetworkError,
+    RateLimitError,
+    TokenError,
+    UserCancelledError,
+    get_jwt_token as device_flow_get_token,
+)
+
+console = Console()
+
+# Environment variable names
+FIREBASE_API_KEY_ENV = "NEXT_PUBLIC_FIREBASE_API_KEY"
+GITHUB_CLIENT_ID_ENV = "GITHUB_CLIENT_ID"
+PDD_CLOUD_URL_ENV = "PDD_CLOUD_URL"
+PDD_JWT_TOKEN_ENV = "PDD_JWT_TOKEN"
+
+# Default cloud endpoints
+DEFAULT_BASE_URL = "https://us-central1-prompt-driven-development.cloudfunctions.net"
+
+# Endpoint paths (can be extended as more endpoints are added)
+CLOUD_ENDPOINTS = {
+    "generateCode": "/generateCode",
+    "generateExample": "/generateExample",
+    "generateTest": "/generateTest",
+    "generateBugTest": "/generateBugTest",
+    "fixCode": "/fixCode",
+    "crashCode": "/crashCode",
+    "verifyCode": "/verifyCode",
+    "syncState": "/syncState",
+    "trackUsage": "/trackUsage",
+    "getCreditBalance": "/getCreditBalance",
+    "llmInvoke": "/llmInvoke",
+    # Remote session endpoints
+    "registerSession": "/registerSession",
+    "listSessions": "/listSessions",
+    "heartbeatSession": "/heartbeatSession",
+    "deregisterSession": "/deregisterSession",
+    # Command relay endpoints (Firestore message bus)
+    "getCommands": "/getCommands",
+    "getCommandStatus": "/getCommandStatus",
+    "updateCommand": "/updateCommand",
+    "cancelCommand": "/cancelCommand",
+}
+
+
+class CloudConfig:
+    """Centralized cloud configuration for all PDD commands."""
+
+    @staticmethod
+    def _ensure_default_env() -> None:
+        """Default PDD_ENV for CLI usage when unset."""
+        if os.environ.get("PDD_ENV"):
+            return
+
+        # Local/emulator signals should keep PDD_ENV local.
+        if (os.environ.get("FUNCTIONS_EMULATOR") or
+                os.environ.get("FIREBASE_AUTH_EMULATOR_HOST") or
+                os.environ.get("FIREBASE_EMULATOR_HUB")):
+            os.environ["PDD_ENV"] = "local"
+            return
+
+        cloud_url = (os.environ.get(PDD_CLOUD_URL_ENV) or "").lower()
+        if cloud_url:
+            if any(host in cloud_url for host in ("localhost", "127.0.0.1", "0.0.0.0")):
+                os.environ["PDD_ENV"] = "local"
+                return
+            if "prompt-driven-development-stg" in cloud_url or "staging" in cloud_url:
+                os.environ["PDD_ENV"] = "staging"
+                return
+
+        # Default to production for typical CLI usage.
+        os.environ["PDD_ENV"] = "prod"
+
+    @staticmethod
+    def get_base_url() -> str:
+        """Get cloud base URL, allowing override via PDD_CLOUD_URL.
+
+        For testing against different environments:
+        - Local emulator: http://127.0.0.1:5555/prompt-driven-development/us-central1
+        - Staging: https://us-central1-prompt-driven-development-stg.cloudfunctions.net
+        - Production: (default) https://us-central1-prompt-driven-development.cloudfunctions.net
+        """
+        custom_url = os.environ.get(PDD_CLOUD_URL_ENV)
+        if custom_url:
+            # If full URL provided (with endpoint), extract base
+            # If base URL provided, use as-is
+            return custom_url.rstrip("/")
+        return DEFAULT_BASE_URL
+
+    @staticmethod
+    def get_endpoint_url(endpoint_name: str) -> str:
+        """Get full URL for a specific cloud endpoint.
+
+        Args:
+            endpoint_name: Name of endpoint (e.g., 'generateCode', 'syncState')
+
+        Returns:
+            Full URL for the endpoint
+        """
+        base = CloudConfig.get_base_url()
+
+        # Check if PDD_CLOUD_URL already includes the endpoint
+        custom_url = os.environ.get(PDD_CLOUD_URL_ENV, "")
+        if endpoint_name in custom_url:
+            return custom_url
+
+        path = CLOUD_ENDPOINTS.get(endpoint_name, f"/{endpoint_name}")
+        return f"{base}{path}"
+
+    @staticmethod
+    def get_jwt_token(
+        verbose: bool = False,
+        app_name: str = "PDD Code Generator"
+    ) -> Optional[str]:
+        """Get JWT token for cloud authentication.
+
+        Checks PDD_JWT_TOKEN environment variable first (for testing/CI),
+        then falls back to interactive device flow authentication.
+
+        Args:
+            verbose: Whether to print status messages
+            app_name: Application name for device flow
+
+        Returns:
+            JWT token string, or None if authentication failed
+
+        Note:
+            Callers should handle None return by falling back to local execution.
+        """
+        # Default env to prod for typical CLI usage (unless emulator/custom URL says otherwise).
+        CloudConfig._ensure_default_env()
+
+        # Check for pre-injected token (testing/CI)
+        injected_token = os.environ.get(PDD_JWT_TOKEN_ENV)
+        if injected_token:
+            if verbose:
+                console.print(f"[info]Using injected JWT token from {PDD_JWT_TOKEN_ENV}[/info]")
+            return injected_token
+
+        # Standard device flow authentication
+        try:
+            firebase_api_key = os.environ.get(FIREBASE_API_KEY_ENV)
+            github_client_id = os.environ.get(GITHUB_CLIENT_ID_ENV)
+
+            if not firebase_api_key:
+                raise AuthError(f"{FIREBASE_API_KEY_ENV} not set.")
+            if not github_client_id:
+                raise AuthError(f"{GITHUB_CLIENT_ID_ENV} not set.")
+
+            return asyncio.run(device_flow_get_token(
+                firebase_api_key=firebase_api_key,
+                github_client_id=github_client_id,
+                app_name=app_name
+            ))
+        except (AuthError, NetworkError, TokenError, UserCancelledError, RateLimitError) as e:
+            # Always display auth errors (both these expected ones and the unexpected ones handled below) - critical for debugging auth issues
+            console.print(f"[yellow]Cloud authentication error: {e}[/yellow]")
+            return None
+        except Exception as e:
+            # Always display unexpected errors too
+            console.print(f"[yellow]Unexpected auth error: {e}[/yellow]")
+            return None
+
+    @staticmethod
+    def is_running_in_cloud() -> bool:
+        """Check if we're running inside a cloud environment.
+
+        Detects Google Cloud Functions/Cloud Run via K_SERVICE env var,
+        or local emulator via FUNCTIONS_EMULATOR. This prevents infinite
+        loops when cloud endpoints call the CLI internally.
+        """
+        return bool(
+            os.environ.get("K_SERVICE") or
+            os.environ.get("FUNCTIONS_EMULATOR")
+        )
+
+    @staticmethod
+    def is_cloud_enabled() -> bool:
+        """Check if cloud features are available.
+
+        Cloud is enabled if:
+        1. PDD_FORCE_LOCAL is NOT set (respects --local flag), AND
+        2. NOT already running inside a cloud environment (prevents infinite loops), AND
+        3. Either:
+           a. PDD_JWT_TOKEN is set (injected token for testing/CI), OR
+           b. Both FIREBASE_API_KEY and GITHUB_CLIENT_ID are set (for device flow auth)
+        """
+        # Respect --local flag (sets PDD_FORCE_LOCAL=1)
+        if os.environ.get("PDD_FORCE_LOCAL"):
+            return False
+
+        # CRITICAL: Never enable cloud mode when already running in cloud
+        # This prevents infinite loops when cloud endpoints call CLI internally
+        if CloudConfig.is_running_in_cloud():
+            return False
+
+        # Check for injected token first (testing/CI scenario)
+        if os.environ.get(PDD_JWT_TOKEN_ENV):
+            return True
+        # Check for device flow auth credentials
+        return bool(
+            os.environ.get(FIREBASE_API_KEY_ENV) and
+            os.environ.get(GITHUB_CLIENT_ID_ENV)
+        )
+
+
+# Re-export exception classes for convenience
+__all__ = [
+    'CloudConfig',
+    'AuthError',
+    'NetworkError',
+    'TokenError',
+    'UserCancelledError',
+    'RateLimitError',
+    'FIREBASE_API_KEY_ENV',
+    'GITHUB_CLIENT_ID_ENV',
+    'PDD_CLOUD_URL_ENV',
+    'PDD_JWT_TOKEN_ENV',
+    'DEFAULT_BASE_URL',
+    'CLOUD_ENDPOINTS',
+]

pdd/core/errors.py

@@ -1,6 +1,7 @@
 """
 Error handling logic for PDD CLI.
 """
+import os
 import traceback
 from typing import Any, Dict, List
 import click
@@ -60,4 +61,7 @@ def handle_error(exception: Exception, command_name: str, quiet: bool):
             console.print(escape(str(exception)))
         else:
             console.print(f"  [error]An unexpected error occurred:[/error] {exception}", style="error")
+    strict_exit = os.environ.get("PDD_STRICT_EXIT", "").strip().lower() in {"1", "true", "yes", "on"}
+    if strict_exit:
+        raise SystemExit(1)
     # Do NOT re-raise e here. Let the command function return None.

pdd/core/remote_session.py

@@ -0,0 +1,61 @@
+"""
+Utility to detect if running in a remote/SSH session or headless environment.
+"""
+import os
+import sys
+from typing import Optional, Tuple
+
+
+def is_remote_session() -> Tuple[bool, str]:
+    """
+    Detect if the current session is remote (SSH) or headless.
+
+    Returns:
+        Tuple[bool, str]: (is_remote, reason) where reason explains why
+
+    Detection criteria:
+    1. SSH environment variables (SSH_CONNECTION, SSH_CLIENT, SSH_TTY)
+    2. DISPLAY not set (headless Linux/Unix)
+    3. WSL without WSLg (Windows Subsystem for Linux)
+    """
+    # Check SSH environment variables
+    if os.environ.get("SSH_CONNECTION"):
+        return True, "SSH_CONNECTION environment variable detected"
+    if os.environ.get("SSH_CLIENT"):
+        return True, "SSH_CLIENT environment variable detected"
+    if os.environ.get("SSH_TTY"):
+        return True, "SSH_TTY environment variable detected"
+
+    # Check for headless environment (no DISPLAY on Unix/Linux)
+    if sys.platform in ("linux", "linux2") or sys.platform == "darwin":
+        if not os.environ.get("DISPLAY"):
+            return True, "No DISPLAY environment variable (headless)"
+
+    # Check for WSL without WSLg (older WSL versions)
+    if os.environ.get("WSL_DISTRO_NAME") and not os.environ.get("WAYLAND_DISPLAY"):
+        return True, "WSL environment without display server"
+
+    return False, "Local session with display capability"
+
+
+def should_skip_browser(explicit_flag: Optional[bool] = None) -> Tuple[bool, str]:
+    """
+    Determine if browser opening should be skipped.
+
+    Args:
+        explicit_flag: True to force browser, False to force no-browser, None to auto-detect
+
+    Returns:
+        Tuple[bool, str]: (skip_browser, reason)
+    """
+    if explicit_flag is True:
+        return False, "User explicitly requested browser opening (--browser flag)"
+    if explicit_flag is False:
+        return True, "User explicitly requested no browser (--no-browser flag)"
+
+    # Auto-detect
+    is_remote, reason = is_remote_session()
+    if is_remote:
+        return True, f"Auto-detected remote session: {reason}"
+
+    return False, "Local session detected, will attempt browser opening"

pdd/crash_main.py

@@ -1,12 +1,21 @@
 import sys
 from typing import Tuple, Optional, Dict, Any
+import json
 import click
 from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
 from pathlib import Path
 
+import requests
+import os
+
 from .config_resolution import resolve_effective_config
 from .construct_paths import construct_paths
 from .fix_code_loop import fix_code_loop
+from .core.cloud import CloudConfig
+from .get_language import get_language
+
 # Import fix_code_module_errors conditionally or ensure it's always available
 try:
     from .fix_code_module_errors import fix_code_module_errors
@@ -14,6 +23,19 @@ except ImportError:
     # Handle case where fix_code_module_errors might not be available if not needed
     fix_code_module_errors = None
 
+# Cloud request timeout
+CLOUD_REQUEST_TIMEOUT = 400  # seconds
+
+console = Console()
+
+
+def _env_flag_enabled(name: str) -> bool:
+    """Return True when an env var is set to a truthy value."""
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return str(value).strip().lower() in {"1", "true", "yes", "on"}
+
 def crash_main(
     ctx: click.Context,
     prompt_file: str,
@@ -107,11 +129,33 @@ def crash_main(
         code_updated: bool = False
         program_updated: bool = False
 
+        # Determine cloud vs local execution preference
+        is_local_execution_preferred = ctx.obj.get('local', False)
+        cloud_only = _env_flag_enabled("PDD_CLOUD_ONLY") or _env_flag_enabled("PDD_NO_LOCAL_FALLBACK")
+        current_execution_is_local = is_local_execution_preferred and not cloud_only
+
+        # Cloud execution tracking
+        cloud_execution_attempted = False
+        cloud_execution_succeeded = False
+
         if loop:
+            # Determine if loop should use cloud for LLM calls (hybrid mode)
+            # Local program execution stays local, but LLM fix calls can go to cloud
+            use_cloud_for_loop = not is_local_execution_preferred and not cloud_only
+
+            # If cloud_only is set but we're in loop mode, we still use hybrid approach
+            if cloud_only and not is_local_execution_preferred:
+                use_cloud_for_loop = True
+
+            if verbose:
+                mode_desc = "hybrid (local execution + cloud LLM)" if use_cloud_for_loop else "local"
+                console.print(Panel(f"Performing {mode_desc} crash fix loop...", title="[blue]Mode[/blue]", expand=False))
+
             success, final_program, final_code, attempts, cost, model = fix_code_loop(
                 code_file, prompt_content, program_file, strength, temperature,
                 max_attempts if max_attempts is not None else 3, budget or 5.0, error_file, verbose, time_param,
-                prompt_file=prompt_file, agentic_fallback=agentic_fallback
+                prompt_file=prompt_file, agentic_fallback=agentic_fallback,
+                use_cloud=use_cloud_for_loop
             )
             # Always set final_code/final_program to something non-empty
             if not final_code:
@@ -121,33 +165,182 @@ def crash_main(
             code_updated = final_code != original_code_content
             program_updated = final_program != original_program_content
         else:
-            if fix_code_module_errors is None:
-                raise ImportError("fix_code_module_errors is required but not available.")
+            # Single-pass mode: attempt cloud first, fallback to local
+            if not current_execution_is_local:
+                if verbose:
+                    console.print(Panel("Attempting cloud crash fix execution...", title="[blue]Mode[/blue]", expand=False))
 
-            update_program, update_code, fixed_program, fixed_code, _, cost, model = fix_code_module_errors(
-                program_content, prompt_content, code_content, error_content,
-                strength, temperature, verbose, time_param
-            )
-            success = True
-            attempts = 1
+                jwt_token = CloudConfig.get_jwt_token(verbose=verbose)
 
-            # Fallback if fixed_program is empty but update_program is True
-            if update_program and not fixed_program.strip():
-                fixed_program = program_content
-            if update_code and not fixed_code.strip():
-                fixed_code = code_content
+                if not jwt_token:
+                    if cloud_only:
+                        console.print("[red]Cloud authentication failed.[/red]")
+                        raise click.UsageError("Cloud authentication failed")
+                    console.print("[yellow]Cloud authentication failed. Falling back to local execution.[/yellow]")
+                    current_execution_is_local = True
 
-            final_code = fixed_code if update_code else code_content
-            final_program = fixed_program if update_program else program_content
+                if jwt_token and not current_execution_is_local:
+                    cloud_execution_attempted = True
+                    # Build cloud payload
+                    payload = {
+                        "programContent": program_content,
+                        "promptContent": prompt_content,
+                        "codeContent": code_content,
+                        "errorContent": error_content,
+                        "language": language,
+                        "strength": strength,
+                        "temperature": temperature,
+                        "time": time_param if time_param is not None else 0.25,
+                        "verbose": verbose,
+                        "programPath": program_file,
+                        "codePath": code_file,
+                    }
 
-            # Always set final_code/final_program to something non-empty
-            if not final_code:
-                final_code = original_code_content
-            if not final_program:
-                final_program = original_program_content
+                    headers = {
+                        "Authorization": f"Bearer {jwt_token}",
+                        "Content-Type": "application/json"
+                    }
+                    cloud_url = CloudConfig.get_endpoint_url("crashCode")
 
-            code_updated = final_code != original_code_content
-            program_updated = final_program != original_program_content
+                    try:
+                        response = requests.post(
+                            cloud_url,
+                            json=payload,
+                            headers=headers,
+                            timeout=CLOUD_REQUEST_TIMEOUT
+                        )
+                        response.raise_for_status()
+
+                        response_data = response.json()
+                        fixed_code = response_data.get("fixedCode", "")
+                        fixed_program = response_data.get("fixedProgram", "")
+                        update_code = response_data.get("updateCode", False)
+                        update_program = response_data.get("updateProgram", False)
+                        cost = float(response_data.get("totalCost", 0.0))
+                        model = response_data.get("modelName", "cloud_model")
+
+                        if not (fixed_code or fixed_program):
+                            if cloud_only:
+                                console.print("[red]Cloud execution returned no fixed code.[/red]")
+                                raise click.UsageError("Cloud execution returned no fixed code")
+                            console.print("[yellow]Cloud execution returned no fixed code. Falling back to local.[/yellow]")
+                            current_execution_is_local = True
+                        else:
+                            cloud_execution_succeeded = True
+                            success = True
+                            attempts = 1
+
+                            # Fallback if fixed_program is empty but update_program is True
+                            if update_program and not fixed_program.strip():
+                                fixed_program = program_content
+                            if update_code and not fixed_code.strip():
+                                fixed_code = code_content
+
+                            final_code = fixed_code if update_code else code_content
+                            final_program = fixed_program if update_program else program_content
+
+                            # Always set final_code/final_program to something non-empty
+                            if not final_code:
+                                final_code = original_code_content
+                            if not final_program:
+                                final_program = original_program_content
+
+                            code_updated = final_code != original_code_content
+                            program_updated = final_program != original_program_content
+
+                            if verbose:
+                                console.print(Panel(
+                                    f"Cloud crash fix completed. Model: {model}, Cost: ${cost:.6f}",
+                                    title="[green]Cloud Success[/green]",
+                                    expand=False
+                                ))
+
+                    except requests.exceptions.Timeout:
+                        if cloud_only:
+                            console.print(f"[red]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s).[/red]")
+                            raise click.UsageError("Cloud execution timed out")
+                        console.print(f"[yellow]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s). Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+
+                    except requests.exceptions.HTTPError as e:
+                        status_code = e.response.status_code if e.response else 0
+                        err_content = e.response.text[:200] if e.response else "No response content"
+
+                        # Non-recoverable errors: do NOT fall back to local
+                        if status_code == 402:  # Insufficient credits
+                            try:
+                                error_data = e.response.json()
+                                current_balance = error_data.get("currentBalance", "unknown")
+                                estimated_cost = error_data.get("estimatedCost", "unknown")
+                                console.print(f"[red]Insufficient credits. Current balance: {current_balance}, estimated cost: {estimated_cost}[/red]")
+                            except Exception:
+                                console.print(f"[red]Insufficient credits: {err_content}[/red]")
+                            raise click.UsageError("Insufficient credits for cloud crash fix")
+                        elif status_code == 401:  # Authentication error
+                            console.print(f"[red]Authentication failed: {err_content}[/red]")
+                            raise click.UsageError("Cloud authentication failed")
+                        elif status_code == 403:  # Authorization error (not approved)
+                            console.print(f"[red]Access denied: {err_content}[/red]")
+                            raise click.UsageError("Access denied - user not approved")
+                        elif status_code == 400:  # Validation error
+                            console.print(f"[red]Invalid request: {err_content}[/red]")
+                            raise click.UsageError(f"Invalid request: {err_content}")
+                        else:
+                            # Recoverable errors (5xx, unexpected errors): fall back to local
+                            if cloud_only:
+                                console.print(f"[red]Cloud HTTP error ({status_code}): {err_content}[/red]")
+                                raise click.UsageError(f"Cloud HTTP error ({status_code}): {err_content}")
+                            console.print(f"[yellow]Cloud HTTP error ({status_code}): {err_content}. Falling back to local.[/yellow]")
+                            current_execution_is_local = True
+
+                    except requests.exceptions.RequestException as e:
+                        if cloud_only:
+                            console.print(f"[red]Cloud network error: {e}[/red]")
+                            raise click.UsageError(f"Cloud network error: {e}")
+                        console.print(f"[yellow]Cloud network error: {e}. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+
+                    except json.JSONDecodeError:
+                        if cloud_only:
+                            console.print("[red]Cloud returned invalid JSON.[/red]")
+                            raise click.UsageError("Cloud returned invalid JSON")
+                        console.print("[yellow]Cloud returned invalid JSON. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+
+            # Local execution path (when cloud failed/skipped or local preferred)
+            if not cloud_execution_succeeded:
+                if fix_code_module_errors is None:
+                    raise ImportError("fix_code_module_errors is required but not available.")
+
+                if verbose:
+                    console.print(Panel("Performing local crash fix...", title="[blue]Mode[/blue]", expand=False))
+
+                update_program, update_code, fixed_program, fixed_code, _, cost, model = fix_code_module_errors(
+                    program_content, prompt_content, code_content, error_content,
+                    strength, temperature, time_param, verbose,
+                    program_path=program_file,
+                    code_path=code_file,
+                )
+                success = True
+                attempts = 1
+
+                # Fallback if fixed_program is empty but update_program is True
+                if update_program and not fixed_program.strip():
+                    fixed_program = program_content
+                if update_code and not fixed_code.strip():
+                    fixed_code = code_content
+
+                final_code = fixed_code if update_code else code_content
+                final_program = fixed_program if update_program else program_content
+
+                # Always set final_code/final_program to something non-empty
+                if not final_code:
+                    final_code = original_code_content
+                if not final_program:
+                    final_program = original_program_content
+
+                code_updated = final_code != original_code_content
+                program_updated = final_program != original_program_content
 
         output_code_path_str = output_file_paths.get("output")
         output_program_path_str = output_file_paths.get("output_program")
@@ -206,6 +399,9 @@ def crash_main(
     except click.Abort:
         # User cancelled - re-raise to stop the sync loop
         raise
+    except click.UsageError:
+        # Re-raise UsageError for proper CLI handling (e.g., cloud auth failures, insufficient credits)
+        raise
     except Exception as e:
         if not quiet:
             rprint(f"[bold red]An unexpected error occurred:[/bold red] {str(e)}")

pdd/data/llm_model.csv

@@ -1,6 +1,6 @@
 provider,model,input,output,coding_arena_elo,base_url,api_key,max_reasoning_tokens,structured_output,reasoning_type,location
 OpenAI,gpt-5-nano,0.05,0.4,1249,,OPENAI_API_KEY,0,True,none,
-Google,vertex_ai/gemini-3-flash-preview,0.5,3.0,1430,,VERTEX_CREDENTIALS,0,True,effort,
+Google,vertex_ai/gemini-3-flash-preview,0.5,3.0,1430,,VERTEX_CREDENTIALS,0,True,effort,global
 Google,gemini/gemini-3-pro-preview,1.25,10.0,1487,,GEMINI_API_KEY,0,True,effort,
 Google,vertex_ai/claude-sonnet-4-5,3.0,15.0,1370,,VERTEX_CREDENTIALS,128000,True,budget,
 Google,vertex_ai/gemini-3-pro-preview,1.25,10.0,1487,,VERTEX_CREDENTIALS,0,True,effort,
@@ -8,12 +8,12 @@ OpenAI,gpt-5.1-codex-mini,0.25,2.0,1325,,OPENAI_API_KEY,0,True,effort,
 OpenAI,gpt-5.2,1.75,14.0,1486,,OPENAI_API_KEY,0,True,effort,
 OpenAI,gpt-5.1-codex,1.25,10.0,1478,,OPENAI_API_KEY,0,True,effort,
 OpenAI,gpt-5.1-codex-max,1.25,10.0,1480,,OPENAI_API_KEY,0,True,effort,
-Google,vertex_ai/deepseek-ai/deepseek-v3.2-maas,0.28,0.42,1450,,VERTEX_CREDENTIALS,0,False,effort,global
+Google,vertex_ai/deepseek-ai/deepseek-v3.2-maas,0.28,0.42,1450,,VERTEX_CREDENTIALS,0,True,effort,global
 Fireworks,fireworks_ai/accounts/fireworks/models/qwen3-coder-480b-a35b-instruct,0.45,1.80,1363,,FIREWORKS_API_KEY,0,False,none,
-Google,vertex_ai/claude-opus-4-5,5.0,25.0,1465,,VERTEX_CREDENTIALS,128000,True,budget,
+Google,vertex_ai/claude-opus-4-5,5.0,25.0,1465,,VERTEX_CREDENTIALS,128000,True,budget,global
 OpenAI,openai/mlx-community/Qwen3-30B-A3B-4bit,0,0,1040,http://localhost:8080,,0,False,none,
 lm_studio,lm_studio/openai-gpt-oss-120b-mlx-6,0.0001,0,1082,http://localhost:1234/v1,,0,True,effort,
-Fireworks,fireworks_ai/accounts/fireworks/models/glm-4p6,0.55,2.19,1442,,FIREWORKS_API_KEY,0,False,none,
+Fireworks,fireworks_ai/accounts/fireworks/models/glm-4p7,0.60,2.20,1481,,FIREWORKS_API_KEY,0,False,none,
 OpenAI,groq/moonshotai/kimi-k2-instruct-0905,1.0,3.0,1330,,GROQ_API_KEY,0,True,none,
 Anthropic,anthropic/claude-sonnet-4-5-20250929,3.0,15.0,1370,,ANTHROPIC_API_KEY,128000,True,budget,
 Anthropic,anthropic/claude-opus-4-5-20251101,5.0,25.0,1474,,ANTHROPIC_API_KEY,128000,True,budget,