shotgun-sh 0.2.11.dev3__py3-none-any.whl → 0.2.19__py3-none-any.whl

shotgun/agents/config/provider.py

@@ -25,6 +25,7 @@ from .models import (
     ProviderType,
     ShotgunConfig,
 )
+from .streaming_test import check_streaming_capability
 
 logger = get_logger(__name__)
 
@@ -207,6 +208,7 @@ async def get_provider_model(
         spec = MODEL_SPECS[model_name]
 
         # Use Shotgun Account with determined model (provider = actual LLM provider)
+        # Shotgun accounts always support streaming (via LiteLLM proxy)
         return ModelConfig(
             name=spec.name,
             provider=spec.provider,  # Actual LLM provider (OPENAI/ANTHROPIC/GOOGLE)
@@ -214,6 +216,7 @@ async def get_provider_model(
             max_input_tokens=spec.max_input_tokens,
             max_output_tokens=spec.max_output_tokens,
             api_key=shotgun_api_key,
+            supports_streaming=True,  # Shotgun accounts always support streaming
         )
 
     # Priority 2: Fall back to individual provider keys
@@ -260,6 +263,29 @@ async def get_provider_model(
             raise ValueError(f"Model '{model_name.value}' not found")
         spec = MODEL_SPECS[model_name]
 
+        # Check and test streaming capability for GPT-5 family models
+        supports_streaming = True  # Default to True for all models
+        if model_name in (ModelName.GPT_5, ModelName.GPT_5_MINI):
+            # Check if streaming capability has been tested
+            streaming_capability = config.openai.supports_streaming
+
+            if streaming_capability is None:
+                # Not tested yet - run streaming test (test once for all GPT-5 models)
+                logger.info("Testing streaming capability for OpenAI GPT-5 family...")
+                streaming_capability = await check_streaming_capability(
+                    api_key, model_name.value
+                )
+
+                # Save result to config (applies to all OpenAI models)
+                config.openai.supports_streaming = streaming_capability
+                await config_manager.save(config)
+                logger.info(
+                    f"Streaming test result: "
+                    f"{'enabled' if streaming_capability else 'disabled'}"
+                )
+
+            supports_streaming = streaming_capability
+
         # Create fully configured ModelConfig
         return ModelConfig(
             name=spec.name,
@@ -268,6 +294,7 @@ async def get_provider_model(
             max_input_tokens=spec.max_input_tokens,
             max_output_tokens=spec.max_output_tokens,
             api_key=api_key,
+            supports_streaming=supports_streaming,
         )
 
     elif provider_enum == ProviderType.ANTHROPIC:

shotgun/agents/config/streaming_test.py

@@ -0,0 +1,119 @@
+"""Utility for testing streaming capability of OpenAI models."""
+
+import logging
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Maximum number of attempts to test streaming capability
+MAX_STREAMING_TEST_ATTEMPTS = 3
+
+# Timeout for each streaming test attempt (in seconds)
+STREAMING_TEST_TIMEOUT = 10.0
+
+
+async def check_streaming_capability(
+    api_key: str, model_name: str, max_attempts: int = MAX_STREAMING_TEST_ATTEMPTS
+) -> bool:
+    """Check if the given OpenAI model supports streaming with this API key.
+
+    Retries multiple times to handle transient network issues. Only returns False
+    if streaming definitively fails after all retry attempts.
+
+    Args:
+        api_key: The OpenAI API key to test
+        model_name: The model name (e.g., "gpt-5", "gpt-5-mini")
+        max_attempts: Maximum number of attempts (default: 3)
+
+    Returns:
+        True if streaming is supported, False if it definitively fails
+    """
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    # GPT-5 family uses max_completion_tokens instead of max_tokens
+    payload = {
+        "model": model_name,
+        "messages": [{"role": "user", "content": "test"}],
+        "stream": True,
+        "max_completion_tokens": 10,
+    }
+
+    last_error = None
+
+    for attempt in range(1, max_attempts + 1):
+        logger.debug(
+            f"Streaming test attempt {attempt}/{max_attempts} for {model_name}"
+        )
+
+        try:
+            async with httpx.AsyncClient(timeout=STREAMING_TEST_TIMEOUT) as client:
+                async with client.stream(
+                    "POST", url, json=payload, headers=headers
+                ) as response:
+                    # Check if we get a successful response
+                    if response.status_code != 200:
+                        last_error = f"HTTP {response.status_code}"
+                        logger.warning(
+                            f"Streaming test attempt {attempt} failed for {model_name}: {last_error}"
+                        )
+
+                        # For definitive errors (403 Forbidden, 404 Not Found), don't retry
+                        if response.status_code in (403, 404):
+                            logger.info(
+                                f"Streaming definitively unsupported for {model_name} (HTTP {response.status_code})"
+                            )
+                            return False
+
+                        # For other errors, retry
+                        continue
+
+                    # Try to read at least one chunk from the stream
+                    try:
+                        async for _ in response.aiter_bytes():
+                            # Successfully received streaming data
+                            logger.info(
+                                f"Streaming test passed for {model_name} (attempt {attempt})"
+                            )
+                            return True
+                    except Exception as e:
+                        last_error = str(e)
+                        logger.warning(
+                            f"Streaming test attempt {attempt} failed for {model_name} while reading stream: {e}"
+                        )
+                        continue
+
+        except httpx.TimeoutException:
+            last_error = "timeout"
+            logger.warning(
+                f"Streaming test attempt {attempt} timed out for {model_name}"
+            )
+            continue
+        except httpx.HTTPStatusError as e:
+            last_error = str(e)
+            logger.warning(
+                f"Streaming test attempt {attempt} failed for {model_name}: {e}"
+            )
+            continue
+        except Exception as e:
+            last_error = str(e)
+            logger.warning(
+                f"Streaming test attempt {attempt} failed for {model_name} with unexpected error: {e}"
+            )
+            continue
+
+        # If we got here without reading any chunks, streaming didn't work
+        last_error = "no data received"
+        logger.warning(
+            f"Streaming test attempt {attempt} failed for {model_name}: no data received"
+        )
+
+    # All attempts exhausted
+    logger.error(
+        f"Streaming test failed for {model_name} after {max_attempts} attempts. "
+        f"Last error: {last_error}. Assuming streaming is NOT supported."
+    )
+    return False

shotgun/agents/conversation_manager.py

@@ -46,9 +46,12 @@ class ConversationManager:
 
             conversation.updated_at = datetime.now()
 
-            # Serialize to JSON using Pydantic's model_dump
-            data = conversation.model_dump(mode="json")
-            json_content = json.dumps(data, indent=2, ensure_ascii=False)
+            # Serialize to JSON in background thread to avoid blocking event loop
+            # This is crucial for large conversations (5k+ tokens)
+            data = await asyncio.to_thread(conversation.model_dump, mode="json")
+            json_content = await asyncio.to_thread(
+                json.dumps, data, indent=2, ensure_ascii=False
+            )
 
             async with aiofiles.open(
                 self.conversation_path, "w", encoding="utf-8"
@@ -76,9 +79,13 @@ class ConversationManager:
         try:
             async with aiofiles.open(self.conversation_path, encoding="utf-8") as f:
                 content = await f.read()
-                data = json.loads(content)
+                # Deserialize JSON in background thread to avoid blocking
+                data = await asyncio.to_thread(json.loads, content)
 
-            conversation = ConversationHistory.model_validate(data)
+            # Validate model in background thread for large conversations
+            conversation = await asyncio.to_thread(
+                ConversationHistory.model_validate, data
+            )
             logger.debug(
                 "Conversation loaded from %s with %d agent messages",
                 self.conversation_path,
@@ -127,10 +134,10 @@ class ConversationManager:
                     "Failed to clear conversation at %s: %s", self.conversation_path, e
                 )
 
-    def exists(self) -> bool:
+    async def exists(self) -> bool:
         """Check if a conversation history file exists.
 
         Returns:
             True if conversation file exists, False otherwise
         """
-        return self.conversation_path.exists()
+        return await aiofiles.os.path.exists(str(self.conversation_path))

shotgun/agents/history/history_processors.py

@@ -1,7 +1,9 @@
 """History processors for managing conversation history in Shotgun agents."""
 
+from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, Protocol
 
+from anthropic import APIStatusError
 from pydantic_ai import ModelSettings
 from pydantic_ai.messages import (
     ModelMessage,
@@ -14,6 +16,7 @@ from pydantic_ai.messages import (
 from shotgun.agents.llm import shotgun_model_request
 from shotgun.agents.messages import AgentSystemPrompt, SystemStatusPrompt
 from shotgun.agents.models import AgentDeps
+from shotgun.exceptions import ContextSizeLimitExceeded
 from shotgun.logging_config import get_logger
 from shotgun.posthog_telemetry import track_event
 from shotgun.prompts import PromptLoader
@@ -51,6 +54,86 @@ logger = get_logger(__name__)
 prompt_loader = PromptLoader()
 
 
+async def _safe_token_estimation(
+    estimation_func: Callable[..., Awaitable[int]],
+    model_name: str,
+    max_tokens: int,
+    *args: Any,
+    **kwargs: Any,
+) -> int:
+    """Safely estimate tokens with proper error handling.
+
+    Wraps token estimation functions to handle failures gracefully.
+    Only RuntimeError (from token counters) is wrapped in ContextSizeLimitExceeded.
+    Other errors (network, auth) are allowed to bubble up.
+
+    Args:
+        estimation_func: Async function that estimates tokens
+        model_name: Name of the model for error messages
+        max_tokens: Maximum tokens for the model
+        *args: Arguments to pass to estimation_func
+        **kwargs: Keyword arguments to pass to estimation_func
+
+    Returns:
+        Token count from estimation_func
+
+    Raises:
+        ContextSizeLimitExceeded: If token counting fails with RuntimeError
+        Exception: Any other exceptions from estimation_func
+    """
+    try:
+        return await estimation_func(*args, **kwargs)
+    except Exception as e:
+        # Log the error with full context
+        logger.warning(
+            f"Token counting failed for {model_name}",
+            extra={
+                "error_type": type(e).__name__,
+                "error_message": str(e),
+                "model": model_name,
+            },
+        )
+
+        # Token counting behavior with oversized context (verified via testing):
+        #
+        # 1. OpenAI/tiktoken:
+        #    - Successfully counts any size (tested with 752K tokens, no error)
+        #    - Library errors: ValueError, KeyError, AttributeError, SSLError (file/cache issues)
+        #    - Wrapped as: RuntimeError by our counter
+        #
+        # 2. Gemini/SentencePiece:
+        #    - Successfully counts any size (tested with 752K tokens, no error)
+        #    - Library errors: RuntimeError, IOError, TypeError (file/model loading issues)
+        #    - Wrapped as: RuntimeError by our counter
+        #
+        # 3. Anthropic API:
+        #    - Successfully counts large token counts (tested with 752K tokens, no error)
+        #    - Only enforces 32 MB request size limit (not token count)
+        #    - Raises: APIStatusError(413) with error type 'request_too_large' for 32MB+ requests
+        #    - Other API errors: APIConnectionError, RateLimitError, APIStatusError (4xx/5xx)
+        #    - Wrapped as: RuntimeError by our counter
+        #
+        # IMPORTANT: No provider raises errors for "too many tokens" during counting.
+        # Token count validation happens separately by comparing count to max_input_tokens.
+        #
+        # We wrap RuntimeError (library-level failures from tiktoken/sentencepiece).
+        # We also wrap Anthropic's 413 error (request exceeds 32 MB) as it indicates
+        # context is effectively too large and needs user action to reduce it.
+        if isinstance(e, RuntimeError):
+            raise ContextSizeLimitExceeded(
+                model_name=model_name, max_tokens=max_tokens
+            ) from e
+
+        # Check for Anthropic's 32 MB request size limit (APIStatusError with status 413)
+        if isinstance(e, APIStatusError) and e.status_code == 413:
+            raise ContextSizeLimitExceeded(
+                model_name=model_name, max_tokens=max_tokens
+            ) from e
+
+        # Re-raise other exceptions (network errors, auth failures, etc.)
+        raise
+
+
 def is_summary_part(part: Any) -> bool:
     """Check if a message part is a compacted summary."""
     return isinstance(part, TextPart) and part.content.startswith(SUMMARY_MARKER)
@@ -157,9 +240,15 @@ async def token_limit_compactor(
 
     if last_summary_index is not None:
         # Check if post-summary conversation exceeds threshold for incremental compaction
-        post_summary_tokens = await estimate_post_summary_tokens(
-            messages, last_summary_index, deps.llm_model
+        post_summary_tokens = await _safe_token_estimation(
+            estimate_post_summary_tokens,
+            deps.llm_model.name,
+            model_max_tokens,
+            messages,
+            last_summary_index,
+            deps.llm_model,
         )
+
         post_summary_percentage = (
             (post_summary_tokens / max_tokens) * 100 if max_tokens > 0 else 0
         )
@@ -366,7 +455,14 @@ async def token_limit_compactor(
 
     else:
         # Check if total conversation exceeds threshold for full compaction
-        total_tokens = await estimate_tokens_from_messages(messages, deps.llm_model)
+        total_tokens = await _safe_token_estimation(
+            estimate_tokens_from_messages,
+            deps.llm_model.name,
+            model_max_tokens,
+            messages,
+            deps.llm_model,
+        )
+
         total_percentage = (total_tokens / max_tokens) * 100 if max_tokens > 0 else 0
 
         logger.debug(

shotgun/agents/history/token_counting/openai.py

@@ -63,7 +63,9 @@ class OpenAITokenCounter(TokenCounter):
 
         try:
             return len(self.encoding.encode(text))
-        except Exception as e:
+        except BaseException as e:
+            # Must catch BaseException to handle PanicException from tiktoken's Rust layer
+            # which can occur with extremely long texts. Regular Exception won't catch it.
             raise RuntimeError(
                 f"Failed to count tokens for OpenAI model {self.model_name}"
             ) from e

shotgun/build_constants.py

@@ -8,12 +8,12 @@ DO NOT EDIT MANUALLY.
 SENTRY_DSN = 'https://2818a6d165c64eccc94cfd51ce05d6aa@o4506813296738304.ingest.us.sentry.io/4510045952409600'
 
 # PostHog configuration embedded at build time (empty strings if not provided)
-POSTHOG_API_KEY = ''
+POSTHOG_API_KEY = 'phc_KKnChzZUKeNqZDOTJ6soCBWNQSx3vjiULdwTR9H5Mcr'
 POSTHOG_PROJECT_ID = '191396'
 
 # Logfire configuration embedded at build time (only for dev builds)
-LOGFIRE_ENABLED = 'true'
-LOGFIRE_TOKEN = 'pylf_v1_us_RwZMlJm1tX6j0PL5RWWbmZpzK2hLBNtFWStNKlySfjh8'
+LOGFIRE_ENABLED = ''
+LOGFIRE_TOKEN = ''
 
 # Build metadata
 BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"

shotgun/exceptions.py

@@ -0,0 +1,32 @@
+"""General exceptions for Shotgun application."""
+
+
+class ErrorNotPickedUpBySentry(Exception):  # noqa: N818
+    """Base for user-actionable errors that shouldn't be sent to Sentry.
+
+    These errors represent expected user conditions requiring action
+    rather than bugs that need tracking.
+    """
+
+
+class ContextSizeLimitExceeded(ErrorNotPickedUpBySentry):
+    """Raised when conversation context exceeds the model's limits.
+
+    This is a user-actionable error - they need to either:
+    1. Switch to a larger context model
+    2. Switch to a larger model, compact their conversation, then switch back
+    3. Clear the conversation and start fresh
+    """
+
+    def __init__(self, model_name: str, max_tokens: int):
+        """Initialize the exception.
+
+        Args:
+            model_name: Name of the model whose limit was exceeded
+            max_tokens: Maximum tokens allowed by the model
+        """
+        self.model_name = model_name
+        self.max_tokens = max_tokens
+        super().__init__(
+            f"Context too large for {model_name} (limit: {max_tokens:,} tokens)"
+        )

shotgun/logging_config.py

@@ -27,6 +27,44 @@ def get_log_directory() -> Path:
     return log_dir
 
 
+def cleanup_old_log_files(log_dir: Path, max_files: int) -> None:
+    """Remove old log files, keeping only the most recent ones.
+
+    Also removes the legacy shotgun.log file if it exists.
+
+    Args:
+        log_dir: Directory containing log files
+        max_files: Maximum number of log files to keep
+    """
+    try:
+        # Remove legacy non-timestamped log file if it exists
+        legacy_log = log_dir / "shotgun.log"
+        if legacy_log.exists():
+            try:
+                legacy_log.unlink()
+            except OSError:
+                pass  # noqa: S110
+
+        # Find all shotgun log files
+        log_files = sorted(
+            log_dir.glob("shotgun-*.log"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,  # Newest first
+        )
+
+        # Remove files beyond the limit
+        files_to_delete = log_files[max_files:]
+        for log_file in files_to_delete:
+            try:
+                log_file.unlink()
+            except OSError:
+                # Ignore errors when deleting individual files
+                pass  # noqa: S110
+    except Exception:  # noqa: S110
+        # Silently fail - log cleanup shouldn't break the application
+        pass
+
+
 class ColoredFormatter(logging.Formatter):
     """Custom formatter with colors for different log levels."""
 
@@ -123,6 +161,10 @@ def setup_logger(
         try:
             # Create file handler with ISO8601 timestamp for each run
             log_dir = get_log_directory()
+
+            # Clean up old log files before creating a new one
+            cleanup_old_log_files(log_dir, settings.logging.max_log_files)
+
             log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
 
             # Use regular FileHandler - each run gets its own isolated log file

shotgun/main.py

@@ -55,6 +55,8 @@ logger = get_logger(__name__)
 logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
+# Note: If config migration fails, ConfigManager will auto-create fresh config
+# and set migration_failed flag for user notification
 try:
     import asyncio
 

shotgun/posthog_telemetry.py

@@ -18,6 +18,9 @@ logger = get_early_logger(__name__)
 # Global PostHog client instance
 _posthog_client = None
 
+# Cache the shotgun instance ID to avoid async calls during event tracking
+_shotgun_instance_id: str | None = None
+
 
 def setup_posthog_observability() -> bool:
     """Set up PostHog analytics for usage tracking.
@@ -25,7 +28,7 @@ def setup_posthog_observability() -> bool:
     Returns:
         True if PostHog was successfully set up, False otherwise
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     try:
         # Check if PostHog is already initialized
@@ -57,31 +60,20 @@ def setup_posthog_observability() -> bool:
         # Store the client for later use
         _posthog_client = posthog
 
-        # Set user context with anonymous shotgun instance ID from config
+        # Cache the shotgun instance ID for later use (avoids async issues)
         try:
             import asyncio
 
             config_manager = get_config_manager()
-            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
-
-            # Identify the user in PostHog
-            posthog.identify(  # type: ignore[attr-defined]
-                distinct_id=shotgun_instance_id,
-                properties={
-                    "version": __version__,
-                    "environment": environment,
-                },
-            )
-
-            # Set default properties for all events
-            posthog.disabled = False
-            posthog.personal_api_key = None  # Not needed for event tracking
+            _shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             logger.debug(
-                "PostHog user identified with anonymous ID: %s", shotgun_instance_id
+                "PostHog initialized with shotgun instance ID: %s",
+                _shotgun_instance_id,
             )
         except Exception as e:
-            logger.warning("Failed to set user context: %s", e)
+            logger.warning("Failed to load shotgun instance ID: %s", e)
+            # Continue anyway - we'll try to get it during event tracking
 
         logger.debug(
             "PostHog analytics configured successfully (environment: %s, version: %s)",
@@ -102,18 +94,19 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         event_name: Name of the event to track
         properties: Optional properties to include with the event
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     if _posthog_client is None:
         logger.debug("PostHog not initialized, skipping event: %s", event_name)
         return
 
     try:
-        import asyncio
-
-        # Get shotgun instance ID for tracking
-        config_manager = get_config_manager()
-        shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
+        # Use cached instance ID (loaded during setup)
+        if _shotgun_instance_id is None:
+            logger.warning(
+                "Shotgun instance ID not available, skipping event: %s", event_name
+            )
+            return
 
         # Add version and environment to properties
         if properties is None:
@@ -128,7 +121,7 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
 
         # Track the event using PostHog's capture method
         _posthog_client.capture(
-            distinct_id=shotgun_instance_id, event=event_name, properties=properties
+            distinct_id=_shotgun_instance_id, event=event_name, properties=properties
         )
         logger.debug("Tracked PostHog event: %s", event_name)
     except Exception as e:

shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -7,10 +7,11 @@ Your extensive expertise spans, among other things:
 ## KEY RULES
 
 {% if interactive_mode %}
-0. Always ask CLARIFYING QUESTIONS using structured output if the user's request is ambiguous or lacks sufficient detail.
+0. Always ask CLARIFYING QUESTIONS using structured output before doing work.
    - Return your response with the clarifying_questions field populated
-   - Do not make assumptions about what the user wants
+   - Do not make assumptions about what the user wants, get a clear understanding first.
    - Questions should be clear, specific, and answerable
+   - Do not ask too many questions that might overwhelm the user; prioritize the most important ones.
 {% endif %}
 1. Above all, prefer using tools to do the work and NEVER respond with text.
 2. IMPORTANT: Always ask for review and go ahead to move forward after using write_file().