shotgun-sh 0.1.16.dev2__tar.gz → 0.2.0__tar.gz

{shotgun_sh-0.1.16.dev2 → shotgun_sh-0.2.0}/.gitignore

@@ -15,6 +15,9 @@ src/shotgun/build_constants.py
 
 .DS_Store
 
+# Tokenizer model files (downloaded on first use)
+*.model
+
 # Created by https://www.toptal.com/developers/gitignore/api/python,visualstudiocode
 # Edit at https://www.toptal.com/developers/gitignore?templates=python,visualstudiocode
 

{shotgun_sh-0.1.16.dev2 → shotgun_sh-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.16.dev2
+Version: 0.2.0
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun
@@ -23,7 +23,6 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.11
 Requires-Dist: anthropic>=0.39.0
 Requires-Dist: genai-prices>=0.0.27
-Requires-Dist: google-generativeai>=0.8.5
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: kuzu>=0.7.0
@@ -33,6 +32,7 @@ Requires-Dist: packaging>=23.0
 Requires-Dist: posthog>=3.0.0
 Requires-Dist: pydantic-ai>=0.0.14
 Requires-Dist: rich>=13.0.0
+Requires-Dist: sentencepiece>=0.2.0
 Requires-Dist: sentry-sdk[pure-eval]>=2.0.0
 Requires-Dist: textual-dev>=1.7.0
 Requires-Dist: textual>=6.1.0

{shotgun_sh-0.1.16.dev2 → shotgun_sh-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.16.dev2"
+version = "0.2.0"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }
@@ -42,8 +42,8 @@ dependencies = [
     "watchdog>=4.0.0",
     "openai>=1.0.0",
     "anthropic>=0.39.0",
-    "google-generativeai>=0.8.5",
     "tiktoken>=0.7.0",
+    "sentencepiece>=0.2.0",
     "packaging>=23.0",
     "genai-prices>=0.0.27",
 ]

{shotgun_sh-0.1.16.dev2 → shotgun_sh-0.2.0}/src/shotgun/agents/common.py

@@ -18,7 +18,7 @@ from pydantic_ai.messages import (
     ModelRequest,
 )
 
-from shotgun.agents.config import ProviderType, get_config_manager, get_provider_model
+from shotgun.agents.config import ProviderType, get_provider_model
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
@@ -115,14 +115,13 @@ def create_base_agent(
     """
     ensure_shotgun_directory_exists()
 
-    # Get configured model or fall back to hardcoded default
+    # Get configured model or fall back to first available provider
     try:
         model_config = get_provider_model(provider)
-        config_manager = get_config_manager()
-        provider_name = provider or config_manager.load().default_provider
+        provider_name = model_config.provider
         logger.debug(
             "🤖 Creating agent with configured %s model: %s",
-            provider_name.upper(),
+            provider_name.value.upper(),
             model_config.name,
         )
         # Use the Model instance directly (has API key baked in)

shotgun_sh-0.2.0/src/shotgun/agents/config/constants.py

@@ -0,0 +1,33 @@
+"""Configuration constants for Shotgun agents."""
+
+from enum import StrEnum, auto
+
+# Field names
+API_KEY_FIELD = "api_key"
+USER_ID_FIELD = "user_id"
+CONFIG_VERSION_FIELD = "config_version"
+
+
+class ConfigSection(StrEnum):
+    """Configuration file section names (JSON keys)."""
+
+    OPENAI = auto()
+    ANTHROPIC = auto()
+    GOOGLE = auto()
+    SHOTGUN = auto()
+
+
+# Backwards compatibility - deprecated
+OPENAI_PROVIDER = ConfigSection.OPENAI.value
+ANTHROPIC_PROVIDER = ConfigSection.ANTHROPIC.value
+GOOGLE_PROVIDER = ConfigSection.GOOGLE.value
+SHOTGUN_PROVIDER = ConfigSection.SHOTGUN.value
+
+# Environment variable names
+OPENAI_API_KEY_ENV = "OPENAI_API_KEY"
+ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY"
+GEMINI_API_KEY_ENV = "GEMINI_API_KEY"
+SHOTGUN_API_KEY_ENV = "SHOTGUN_API_KEY"
+
+# Token limits
+MEDIUM_TEXT_8K_TOKENS = 8192  # Default max_tokens for web search requests

{shotgun_sh-0.1.16.dev2 → shotgun_sh-0.2.0}/src/shotgun/agents/config/manager.py

@@ -1,7 +1,6 @@
 """Configuration manager for Shotgun CLI."""
 
 import json
-import os
 import uuid
 from pathlib import Path
 from typing import Any
@@ -12,18 +11,24 @@ from shotgun.logging_config import get_logger
 from shotgun.utils import get_shotgun_home
 
 from .constants import (
-    ANTHROPIC_API_KEY_ENV,
-    ANTHROPIC_PROVIDER,
     API_KEY_FIELD,
-    GEMINI_API_KEY_ENV,
-    GOOGLE_PROVIDER,
-    OPENAI_API_KEY_ENV,
-    OPENAI_PROVIDER,
+    ConfigSection,
+)
+from .models import (
+    AnthropicConfig,
+    GoogleConfig,
+    ModelName,
+    OpenAIConfig,
+    ProviderType,
+    ShotgunAccountConfig,
+    ShotgunConfig,
 )
-from .models import ProviderType, ShotgunConfig
 
 logger = get_logger(__name__)
 
+# Type alias for provider configuration objects
+ProviderConfig = OpenAIConfig | AnthropicConfig | GoogleConfig | ShotgunAccountConfig
+
 
 class ConfigManager:
     """Manager for Shotgun configuration."""
@@ -41,13 +46,16 @@ class ConfigManager:
 
         self._config: ShotgunConfig | None = None
 
-    def load(self) -> ShotgunConfig:
+    def load(self, force_reload: bool = True) -> ShotgunConfig:
         """Load configuration from file.
 
+        Args:
+            force_reload: If True, reload from disk even if cached (default: True)
+
         Returns:
             ShotgunConfig: Loaded configuration or default config if file doesn't exist
         """
-        if self._config is not None:
+        if self._config is not None and not force_reload:
             return self._config
 
         if not self.config_path.exists():
@@ -69,20 +77,56 @@ class ConfigManager:
             self._config = ShotgunConfig.model_validate(data)
             logger.debug("Configuration loaded successfully from %s", self.config_path)
 
-            # Check if the default provider has a key, if not find one that does
-            if not self.has_provider_key(self._config.default_provider):
-                original_default = self._config.default_provider
-                # Find first provider with a configured key
-                for provider in ProviderType:
-                    if self.has_provider_key(provider):
+            # Validate selected_model if in BYOK mode (no Shotgun key)
+            if not self._provider_has_api_key(self._config.shotgun):
+                should_save = False
+
+                # If selected_model is set, verify its provider has a key
+                if self._config.selected_model:
+                    from .models import MODEL_SPECS
+
+                    if self._config.selected_model in MODEL_SPECS:
+                        spec = MODEL_SPECS[self._config.selected_model]
+                        if not self.has_provider_key(spec.provider):
+                            logger.info(
+                                "Selected model %s provider has no API key, finding available model",
+                                self._config.selected_model.value,
+                            )
+                            self._config.selected_model = None
+                            should_save = True
+                    else:
                         logger.info(
-                            "Default provider %s has no API key, updating to %s",
-                            original_default.value,
-                            provider.value,
+                            "Selected model %s not found in MODEL_SPECS, resetting",
+                            self._config.selected_model.value,
                         )
-                        self._config.default_provider = provider
-                        self.save(self._config)
-                        break
+                        self._config.selected_model = None
+                        should_save = True
+
+                # If no selected_model or it was invalid, find first available model
+                if not self._config.selected_model:
+                    for provider in ProviderType:
+                        if self.has_provider_key(provider):
+                            # Set to that provider's default model
+                            from .models import MODEL_SPECS, ModelName
+
+                            # Find default model for this provider
+                            provider_models = {
+                                ProviderType.OPENAI: ModelName.GPT_5,
+                                ProviderType.ANTHROPIC: ModelName.CLAUDE_SONNET_4_5,
+                                ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
+                            }
+
+                            if provider in provider_models:
+                                self._config.selected_model = provider_models[provider]
+                                logger.info(
+                                    "Set selected_model to %s (first available provider)",
+                                    self._config.selected_model.value,
+                                )
+                                should_save = True
+                                break
+
+                if should_save:
+                    self.save(self._config)
 
             return self._config
 
@@ -107,7 +151,6 @@ class ConfigManager:
                 # Create a new config with generated user_id
                 config = ShotgunConfig(
                     user_id=str(uuid.uuid4()),
-                    config_version=1,
                 )
 
         # Ensure directory exists
@@ -136,8 +179,13 @@ class ConfigManager:
             **kwargs: Configuration fields to update (only api_key supported)
         """
         config = self.load()
-        provider_enum = self._ensure_provider_enum(provider)
-        provider_config = self._get_provider_config(config, provider_enum)
+
+        # Get provider config and check if it's shotgun
+        provider_config, is_shotgun = self._get_provider_config_and_type(
+            config, provider
+        )
+        # For non-shotgun providers, we need the enum for default provider logic
+        provider_enum = None if is_shotgun else self._ensure_provider_enum(provider)
 
         # Only support api_key updates
         if API_KEY_FIELD in kwargs:
@@ -152,50 +200,65 @@ class ConfigManager:
             raise ValueError(f"Unsupported configuration fields: {unsupported_fields}")
 
         # If no other providers have keys configured and we just added one,
-        # set this provider as the default
-        if API_KEY_FIELD in kwargs and api_key_value is not None:
+        # set selected_model to that provider's default model (only for LLM providers, not shotgun)
+        if not is_shotgun and API_KEY_FIELD in kwargs and api_key_value is not None:
+            # provider_enum is guaranteed to be non-None here since is_shotgun is False
+            if provider_enum is None:
+                raise RuntimeError("Provider enum should not be None for LLM providers")
             other_providers = [p for p in ProviderType if p != provider_enum]
             has_other_keys = any(self.has_provider_key(p) for p in other_providers)
             if not has_other_keys:
-                config.default_provider = provider_enum
+                # Set selected_model to this provider's default model
+                from .models import ModelName
+
+                provider_models = {
+                    ProviderType.OPENAI: ModelName.GPT_5,
+                    ProviderType.ANTHROPIC: ModelName.CLAUDE_SONNET_4_5,
+                    ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
+                }
+                if provider_enum in provider_models:
+                    config.selected_model = provider_models[provider_enum]
 
         self.save(config)
 
     def clear_provider_key(self, provider: ProviderType | str) -> None:
-        """Remove the API key for the given provider."""
+        """Remove the API key for the given provider (LLM provider or shotgun)."""
         config = self.load()
-        provider_enum = self._ensure_provider_enum(provider)
-        provider_config = self._get_provider_config(config, provider_enum)
+
+        # Get provider config (shotgun or LLM provider)
+        provider_config, _ = self._get_provider_config_and_type(config, provider)
+
         provider_config.api_key = None
         self.save(config)
 
+    def update_selected_model(self, model_name: "ModelName") -> None:
+        """Update the selected model.
+
+        Args:
+            model_name: Model to select
+        """
+        config = self.load()
+        config.selected_model = model_name
+        self.save(config)
+
     def has_provider_key(self, provider: ProviderType | str) -> bool:
         """Check if the given provider has a non-empty API key configured.
 
-        This checks both the configuration file and environment variables.
+        This checks only the configuration file.
         """
-        config = self.load()
+        # Use force_reload=False to avoid infinite loop when called from load()
+        config = self.load(force_reload=False)
         provider_enum = self._ensure_provider_enum(provider)
         provider_config = self._get_provider_config(config, provider_enum)
 
-        # Check config first
-        if self._provider_has_api_key(provider_config):
-            return True
-
-        # Check environment variable
-        if provider_enum == ProviderType.OPENAI:
-            return bool(os.getenv(OPENAI_API_KEY_ENV))
-        elif provider_enum == ProviderType.ANTHROPIC:
-            return bool(os.getenv(ANTHROPIC_API_KEY_ENV))
-        elif provider_enum == ProviderType.GOOGLE:
-            return bool(os.getenv(GEMINI_API_KEY_ENV))
-
-        return False
+        return self._provider_has_api_key(provider_config)
 
     def has_any_provider_key(self) -> bool:
         """Determine whether any provider has a configured API key."""
-        config = self.load()
-        return any(
+        # Use force_reload=False to avoid infinite loop when called from load()
+        config = self.load(force_reload=False)
+        # Check LLM provider keys (BYOK)
+        has_llm_key = any(
             self._provider_has_api_key(self._get_provider_config(config, provider))
             for provider in (
                 ProviderType.OPENAI,
@@ -203,6 +266,9 @@ class ConfigManager:
                 ProviderType.GOOGLE,
             )
         )
+        # Also check Shotgun Account key
+        has_shotgun_key = self._provider_has_api_key(config.shotgun)
+        return has_llm_key or has_shotgun_key
 
     def initialize(self) -> ShotgunConfig:
         """Initialize configuration with defaults and save to file.
@@ -213,7 +279,6 @@ class ConfigManager:
         # Generate unique user ID for new config
         config = ShotgunConfig(
             user_id=str(uuid.uuid4()),
-            config_version=1,
         )
         self.save(config)
         logger.info(
@@ -225,26 +290,26 @@ class ConfigManager:
 
     def _convert_secrets_to_secretstr(self, data: dict[str, Any]) -> None:
         """Convert plain text secrets in data to SecretStr objects."""
-        for provider in [OPENAI_PROVIDER, ANTHROPIC_PROVIDER, GOOGLE_PROVIDER]:
-            if provider in data and isinstance(data[provider], dict):
+        for section in ConfigSection:
+            if section.value in data and isinstance(data[section.value], dict):
                 if (
-                    API_KEY_FIELD in data[provider]
-                    and data[provider][API_KEY_FIELD] is not None
+                    API_KEY_FIELD in data[section.value]
+                    and data[section.value][API_KEY_FIELD] is not None
                 ):
-                    data[provider][API_KEY_FIELD] = SecretStr(
-                        data[provider][API_KEY_FIELD]
+                    data[section.value][API_KEY_FIELD] = SecretStr(
+                        data[section.value][API_KEY_FIELD]
                     )
 
     def _convert_secretstr_to_plain(self, data: dict[str, Any]) -> None:
         """Convert SecretStr objects in data to plain text for JSON serialization."""
-        for provider in [OPENAI_PROVIDER, ANTHROPIC_PROVIDER, GOOGLE_PROVIDER]:
-            if provider in data and isinstance(data[provider], dict):
+        for section in ConfigSection:
+            if section.value in data and isinstance(data[section.value], dict):
                 if (
-                    API_KEY_FIELD in data[provider]
-                    and data[provider][API_KEY_FIELD] is not None
+                    API_KEY_FIELD in data[section.value]
+                    and data[section.value][API_KEY_FIELD] is not None
                 ):
-                    if hasattr(data[provider][API_KEY_FIELD], "get_secret_value"):
-                        data[provider][API_KEY_FIELD] = data[provider][
+                    if hasattr(data[section.value][API_KEY_FIELD], "get_secret_value"):
+                        data[section.value][API_KEY_FIELD] = data[section.value][
                             API_KEY_FIELD
                         ].get_secret_value()
 
@@ -279,6 +344,38 @@ class ConfigManager:
 
         return bool(value.strip())
 
+    def _is_shotgun_provider(self, provider: ProviderType | str) -> bool:
+        """Check if provider string represents Shotgun Account.
+
+        Args:
+            provider: Provider type or string
+
+        Returns:
+            True if provider is shotgun account
+        """
+        return (
+            isinstance(provider, str)
+            and provider.lower() == ConfigSection.SHOTGUN.value
+        )
+
+    def _get_provider_config_and_type(
+        self, config: ShotgunConfig, provider: ProviderType | str
+    ) -> tuple[ProviderConfig, bool]:
+        """Get provider config, handling shotgun as special case.
+
+        Args:
+            config: Shotgun configuration
+            provider: Provider type or string
+
+        Returns:
+            Tuple of (provider_config, is_shotgun)
+        """
+        if self._is_shotgun_provider(provider):
+            return (config.shotgun, True)
+
+        provider_enum = self._ensure_provider_enum(provider)
+        return (self._get_provider_config(config, provider_enum), False)
+
     def get_user_id(self) -> str:
         """Get the user ID from configuration.
 
@@ -289,6 +386,17 @@ class ConfigManager:
         return config.user_id
 
 
+# Global singleton instance
+_config_manager_instance: ConfigManager | None = None
+
+
 def get_config_manager() -> ConfigManager:
-    """Get the global ConfigManager instance."""
-    return ConfigManager()
+    """Get the global singleton ConfigManager instance.
+
+    Returns:
+        The singleton ConfigManager instance
+    """
+    global _config_manager_instance
+    if _config_manager_instance is None:
+        _config_manager_instance = ConfigManager()
+    return _config_manager_instance

shotgun_sh-0.2.0/src/shotgun/agents/config/models.py

@@ -0,0 +1,166 @@
+"""Pydantic models for configuration."""
+
+from enum import StrEnum
+
+from pydantic import BaseModel, Field, PrivateAttr, SecretStr
+from pydantic_ai.models import Model
+
+
+class ProviderType(StrEnum):
+    """Provider types for AI services."""
+
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    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: 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: 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
+    _model_instance: Model | None = PrivateAttr(default=None)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @property
+    def model_instance(self) -> Model:
+        """Lazy load the Model instance."""
+        if self._model_instance is None:
+            from .provider import get_or_create_model
+
+            self._model_instance = get_or_create_model(
+                self.provider, self.key_provider, self.name, self.api_key
+            )
+        return self._model_instance
+
+    @property
+    def pydantic_model_name(self) -> str:
+        """Compute the full Pydantic AI model identifier. For backward compatibility."""
+        provider_prefix = {
+            ProviderType.OPENAI: "openai",
+            ProviderType.ANTHROPIC: "anthropic",
+            ProviderType.GOOGLE: "google-gla",
+        }
+        return f"{provider_prefix[self.provider]}:{self.name}"
+
+
+# Model specifications registry (static metadata)
+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",
+    ),
+    ModelName.GPT_5_MINI: ModelSpec(
+        name=ModelName.GPT_5_MINI,
+        provider=ProviderType.OPENAI,
+        max_input_tokens=400_000,
+        max_output_tokens=128_000,
+        litellm_proxy_model_name="openai/gpt-5-mini",
+    ),
+    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",
+    ),
+    ModelName.CLAUDE_SONNET_4_5: ModelSpec(
+        name=ModelName.CLAUDE_SONNET_4_5,
+        provider=ProviderType.ANTHROPIC,
+        max_input_tokens=200_000,
+        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",
+    ),
+    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",
+    ),
+}
+
+
+class OpenAIConfig(BaseModel):
+    """Configuration for OpenAI provider."""
+
+    api_key: SecretStr | None = None
+
+
+class AnthropicConfig(BaseModel):
+    """Configuration for Anthropic provider."""
+
+    api_key: SecretStr | None = None
+
+
+class GoogleConfig(BaseModel):
+    """Configuration for Google provider."""
+
+    api_key: SecretStr | None = None
+
+
+class ShotgunAccountConfig(BaseModel):
+    """Configuration for Shotgun Account (LiteLLM proxy)."""
+
+    api_key: SecretStr | None = None
+
+
+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)
+    shotgun: ShotgunAccountConfig = Field(default_factory=ShotgunAccountConfig)
+    selected_model: ModelName | None = Field(
+        default=None,
+        description="User-selected model",
+    )
+    user_id: str = Field(description="Unique anonymous user identifier")
+    config_version: int = Field(default=2, description="Configuration schema version")