shotgun-sh 0.1.16.dev2__py3-none-any.whl → 0.2.1__py3-none-any.whl

shotgun/agents/config/models.py

@@ -1,16 +1,12 @@
 """Pydantic models for configuration."""
 
-from enum import Enum
-from typing import Any
+from enum import StrEnum
 
 from pydantic import BaseModel, Field, PrivateAttr, SecretStr
-from pydantic_ai.direct import model_request
-from pydantic_ai.messages import ModelMessage, ModelResponse
 from pydantic_ai.models import Model
-from pydantic_ai.settings import ModelSettings
 
 
-class ProviderType(str, Enum):
+class ProviderType(StrEnum):
     """Provider types for AI services."""
 
     OPENAI = "openai"
@@ -18,20 +14,42 @@ class ProviderType(str, Enum):
     GOOGLE = "google"
 
 
+class KeyProvider(StrEnum):
+    """Authentication method for accessing AI models."""
+
+    BYOK = "byok"  # Bring Your Own Key (individual provider keys)
+    SHOTGUN = "shotgun"  # Shotgun Account (unified LiteLLM proxy)
+
+
+class ModelName(StrEnum):
+    """Available AI model names."""
+
+    GPT_5 = "gpt-5"
+    GPT_5_MINI = "gpt-5-mini"
+    CLAUDE_OPUS_4_1 = "claude-opus-4-1"
+    CLAUDE_SONNET_4_5 = "claude-sonnet-4-5"
+    GEMINI_2_5_PRO = "gemini-2.5-pro"
+    GEMINI_2_5_FLASH = "gemini-2.5-flash"
+
+
 class ModelSpec(BaseModel):
     """Static specification for a model - just metadata."""
 
-    name: str  # Model identifier (e.g., "gpt-5", "claude-opus-4-1")
+    name: ModelName  # Model identifier
     provider: ProviderType
     max_input_tokens: int
     max_output_tokens: int
+    litellm_proxy_model_name: (
+        str  # LiteLLM format (e.g., "openai/gpt-5", "gemini/gemini-2-pro")
+    )
 
 
 class ModelConfig(BaseModel):
     """A fully configured model with API key and settings."""
 
-    name: str  # Model identifier (e.g., "gpt-5", "claude-opus-4-1")
-    provider: ProviderType
+    name: ModelName  # Model identifier
+    provider: ProviderType  # Actual LLM provider (openai, anthropic, google)
+    key_provider: KeyProvider  # Authentication method (byok or shotgun)
     max_input_tokens: int
     max_output_tokens: int
     api_key: str
@@ -47,7 +65,7 @@ class ModelConfig(BaseModel):
             from .provider import get_or_create_model
 
             self._model_instance = get_or_create_model(
-                self.provider, self.name, self.api_key
+                self.provider, self.key_provider, self.name, self.api_key
             )
         return self._model_instance
 
@@ -61,54 +79,50 @@ class ModelConfig(BaseModel):
         }
         return f"{provider_prefix[self.provider]}:{self.name}"
 
-    def get_model_settings(self, max_tokens: int | None = None) -> ModelSettings:
-        """Get ModelSettings with optional token override.
-
-        This provides flexibility for specific use cases that need different
-        token limits while defaulting to maximum utilization.
-
-        Args:
-            max_tokens: Optional override for max_tokens. If None, uses max_output_tokens
-
-        Returns:
-            ModelSettings configured with specified or maximum tokens
-        """
-        return ModelSettings(
-            max_tokens=max_tokens if max_tokens is not None else self.max_output_tokens
-        )
-
 
 # Model specifications registry (static metadata)
-MODEL_SPECS: dict[str, ModelSpec] = {
-    "gpt-5": ModelSpec(
-        name="gpt-5",
+MODEL_SPECS: dict[ModelName, ModelSpec] = {
+    ModelName.GPT_5: ModelSpec(
+        name=ModelName.GPT_5,
         provider=ProviderType.OPENAI,
         max_input_tokens=400_000,
         max_output_tokens=128_000,
+        litellm_proxy_model_name="openai/gpt-5",
     ),
-    "gpt-4o": ModelSpec(
-        name="gpt-4o",
+    ModelName.GPT_5_MINI: ModelSpec(
+        name=ModelName.GPT_5_MINI,
         provider=ProviderType.OPENAI,
-        max_input_tokens=128_000,
-        max_output_tokens=16_000,
+        max_input_tokens=400_000,
+        max_output_tokens=128_000,
+        litellm_proxy_model_name="openai/gpt-5-mini",
     ),
-    "claude-opus-4-1": ModelSpec(
-        name="claude-opus-4-1",
+    ModelName.CLAUDE_OPUS_4_1: ModelSpec(
+        name=ModelName.CLAUDE_OPUS_4_1,
         provider=ProviderType.ANTHROPIC,
         max_input_tokens=200_000,
         max_output_tokens=32_000,
+        litellm_proxy_model_name="anthropic/claude-opus-4-1",
     ),
-    "claude-3-5-sonnet-latest": ModelSpec(
-        name="claude-3-5-sonnet-latest",
+    ModelName.CLAUDE_SONNET_4_5: ModelSpec(
+        name=ModelName.CLAUDE_SONNET_4_5,
         provider=ProviderType.ANTHROPIC,
         max_input_tokens=200_000,
-        max_output_tokens=8_192,
+        max_output_tokens=16_000,
+        litellm_proxy_model_name="anthropic/claude-sonnet-4-5",
+    ),
+    ModelName.GEMINI_2_5_PRO: ModelSpec(
+        name=ModelName.GEMINI_2_5_PRO,
+        provider=ProviderType.GOOGLE,
+        max_input_tokens=1_000_000,
+        max_output_tokens=64_000,
+        litellm_proxy_model_name="gemini/gemini-2.5-pro",
     ),
-    "gemini-2.5-pro": ModelSpec(
-        name="gemini-2.5-pro",
+    ModelName.GEMINI_2_5_FLASH: ModelSpec(
+        name=ModelName.GEMINI_2_5_FLASH,
         provider=ProviderType.GOOGLE,
         max_input_tokens=1_000_000,
         max_output_tokens=64_000,
+        litellm_proxy_model_name="gemini/gemini-2.5-flash",
     ),
 }
 
@@ -131,55 +145,31 @@ class GoogleConfig(BaseModel):
     api_key: SecretStr | None = None
 
 
+class ShotgunAccountConfig(BaseModel):
+    """Configuration for Shotgun Account (LiteLLM proxy)."""
+
+    api_key: SecretStr | None = None
+    supabase_jwt: SecretStr | None = Field(
+        default=None, description="Supabase authentication JWT"
+    )
+
+
 class ShotgunConfig(BaseModel):
     """Main configuration for Shotgun CLI."""
 
     openai: OpenAIConfig = Field(default_factory=OpenAIConfig)
     anthropic: AnthropicConfig = Field(default_factory=AnthropicConfig)
     google: GoogleConfig = Field(default_factory=GoogleConfig)
-    default_provider: ProviderType = Field(
-        default=ProviderType.OPENAI, description="Default AI provider to use"
+    shotgun: ShotgunAccountConfig = Field(default_factory=ShotgunAccountConfig)
+    selected_model: ModelName | None = Field(
+        default=None,
+        description="User-selected model",
+    )
+    shotgun_instance_id: str = Field(
+        description="Unique shotgun instance identifier (also used for anonymous telemetry)",
     )
-    user_id: str = Field(description="Unique anonymous user identifier")
-    config_version: int = Field(default=1, description="Configuration schema version")
-
-
-async def shotgun_model_request(
-    model_config: ModelConfig,
-    messages: list[ModelMessage],
-    max_tokens: int | None = None,
-    **kwargs: Any,
-) -> ModelResponse:
-    """Model request wrapper that uses full token capacity by default.
-
-    This wrapper ensures all LLM calls in Shotgun use the maximum available
-    token capacity of each model, improving response quality and completeness.
-    The most common issue this fixes is truncated summaries that were cut off
-    at default token limits (e.g., 4096 for Claude models).
-
-    Args:
-        model_config: ModelConfig instance with model settings and API key
-        messages: Messages to send to the model
-        max_tokens: Optional override for max_tokens. If None, uses model's max_output_tokens
-        **kwargs: Additional arguments passed to model_request
-
-    Returns:
-        ModelResponse from the model
-
-    Example:
-        # Uses full token capacity (e.g., 4096 for Claude, 128k for GPT-5)
-        response = await shotgun_model_request(model_config, messages)
-
-        # Override for specific use case
-        response = await shotgun_model_request(model_config, messages, max_tokens=1000)
-    """
-    # Get properly configured ModelSettings with maximum or overridden token limit
-    model_settings = model_config.get_model_settings(max_tokens)
-
-    # Make the model request with full token utilization
-    return await model_request(
-        model=model_config.model_instance,
-        messages=messages,
-        model_settings=model_settings,
-        **kwargs,
+    config_version: int = Field(default=3, description="Configuration schema version")
+    shown_welcome_screen: bool = Field(
+        default=False,
+        description="Whether the welcome screen has been shown to the user",
     )

shotgun/agents/config/provider.py

@@ -1,7 +1,5 @@
 """Provider management for LLM configuration."""
 
-import os
-
 from pydantic import SecretStr
 from pydantic_ai.models import Model
 from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
@@ -12,27 +10,36 @@ from pydantic_ai.providers.google import GoogleProvider
 from pydantic_ai.providers.openai import OpenAIProvider
 from pydantic_ai.settings import ModelSettings
 
+from shotgun.llm_proxy import create_litellm_provider
 from shotgun.logging_config import get_logger
 
-from .constants import (
-    ANTHROPIC_API_KEY_ENV,
-    GEMINI_API_KEY_ENV,
-    OPENAI_API_KEY_ENV,
-)
 from .manager import get_config_manager
-from .models import MODEL_SPECS, ModelConfig, ProviderType
+from .models import (
+    MODEL_SPECS,
+    KeyProvider,
+    ModelConfig,
+    ModelName,
+    ProviderType,
+    ShotgunConfig,
+)
 
 logger = get_logger(__name__)
 
 # Global cache for Model instances (singleton pattern)
-_model_cache: dict[tuple[ProviderType, str, str], Model] = {}
+_model_cache: dict[tuple[ProviderType, KeyProvider, ModelName, str], Model] = {}
 
 
-def get_or_create_model(provider: ProviderType, model_name: str, api_key: str) -> Model:
+def get_or_create_model(
+    provider: ProviderType,
+    key_provider: "KeyProvider",
+    model_name: ModelName,
+    api_key: str,
+) -> Model:
     """Get or create a singleton Model instance.
 
     Args:
-        provider: Provider type
+        provider: Actual LLM provider (openai, anthropic, google)
+        key_provider: Authentication method (byok or shotgun)
         model_name: Name of the model
         api_key: API key for the provider
 
@@ -42,66 +49,88 @@ def get_or_create_model(provider: ProviderType, model_name: str, api_key: str) -
     Raises:
         ValueError: If provider is not supported
     """
-    cache_key = (provider, model_name, api_key)
+    cache_key = (provider, key_provider, model_name, api_key)
 
     if cache_key not in _model_cache:
-        logger.debug("Creating new %s model instance: %s", provider.value, model_name)
+        logger.debug(
+            "Creating new %s model instance via %s: %s",
+            provider.value,
+            key_provider.value,
+            model_name,
+        )
 
-        if provider == ProviderType.OPENAI:
-            # Get max_tokens from MODEL_SPECS to use full capacity
+        # Get max_tokens from MODEL_SPECS
+        if model_name in MODEL_SPECS:
+            max_tokens = MODEL_SPECS[model_name].max_output_tokens
+        else:
+            # Fallback defaults based on provider
+            max_tokens = {
+                ProviderType.OPENAI: 16_000,
+                ProviderType.ANTHROPIC: 32_000,
+                ProviderType.GOOGLE: 64_000,
+            }.get(provider, 16_000)
+
+        # Use LiteLLM proxy for Shotgun Account, native providers for BYOK
+        if key_provider == KeyProvider.SHOTGUN:
+            # Shotgun Account uses LiteLLM proxy for any model
             if model_name in MODEL_SPECS:
-                max_tokens = MODEL_SPECS[model_name].max_output_tokens
+                litellm_model_name = MODEL_SPECS[model_name].litellm_proxy_model_name
             else:
-                max_tokens = 16_000  # Default for GPT models
+                # Fallback for unmapped models
+                litellm_model_name = f"openai/{model_name.value}"
 
-            openai_provider = OpenAIProvider(api_key=api_key)
+            litellm_provider = create_litellm_provider(api_key)
             _model_cache[cache_key] = OpenAIChatModel(
-                model_name,
-                provider=openai_provider,
+                litellm_model_name,
+                provider=litellm_provider,
                 settings=ModelSettings(max_tokens=max_tokens),
             )
-        elif provider == ProviderType.ANTHROPIC:
-            # Get max_tokens from MODEL_SPECS to use full capacity
-            if model_name in MODEL_SPECS:
-                max_tokens = MODEL_SPECS[model_name].max_output_tokens
+        elif key_provider == KeyProvider.BYOK:
+            # Use native provider implementations with user's API keys
+            if provider == ProviderType.OPENAI:
+                openai_provider = OpenAIProvider(api_key=api_key)
+                _model_cache[cache_key] = OpenAIChatModel(
+                    model_name,
+                    provider=openai_provider,
+                    settings=ModelSettings(max_tokens=max_tokens),
+                )
+            elif provider == ProviderType.ANTHROPIC:
+                anthropic_provider = AnthropicProvider(api_key=api_key)
+                _model_cache[cache_key] = AnthropicModel(
+                    model_name,
+                    provider=anthropic_provider,
+                    settings=AnthropicModelSettings(
+                        max_tokens=max_tokens,
+                        timeout=600,  # 10 minutes timeout for large responses
+                    ),
+                )
+            elif provider == ProviderType.GOOGLE:
+                google_provider = GoogleProvider(api_key=api_key)
+                _model_cache[cache_key] = GoogleModel(
+                    model_name,
+                    provider=google_provider,
+                    settings=ModelSettings(max_tokens=max_tokens),
+                )
             else:
-                max_tokens = 32_000  # Default for Claude models
-
-            anthropic_provider = AnthropicProvider(api_key=api_key)
-            _model_cache[cache_key] = AnthropicModel(
-                model_name,
-                provider=anthropic_provider,
-                settings=AnthropicModelSettings(
-                    max_tokens=max_tokens,
-                    timeout=600,  # 10 minutes timeout for large responses
-                ),
-            )
-        elif provider == ProviderType.GOOGLE:
-            # Get max_tokens from MODEL_SPECS to use full capacity
-            if model_name in MODEL_SPECS:
-                max_tokens = MODEL_SPECS[model_name].max_output_tokens
-            else:
-                max_tokens = 64_000  # Default for Gemini models
-
-            google_provider = GoogleProvider(api_key=api_key)
-            _model_cache[cache_key] = GoogleModel(
-                model_name,
-                provider=google_provider,
-                settings=ModelSettings(max_tokens=max_tokens),
-            )
+                raise ValueError(f"Unsupported provider: {provider}")
         else:
-            raise ValueError(f"Unsupported provider: {provider}")
+            raise ValueError(f"Unsupported key provider: {key_provider}")
     else:
         logger.debug("Reusing cached %s model instance: %s", provider.value, model_name)
 
     return _model_cache[cache_key]
 
 
-def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
+def get_provider_model(
+    provider_or_model: ProviderType | ModelName | None = None,
+) -> ModelConfig:
     """Get a fully configured ModelConfig with API key and Model instance.
 
     Args:
-        provider: Provider to get model for. If None, uses default provider
+        provider_or_model: Either a ProviderType, ModelName, or None.
+            - If ModelName: returns that specific model with appropriate API key
+            - If ProviderType: returns default model for that provider (backward compatible)
+            - If None: uses default provider with its default model
 
     Returns:
         ModelConfig with API key configured and lazy Model instance
@@ -110,77 +139,119 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
         ValueError: If provider is not configured properly or model not found
     """
     config_manager = get_config_manager()
-    config = config_manager.load()
-    # Convert string to ProviderType enum if needed
-    provider_enum = (
-        provider
-        if isinstance(provider, ProviderType)
-        else ProviderType(provider)
-        if provider
-        else config.default_provider
-    )
+    # Use cached config for read-only access (performance)
+    config = config_manager.load(force_reload=False)
+
+    # Priority 1: Check if Shotgun key exists - if so, use it for ANY model
+    shotgun_api_key = _get_api_key(config.shotgun.api_key)
+    if shotgun_api_key:
+        # Use selected model or default to claude-sonnet-4-5
+        model_name = config.selected_model or ModelName.CLAUDE_SONNET_4_5
+        if model_name not in MODEL_SPECS:
+            raise ValueError(f"Model '{model_name.value}' not found")
+        spec = MODEL_SPECS[model_name]
+
+        # Use Shotgun Account with selected model (provider = actual LLM provider)
+        return ModelConfig(
+            name=spec.name,
+            provider=spec.provider,  # Actual LLM provider (OPENAI/ANTHROPIC/GOOGLE)
+            key_provider=KeyProvider.SHOTGUN,  # Authenticated via Shotgun Account
+            max_input_tokens=spec.max_input_tokens,
+            max_output_tokens=spec.max_output_tokens,
+            api_key=shotgun_api_key,
+        )
+
+    # Priority 2: Fall back to individual provider keys
+
+    # Check if a specific model was requested
+    if isinstance(provider_or_model, ModelName):
+        # Look up the model spec
+        if provider_or_model not in MODEL_SPECS:
+            raise ValueError(f"Model '{provider_or_model.value}' not found")
+        spec = MODEL_SPECS[provider_or_model]
+        provider_enum = spec.provider
+        requested_model = provider_or_model
+    else:
+        # Convert string to ProviderType enum if needed (backward compatible)
+        if provider_or_model:
+            provider_enum = (
+                provider_or_model
+                if isinstance(provider_or_model, ProviderType)
+                else ProviderType(provider_or_model)
+            )
+        else:
+            # No provider specified - find first available provider with a key
+            provider_enum = None
+            for provider in ProviderType:
+                if _has_provider_key(config, provider):
+                    provider_enum = provider
+                    break
+
+            if provider_enum is None:
+                raise ValueError(
+                    "No provider keys configured. Set via environment variables or config."
+                )
+
+        requested_model = None  # Will use provider's default model
 
     if provider_enum == ProviderType.OPENAI:
-        api_key = _get_api_key(config.openai.api_key, OPENAI_API_KEY_ENV)
+        api_key = _get_api_key(config.openai.api_key)
         if not api_key:
-            raise ValueError(
-                f"OpenAI API key not configured. Set via environment variable {OPENAI_API_KEY_ENV} or config."
-            )
+            raise ValueError("OpenAI API key not configured. Set via config.")
 
-        # Get model spec - hardcoded to gpt-5
-        model_name = "gpt-5"
+        # Use requested model or default to gpt-5
+        model_name = requested_model if requested_model else ModelName.GPT_5
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name}' not found")
+            raise ValueError(f"Model '{model_name.value}' not found")
         spec = MODEL_SPECS[model_name]
 
         # Create fully configured ModelConfig
         return ModelConfig(
             name=spec.name,
             provider=spec.provider,
+            key_provider=KeyProvider.BYOK,
             max_input_tokens=spec.max_input_tokens,
             max_output_tokens=spec.max_output_tokens,
             api_key=api_key,
         )
 
     elif provider_enum == ProviderType.ANTHROPIC:
-        api_key = _get_api_key(config.anthropic.api_key, ANTHROPIC_API_KEY_ENV)
+        api_key = _get_api_key(config.anthropic.api_key)
         if not api_key:
-            raise ValueError(
-                f"Anthropic API key not configured. Set via environment variable {ANTHROPIC_API_KEY_ENV} or config."
-            )
+            raise ValueError("Anthropic API key not configured. Set via config.")
 
-        # Get model spec - hardcoded to claude-opus-4-1
-        model_name = "claude-opus-4-1"
+        # Use requested model or default to claude-sonnet-4-5
+        model_name = requested_model if requested_model else ModelName.CLAUDE_SONNET_4_5
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name}' not found")
+            raise ValueError(f"Model '{model_name.value}' not found")
         spec = MODEL_SPECS[model_name]
 
         # Create fully configured ModelConfig
         return ModelConfig(
             name=spec.name,
             provider=spec.provider,
+            key_provider=KeyProvider.BYOK,
             max_input_tokens=spec.max_input_tokens,
             max_output_tokens=spec.max_output_tokens,
             api_key=api_key,
         )
 
     elif provider_enum == ProviderType.GOOGLE:
-        api_key = _get_api_key(config.google.api_key, GEMINI_API_KEY_ENV)
+        api_key = _get_api_key(config.google.api_key)
         if not api_key:
-            raise ValueError(
-                f"Gemini API key not configured. Set via environment variable {GEMINI_API_KEY_ENV} or config."
-            )
+            raise ValueError("Gemini API key not configured. Set via config.")
 
-        # Get model spec - hardcoded to gemini-2.5-pro
-        model_name = "gemini-2.5-pro"
+        # Use requested model or default to gemini-2.5-pro
+        model_name = requested_model if requested_model else ModelName.GEMINI_2_5_PRO
         if model_name not in MODEL_SPECS:
-            raise ValueError(f"Model '{model_name}' not found")
+            raise ValueError(f"Model '{model_name.value}' not found")
         spec = MODEL_SPECS[model_name]
 
         # Create fully configured ModelConfig
         return ModelConfig(
             name=spec.name,
             provider=spec.provider,
+            key_provider=KeyProvider.BYOK,
             max_input_tokens=spec.max_input_tokens,
             max_output_tokens=spec.max_output_tokens,
             api_key=api_key,
@@ -190,12 +261,30 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
         raise ValueError(f"Unsupported provider: {provider_enum}")
 
 
-def _get_api_key(config_key: SecretStr | None, env_var: str) -> str | None:
-    """Get API key from config or environment variable.
+def _has_provider_key(config: "ShotgunConfig", provider: ProviderType) -> bool:
+    """Check if a provider has a configured API key.
+
+    Args:
+        config: Shotgun configuration
+        provider: Provider to check
+
+    Returns:
+        True if provider has a configured API key
+    """
+    if provider == ProviderType.OPENAI:
+        return bool(_get_api_key(config.openai.api_key))
+    elif provider == ProviderType.ANTHROPIC:
+        return bool(_get_api_key(config.anthropic.api_key))
+    elif provider == ProviderType.GOOGLE:
+        return bool(_get_api_key(config.google.api_key))
+    return False
+
+
+def _get_api_key(config_key: SecretStr | None) -> str | None:
+    """Get API key from config.
 
     Args:
         config_key: API key from configuration
-        env_var: Environment variable name to check
 
     Returns:
         API key string or None
@@ -203,4 +292,4 @@ def _get_api_key(config_key: SecretStr | None, env_var: str) -> str | None:
     if config_key is not None:
         return config_key.get_secret_value()
 
-    return os.getenv(env_var)
+    return None

shotgun/agents/history/compaction.py

@@ -31,7 +31,7 @@ async def apply_persistent_compaction(
 
     try:
         # Count actual token usage using shared utility
-        estimated_tokens = estimate_tokens_from_messages(messages, deps.llm_model)
+        estimated_tokens = await estimate_tokens_from_messages(messages, deps.llm_model)
 
         # Create minimal usage info for compaction check
         usage = RequestUsage(