shotgun-sh 0.2.3.dev2__py3-none-any.whl → 0.2.11.dev5__py3-none-any.whl

shotgun/agents/config/models.py

@@ -1,5 +1,6 @@
 """Pydantic models for configuration."""
 
+from datetime import datetime
 from enum import StrEnum
 
 from pydantic import BaseModel, Field, PrivateAttr, SecretStr
@@ -28,6 +29,7 @@ class ModelName(StrEnum):
     GPT_5_MINI = "gpt-5-mini"
     CLAUDE_OPUS_4_1 = "claude-opus-4-1"
     CLAUDE_SONNET_4_5 = "claude-sonnet-4-5"
+    CLAUDE_HAIKU_4_5 = "claude-haiku-4-5"
     GEMINI_2_5_PRO = "gemini-2.5-pro"
     GEMINI_2_5_FLASH = "gemini-2.5-flash"
 
@@ -42,6 +44,7 @@ class ModelSpec(BaseModel):
     litellm_proxy_model_name: (
         str  # LiteLLM format (e.g., "openai/gpt-5", "gemini/gemini-2-pro")
     )
+    short_name: str  # Display name for UI (e.g., "Sonnet 4.5", "GPT-5")
 
 
 class ModelConfig(BaseModel):
@@ -88,6 +91,7 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_input_tokens=400_000,
         max_output_tokens=128_000,
         litellm_proxy_model_name="openai/gpt-5",
+        short_name="GPT-5",
     ),
     ModelName.GPT_5_MINI: ModelSpec(
         name=ModelName.GPT_5_MINI,
@@ -95,6 +99,7 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_input_tokens=400_000,
         max_output_tokens=128_000,
         litellm_proxy_model_name="openai/gpt-5-mini",
+        short_name="GPT-5 Mini",
     ),
     ModelName.CLAUDE_OPUS_4_1: ModelSpec(
         name=ModelName.CLAUDE_OPUS_4_1,
@@ -102,6 +107,7 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_input_tokens=200_000,
         max_output_tokens=32_000,
         litellm_proxy_model_name="anthropic/claude-opus-4-1",
+        short_name="Opus 4.1",
     ),
     ModelName.CLAUDE_SONNET_4_5: ModelSpec(
         name=ModelName.CLAUDE_SONNET_4_5,
@@ -109,6 +115,15 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_input_tokens=200_000,
         max_output_tokens=16_000,
         litellm_proxy_model_name="anthropic/claude-sonnet-4-5",
+        short_name="Sonnet 4.5",
+    ),
+    ModelName.CLAUDE_HAIKU_4_5: ModelSpec(
+        name=ModelName.CLAUDE_HAIKU_4_5,
+        provider=ProviderType.ANTHROPIC,
+        max_input_tokens=200_000,
+        max_output_tokens=64_000,
+        litellm_proxy_model_name="anthropic/claude-haiku-4-5",
+        short_name="Haiku 4.5",
     ),
     ModelName.GEMINI_2_5_PRO: ModelSpec(
         name=ModelName.GEMINI_2_5_PRO,
@@ -116,6 +131,7 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_input_tokens=1_000_000,
         max_output_tokens=64_000,
         litellm_proxy_model_name="gemini/gemini-2.5-pro",
+        short_name="Gemini 2.5 Pro",
     ),
     ModelName.GEMINI_2_5_FLASH: ModelSpec(
         name=ModelName.GEMINI_2_5_FLASH,
@@ -123,6 +139,7 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_input_tokens=1_000_000,
         max_output_tokens=64_000,
         litellm_proxy_model_name="gemini/gemini-2.5-flash",
+        short_name="Gemini 2.5 Flash",
     ),
 }
 
@@ -154,6 +171,21 @@ class ShotgunAccountConfig(BaseModel):
     )
 
 
+class MarketingMessageRecord(BaseModel):
+    """Record of when a marketing message was shown to the user."""
+
+    shown_at: datetime = Field(description="Timestamp when the message was shown")
+
+
+class MarketingConfig(BaseModel):
+    """Configuration for marketing messages shown to users."""
+
+    messages: dict[str, MarketingMessageRecord] = Field(
+        default_factory=dict,
+        description="Tracking which marketing messages have been shown. Key is message ID (e.g., 'github_star_v1')",
+    )
+
+
 class ShotgunConfig(BaseModel):
     """Main configuration for Shotgun CLI."""
 
@@ -168,8 +200,16 @@ class ShotgunConfig(BaseModel):
     shotgun_instance_id: str = Field(
         description="Unique shotgun instance identifier (also used for anonymous telemetry)",
     )
-    config_version: int = Field(default=3, description="Configuration schema version")
+    config_version: int = Field(default=4, description="Configuration schema version")
     shown_welcome_screen: bool = Field(
         default=False,
         description="Whether the welcome screen has been shown to the user",
     )
+    shown_onboarding_popup: datetime | None = Field(
+        default=None,
+        description="Timestamp when the onboarding popup was shown to the user (ISO8601 format)",
+    )
+    marketing: MarketingConfig = Field(
+        default_factory=MarketingConfig,
+        description="Marketing messages configuration and tracking",
+    )

shotgun/agents/config/provider.py

@@ -10,7 +10,10 @@ 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.llm_proxy import (
+    create_anthropic_proxy_provider,
+    create_litellm_provider,
+)
 from shotgun.logging_config import get_logger
 
 from .manager import get_config_manager
@@ -29,6 +32,34 @@ logger = get_logger(__name__)
 _model_cache: dict[tuple[ProviderType, KeyProvider, ModelName, str], Model] = {}
 
 
+def get_default_model_for_provider(config: ShotgunConfig) -> ModelName:
+    """Get the default model based on which provider/account is configured.
+
+    Checks API keys in priority order and returns appropriate default model.
+    Treats Shotgun Account as a provider context.
+
+    Args:
+        config: Shotgun configuration containing API keys
+
+    Returns:
+        Default ModelName for the configured provider/account
+    """
+    # Priority 1: Shotgun Account
+    if _get_api_key(config.shotgun.api_key):
+        return ModelName.GPT_5
+
+    # Priority 2: Individual provider keys
+    if _get_api_key(config.anthropic.api_key):
+        return ModelName.CLAUDE_HAIKU_4_5
+    if _get_api_key(config.openai.api_key):
+        return ModelName.GPT_5
+    if _get_api_key(config.google.api_key):
+        return ModelName.GEMINI_2_5_PRO
+
+    # Fallback: system-wide default
+    return ModelName.CLAUDE_HAIKU_4_5
+
+
 def get_or_create_model(
     provider: ProviderType,
     key_provider: "KeyProvider",
@@ -72,19 +103,37 @@ def get_or_create_model(
 
         # Use LiteLLM proxy for Shotgun Account, native providers for BYOK
         if key_provider == KeyProvider.SHOTGUN:
-            # Shotgun Account uses LiteLLM proxy for any model
+            # Shotgun Account uses LiteLLM proxy with native model types where possible
             if model_name in MODEL_SPECS:
                 litellm_model_name = MODEL_SPECS[model_name].litellm_proxy_model_name
             else:
                 # Fallback for unmapped models
                 litellm_model_name = f"openai/{model_name.value}"
 
-            litellm_provider = create_litellm_provider(api_key)
-            _model_cache[cache_key] = OpenAIChatModel(
-                litellm_model_name,
-                provider=litellm_provider,
-                settings=ModelSettings(max_tokens=max_tokens),
-            )
+            # Use native provider types to preserve API formats and features
+            if provider == ProviderType.ANTHROPIC:
+                # Anthropic: Use native AnthropicProvider with /anthropic endpoint
+                # This preserves Anthropic-specific features like tool_choice
+                # Note: Web search for Shotgun Account uses Gemini only (not Anthropic)
+                # Note: Anthropic API expects model name without prefix (e.g., "claude-sonnet-4-5")
+                anthropic_provider = create_anthropic_proxy_provider(api_key)
+                _model_cache[cache_key] = AnthropicModel(
+                    model_name.value,  # Use model name without "anthropic/" prefix
+                    provider=anthropic_provider,
+                    settings=AnthropicModelSettings(
+                        max_tokens=max_tokens,
+                        timeout=600,  # 10 minutes timeout for large responses
+                    ),
+                )
+            else:
+                # OpenAI and Google: Use LiteLLMProvider (OpenAI-compatible format)
+                # Google's GoogleProvider doesn't support base_url, so use LiteLLM
+                litellm_provider = create_litellm_provider(api_key)
+                _model_cache[cache_key] = OpenAIChatModel(
+                    litellm_model_name,
+                    provider=litellm_provider,
+                    settings=ModelSettings(max_tokens=max_tokens),
+                )
         elif key_provider == KeyProvider.BYOK:
             # Use native provider implementations with user's API keys
             if provider == ProviderType.OPENAI:
@@ -121,7 +170,7 @@ def get_or_create_model(
     return _model_cache[cache_key]
 
 
-def get_provider_model(
+async def get_provider_model(
     provider_or_model: ProviderType | ModelName | None = None,
 ) -> ModelConfig:
     """Get a fully configured ModelConfig with API key and Model instance.
@@ -140,18 +189,24 @@ def get_provider_model(
     """
     config_manager = get_config_manager()
     # Use cached config for read-only access (performance)
-    config = config_manager.load(force_reload=False)
+    config = await 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
+        # Determine which model to use
+        if isinstance(provider_or_model, ModelName):
+            # Specific model requested - honor it (e.g., web search tools)
+            model_name = provider_or_model
+        else:
+            # No specific model requested - use selected or default
+            model_name = config.selected_model or ModelName.GPT_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)
+        # Use Shotgun Account with determined model (provider = actual LLM provider)
         return ModelConfig(
             name=spec.name,
             provider=spec.provider,  # Actual LLM provider (OPENAI/ANTHROPIC/GOOGLE)
@@ -220,8 +275,8 @@ def get_provider_model(
         if not api_key:
             raise ValueError("Anthropic API key not configured. Set via config.")
 
-        # Use requested model or default to claude-sonnet-4-5
-        model_name = requested_model if requested_model else ModelName.CLAUDE_SONNET_4_5
+        # Use requested model or default to claude-haiku-4-5
+        model_name = requested_model if requested_model else ModelName.CLAUDE_HAIKU_4_5
         if model_name not in MODEL_SPECS:
             raise ValueError(f"Model '{model_name.value}' not found")
         spec = MODEL_SPECS[model_name]

shotgun/agents/context_analyzer/__init__.py

@@ -0,0 +1,28 @@
+"""Context analysis module for conversation composition statistics.
+
+This module provides tools for analyzing conversation context usage, breaking down
+token consumption by message type and tool category.
+"""
+
+from .analyzer import ContextAnalyzer
+from .constants import ToolCategory, get_tool_category
+from .formatter import ContextFormatter
+from .models import (
+    ContextAnalysis,
+    ContextAnalysisOutput,
+    ContextCompositionTelemetry,
+    MessageTypeStats,
+    TokenAllocation,
+)
+
+__all__ = [
+    "ContextAnalyzer",
+    "ContextAnalysis",
+    "ContextAnalysisOutput",
+    "ContextCompositionTelemetry",
+    "ContextFormatter",
+    "MessageTypeStats",
+    "TokenAllocation",
+    "ToolCategory",
+    "get_tool_category",
+]