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

shotgun/agents/common.py

@@ -1,14 +1,11 @@
 """Common utilities for agent creation and management."""
 
-import asyncio
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 from pydantic_ai import (
     Agent,
-    DeferredToolRequests,
-    DeferredToolResults,
     RunContext,
     UsageLimits,
 )
@@ -19,20 +16,19 @@ from pydantic_ai.messages import (
 )
 
 from shotgun.agents.config import ProviderType, get_provider_model
-from shotgun.agents.models import AgentType
+from shotgun.agents.models import AgentResponse, AgentType
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
 from shotgun.sdk.services import get_codebase_service
 from shotgun.utils import ensure_shotgun_directory_exists
+from shotgun.utils.datetime_utils import get_datetime_context
 from shotgun.utils.file_system_utils import get_shotgun_base_path
 
 from .history import token_limit_compactor
-from .history.compaction import apply_persistent_compaction
 from .messages import AgentSystemPrompt, SystemStatusPrompt
 from .models import AgentDeps, AgentRuntimeOptions, PipelineConfigEntry
 from .tools import (
     append_file,
-    ask_user,
     codebase_shell,
     directory_lister,
     file_read,
@@ -74,12 +70,18 @@ async def add_system_status_message(
     # Extract table of contents from the agent's markdown file
     markdown_toc = extract_markdown_toc(deps.agent_mode)
 
+    # Get current datetime with timezone information
+    dt_context = get_datetime_context()
+
     system_state = prompt_loader.render(
         "agents/state/system_state.j2",
         codebase_understanding_graphs=codebase_understanding_graphs,
         is_tui_context=deps.is_tui_context,
         existing_files=existing_files,
         markdown_toc=markdown_toc,
+        current_datetime=dt_context.datetime_formatted,
+        timezone_name=dt_context.timezone_name,
+        utc_offset=dt_context.utc_offset,
     )
 
     message_history.append(
@@ -99,7 +101,7 @@ def create_base_agent(
     additional_tools: list[Any] | None = None,
     provider: ProviderType | None = None,
     agent_mode: AgentType | None = None,
-) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
+) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a base agent with common configuration.
 
     Args:
@@ -157,7 +159,7 @@ def create_base_agent(
 
     agent = Agent(
         model,
-        output_type=[str, DeferredToolRequests],
+        output_type=AgentResponse,
         deps_type=AgentDeps,
         instrument=True,
         history_processors=[history_processor],
@@ -172,11 +174,6 @@ def create_base_agent(
     for tool in additional_tools or []:
         agent.tool_plain(tool)
 
-    # Register interactive tool conditionally based on deps
-    if deps.interactive_mode:
-        agent.tool(ask_user)
-        logger.debug("📞 Interactive mode enabled - ask_user tool registered")
-
     # Register common file management tools (always available)
     agent.tool(write_file)
     agent.tool(append_file)
@@ -316,7 +313,9 @@ def extract_markdown_toc(agent_mode: AgentType | None) -> str | None:
         if prior_toc:
             # Add section with XML tags
             toc_sections.append(
-                f'<TABLE_OF_CONTENTS file_name="{prior_file}">\n{prior_toc}\n</TABLE_OF_CONTENTS>'
+                f'<TABLE_OF_CONTENTS file_name="{prior_file}">\n'
+                f"{prior_toc}\n"
+                f"</TABLE_OF_CONTENTS>"
             )
 
     # Extract TOC from own file (full detail)
@@ -327,7 +326,9 @@ def extract_markdown_toc(agent_mode: AgentType | None) -> str | None:
             # Put own file TOC at the beginning with XML tags
             toc_sections.insert(
                 0,
-                f'<TABLE_OF_CONTENTS file_name="{config.own_file}">\n{own_toc}\n</TABLE_OF_CONTENTS>',
+                f'<TABLE_OF_CONTENTS file_name="{config.own_file}">\n'
+                f"{own_toc}\n"
+                f"</TABLE_OF_CONTENTS>",
             )
 
     # Combine all sections
@@ -383,23 +384,48 @@ def get_agent_existing_files(agent_mode: AgentType | None = None) -> list[str]:
                     relative_path = file_path.relative_to(base_path)
                     existing_files.append(str(relative_path))
     else:
-        # For other agents, check both .md file and directory with same name
-        allowed_file = AGENT_DIRECTORIES[agent_mode]
-
-        # Check for the .md file
-        md_file_path = base_path / allowed_file
-        if md_file_path.exists():
-            existing_files.append(allowed_file)
-
-        # Check for directory with same base name (e.g., research/ for research.md)
-        base_name = allowed_file.replace(".md", "")
-        dir_path = base_path / base_name
-        if dir_path.exists() and dir_path.is_dir():
-            # List all files in the directory
-            for file_path in dir_path.rglob("*"):
-                if file_path.is_file():
-                    relative_path = file_path.relative_to(base_path)
-                    existing_files.append(str(relative_path))
+        # For other agents, check files/directories they have access to
+        allowed_paths_raw = AGENT_DIRECTORIES[agent_mode]
+
+        # Convert single Path/string to list of Paths for uniform handling
+        if isinstance(allowed_paths_raw, str):
+            # Special case: "*" means export agent (shouldn't reach here but handle it)
+            allowed_paths = (
+                [Path(allowed_paths_raw)] if allowed_paths_raw != "*" else []
+            )
+        elif isinstance(allowed_paths_raw, Path):
+            allowed_paths = [allowed_paths_raw]
+        else:
+            # Already a list
+            allowed_paths = allowed_paths_raw
+
+        # Check each allowed path
+        for allowed_path in allowed_paths:
+            allowed_str = str(allowed_path)
+
+            # Check if it's a directory (no .md suffix)
+            if not allowed_path.suffix or not allowed_str.endswith(".md"):
+                # It's a directory - list all files within it
+                dir_path = base_path / allowed_str
+                if dir_path.exists() and dir_path.is_dir():
+                    for file_path in dir_path.rglob("*"):
+                        if file_path.is_file():
+                            relative_path = file_path.relative_to(base_path)
+                            existing_files.append(str(relative_path))
+            else:
+                # It's a file - check if it exists
+                file_path = base_path / allowed_str
+                if file_path.exists():
+                    existing_files.append(allowed_str)
+
+                # Also check for associated directory (e.g., research/ for research.md)
+                base_name = allowed_str.replace(".md", "")
+                dir_path = base_path / base_name
+                if dir_path.exists() and dir_path.is_dir():
+                    for file_path in dir_path.rglob("*"):
+                        if file_path.is_file():
+                            relative_path = file_path.relative_to(base_path)
+                            existing_files.append(str(relative_path))
 
     return existing_files
 
@@ -469,7 +495,8 @@ async def add_system_prompt_message(
     message_history = message_history or []
 
     # Create a minimal RunContext to call the system prompt function
-    # We'll pass None for model and usage since they're not used by our system prompt functions
+    # We'll pass None for model and usage since they're not used
+    # by our system prompt functions
     context = type(
         "RunContext", (), {"deps": deps, "retry": 0, "model": None, "usage": None}
     )()
@@ -493,12 +520,12 @@ async def add_system_prompt_message(
 
 
 async def run_agent(
-    agent: Agent[AgentDeps, str | DeferredToolRequests],
+    agent: Agent[AgentDeps, AgentResponse],
     prompt: str,
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
     usage_limits: UsageLimits | None = None,
-) -> AgentRunResult[str | DeferredToolRequests]:
+) -> AgentRunResult[AgentResponse]:
     # Clear file tracker for new run
     deps.file_tracker.clear()
     logger.debug("🔧 Cleared file tracker for new agent run")
@@ -513,33 +540,6 @@ async def run_agent(
         message_history=message_history,
     )
 
-    # Apply persistent compaction to prevent cascading token growth across CLI commands
-    messages = await apply_persistent_compaction(result.all_messages(), deps)
-    while isinstance(result.output, DeferredToolRequests):
-        logger.info("got deferred tool requests")
-        await deps.queue.join()
-        requests = result.output
-        done, _ = await asyncio.wait(deps.tasks)
-
-        task_results = [task.result() for task in done]
-        task_results_by_tool_call_id = {
-            result.tool_call_id: result.answer for result in task_results
-        }
-        logger.info("got task results", task_results_by_tool_call_id)
-        results = DeferredToolResults()
-        for call in requests.calls:
-            results.calls[call.tool_call_id] = task_results_by_tool_call_id[
-                call.tool_call_id
-            ]
-        result = await agent.run(
-            deps=deps,
-            usage_limits=usage_limits,
-            message_history=messages,
-            deferred_tool_results=results,
-        )
-        # Apply persistent compaction to prevent cascading token growth in multi-turn loops
-        messages = await apply_persistent_compaction(result.all_messages(), deps)
-
     # Log file operations summary if any files were modified
     if deps.file_tracker.operations:
         summary = deps.file_tracker.format_summary()

shotgun/agents/config/constants.py

@@ -24,11 +24,5 @@ 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/agents/config/manager.py

@@ -142,7 +142,7 @@ class ConfigManager:
                             # Find default model for this provider
                             provider_models = {
                                 ProviderType.OPENAI: ModelName.GPT_5,
-                                ProviderType.ANTHROPIC: ModelName.CLAUDE_SONNET_4_5,
+                                ProviderType.ANTHROPIC: ModelName.CLAUDE_HAIKU_4_5,
                                 ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
                             }
 
@@ -243,12 +243,16 @@ class ConfigManager:
 
                 provider_models = {
                     ProviderType.OPENAI: ModelName.GPT_5,
-                    ProviderType.ANTHROPIC: ModelName.CLAUDE_SONNET_4_5,
+                    ProviderType.ANTHROPIC: ModelName.CLAUDE_HAIKU_4_5,
                     ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
                 }
                 if provider_enum in provider_models:
                     config.selected_model = provider_models[provider_enum]
 
+            # Mark welcome screen as shown when BYOK provider is configured
+            # This prevents the welcome screen from showing again after user has made their choice
+            config.shown_welcome_screen = True
+
         self.save(config)
 
     def clear_provider_key(self, provider: ProviderType | str) -> None:
@@ -256,9 +260,16 @@ class ConfigManager:
         config = self.load()
 
         # Get provider config (shotgun or LLM provider)
-        provider_config, _ = self._get_provider_config_and_type(config, provider)
+        provider_config, is_shotgun = self._get_provider_config_and_type(
+            config, provider
+        )
 
         provider_config.api_key = None
+
+        # For Shotgun Account, also clear the JWT
+        if is_shotgun and isinstance(provider_config, ShotgunAccountConfig):
+            provider_config.supabase_jwt = None
+
         self.save(config)
 
     def update_selected_model(self, model_name: "ModelName") -> None:

shotgun/agents/config/models.py

@@ -28,6 +28,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 +43,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 +90,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 +98,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 +106,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 +114,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 +130,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 +138,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",
     ),
 }
 

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:
@@ -145,13 +194,19 @@ def get_provider_model(
     # 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",
+]