gac 3.6.0__py3-none-any.whl → 3.10.10__py3-none-any.whl

gac/model_cli.py

@@ -2,6 +2,7 @@
 
 import os
 from pathlib import Path
+from typing import cast
 
 import click
 import questionary
@@ -61,7 +62,7 @@ def _prompt_required_text(prompt: str) -> str | None:
             return None
         value = response.strip()
         if value:
-            return value  # type: ignore[no-any-return]
+            return cast(str, value)
         click.echo("A value is required. Please try again.")
 
 
@@ -84,7 +85,7 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
         ("Azure OpenAI", "gpt-5-mini"),
         ("Cerebras", "zai-glm-4.6"),
         ("Chutes", "zai-org/GLM-4.6-FP8"),
-        ("Claude Code", "claude-sonnet-4-5"),
+        ("Claude Code (OAuth)", "claude-sonnet-4-5"),
         ("Custom (Anthropic)", ""),
         ("Custom (OpenAI)", ""),
         ("DeepSeek", "deepseek-chat"),
@@ -99,6 +100,7 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
         ("Ollama", "gemma3"),
         ("OpenAI", "gpt-5-mini"),
         ("OpenRouter", "openrouter/auto"),
+        ("Qwen.ai (OAuth)", "qwen3-coder-plus"),
         ("Replicate", "openai/gpt-oss-120b"),
         ("Streamlake", ""),
         ("Synthetic.new", "hf:zai-org/GLM-4.6"),
@@ -116,22 +118,27 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
     provider_key = provider.lower().replace(".", "").replace(" ", "-").replace("(", "").replace(")", "")
 
     is_azure_openai = provider_key == "azure-openai"
-    is_claude_code = provider_key == "claude-code"
+    is_claude_code = provider_key == "claude-code-oauth"
     is_custom_anthropic = provider_key == "custom-anthropic"
     is_custom_openai = provider_key == "custom-openai"
     is_lmstudio = provider_key == "lm-studio"
     is_ollama = provider_key == "ollama"
+    is_qwen = provider_key == "qwenai-oauth"
     is_streamlake = provider_key == "streamlake"
     is_zai = provider_key in ("zai", "zai-coding")
 
-    if provider_key == "minimaxio":
+    if provider_key == "claude-code-oauth":
+        provider_key = "claude-code"
+    elif provider_key == "kimi-for-coding":
+        provider_key = "kimi-coding"
+    elif provider_key == "minimaxio":
         provider_key = "minimax"
-    elif provider_key == "syntheticnew":
-        provider_key = "synthetic"
     elif provider_key == "moonshot-ai":
         provider_key = "moonshot"
-    elif provider_key == "kimi-for-coding":
-        provider_key = "kimi-coding"
+    elif provider_key == "qwenai-oauth":
+        provider_key = "qwen"
+    elif provider_key == "syntheticnew":
+        provider_key = "synthetic"
 
     if is_streamlake:
         endpoint_id = _prompt_required_text("Enter the Streamlake inference endpoint ID (required):")
@@ -269,10 +276,12 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
 
     # Handle Claude Code OAuth separately
     if is_claude_code:
-        from gac.oauth.claude_code import authenticate_and_save, load_stored_token
+        from gac.oauth.claude_code import authenticate_and_save
+        from gac.oauth.token_store import TokenStore
 
-        existing_token = load_stored_token()
-        if existing_token:
+        token_store = TokenStore()
+        existing_token_data = token_store.get_token("claude-code")
+        if existing_token_data:
             click.echo("\n✓ Claude Code access token already configured.")
             action = questionary.select(
                 "What would you like to do?",
@@ -305,6 +314,53 @@ def _configure_model(existing_env: dict[str, str]) -> bool:
                 return False
             return True
 
+    # Handle Qwen OAuth separately
+    if is_qwen:
+        from gac.oauth import QwenOAuthProvider, TokenStore
+
+        token_store = TokenStore()
+        qwen_token = token_store.get_token("qwen")
+        if qwen_token:
+            click.echo("\n✓ Qwen access token already configured.")
+            action = questionary.select(
+                "What would you like to do?",
+                choices=[
+                    "Keep existing token",
+                    "Re-authenticate (get new token)",
+                ],
+                use_shortcuts=True,
+                use_arrow_keys=True,
+                use_jk_keys=False,
+            ).ask()
+
+            if action is None or action.startswith("Keep existing"):
+                if action is None:
+                    click.echo("Qwen configuration cancelled. Keeping existing token.")
+                else:
+                    click.echo("Keeping existing Qwen token")
+                return True
+            else:
+                click.echo("\n🔐 Starting Qwen OAuth authentication...")
+                provider = QwenOAuthProvider(token_store)
+                try:
+                    provider.initiate_auth(open_browser=True)
+                    click.echo("✅ Qwen authentication completed successfully!")
+                    return True
+                except Exception as e:
+                    click.echo(f"❌ Qwen authentication failed: {e}")
+                    return False
+        else:
+            click.echo("\n🔐 Starting Qwen OAuth authentication...")
+            click.echo("   (Your browser will open automatically)\n")
+            provider = QwenOAuthProvider(token_store)
+            try:
+                provider.initiate_auth(open_browser=True)
+                click.echo("\n✅ Qwen authentication completed successfully!")
+                return True
+            except Exception as e:
+                click.echo(f"\n❌ Qwen authentication failed: {e}")
+                return False
+
     # Determine API key name based on provider
     if is_lmstudio:
         api_key_name = "LMSTUDIO_API_KEY"

gac/model_identifier.py

@@ -0,0 +1,70 @@
+"""Model identifier value object for parsing and validating model strings."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from gac.errors import ConfigError
+
+
+@dataclass(frozen=True)
+class ModelIdentifier:
+    """Represents a parsed model identifier in the format 'provider:model_name'.
+
+    This is an immutable value object that ensures model identifiers are
+    properly validated and provides convenient access to the components.
+
+    Attributes:
+        provider: The provider name (e.g., 'openai', 'anthropic', 'claude-code')
+        model_name: The model name (e.g., 'gpt-4o-mini', 'claude-haiku-4-5')
+    """
+
+    provider: str
+    model_name: str
+
+    @classmethod
+    def parse(cls, model_string: str) -> ModelIdentifier:
+        """Parse a model string into a ModelIdentifier.
+
+        Args:
+            model_string: A string in the format 'provider:model_name'
+
+        Returns:
+            A ModelIdentifier instance
+
+        Raises:
+            ConfigError: If the format is invalid or components are empty
+        """
+        normalized = model_string.strip()
+
+        if ":" not in normalized:
+            raise ConfigError(
+                f"Invalid model format: '{model_string}'. Expected 'provider:model', "
+                "e.g. 'openai:gpt-4o-mini'. Use 'gac config set model <provider:model>' "
+                "to update your configuration."
+            )
+
+        provider, model_name = normalized.split(":", 1)
+
+        if not provider or not model_name:
+            raise ConfigError(
+                f"Invalid model format: '{model_string}'. Both provider and model name "
+                "are required (example: 'anthropic:claude-haiku-4-5')."
+            )
+
+        return cls(provider=provider, model_name=model_name)
+
+    def __str__(self) -> str:
+        """Return the canonical string representation."""
+        return f"{self.provider}:{self.model_name}"
+
+    def starts_with_provider(self, prefix: str) -> bool:
+        """Check if the provider starts with the given prefix.
+
+        Args:
+            prefix: The prefix to check (e.g., 'claude-code', 'qwen')
+
+        Returns:
+            True if the provider matches or the full identifier starts with prefix
+        """
+        return self.provider == prefix or str(self).startswith(f"{prefix}:")

gac/oauth/__init__.py

@@ -1 +1,27 @@
 """OAuth authentication utilities for GAC."""
+
+from .claude_code import (
+    authenticate_and_save,
+    is_token_expired,
+    load_stored_token,
+    perform_oauth_flow,
+    refresh_token_if_expired,
+    remove_token,
+    save_token,
+)
+from .qwen_oauth import QwenDeviceFlow, QwenOAuthProvider
+from .token_store import OAuthToken, TokenStore
+
+__all__ = [
+    "authenticate_and_save",
+    "is_token_expired",
+    "load_stored_token",
+    "OAuthToken",
+    "perform_oauth_flow",
+    "QwenDeviceFlow",
+    "QwenOAuthProvider",
+    "refresh_token_if_expired",
+    "remove_token",
+    "save_token",
+    "TokenStore",
+]

gac/oauth/claude_code.py

@@ -12,12 +12,14 @@ import time
 import webbrowser
 from dataclasses import dataclass
 from http.server import BaseHTTPRequestHandler, HTTPServer
-from pathlib import Path
-from typing import Any, TypedDict
+from typing import Any, TypedDict, cast
 from urllib.parse import parse_qs, urlencode, urlparse
 
 import httpx
 
+from gac.oauth.token_store import OAuthToken, TokenStore
+from gac.utils import get_ssl_verify
+
 logger = logging.getLogger(__name__)
 
 
@@ -250,6 +252,7 @@ def exchange_code_for_tokens(auth_code: str, context: OAuthContext) -> dict[str,
             json=payload,
             headers=headers,
             timeout=30,
+            verify=get_ssl_verify(),
         )
         logger.info("Token exchange response: %s", response.status_code)
         if response.status_code == 200:
@@ -328,7 +331,7 @@ def perform_oauth_flow(quiet: bool = False) -> dict[str, Any] | None:
         print("✓ Authorization code received")
         print("  Exchanging for access token...\n")
 
-    tokens = exchange_code_for_tokens(result.code, context)  # type: ignore[arg-type]
+    tokens = exchange_code_for_tokens(cast(str, result.code), context)
     if not tokens:
         if not quiet:
             print("❌ Token exchange failed. Please try again.")
@@ -340,32 +343,82 @@ def perform_oauth_flow(quiet: bool = False) -> dict[str, Any] | None:
     return tokens
 
 
-def get_token_storage_path() -> Path:
-    """Get path for storing OAuth tokens."""
-    return Path.home() / ".gac.env"
+def load_stored_token() -> str | None:
+    """Load stored access token from token store."""
+    store = TokenStore()
+    token = store.get_token("claude-code")
+    if token:
+        return token.get("access_token")
+    return None
 
 
-def load_stored_token() -> str | None:
-    """Load stored access token from .gac.env."""
-    from dotenv import dotenv_values
+def is_token_expired() -> bool:
+    """Check if the stored Claude Code token has expired.
 
-    env_path = get_token_storage_path()
-    if not env_path.exists():
-        return None
+    Returns True if the token is expired or close to expiring (within 5 minutes).
+    """
+    store = TokenStore()
+    token = store.get_token("claude-code")
+    if not token:
+        return True
+
+    expiry = token.get("expiry")
+    if not expiry:
+        # No expiry information, assume it's still valid
+        return False
 
-    env_vars = dotenv_values(str(env_path))
-    return env_vars.get("CLAUDE_CODE_ACCESS_TOKEN")
+    # Consider token expired if it expires within 5 minutes
+    current_time = time.time()
+    return current_time >= (expiry - 300)
 
 
-def save_token(access_token: str) -> bool:
-    """Save access token to .gac.env and update environment."""
-    import os
+def refresh_token_if_expired(quiet: bool = True) -> bool:
+    """Refresh the Claude Code token if it has expired.
+
+    Args:
+        quiet: If True, suppress output messages
+
+    Returns:
+        True if token is valid (or was successfully refreshed), False otherwise
+    """
+    if not is_token_expired():
+        return True
+
+    if not quiet:
+        logger.info("Claude Code token expired, attempting to refresh...")
 
-    from dotenv import set_key
+    # Perform OAuth flow to get a new token
+    success = authenticate_and_save(quiet=quiet)
+    if not success and not quiet:
+        logger.error("Failed to refresh Claude Code token")
 
-    env_path = get_token_storage_path()
+    return success
+
+
+def save_token(access_token: str, token_data: dict[str, Any] | None = None) -> bool:
+    """Save access token to token store.
+
+    Args:
+        access_token: The OAuth access token string
+        token_data: Optional full token response data (includes expiry info)
+    """
+    import os
+
+    store = TokenStore()
     try:
-        set_key(str(env_path), "CLAUDE_CODE_ACCESS_TOKEN", access_token)
+        token: OAuthToken = {
+            "access_token": access_token,
+            "token_type": "Bearer",
+        }
+
+        # Add expiry information if available
+        if token_data:
+            if "expires_at" in token_data:
+                token["expiry"] = int(token_data["expires_at"])
+            elif "expires_in" in token_data:
+                token["expiry"] = int(time.time() + token_data["expires_in"])
+
+        store.save_token("claude-code", token)
         # Also update the current environment so the token is immediately available
         os.environ["CLAUDE_CODE_ACCESS_TOKEN"] = access_token
         return True
@@ -374,6 +427,20 @@ def save_token(access_token: str) -> bool:
         return False
 
 
+def remove_token() -> bool:
+    """Remove stored access token from token store."""
+    import os
+
+    store = TokenStore()
+    try:
+        store.remove_token("claude-code")
+        os.environ.pop("CLAUDE_CODE_ACCESS_TOKEN", None)
+        return True
+    except Exception as exc:
+        logger.error("Failed to remove token: %s", exc)
+        return False
+
+
 def authenticate_and_save(quiet: bool = False) -> bool:
     """Perform OAuth flow and save token."""
     tokens = perform_oauth_flow(quiet=quiet)
@@ -386,12 +453,12 @@ def authenticate_and_save(quiet: bool = False) -> bool:
             print("❌ No access token returned from authentication")
         return False
 
-    if not save_token(access_token):
+    if not save_token(access_token, token_data=tokens):
         if not quiet:
             print("❌ Failed to save access token")
         return False
 
     if not quiet:
-        print(f"✓ Access token saved to {get_token_storage_path()}")
+        print("✓ Access token saved to ~/.gac/oauth/claude-code.json")
 
     return True