shotgun-sh 0.2.11.dev7__py3-none-any.whl → 0.2.23.dev1__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -615,19 +615,33 @@ class AgentManager(Widget):
         self._stream_state = _PartialStreamState()
 
         model_name = ""
+        supports_streaming = True  # Default to streaming enabled
+
         if hasattr(deps, "llm_model") and deps.llm_model is not None:
             model_name = deps.llm_model.name
+            supports_streaming = deps.llm_model.supports_streaming
 
-        # Check if it's a Shotgun account
-        is_shotgun_account = (
-            hasattr(deps, "llm_model")
-            and deps.llm_model is not None
-            and deps.llm_model.key_provider == KeyProvider.SHOTGUN
-        )
-
-        # Only disable streaming for GPT-5 if NOT a Shotgun account
-        # Shotgun accounts support streaming for GPT-5
-        is_gpt5_byok = "gpt-5" in model_name.lower() and not is_shotgun_account
+            # Add hint message if streaming is disabled for BYOK GPT-5 models
+            if (
+                not supports_streaming
+                and deps.llm_model.key_provider == KeyProvider.BYOK
+            ):
+                self.ui_message_history.append(
+                    HintMessage(
+                        message=(
+                            "⚠️ **Streaming not available for GPT-5**\n\n"
+                            "Your OpenAI organization doesn't have streaming enabled for this model.\n\n"
+                            "**Options:**\n"
+                            "- Get a [Shotgun Account](https://shotgun.sh) - streaming works out of the box\n"
+                            "- Complete [Biometric Verification](https://platform.openai.com/settings/organization/general) with OpenAI, then:\n"
+                            "  1. Press `Ctrl+P` → Open Provider Setup\n"
+                            "  2. Select OpenAI → Clear key\n"
+                            "  3. Re-add your OpenAI API key\n\n"
+                            "Continuing without streaming (responses will appear all at once)."
+                        )
+                    )
+                )
+                self._post_messages_updated()
 
         # Track message send event
         event_name = f"message_send_{self._current_agent_type.value}"
@@ -647,7 +661,7 @@ class AgentManager(Widget):
                 usage_limits=usage_limits,
                 message_history=message_history,
                 event_stream_handler=self._handle_event_stream
-                if not is_gpt5_byok
+                if supports_streaming
                 else None,
                 **kwargs,
             )

shotgun/agents/config/README.md

@@ -0,0 +1,89 @@
+# Configuration Management
+
+This directory contains the configuration management system for Shotgun, including models, migrations, and provider integration.
+
+## Config Version History
+
+### Version 1 (Config Versioning Introduced)
+
+- **Commit**: `f36defc` (Sep 19, 2025)
+- **Title**: "feat: add Sentry error tracking with anonymous user identification"
+- **Key Fields**: `user_id`, `config_version: 1`
+- **Note**: First version to include explicit versioning
+
+### Version 2 (Shotgun Account Provider)
+
+- **Commit**: `37a5add` (Oct 3, 2025)
+- **Title**: "feat: add Shotgun Account provider with LiteLLM proxy support"
+- **Key Fields**: `user_id`, `config_version: 2`, added `shotgun` provider config
+- **Note**: Configs without a version field default to v2 during migration
+
+### Version 3 (OAuth Authentication)
+
+- **Commit**: `39d2af9` (Oct 6, 2025)
+- **Title**: "feat: implement OAuth-style authentication flow for Shotgun Account"
+- **Key Changes**:
+  - Renamed `user_id` → `shotgun_instance_id`
+  - Added `supabase_jwt` field to Shotgun Account config
+- **Git Tags**: Both `0.2.11.dev1` and `0.2.11.dev2` are at this version
+
+### Version 4 (Marketing Messages)
+
+- **Commit**: `8638a6d` (Nov 4, 2025)
+- **Title**: "feat: add marketing message system for GitHub star promotion"
+- **Key Changes**:
+  - Added `marketing` configuration with message tracking
+  - Added `shown_welcome_screen` field (set to `False` for existing BYOK users)
+
+### Version 5 (Streaming Detection) - CURRENT
+
+- **Commit**: `fded351` (Nov 6, 2025)
+- **Title**: "feat: add config migration for streaming capability field (v4->v5)"
+- **Key Changes**:
+  - Added `supports_streaming` field to OpenAI config
+  - Added `shown_onboarding_popup` timestamp field
+  - Added `supabase_jwt` to Shotgun Account config
+
+## Migration System
+
+The migration system is designed to be sequential and idempotent. Migrations are defined in `manager.py`:
+
+- `_migrate_v2_to_v3()`: Renames `user_id` to `shotgun_instance_id`
+- `_migrate_v3_to_v4()`: Adds marketing config and welcome screen flag
+- `_migrate_v4_to_v5()`: Adds streaming support fields
+
+All migrations preserve user data (API keys, settings) and can be safely run multiple times.
+
+## Adding a New Config Version
+
+When adding a new config version:
+
+1. **Update `models.py`**:
+   - Increment `CURRENT_CONFIG_VERSION` constant
+   - Add new fields to appropriate config models
+
+2. **Create migration function in `manager.py`**:
+   ```python
+   def _migrate_vN_to_vN+1(data: dict[str, Any]) -> dict[str, Any]:
+       """Migrate config from version N to N+1."""
+       data["config_version"] = N + 1
+       # Add migration logic
+       return data
+   ```
+
+3. **Register migration**:
+   - Add to `migrations` dict in `_apply_migrations()`
+
+4. **Add tests in `test/unit/test_config_migrations.py`**:
+   - Create example config for version N
+   - Test individual migration function
+   - Test sequential migration from version N to current
+   - Test with populated configs (non-empty API keys, etc.)
+   - Test edge cases
+
+## Files
+
+- **`models.py`**: Pydantic models for configuration schema
+- **`manager.py`**: ConfigManager class and migration functions
+- **`provider.py`**: LLM provider integration and model creation
+- **`streaming_test.py`**: OpenAI streaming capability detection

shotgun/agents/config/__init__.py

@@ -1,11 +1,20 @@
 """Configuration module for Shotgun CLI."""
 
-from .manager import ConfigManager, get_config_manager
+from .manager import (
+    BACKUP_DIR_NAME,
+    ConfigManager,
+    ConfigMigrationError,
+    get_backup_dir,
+    get_config_manager,
+)
 from .models import ProviderType, ShotgunConfig
 from .provider import get_provider_model
 
 __all__ = [
+    "BACKUP_DIR_NAME",
     "ConfigManager",
+    "ConfigMigrationError",
+    "get_backup_dir",
     "get_config_manager",
     "ProviderType",
     "ShotgunConfig",

shotgun/agents/config/manager.py

@@ -1,7 +1,9 @@
 """Configuration manager for Shotgun CLI."""
 
 import json
+import shutil
 import uuid
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -30,9 +32,196 @@ from .models import (
 
 logger = get_logger(__name__)
 
+
+class ConfigMigrationError(Exception):
+    """Exception raised when config migration fails."""
+
+    def __init__(self, message: str, backup_path: Path | None = None):
+        """Initialize with error message and optional backup path.
+
+        Args:
+            message: Error message describing what went wrong
+            backup_path: Path to backup file if one was created
+        """
+        self.backup_path = backup_path
+        super().__init__(message)
+
+
 # Type alias for provider configuration objects
 ProviderConfig = OpenAIConfig | AnthropicConfig | GoogleConfig | ShotgunAccountConfig
 
+# Current config version
+CURRENT_CONFIG_VERSION = 5
+
+# Backup directory name
+BACKUP_DIR_NAME = "backup"
+
+
+def get_backup_dir(config_path: Path) -> Path:
+    """Get the backup directory path for a given config file.
+
+    Args:
+        config_path: Path to the config file
+
+    Returns:
+        Path to the backup directory (e.g., ~/.shotgun-sh/backup/)
+    """
+    return config_path.parent / BACKUP_DIR_NAME
+
+
+def _create_backup(config_path: Path) -> Path:
+    """Create a timestamped backup of the config file before migration.
+
+    Backups are saved to ~/.shotgun-sh/backup/ directory.
+
+    Args:
+        config_path: Path to the config file to backup
+
+    Returns:
+        Path to the backup file in the backup directory
+
+    Raises:
+        OSError: If backup creation fails
+    """
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_dir = get_backup_dir(config_path)
+    backup_path = backup_dir / f"config.backup.{timestamp}.json"
+
+    try:
+        # Create backup directory if it doesn't exist
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(config_path, backup_path)
+        logger.info(f"Created config backup at {backup_path}")
+        return backup_path
+    except Exception as e:
+        logger.error(f"Failed to create config backup: {e}")
+        raise OSError(f"Failed to create config backup: {e}") from e
+
+
+def _migrate_v2_to_v3(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config from version 2 to version 3.
+
+    Changes:
+    - Rename 'user_id' field to 'shotgun_instance_id'
+
+    Args:
+        data: Config data dict at version 2
+
+    Returns:
+        Modified config data dict at version 3
+    """
+    if "user_id" in data and SHOTGUN_INSTANCE_ID_FIELD not in data:
+        data[SHOTGUN_INSTANCE_ID_FIELD] = data.pop("user_id")
+        data["config_version"] = 3
+        logger.info("Migrated config v2->v3: renamed user_id to shotgun_instance_id")
+
+    return data
+
+
+def _migrate_v3_to_v4(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config from version 3 to version 4.
+
+    Changes:
+    - Add 'marketing' field with empty messages dict
+    - Set 'shown_welcome_screen' to False for existing BYOK users
+
+    Args:
+        data: Config data dict at version 3
+
+    Returns:
+        Modified config data dict at version 4
+    """
+    # Add marketing config
+    if "marketing" not in data:
+        data["marketing"] = {"messages": {}}
+        logger.info("Migrated config v3->v4: added marketing configuration")
+
+    # Set shown_welcome_screen for existing BYOK users
+    # If shown_welcome_screen doesn't exist AND any BYOK provider has a key,
+    # set it to False so they see the welcome screen once
+    if "shown_welcome_screen" not in data:
+        has_byok_key = False
+        for section in ["openai", "anthropic", "google"]:
+            if (
+                section in data
+                and isinstance(data[section], dict)
+                and data[section].get("api_key")
+            ):
+                has_byok_key = True
+                break
+
+        if has_byok_key:
+            data["shown_welcome_screen"] = False
+            logger.info(
+                "Existing BYOK user detected: set shown_welcome_screen=False to show welcome screen"
+            )
+
+    data["config_version"] = 4
+    return data
+
+
+def _migrate_v4_to_v5(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config from version 4 to version 5.
+
+    Changes:
+    - Add 'supports_streaming' field to OpenAI config (initially None for auto-detection)
+
+    Args:
+        data: Config data dict at version 4
+
+    Returns:
+        Modified config data dict at version 5
+    """
+    if "openai" in data and isinstance(data["openai"], dict):
+        if "supports_streaming" not in data["openai"]:
+            data["openai"]["supports_streaming"] = None
+            logger.info(
+                "Migrated config v4->v5: added streaming capability detection for OpenAI"
+            )
+
+    data["config_version"] = 5
+    return data
+
+
+def _apply_migrations(data: dict[str, Any]) -> dict[str, Any]:
+    """Apply all necessary migrations to bring config to current version.
+
+    Migrations are applied sequentially from the config's current version
+    to CURRENT_CONFIG_VERSION.
+
+    Args:
+        data: Config data dict at any version
+
+    Returns:
+        Config data dict at CURRENT_CONFIG_VERSION
+    """
+    # Get current version (default to 2 for very old configs)
+    current_version = data.get("config_version", 2)
+
+    # Define migrations in order
+    migrations = {
+        2: _migrate_v2_to_v3,
+        3: _migrate_v3_to_v4,
+        4: _migrate_v4_to_v5,
+    }
+
+    # Apply migrations sequentially
+    while current_version < CURRENT_CONFIG_VERSION:
+        if current_version in migrations:
+            logger.info(
+                f"Applying migration from v{current_version} to v{current_version + 1}"
+            )
+            data = migrations[current_version](data)
+            current_version = data.get("config_version", current_version + 1)
+        else:
+            logger.warning(
+                f"No migration defined for v{current_version}, skipping to v{current_version + 1}"
+            )
+            current_version += 1
+            data["config_version"] = current_version
+
+    return data
+
 
 class ConfigManager:
     """Manager for Shotgun configuration."""
@@ -71,44 +260,49 @@ class ConfigManager:
             self._config = await self.initialize()
             return self._config
 
+        backup_path: Path | None = None
         try:
             async with aiofiles.open(self.config_path, encoding="utf-8") as f:
                 content = await f.read()
                 data = json.loads(content)
 
-            # Migration: Rename user_id to shotgun_instance_id (config v2 -> v3)
-            if "user_id" in data and SHOTGUN_INSTANCE_ID_FIELD not in data:
-                data[SHOTGUN_INSTANCE_ID_FIELD] = data.pop("user_id")
-                data["config_version"] = 3
+            # Get current version to determine if migration is needed
+            current_version = data.get("config_version", 2)
+
+            # Create backup before migration if config needs upgrading
+            if current_version < CURRENT_CONFIG_VERSION:
                 logger.info(
-                    "Migrated config v2->v3: renamed user_id to shotgun_instance_id"
+                    f"Config needs migration from v{current_version} to v{CURRENT_CONFIG_VERSION}"
                 )
-
-            # Migration: Set shown_welcome_screen for existing BYOK users
-            # If shown_welcome_screen doesn't exist AND any BYOK provider has a key,
-            # set it to False so they see the welcome screen once
-            if "shown_welcome_screen" not in data:
-                has_byok_key = False
-                for section in ["openai", "anthropic", "google"]:
-                    if (
-                        section in data
-                        and isinstance(data[section], dict)
-                        and data[section].get("api_key")
-                    ):
-                        has_byok_key = True
-                        break
-
-                if has_byok_key:
-                    data["shown_welcome_screen"] = False
-                    logger.info(
-                        "Existing BYOK user detected: set shown_welcome_screen=False to show welcome screen"
+                try:
+                    backup_path = _create_backup(self.config_path)
+                except OSError as backup_error:
+                    logger.warning(
+                        f"Could not create backup before migration: {backup_error}"
                     )
+                    # Continue without backup - better than failing completely
+
+            # Apply all necessary migrations to bring config to current version
+            try:
+                data = _apply_migrations(data)
+            except Exception as migration_error:
+                error_msg = (
+                    f"Failed to migrate configuration from v{current_version} to v{CURRENT_CONFIG_VERSION}. "
+                    f"Error: {migration_error}"
+                )
+                if backup_path:
+                    error_msg += f"\n\nYour original config has been backed up to:\n{backup_path}"
+                    error_msg += (
+                        "\n\nTo start fresh, delete or rename your config file:\n"
+                        f"  rm {self.config_path}\n"
+                        f"  shotgun config init\n\n"
+                        "To restore your backup:\n"
+                        f"  cp {backup_path} {self.config_path}"
+                    )
+                else:
+                    error_msg += "\n\nTo start fresh, run: shotgun config init"
 
-            # Migration: Add marketing config for v3 -> v4
-            if "marketing" not in data:
-                data["marketing"] = {"messages": {}}
-                data["config_version"] = 4
-                logger.info("Migrated config v3->v4: added marketing configuration")
+                raise ConfigMigrationError(error_msg, backup_path) from migration_error
 
             # Convert plain text secrets to SecretStr objects
             self._convert_secrets_to_secretstr(data)
@@ -169,12 +363,56 @@ class ConfigManager:
 
             return self._config
 
-        except Exception as e:
+        except ConfigMigrationError as migration_error:
+            # Migration failed - automatically create fresh config with migration info
             logger.error(
-                "Failed to load configuration from %s: %s", self.config_path, e
+                "Config migration failed, creating fresh config: %s", migration_error
             )
-            logger.info("Creating new configuration with generated shotgun_instance_id")
+            backup_path = migration_error.backup_path
+
+            # Create fresh config with migration failure info
+            self._config = await self.initialize()
+            self._config.migration_failed = True
+            if backup_path:
+                self._config.migration_backup_path = str(backup_path)
+
+            # Save the fresh config
+            await self.save(self._config)
+            logger.info("Created fresh config after migration failure")
+
+            return self._config
+
+        except json.JSONDecodeError as json_error:
+            # Invalid JSON - create backup and fresh config
+            logger.error("Config file has invalid JSON: %s", json_error)
+
+            try:
+                backup_path = _create_backup(self.config_path)
+            except OSError:
+                backup_path = None
+
+            self._config = await self.initialize()
+            self._config.migration_failed = True
+            if backup_path:
+                self._config.migration_backup_path = str(backup_path)
+
+            await self.save(self._config)
+            logger.info("Created fresh config after JSON parse error")
+
+            return self._config
+
+        except Exception as e:
+            # Generic error - create fresh config
+            logger.error("Failed to load config: %s", e)
+
             self._config = await self.initialize()
+            self._config.migration_failed = True
+            if backup_path:
+                self._config.migration_backup_path = str(backup_path)
+
+            await self.save(self._config)
+            logger.info("Created fresh config after load error")
+
             return self._config
 
     async def save(self, config: ShotgunConfig | None = None) -> None:
@@ -237,6 +475,11 @@ class ConfigManager:
                 SecretStr(api_key_value) if api_key_value is not None else None
             )
 
+            # Reset streaming capabilities when OpenAI API key is changed
+            if not is_shotgun and provider_enum == ProviderType.OPENAI:
+                if isinstance(provider_config, OpenAIConfig):
+                    provider_config.supports_streaming = None
+
         # Reject other fields
         unsupported_fields = set(kwargs.keys()) - {API_KEY_FIELD}
         if unsupported_fields:
@@ -266,6 +509,11 @@ class ConfigManager:
             # This prevents the welcome screen from showing again after user has made their choice
             config.shown_welcome_screen = True
 
+        # Clear migration failure flag when user successfully configures a provider
+        if API_KEY_FIELD in kwargs and api_key_value is not None:
+            config.migration_failed = False
+            config.migration_backup_path = None
+
         await self.save(config)
 
     async def clear_provider_key(self, provider: ProviderType | str) -> None:
@@ -283,6 +531,13 @@ class ConfigManager:
         if is_shotgun and isinstance(provider_config, ShotgunAccountConfig):
             provider_config.supabase_jwt = None
 
+        # Reset streaming capabilities when OpenAI API key is cleared
+        if not is_shotgun:
+            provider_enum = self._ensure_provider_enum(provider)
+            if provider_enum == ProviderType.OPENAI:
+                if isinstance(provider_config, OpenAIConfig):
+                    provider_config.supports_streaming = None
+
         await self.save(config)
 
     async def update_selected_model(self, model_name: "ModelName") -> None:

shotgun/agents/config/models.py

@@ -56,6 +56,10 @@ class ModelConfig(BaseModel):
     max_input_tokens: int
     max_output_tokens: int
     api_key: str
+    supports_streaming: bool = Field(
+        default=True,
+        description="Whether this model configuration supports streaming. False only for BYOK GPT-5 models without streaming enabled.",
+    )
     _model_instance: Model | None = PrivateAttr(default=None)
 
     class Config:
@@ -82,6 +86,15 @@ class ModelConfig(BaseModel):
         }
         return f"{provider_prefix[self.provider]}:{self.name}"
 
+    @property
+    def is_shotgun_account(self) -> bool:
+        """Check if this model is using Shotgun Account authentication.
+
+        Returns:
+            True if using Shotgun Account, False if BYOK
+        """
+        return self.key_provider == KeyProvider.SHOTGUN
+
 
 # Model specifications registry (static metadata)
 MODEL_SPECS: dict[ModelName, ModelSpec] = {
@@ -148,6 +161,10 @@ class OpenAIConfig(BaseModel):
     """Configuration for OpenAI provider."""
 
     api_key: SecretStr | None = None
+    supports_streaming: bool | None = Field(
+        default=None,
+        description="Whether streaming is supported for this API key. None = not tested yet",
+    )
 
 
 class AnthropicConfig(BaseModel):
@@ -200,7 +217,7 @@ class ShotgunConfig(BaseModel):
     shotgun_instance_id: str = Field(
         description="Unique shotgun instance identifier (also used for anonymous telemetry)",
     )
-    config_version: int = Field(default=4, description="Configuration schema version")
+    config_version: int = Field(default=5, description="Configuration schema version")
     shown_welcome_screen: bool = Field(
         default=False,
         description="Whether the welcome screen has been shown to the user",
@@ -213,3 +230,11 @@ class ShotgunConfig(BaseModel):
         default_factory=MarketingConfig,
         description="Marketing messages configuration and tracking",
     )
+    migration_failed: bool = Field(
+        default=False,
+        description="Whether the last config migration failed (cleared after user configures a provider)",
+    )
+    migration_backup_path: str | None = Field(
+        default=None,
+        description="Path to the backup file created when migration failed",
+    )

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: